void VcfFile::printVCFHeader(IFILE oFile) { for(int i=0; i < getMetaCount(); ++i) { ifprintf(oFile,"##%s=%s\n",getMetaKey(i).c_str(), getMetaValue(i, "<na>").c_str()); } ifprintf(oFile,"#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO"); if ( ( getSampleCount() > 0 ) && ( !bSiteOnly ) ) { ifprintf(oFile,"\tFORMAT"); for(int i=0; i < getSampleCount(); ++i) { ifprintf(oFile,"\t%s",vpVcfInds[i]->sIndID.c_str()); } } ifprintf(oFile,"\n"); }
static void mergeElementaryIntervals( uint *dstKey, uint *dstVal, uint *srcKey, uint *srcVal, uint *limitsA, uint *limitsB, uint stride, uint N, uint sortDir ){ uint lastSegmentElements = N % (2 * stride); uint mergePairs = (lastSegmentElements > stride) ? getSampleCount(N) : (N - lastSegmentElements) / SAMPLE_STRIDE; for(uint pos = 0; pos < mergePairs; pos++){ uint i = pos & ( (2 * stride) / SAMPLE_STRIDE - 1 ); uint segmentBase = (pos - i) * SAMPLE_STRIDE; const uint lenA = stride; const uint lenB = umin(stride, N - segmentBase - stride); const uint nA = stride / SAMPLE_STRIDE; const uint nB = getSampleCount(lenB); const uint n = nA + nB; const uint startPosA = limitsA[pos]; const uint endPosA = (i + 1 < n) ? limitsA[pos + 1] : lenA; const uint startPosB = limitsB[pos]; const uint endPosB = (i + 1 < n) ? limitsB[pos + 1] : lenB; const uint startPosDst = startPosA + startPosB; assert( startPosA <= endPosA && endPosA <= lenA); assert( startPosB <= endPosB && endPosB <= lenB); assert( (endPosA - startPosA) <= SAMPLE_STRIDE); assert( (endPosB - startPosB) <= SAMPLE_STRIDE); merge( dstKey + segmentBase + startPosDst, dstVal + segmentBase + startPosDst, (srcKey + segmentBase + 0) + startPosA, (srcVal + segmentBase + 0) + startPosA, (srcKey + segmentBase + stride) + startPosB, (srcVal + segmentBase + stride) + startPosB, endPosA - startPosA, endPosB - startPosB, sortDir ); } }
//////////////////////////////////////////////////////////////////////////////// // Merge step 1: find sample ranks in each segment //////////////////////////////////////////////////////////////////////////////// static void generateSampleRanks( uint *ranksA, uint *ranksB, uint *srcKey, uint stride, uint N, uint sortDir ){ uint lastSegmentElements = N % (2 * stride); uint sampleCount = (lastSegmentElements > stride) ? (N + 2 * stride - lastSegmentElements) / (2 * SAMPLE_STRIDE) : (N - lastSegmentElements) / (2 * SAMPLE_STRIDE); for(uint pos = 0; pos < sampleCount; pos++){ const uint i = pos & ( (stride / SAMPLE_STRIDE) - 1 ); const uint segmentBase = (pos - i) * (2 * SAMPLE_STRIDE); const uint lenA = stride; const uint lenB = umin(stride, N - segmentBase - stride); const uint nA = stride / SAMPLE_STRIDE; const uint nB = getSampleCount(lenB); if(i < nA){ ranksA[(segmentBase + 0) / SAMPLE_STRIDE + i] = i * SAMPLE_STRIDE; ranksB[(segmentBase + 0) / SAMPLE_STRIDE + i] = binarySearchExclusive(srcKey[segmentBase + i * SAMPLE_STRIDE], srcKey + segmentBase + stride, lenB, sortDir); } if(i < nB){ ranksB[(segmentBase + stride) / SAMPLE_STRIDE + i] = i * SAMPLE_STRIDE; ranksA[(segmentBase + stride) / SAMPLE_STRIDE + i] = binarySearchInclusive(srcKey[segmentBase + stride + i * SAMPLE_STRIDE], srcKey + segmentBase, lenA, sortDir); } } }
//////////////////////////////////////////////////////////////////////////////// // Merge step 2: merge ranks and indices to derive elementary intervals //////////////////////////////////////////////////////////////////////////////// static void mergeRanksAndIndices( uint *limits, uint *ranks, uint stride, uint N ){ uint lastSegmentElements = N % (2 * stride); uint sampleCount = (lastSegmentElements > stride) ? (N + 2 * stride - lastSegmentElements) / (2 * SAMPLE_STRIDE) : (N - lastSegmentElements) / (2 * SAMPLE_STRIDE); for(uint pos = 0; pos < sampleCount; pos++){ const uint i = pos & ( (stride / SAMPLE_STRIDE) - 1 ); const uint segmentBase = (pos - i) * (2 * SAMPLE_STRIDE); const uint lenA = stride; const uint lenB = umin(stride, N - segmentBase - stride); const uint nA = stride / SAMPLE_STRIDE; const uint nB = getSampleCount(lenB); if(i < nA){ uint dstPosA = binarySearchExclusive(ranks[(segmentBase + 0) / SAMPLE_STRIDE + i], ranks + (segmentBase + stride) / SAMPLE_STRIDE, nB, 1) + i; assert( dstPosA < nA + nB ); limits[(segmentBase / SAMPLE_STRIDE) + dstPosA] = ranks[(segmentBase + 0) / SAMPLE_STRIDE + i]; } if(i < nB){ uint dstPosA = binarySearchInclusive(ranks[(segmentBase + stride) / SAMPLE_STRIDE + i], ranks + (segmentBase + 0) / SAMPLE_STRIDE, nA, 1) + i; assert( dstPosA < nA + nB ); limits[(segmentBase / SAMPLE_STRIDE) + dstPosA] = ranks[(segmentBase + stride) / SAMPLE_STRIDE + i]; } } }
love::sound::SoundData *RecordingDevice::getData() { if (!isRecording()) return nullptr; int samples = getSampleCount(); if (samples == 0) return nullptr; love::sound::SoundData *soundData = soundInstance()->newSoundData(samples, sampleRate, bitDepth, channels); alcCaptureSamples(device, soundData->getData(), samples); return soundData; }
void VcfFile::printBEDHeader(IFILE oBedFile, IFILE oFamFile) { for(int i=0; i < getSampleCount(); ++i) { if ( vpVcfInds[i]->sFamID.Length() == 0 ) { ifprintf(oFamFile,"%s",vpVcfInds[i]->sIndID.c_str()); } else { ifprintf(oFamFile,"%s",vpVcfInds[i]->sFamID.c_str()); } ifprintf(oFamFile,"\t%s",vpVcfInds[i]->sIndID.c_str()); if ( vpVcfInds[i]->sFatID.Length() == 0 ) { ifprintf(oFamFile,"\t0"); } else { ifprintf(oFamFile,"%s",vpVcfInds[i]->sFatID.c_str()); } if ( vpVcfInds[i]->sMotID.Length() == 0 ) { ifprintf(oFamFile,"\t0"); } else { ifprintf(oFamFile,"\t%s",vpVcfInds[i]->sMotID.c_str()); } switch( vpVcfInds[i]->gender ) { case VcfInd::UNKNOWN: ifprintf(oFamFile,"\t0"); break; case VcfInd::MALE: ifprintf(oFamFile,"\t1"); break; case VcfInd::FEMALE: ifprintf(oFamFile,"\t2"); break; default: throw VcfFileException("Unrecognized value for gender"); break; } ifprintf(oFamFile,"\t-9\n"); } char magicNumbers[3] = {0x6c,0x1b,0x01}; oBedFile->ifwrite(magicNumbers, 3); }
Mahalanobis TogersonMetricLearner::learnMetric() { dim = getVectorDim(); sampleCount = getSampleCount(); int iIdx = selectI(); mat B = generateB(iIdx); mat X = generateX(); mat Y = generateY(B); mat Z = generateZ(X, Y); mat A = Z.t() * Z; // normalize it for convenience A = 1 / A(0, 0) * A; return Mahalanobis(A); }
bool SkiaWindow::attachGL() { if (!m_glCtx) { try { auto ctx = new GLContextSkia<GLContextWGL>(handle()); m_stencilBits = ctx->getStencilBits(); m_sampleCount = ctx->getSampleCount(); m_glCtx.reset(ctx); m_grCtx.reset(GrContext::Create(kOpenGL_GrBackend, (GrBackendContext)m_glCtx->gl())); } catch (const std::exception& ex) { LOG("Cannot create GL context: %s\n", ex.what()); detachGL(); } } if (m_glCtx) return true; else return false; }
int WavReader::decodeADPCM(unsigned max_samples) { unsigned sample_count = getSampleCount(); unsigned samples_per_block = (m_BlockSize - m_Channels * 4) * (m_Channels ^ 3) + 1; if (sample_count > max_samples) sample_count = max_samples; unsigned sample = 0; while (sample < sample_count) { unsigned this_block_adpcm_samples = samples_per_block; int this_block_pcm_samples = samples_per_block; if (this_block_adpcm_samples > sample_count) { this_block_adpcm_samples = ((sample_count + 6) & ~7) + 1; this_block_pcm_samples = sample_count; } // Add to out-wav size_t ofidx = m_Dest.size(); m_Dest.resize(m_Dest.size() + this_block_pcm_samples * m_Channels * 2); adpcm_decode_block(reinterpret_cast<int16_t*>(&m_Dest[ofidx]), &m_Source[m_SourceOffset], m_BlockSize, m_Channels); /* if (adpcm_decode_block(reinterpret_cast<int16_t*>(&dest[ofidx]), sourcep, block_size, num_channels) != this_block_adpcm_samples) { LogWarn() << "adpcm_decode_block() failed"; return false; } */ m_SourceOffset += m_BlockSize; sample += this_block_pcm_samples; } return sample; }
void InfTheoMetricLearner::computeConstraints() { simConstraints.flush(); disSimConstraints.flush(); int sampleCount = getSampleCount(); for(int i = 0; i < sampleCount; ++i) { vec x1 = getX1(i); vec x2 = getX2(i); double dist = getSampleDistance(i); if(dist <= simBorder) { simConstraints.addConstraint(x1, x2, simBorder); } else if(dist >= disSimBorder) { disSimConstraints.addConstraint(x1, x2, disSimBorder); } else { // no additional constraint } } }
soundDataBuffer* sound_DecodeOggVorbis(struct OggVorbisDecoderState* decoder, size_t bufferSize) { size_t size = 0; #ifndef WZ_NOSOUND int result; #endif soundDataBuffer* buffer; ASSERT(decoder != NULL, "NULL decoder passed!"); #ifndef WZ_NOSOUND if (decoder->allowSeeking) { unsigned int sampleCount = getSampleCount(decoder); unsigned int sizeEstimate = sampleCount * decoder->VorbisInfo->channels * 2; if (((bufferSize == 0) || (bufferSize > sizeEstimate)) && (sizeEstimate != 0)) { bufferSize = (sampleCount - getCurrentSample(decoder)) * decoder->VorbisInfo->channels * 2; } } // If we can't seek nor receive any suggested size for our buffer, just quit if (bufferSize == 0) { debug(LOG_ERROR, "can't find a proper buffer size"); return NULL; } #else bufferSize = 0; #endif buffer = malloc(bufferSize + sizeof(soundDataBuffer)); if (buffer == NULL) { debug(LOG_ERROR, "couldn't allocate memory (%lu bytes requested)", (unsigned long) bufferSize + sizeof(soundDataBuffer)); return NULL; } buffer->data = (char*)(buffer + 1); buffer->bufferSize = bufferSize; buffer->bitsPerSample = 16; #ifndef WZ_NOSOUND buffer->channelCount = decoder->VorbisInfo->channels; buffer->frequency = decoder->VorbisInfo->rate; // Decode PCM data into the buffer until there is nothing to decode left do { // Decode int section; result = ov_read(&decoder->oggVorbis_stream, &buffer->data[size], bufferSize - size, OGG_ENDIAN, 2, 1, §ion); if (result < 0) { debug(LOG_ERROR, "error decoding from OggVorbis file; errorcode from ov_read: %d", result); free(buffer); return NULL; } else { size += result; } } while ((result != 0 && size < bufferSize)); #endif buffer->size = size; return buffer; }
double TSoundTrack::getMinPressure(TSound::Channel chan) const { return getMinPressure(0, (TINT32)(getSampleCount() - 1), chan); }
void TSoundTrack::getMinMaxPressure(TSound::Channel chan, double &min, double &max) const { getMinMaxPressure(0, (TINT32)(getSampleCount() - 1), chan, min, max); }
//////////////////////////////////////////////////////////////////////////////// // Interface function //////////////////////////////////////////////////////////////////////////////// extern "C" void mergeSortHost( uint *dstKey, uint *dstVal, uint *bufKey, uint *bufVal, uint *srcKey, uint *srcVal, uint N, uint sortDir ){ uint *ikey, *ival, *okey, *oval; uint stageCount = 0; for(uint stride = SHARED_SIZE_LIMIT; stride < N; stride <<= 1, stageCount++); if(stageCount & 1){ ikey = bufKey; ival = bufVal; okey = dstKey; oval = dstVal; }else{ ikey = dstKey; ival = dstVal; okey = bufKey; oval = bufVal; } printf("Bottom-level sort...\n"); memcpy(ikey, srcKey, N * sizeof(uint)); memcpy(ival, srcVal, N * sizeof(uint)); for(uint pos = 0; pos < N; pos += SHARED_SIZE_LIMIT) bubbleSort(ikey + pos, ival + pos, umin(SHARED_SIZE_LIMIT, N - pos), sortDir); printf("Merge...\n"); uint *ranksA = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); uint *ranksB = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); uint *limitsA = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); uint *limitsB = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); memset(ranksA, 0xFF, getSampleCount(N) * sizeof(uint)); memset(ranksB, 0xFF, getSampleCount(N) * sizeof(uint)); memset(limitsA, 0xFF, getSampleCount(N) * sizeof(uint)); memset(limitsB, 0xFF, getSampleCount(N) * sizeof(uint)); for(uint stride = SHARED_SIZE_LIMIT; stride < N; stride <<= 1){ uint lastSegmentElements = N % (2 * stride); //Find sample ranks and prepare for limiters merge generateSampleRanks(ranksA, ranksB, ikey, stride, N, sortDir); //Merge ranks and indices mergeRanksAndIndices(limitsA, ranksA, stride, N); mergeRanksAndIndices(limitsB, ranksB, stride, N); //Merge elementary intervals mergeElementaryIntervals(okey, oval, ikey, ival, limitsA, limitsB, stride, N, sortDir); if( lastSegmentElements <= stride ) { //Last merge segment consists of a single array which just needs to be passed through memcpy(okey + (N - lastSegmentElements), ikey + (N - lastSegmentElements), lastSegmentElements * sizeof(uint)); memcpy(oval + (N - lastSegmentElements), ival + (N - lastSegmentElements), lastSegmentElements * sizeof(uint)); } uint *t; t = ikey; ikey = okey; okey = t; t = ival; ival = oval; oval = t; } free(limitsB); free(limitsA); free(ranksB); free(ranksA); }