private static bool kl_init(bilist *****bucket_ptrs, /* space for multiple bucket sorts */ bilist ***listspace, /* space for all elements of linked lists */ int ***dvals, /* change in cross edges for each move */ int ***tops, /* top dval for each type of move */ int nvtxs, /* number of vertices in the graph */ int nsets, /* number of sets created at each step */ int maxchange /* maximum change by moving a vertex */ ) { bilist * spacel; /* space for all listspace entries */ bilist **spaceb; /* space for all buckets entries */ int sizeb; /* size of set of buckets */ int sizel; /* size of set of pointers for all vertices */ int i, j; /* loop counters */ /* Allocate appropriate data structures for buckets, and listspace. */ *bucket_ptrs = (bilist ****)array_alloc_2D_ret <IntPtr>(nsets, nsets, sizeof(bilist *)); *dvals = (int **)array_alloc_2D_ret <int>(nvtxs + 1, nsets - 1, sizeof(int)); *tops = (int **)array_alloc_2D_ret <int>(nsets, nsets, sizeof(int)); /* By using '-1' in the next line, I save space, but I need to */ /* be careful to get the right element in listspace each time. */ *listspace = (bilist **)Marshal.AllocHGlobal((nsets - 1) * sizeof(bilist *)); sizeb = (2 * maxchange + 1) * sizeof(bilist *); sizel = (nvtxs + 1) * sizeof(bilist); spacel = (bilist *)Marshal.AllocHGlobal((nsets - 1) * sizel); spaceb = (bilist **)Marshal.AllocHGlobal(nsets * (nsets - 1) * sizeb); if (*bucket_ptrs == null || *dvals == null || *tops == null || *listspace == null || spacel == null || spaceb == null) { Marshal.FreeHGlobal((IntPtr)spacel); Marshal.FreeHGlobal((IntPtr)spaceb); return(true); } for (i = 0; i < nsets; i++) { if (i != nsets - 1) { (*listspace)[i] = spacel; spacel += nvtxs + 1; } for (j = 0; j < nsets; j++) { if (i != j) { (*bucket_ptrs)[i][j] = spaceb; spaceb += 2 * maxchange + 1; } } } return(false); }
public static void DuplicatePointers(int*** values, int numValues) { int sizeInBytes = sizeof(int*) * numValues; int** newArray = (int**)Marshal.AllocCoTaskMem(sizeInBytes); new Span<byte>(*values, sizeInBytes).CopyTo(new Span<byte>(newArray, sizeInBytes)); Marshal.FreeCoTaskMem((IntPtr)(*values)); *values = newArray; }
public static int SumInPointers(int*** values, int numValues) { if (*values == null) return -1; int sum = 0; for (int i = 0; i < numValues; i++) { sum += *(*values)[i]; } return sum; }
public static int SumInPointers(int ***values, int numValues) { if (*values == null) { return(-1); } int sum = 0; for (int i = 0; i < numValues; i++) { sum += *(*values)[i]; } return(sum); }
/// <summary> /// This method retrieves the result set from executing the @script in sp_execute_external_script. /// </summary> public void GetResults( ulong *rowsNumber, void ***data, int ***strLenOrNullMap) { Logging.Trace("CSharpSession::GetResults"); if (_outputDataSet.CSharpDataFrame != null) { *rowsNumber = (ulong)_outputDataSet.CSharpDataFrame.Rows.Count; _outputDataSet.RetrieveColumns(data, strLenOrNullMap); } else { *rowsNumber = 0; } }
/// <summary> /// This method implements GetResults API. /// Retrieve the result set from executing the @script in sp_execute_external_script. /// </summary> /// <param name="sessionId"> /// GUID uniquely identifying this script session. /// </param> /// <param name="taskId"> /// An integer uniquely identifying this execution process. /// </param> /// <param name="rowsNumber"> /// A pointer to a buffer that contains the number of rows in the Data. /// </param> /// <param name="data"> /// A pointer to a two-dimensional array allocated by the extension that /// contains the result set of @script n sp_execute_external_script. /// </param> /// <param name="strLenOrNullMap"> /// A pointer to a two-dimensional array allocated by the extension that /// contains the length/NULL indicator for each value in Data. /// <returns> /// SQL_SUCCESS(0), SQL_ERROR(-1) /// </returns> public static short GetResults( Guid sessionId, ushort TaskId, ulong *rowsNumber, void ***data, int ***strLenOrNullMap) { Logging.Trace("CSharpExtension::GetResults"); return(ExceptionUtils.WrapError(() => { _currentSession.GetResults( rowsNumber, data, strLenOrNullMap); })); }
public static extern unsafe int MXSymbolInferShapeEx(SymbolHandle sym, uint num_args, [In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPUTF8Str)] string[] keys, int[] arg_ind_ptr, int[] arg_shape_data, int *in_shape_size, int **in_shape_ndim, int ***in_shape_data, out int out_shape_size, out int *out_shape_ndim, out int **out_shape_data, out int aux_shape_size, out int *aux_shape_ndim, out int **aux_shape_data, out int complete);
/// <summary> /// This method retrieves the DataFrame data from output DataSet by assigning /// pointers to the data pointers array and strLenOrNullMap pointers array /// </summary> public unsafe void RetrieveColumns( void ***data, int ***strLenOrNullMap ) { Logging.Trace("CSharpOutputDataSet::RetrieveColumns"); fixed(void **ptrptr = _dataPtrs) { _handleList.Add(GCHandle.Alloc(_dataPtrs)); *data = ptrptr; } fixed(int **ptrptr = _strLenOrNullMapPtrs) { _handleList.Add(GCHandle.Alloc(_strLenOrNullMapPtrs)); *strLenOrNullMap = ptrptr; } }
public unsafe bool Query() { Guid classGuid = Guid.Empty; Guid interfaceGuid = Guid.Empty; Guid classFactoryGuid = typeof(IClassFactory).GUID; Guid classFactory2Guid = typeof(IClassFactory2).GUID; int[] vTableOffsets = null; object classInstance = null; if (ClassType != null) { classGuid = ClassType.GUID; interfaceGuid = InterfaceType.GUID; // get com-slot-number (vtable-index) of function X vTableOffsets = new int[MethodPointers.Length]; for (var i = 0; i < Methods.Length; i++) { vTableOffsets[i] = Marshal.GetComSlotForMethodInfo(Methods[i]); } } else { classGuid = ClassId; interfaceGuid = InterfaceId; // get com-slot-number (vtable-index) of function N vTableOffsets = VTableIndexes; } classInstance = GetClassInstance(classGuid, interfaceGuid, classFactoryGuid, classFactory2Guid); if (classInstance == null) { return(false); } IntPtr interfaceIntPtr = IntPtr.Zero; if (InterfaceType != null) { interfaceIntPtr = Marshal.GetComInterfaceForObject(classInstance, InterfaceType); } else { interfaceIntPtr = Marshal.GetIUnknownForObject(classInstance); } try { int ***interfaceRawPtr = (int ***)interfaceIntPtr.ToPointer(); // get vtable int **vTable = *interfaceRawPtr; // get function-addresses from vtable for (var i = 0; i < vTableOffsets.Length; i++) { int *faddr = vTable[vTableOffsets[i]]; MethodPointers[i] = new IntPtr(faddr); } } finally { // release intptr if (interfaceIntPtr != IntPtr.Zero) { Marshal.Release(interfaceIntPtr); } Marshal.FinalReleaseComObject(classInstance); } return(true); }
static int mapping0_forward(ref vorbis_block vb) { vorbis_dsp_state vd = vb.vd; vorbis_info vi = vd.vi; codec_setup_info ci = vi.codec_setup as codec_setup_info; private_state b = vb.vd.backend_state as private_state; vorbis_block_internal vbi = vb._internal as vorbis_block_internal; int n = vb.pcmend; int i, j, k; int * nonzero = stackalloc int[vi.channels]; float **gmdct = (float **)_vorbis_block_alloc(ref vb, vi.channels * sizeof(float *)); int ** iwork = (int **)_vorbis_block_alloc(ref vb, vi.channels * sizeof(int *)); int *** floor_posts = (int ***)_vorbis_block_alloc(ref vb, vi.channels * sizeof(int **)); float global_ampmax = vbi.ampmax; float *local_ampmax = stackalloc float[vi.channels]; int blocktype = vbi.blocktype; int modenumber = vb.W; vorbis_info_mapping0 info = ci.map_param[modenumber] as vorbis_info_mapping0; vorbis_look_psy psy_look = b.psy[blocktype + (vb.W != 0 ? 2 : 0)]; vb.mode = modenumber; for (i = 0; i < vi.channels; i++) { float scale = 4.0f / n; float scale_dB; float *pcm = vb.pcm[i]; float *logfft = pcm; iwork[i] = (int *)_vorbis_block_alloc(ref vb, (n / 2) * sizeof(int)); gmdct[i] = (float *)_vorbis_block_alloc(ref vb, (n / 2) * sizeof(float)); /* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that * returned dB values about a third of a decibel too high. The bug was harmless because tunings * implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well. * For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */ scale_dB = todB(scale) + 0.345f; /* window the PCM data */ _vorbis_apply_window(pcm, ref b.window, ref ci.blocksizes, vb.lW, vb.W, vb.nW); /* transform the PCM data */ /* only MDCT right now.... */ mdct_forward(b.transform[vb.W][0] as mdct_lookup, pcm, gmdct[i]); /* FFT yields more accurate tonal estimation (not phase sensitive) */ drft_forward(ref b.fft_look[vb.W], pcm); /* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that * returned dB values about a third of a decibel too high. The bug was harmless because tunings * implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well. * For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */ logfft[0] = scale_dB + todB(*pcm) + 0.345f; local_ampmax[i] = logfft[0]; for (j = 1; j < n - 1; j += 2) { float temp = pcm[j] * pcm[j] + pcm[j + 1] * pcm[j + 1]; /* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that * returned dB values about a third of a decibel too high. The bug was harmless because tunings * implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well. * For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */ temp = logfft[(j + 1) >> 1] = scale_dB + 0.5f * todB(temp) + 0.345f; if (temp > local_ampmax[i]) { local_ampmax[i] = temp; } } if (local_ampmax[i] > 0.0f) { local_ampmax[i] = 0.0f; } if (local_ampmax[i] > global_ampmax) { global_ampmax = local_ampmax[i]; } } { float *noise = (float *)_vorbis_block_alloc(ref vb, n / 2 * sizeof(float)); float *tone = (float *)_vorbis_block_alloc(ref vb, n / 2 * sizeof(float)); for (i = 0; i < vi.channels; i++) { /* the encoder setup assumes that all the modes used by any * specific bitrate tweaking use the same floor */ int submap = info.chmuxlist[i]; /* the following makes things clearer to *me* anyway */ float *mdct = gmdct[i]; float *logfft = vb.pcm[i]; float *logmdct = logfft + n / 2; float *logmask = logfft; vb.mode = modenumber; floor_posts[i] = (int **)_vorbis_block_alloc(ref vb, PACKETBLOBS * sizeof(int *)); ZeroMemory(floor_posts[i], sizeof(int *) * PACKETBLOBS); for (j = 0; j < n / 2; j++) { /* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that * returned dB values about a third of a decibel too high. The bug was harmless because tunings * implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well. * For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */ logmdct[j] = todB(mdct[j]) + 0.345f; /* first step; noise masking. Not only does 'noise masking' give us curves from which we can decide how much resolution * to give noise parts of the spectrum, it also implicitly hands us a tonality estimate (the larger the value in the * 'noise_depth' vector, the more tonal that area is) */ _vp_noisemask(ref psy_look, logmdct, noise); /* noise does not have by-frequency offset bias applied yet */ /* second step: 'all the other crap'; all the stuff that isn't computed/fit for bitrate management goes in the second psy * vector. This includes tone masking, peak limiting and ATH */ _vp_tonemask(ref psy_look, logfft, tone, global_ampmax, local_ampmax[i]); /* third step; we offset the noise vectors, overlay tone masking. We then do a floor1-specific line fit. If we're * performing bitrate management, the line fit is performed multiple times for up/down tweakage on demand. */ _vp_offset_and_mix(ref psy_look, noise, tone, 1, logmask, mdct, logmdct); /* this algorithm is hardwired to floor 1 for now; abort out if we're *not* floor1. This won't happen unless someone has * broken the encode setup lib. Guard it anyway. */ if (ci.floor_type[info.floorsubmap[submap]] != 1) { return(-1); } floor_posts[i][PACKETBLOBS / 2] = floor1_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, logmdct, logmask); /* are we managing bitrate? If so, perform two more fits for later rate tweaking (fits represent hi/lo) */ if (vorbis_bitrate_managed(ref vb) != 0 && floor_posts[i][PACKETBLOBS / 2] != null) { /* higher rate by way of lower noise curve */ _vp_offset_and_mix(ref psy_look, noise, tone, 2, logmask, mdct, logmdct); floor_posts[i][PACKETBLOBS - 1] = floor1_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, logmdct, logmask); /* lower rate by way of higher noise curve */ _vp_offset_and_mix(ref psy_look, noise, tone, 0, logmask, mdct, logmdct); floor_posts[i][0] = floor1_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, logmdct, logmask); /* we also interpolate a range of intermediate curves for * intermediate rates */ for (k = 1; k < PACKETBLOBS / 2; k++) { floor_posts[i][k] = floor1_interpolate_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, floor_posts[i][0], floor_posts[i][PACKETBLOBS / 2], k * 65536 / (PACKETBLOBS / 2)); } for (k = PACKETBLOBS / 2 + 1; k < PACKETBLOBS - 1; k++) { floor_posts[i][k] = floor1_interpolate_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, floor_posts[i][PACKETBLOBS / 2], floor_posts[i][PACKETBLOBS - 1], (k - PACKETBLOBS / 2) * 65536 / (PACKETBLOBS / 2)); } } } } vbi.ampmax = global_ampmax; /* * the next phases are performed once for vbr-only and PACKETBLOB * times for bitrate managed modes. * * 1) encode actual mode being used * 2) encode the floor for each channel, compute coded mask curve/res * 3) normalize and couple. * 4) encode residue * 5) save packet bytes to the packetblob vector */ /* iterate over the many masking curve fits we've created */ { int **couple_bundle = stackalloc int *[vi.channels]; int * zerobundle = stackalloc int[vi.channels]; for (k = (vorbis_bitrate_managed(ref vb) != 0 ? 0 : PACKETBLOBS / 2); k <= (vorbis_bitrate_managed(ref vb) != 0 ? PACKETBLOBS - 1 : PACKETBLOBS / 2); k++) { Ogg.oggpack_buffer opb = vbi.packetblob[k]; /* start out our new packet blob with packet type and mode */ /* Encode the packet type */ Ogg.oggpack_write(ref opb, 0, 1); /* Encode the modenumber */ /* Encode frame mode, pre,post windowsize, then dispatch */ Ogg.oggpack_write(ref opb, (uint)modenumber, b.modebits); if (vb.W != 0) { Ogg.oggpack_write(ref opb, (uint)vb.lW, 1); Ogg.oggpack_write(ref opb, (uint)vb.nW, 1); } /* encode floor, compute masking curve, sep out residue */ for (i = 0; i < vi.channels; i++) { int submap = info.chmuxlist[i]; int *ilogmask = iwork[i]; nonzero[i] = floor1_encode(ref opb, ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, floor_posts[i][k], ilogmask); } /* our iteration is now based on masking curve, not prequant and coupling. Only one prequant/coupling step */ /* quantize/couple */ /* incomplete implementation that assumes the tree is all depth one, or no tree at all */ _vp_couple_quantize_normalize(k, ci.psy_g_param, ref psy_look, info, gmdct, iwork, nonzero, ci.psy_g_param.sliding_lowpass[vb.W, k], vi.channels); /* classify and encode by submap */ for (i = 0; i < info.submaps; i++) { int ch_in_bundle = 0; int **classifications; int resnum = info.residuesubmap[i]; for (j = 0; j < vi.channels; j++) { if (info.chmuxlist[j] == i) { zerobundle[ch_in_bundle] = 0; if (nonzero[j] != 0) { zerobundle[ch_in_bundle] = 1; } couple_bundle[ch_in_bundle++] = iwork[j]; } } classifications = _residue_P[ci.residue_type[resnum]]._class(ref vb, b.residue[resnum], couple_bundle, zerobundle, ch_in_bundle); ch_in_bundle = 0; for (j = 0; j < vi.channels; j++) { if (info.chmuxlist[j] == i) { couple_bundle[ch_in_bundle++] = iwork[j]; } } _residue_P[ci.residue_type[resnum]].forward(ref opb, ref vb, b.residue[resnum], couple_bundle, zerobundle, ch_in_bundle, classifications, i); } /* ok, done encoding. Next protopacket. */ } } return(0); } }