Esempio n. 1
0
void Soundy::playABC(String abc) {

  //abc.toLowerCase(); // legacy
  
  Serial.write("L="+L);
  
  for (int n = 0; n < abc.length(); n++) {
    char note = abc.charAt(n);    

    if (!isNote(String(note))) continue;
    Serial.write(note);

    int duration = 1;    
    if (n < abc.length()-1) {
      String next = String(abc.charAt(n+1));
      if (next.toInt() > 0) {
        duration = next.toInt();        
        n++;
      }
    }
    Serial.write(duration);    
        
    if (note == ' ') {
      delay ( duration * L);
    } else {
      playNote(String(note), duration * L);
    }
    delay( L / 2);    
  }
}
Esempio n. 2
0
 void Parser::parseSeqNonNotes()
 {
   qDebug() << "Parser::parseSeqNonNotes() value:" << qPrintable(lex.symValue());
   MeasureBeginFlags mbfl;
   MeasureEndFlags mefl;
   while (isNonNote(lex.symType()))
   {
     if (lex.symType() == CLEF)
     {
       mbfl.firstOfSystem = true;
       mefl.lastOfSystem = true;
       lex.getSym();
     }
     else if (lex.symType() == KEY)
       lex.getSym(); // ignore
     else if (lex.symType() == TSIG)
       parseTSig();
     else if (lex.symType() == PART)
       parsePart(mbfl, mefl);
     else if (lex.symType() == BAR)
       parseBar(mefl);
   }
   // First end the previous measure
   if (!measures.isEmpty())
   {
     measures.last().mef = mefl;
   }
   // Then start a new measure, if necessary
   if (isNote(lex.symType()))
   {
     MeasureDescription md;
     md.mbf = mbfl;
     measures.append(md);
   }
 }
