Example #1
0
void makeMap(peak_param *peak, gal_map *gMap, map_t *kMap, map_t *nMap, FFT_t *transformer, error **err)
{
  //-- Map making main function
  
  if (peak->doKappa == 1) {
    //-- Do convergence
    
    kappaMapFromKappa(gMap, kMap, err);           forwardError(*err, __LINE__,);
    subtractMean_map_t(peak, kMap);
    if (peak->doNewNoise == 1) {
      //-- Overwrite nMap
      u_int64_t seed = renewSeed();
      fillNoise(peak, nMap, seed);
    }
    addNoise(kMap, nMap, err);                    forwardError(*err, __LINE__,);
    doFFTSmoothing(peak, kMap, transformer, err); forwardError(*err, __LINE__,);
  }
Example #2
0
// fill buff
int SoundGenPCJr::chanGen(int chan, int16 *stream, int len) {
    ToneChan *tpcm;
    Tone toneNew;
    int fillSize;
    int retVal;

    tpcm = &_tchannel[chan];

    retVal = -1;

    while (len > 0) {
        if (tpcm->noteCount <= 0) {
            // get new tone data
            toneNew.freqCount = 0;
            toneNew.atten = 0xF;
            toneNew.type = kGenTone;
            if ((tpcm->avail) && (getNextNote(chan, &toneNew) == 0)) {
                tpcm->atten = toneNew.atten;
                tpcm->freqCount = toneNew.freqCount;
                tpcm->genType = toneNew.type;

                // setup counters 'n stuff
                // SAMPLE_RATE samples per sec.. tone changes 60 times per sec
                tpcm->noteCount = SAMPLE_RATE / 60;
                retVal = 0;
            } else {
                // if it doesn't return an
                tpcm->genType = kGenSilence;
                tpcm->noteCount = len;
                tpcm->avail = 0;
            }
        }

        // write nothing
        if ((tpcm->freqCount == 0) || (tpcm->atten == 0xf)) {
            tpcm->genType = kGenSilence;
        }

        // find which is smaller.. the buffer or the
        fillSize = (tpcm->noteCount <= len) ? tpcm->noteCount : len;

        switch (tpcm->genType) {
        case kGenTone:
            fillSize = fillSquare(tpcm, stream, fillSize);
            break;
        case kGenPeriod:
        case kGenWhite:
            fillSize = fillNoise(tpcm, stream, fillSize);
            break;
        case kGenSilence:
        default:
            // fill with whitespace
            memset(stream, 0, fillSize * sizeof(int16));
            break;
        }

        tpcm->noteCount -= fillSize;
        stream += fillSize;
        len -= fillSize;
    }

    return retVal;
}