Esempio n. 3
0
void CIniFile::readInfo(void)
{
    m_lstNodeInfo.clear();

    std::fstream inStream(m_strFile.c_str(), std::ios::in);
    if (!inStream.good())
    {
        Q_Printf("open file %s error.", m_strFile.c_str());
        inStream.close();

        return;
    }

    char pBuffer[Q_ONEK];
    std::string strTmp;
    std::string strNode;

    while(inStream.good())
    {
        Q_Zero(pBuffer, sizeof(pBuffer));

        inStream.getline(pBuffer, (std::streamsize)(sizeof(pBuffer) - 1));

        strTmp = std::string(pBuffer);
        strTmp = Q_Trim(strTmp);
        if (strTmp.empty()
            || isNote(strTmp))
        {
            continue;
        }

        //去掉注释
        removeNote(strTmp);
        strTmp = Q_Trim(strTmp);
        if (strTmp.empty())
        {
            continue;
        }

        if (isNode(strTmp))
        {
            strNode = getNode(strTmp);

            continue;
        }

        if (isKey(strTmp))
        {
            setStringValue(strNode.c_str(), getKey(strTmp).c_str(), getVal(strTmp).c_str());
        }
    }

    inStream.close();

    return;
}
Esempio n. 4
0
int ConfigLoader::loadInfo(const char* tool_file) {
    FILE* fp = fopen(tool_file, "r");
    if (fp == NULL) {
       fprintf(stderr, "can't open file\n");
       return 0;
    }

    const char* value = NULL;
    char buffer[CONFIG_BUFFER_SIZE];
    while(fgets(buffer, 4095, fp) != NULL) {
        if (isNote(buffer)) {
            continue;
        }
        
        value = match(buffer, CONFIG_SERVER_1);
        if (value != NULL) {
            int len = strlen(value);
            _master_config_server = (char*)malloc(sizeof(char) * (len + 1));
            if (_master_config_server == NULL) {
                fprintf(stderr, "file %s, line %d: malloc failed\n",
                        __FILE__, __LINE__);
            }
            strcpy(_master_config_server, value);
            continue;
        }
        
        value = match(buffer, CONFIG_SERVER_2);
        if (value != NULL) {
            int len = strlen(value);
            _slave_config_server = (char*)malloc(sizeof(char) * (len + 1));
            if (_slave_config_server == NULL) {
                fprintf(stderr, "file %s, line %d: malloc failed\n",
                        __FILE__, __LINE__);
            }
            strcpy(_slave_config_server, value);
            continue;
        }

        value = match(buffer, GROUP_NAME);
        if (value != NULL) {
            int len = strlen(value);
            _group_name = (char*)malloc(sizeof(char) * (len + 1));
            if (_group_name == NULL) {
                fprintf(stderr, "file %s, line %d: malloc failed\n",
                        __FILE__, __LINE__);
            }
            strcpy(_group_name, value);
            continue;
        }

        value = match(buffer, NAMESPACE);
        if (value != NULL) {
            sscanf(value, "%d", &_namespace);
            continue;
        }

        value = match(buffer, KEYS_FILE);
        if (value != NULL) {
            int len = strlen(value);
            _keys_file = (char*)malloc(sizeof(char) * (len + 1));
            if (_keys_file == NULL) {
                fprintf(stderr, "file %s, line %d: malloc failed\n",
                        __FILE__, __LINE__);
            }
            strcpy(_keys_file, value);
            continue;
        }

        value = match(buffer, WORKER_NUM);
        if (value != NULL) {
            sscanf(value, "%d", &_worker_num);
            continue;
        }

        value = match(buffer, DEL_JOB_SIZE);
        if (value != NULL) {
            sscanf(value, "%d", &_del_job_size);
            continue;
        }
        
        value = match(buffer, KEY_FORMAT);
        if (value != NULL) {
            sscanf(value, "%d", &_key_format);
            continue;
        }
    } 

    if (fp != NULL) {
        fclose(fp);
    }

    return 1;
}
Esempio n. 5
0
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
void BufferOverride::doTheProcess(float **inputs, float **outputs, long sampleFrames, bool replacing)
{

//-------------------------SAFETY CHECK----------------------
#if LINUX
    // no memory allocations during interrupt
#else
    // there must have not been available memory or something (like WaveLab goofing up),
    // so try to allocate buffers now
    if ( (buffer1 == NULL)
#ifdef BUFFEROVERRIDE_STEREO
            || (buffer2 == NULL)
#endif
       )
        createAudioBuffers();
#endif

    // if the creation failed, then abort audio processing
    if (buffer1 == NULL)
        return;
#ifdef BUFFEROVERRIDE_STEREO
    if (buffer2 == NULL)
        return;
#endif


//-------------------------INITIALIZATIONS----------------------
    // this is a handy value to have during LFO calculations & wasteful to recalculate at every sample
    numLFOpointsDivSR = NUM_LFO_POINTS_FLOAT / SAMPLERATE;
    divisorLFO->pickTheLFOwaveform();
    bufferLFO->pickTheLFOwaveform();

    // calculate this scaler value to minimize calculations later during processOutput()
//	float inputGain = 1.0f - fDryWetMix;
//	float outputGain = fDryWetMix;
    float inputGain = sqrtf(1.0f - fDryWetMix);
    float outputGain = sqrtf(fDryWetMix);


//-----------------------TEMPO STUFF---------------------------
    // figure out the current tempo if we're doing tempo sync
    if ( onOffTest(fBufferTempoSync) ||
            (onOffTest(divisorLFO->fTempoSync) || onOffTest(bufferLFO->fTempoSync)) )
    {
        // calculate the tempo at the current processing buffer
        if ( (fTempo > 0.0f) || (hostCanDoTempo != 1) )	// get the tempo from the user parameter
        {
            currentTempoBPS = tempoScaled(fTempo) / 60.0f;
            needResync = false;	// we don't want it true if we're not syncing to host tempo
        }
        else	// get the tempo from the host
        {
            timeInfo = getTimeInfo(kBeatSyncTimeInfoFlags);
            if (timeInfo)
            {
                if (kVstTempoValid & timeInfo->flags)
                    currentTempoBPS = (float)timeInfo->tempo / 60.0f;
                else
                    currentTempoBPS = tempoScaled(fTempo) / 60.0f;
//				currentTempoBPS = ((float)tempoAt(reportCurrentPosition())) / 600000.0f;
                // but zero & negative tempos are bad, so get the user tempo value instead if that happens
                if (currentTempoBPS <= 0.0f)
                    currentTempoBPS = tempoScaled(fTempo) / 60.0f;
                //
                // check if audio playback has just restarted & reset buffer stuff if it has (for measure sync)
                if (timeInfo->flags & kVstTransportChanged)
                {
                    needResync = true;
                    currentForcedBufferSize = 1;
                    writePos = 1;
                    minibufferSize = 1;
                    prevMinibufferSize = 0;
                    smoothcount = smoothDur = 0;
                }
            }
            else	// do the same stuff as above if the timeInfo gets a null pointer
            {
                currentTempoBPS = tempoScaled(fTempo) / 60.0f;
                needResync = false;	// we don't want it true if we're not syncing to host tempo
            }
        }
    }


//-----------------------AUDIO STUFF---------------------------
    // here we begin the audio output loop, which has two checkpoints at the beginning
    for (long samplecount = 0; (samplecount < sampleFrames); samplecount++)
    {
        // check if it's the end of this minibuffer
        if (readPos >= minibufferSize)
            updateBuffer(samplecount);

        // store the latest input samples into the buffers
        buffer1[writePos] = inputs[0][samplecount];
#ifdef BUFFEROVERRIDE_STEREO
        buffer2[writePos] = inputs[1][samplecount];
#endif

        // get the current output without any smoothing
        float out1 = buffer1[readPos];
#ifdef BUFFEROVERRIDE_STEREO
        float out2 = buffer2[readPos];
#endif

        // and if smoothing is taking place, get the smoothed audio output
        if (smoothcount > 0)
        {
            // crossfade between the current input & its corresponding overlap sample
//			out1 *= 1.0f - (smoothStep * (float)smoothcount);	// current
//			out1 += buffer1[readPos+prevMinibufferSize] * smoothStep*(float)smoothcount;	// + previous
//			float smoothfract = smoothStep * (float)smoothcount;
//			float newgain = sqrt(1.0f - smoothfract);
//			float oldgain = sqrt(smoothfract);
//			out1 = (out1 * newgain) + (buffer1[readPos+prevMinibufferSize] * oldgain);
//			out1 = (out1 * sqrtFadeIn) + (buffer1[readPos+prevMinibufferSize] * sqrtFadeOut);
            out1 = (out1 * fadeInGain) + (buffer1[readPos+prevMinibufferSize] * fadeOutGain);
#ifdef BUFFEROVERRIDE_STEREO
//			out2 *= 1.0f - (smoothStep * (float)smoothcount);	// current
//			out2 += buffer2[readPos+prevMinibufferSize] * smoothStep*(float)smoothcount;	// + previous
//			out2 = (out2 * newgain) + (buffer2[readPos+prevMinibufferSize] * oldgain);
//			out2 = (out2 * sqrtFadeIn) + (buffer2[readPos+prevMinibufferSize] * sqrtFadeOut);
            out2 = (out2 * fadeInGain) + (buffer2[readPos+prevMinibufferSize] * fadeOutGain);
#endif
            smoothcount--;
//			smoothFract += smoothStep;
//			sqrtFadeIn = 0.5f * (sqrtFadeIn + (smoothFract / sqrtFadeIn));
//			sqrtFadeOut = 0.5f * (sqrtFadeOut + ((1.0f-smoothFract) / sqrtFadeOut));
            fadeInGain = (fadeOutGain * imaginaryFadePart) + (fadeInGain * realFadePart);
            fadeOutGain = (realFadePart * fadeOutGain) - (imaginaryFadePart * fadeInGain);
        }

        // write the output samples into the output stream
        if (replacing)
        {
            outputs[0][samplecount] = (out1 * outputGain) + (inputs[0][samplecount] * inputGain);
#ifdef BUFFEROVERRIDE_STEREO
            outputs[1][samplecount] = (out2 * outputGain) + (inputs[1][samplecount] * inputGain);
#endif
        }
        else
        {
            outputs[0][samplecount] += (out1 * outputGain) + (inputs[0][samplecount] * inputGain);
#ifdef BUFFEROVERRIDE_STEREO
            outputs[1][samplecount] += (out2 * outputGain) + (inputs[1][samplecount] * inputGain);
#endif
        }

        // increment the position trackers
        readPos++;
        writePos++;
    }


//-----------------------MIDI STUFF---------------------------
    // check to see if there may be a note or pitchbend message left over that hasn't been implemented
    if (midistuff->numBlockEvents > 0)
    {
        long eventcount;
        for (eventcount = 0; eventcount < midistuff->numBlockEvents; eventcount++)
        {
            if (isNote(midistuff->blockEvents[eventcount].status))
            {
                // regardless of whether it's a note-on or note-off, we've found some note message
                oldNote = true;
                // store the note & update the notes table if it's a note-on message
                if (midistuff->blockEvents[eventcount].status == kMidiNoteOn)
                {
                    midistuff->insertNote(midistuff->blockEvents[eventcount].byte1);
                    lastNoteOn = midistuff->blockEvents[eventcount].byte1;
                    // since we're not doing the fDivisor updating yet, this needs to be falsed
                    divisorWasChangedByHand = false;
                }
                // otherwise remove the note from the notes table
                else
                    midistuff->removeNote(midistuff->blockEvents[eventcount].byte1);
            }
            else if (midistuff->blockEvents[eventcount].status == ccAllNotesOff)
            {
                oldNote = true;
                midistuff->removeAllNotes();
            }
        }
        for (eventcount = (midistuff->numBlockEvents-1); (eventcount >= 0); eventcount--)
        {
            if (midistuff->blockEvents[eventcount].status == kMidiPitchbend)
            {
                // set this pitchbend message as lastPitchbend
                lastPitchbend = midistuff->blockEvents[eventcount].byte2;
                break;	// leave this for loop
            }
        }
    }

    // always reset numBlockEvents because processEvents() may not get called before the next process()
    midistuff->numBlockEvents = 0;
}
Esempio n. 6
0
  void Parser::parse()
  {
    // read the header, handling only strings and tune tempo
    while (lex.symType() == COMMENT
           || lex.symType() == STRING
           || lex.symType() == TEMPO)
    {
      if (lex.symType() == STRING)
        parseString();
      else if (lex.symType() == TEMPO)
        parseTempo();
      else if (lex.symType() == COMMENT)
        lex.getSym();
    }
    qDebug() << "Parser::parse()"
        << "title:" << title
        << "type:" << type
        << "composer:" << composer
        << "footer:" << footer
        ;
    wrt.header(title, type, composer, footer, tempo);

    // read the actual music
    if (lex.symType() != CLEF)
      errorHandler("clef ('&') expected");
    while (lex.symType() != NONE)
    {
      if (isNonNote(lex.symType()))
        parseSeqNonNotes();
      else if (isNote(lex.symType()))
        parseSeqNotes();
      else if (lex.symType() == UNKNOWN)
      {
        errorHandler("unknown symbol '" + lex.symValue() + "'");
        lex.getSym();
      }
      else
      {
        ; // others not implemented yet: silently ignored
        lex.getSym();
      }
    }

    qDebug() << "Parser::parse() finished, #measures" << measures.size()
        ;

    calculateMeasureDurations(measures);
    if (!tsigFound)
    {
      determineTimesig(measures, beats, beat);
      wrt.tsig(beats, beat);
    }
    findIrregularMeasures(measures, beats, beat);
    determineBeamStates(measures);
    setLastOfPart(measures);
    dumpMeasures(measures);
    dumpBeams(measures);

    for (int j = 0; j < measures.size(); ++j)
    {
      wrt.beginMeasure(measures.at(j).mbf);
      for (int i = 0; i < measures.at(j).notes.size(); ++i)
      {
        wrt.note(measures.at(j).notes.at(i).pitch,
                 measures.at(j).notes.at(i).beamList,
                 measures.at(j).notes.at(i).type,
                 measures.at(j).notes.at(i).dots,
                 measures.at(j).notes.at(i).tieStart,
                 measures.at(j).notes.at(i).tieStop,
                 measures.at(j).notes.at(i).triplet,
                 measures.at(j).notes.at(i).grace
                 );
      }
      wrt.endMeasure(measures.at(j).mef);
    }

    // trailer
    wrt.trailer();
  }