예제 #1
0
파일: Actions.cpp 프로젝트: majeski/NUBZ
boost::optional<Actions::Action> Actions::getOpt(std::int32_t ID) {
    if (auto res = Impl::get(session, ID)) {
        return fromDB(res.value());
    } else {
        return {};
    }
}
예제 #2
0
/// ValueOfPixel() converts a y position on screen to an envelope value.
/// @param y - y position, usually of the mouse.relative to the clip.
/// @param height - height of the rectangle we are in.
/// @upper - true if we are on the upper line, false if on lower.
/// @dB - display mode either linear or log.
/// @zoomMin - vertical scale, typically -1.0
/// @zoomMax - vertical scale, typically +1.0
/// @eMin - clips result to this range.
/// @eMax - clips result to this range.
float Envelope::ValueOfPixel( int y, int height, bool upper, bool dB,
                              float zoomMin, float zoomMax, float eMin, float eMax )
{
    float v;

    wxASSERT( height > 0 );
    v = zoomMax - (y/(float)height) * (zoomMax - zoomMin);

    if (mContourOffset) {
        if( v > 0.0 )
            v += .5;
        else
            v -= .5;
    }
    if (dB)
        v = fromDB(v);

    // JC: The eMin/eMax code originally assumed a symmetrical range.
    // so only eMin was needed.  I'm very dubious about the lower curve
    // behaviour and expect some funny behaviour when dragging
    // the lower curve when we have asymmetric ranges.

    // Upper curve: gets clamped between eMin and eMax.  Looks OK.
    // Lower curve: reset to eMin if > 0 otherwise made positive and <=eMax.
    if ((upper && v < eMin) || (!upper && v > 0))
        v = eMin;
    else if (!upper)
        v = -v;

    if(v > eMax)
        v = eMax;

    return v;
}
예제 #3
0
void PowerJuiceX2Plugin::d_setParameterValue(uint32_t index, float value)
{
    switch (index)
    {
    case paramAttack:
        attack = value;
        attackSamples = d_getSampleRate()*(attack/1000.0f);
        break;
    case paramRelease:
        release = value;
        releaseSamples = d_getSampleRate()*(release/1000.0f);
        break;
    case paramThreshold:
        threshold = value;
        break;
    case paramRatio:
        ratio = value;
        break;
    case paramMakeup:
        makeup = value;
        makeupFloat = fromDB(makeup);
        break;
    case paramMix:
        mix = value;
        break;
    }
}
예제 #4
0
파일: Reports.cpp 프로젝트: majeski/NUBZ
boost::optional<Reports::Report> Reports::get(std::int32_t ID) {
    auto sql = Table::Sql::select().where(Table::ID == ID);
    if (auto dbTuple = session.getResult(sql)) {
        return fromDB(dbTuple.value());
    } else {
        return {};
    }
}
예제 #5
0
float Envelope::ValueOfPixel( int y, int height, bool upper, bool dB,
                              float zoomMin, float zoomMax, float eMin ) {
    float v;

    v = zoomMax - (y/(float)height) * (zoomMax - zoomMin);

    if (mContourOffset) {
        if( v > 0.0 )
            v += .5;
        else
            v -= .5;
    }
    if (dB)
        v = fromDB(v);

    if ((upper && v < eMin) || (!upper && v > 0))
        v = eMin;
    else if (!upper)
        v = -v;

    return v;
}
예제 #6
0
/// ValueOfPixel() converts a y position on screen to an envelope value.
/// @param y - y position, usually of the mouse.relative to the clip.
/// @param height - height of the rectangle we are in.
/// @upper - true if we are on the upper line, false if on lower.
/// @dB - display mode either linear or log.
/// @zoomMin - vertical scale, typically -1.0
/// @zoomMax - vertical scale, typically +1.0
float Envelope::ValueOfPixel( int y, int height, bool upper, bool dB,
                              float zoomMin, float zoomMax)
{
   float v;

   wxASSERT( height > 0 );
   v = zoomMax - (y/(float)height) * (zoomMax - zoomMin);

   if (mContourOffset) {
     if( v > 0.0 )
       v += .5;
     else
       v -= .5;
   }
   if (dB)
      v = fromDB(v);

   // MB: this is mostly equivalent to what the old code did, I'm not sure
   // if anything special is needed for asymmetric ranges
   if(upper)
      return ClampValue(v);
   else
      return ClampValue(-v);
}
예제 #7
0
// Returns true if parent needs to be redrawn
bool Envelope::MouseEvent(wxMouseEvent & event, wxRect & r,
                          double h, double pps, bool dB)
{
   //h -= mOffset;

   int ctr, height;
   bool upper;
   if (mMirror) {
      height = r.height / 2;
      ctr = r.y + height;
      upper = (event.m_y < ctr);
   }
   else {
      height = r.height;
      ctr = r.y + height;
      upper = true;
   }

   if (event.ButtonDown()) {
      mIsDeleting = false;
      double tleft = h - mOffset;
      double tright = tleft + (r.width / pps);
      int bestNum = -1;
      int bestDist = 10;

      int len = mEnv.Count();
      for (int i = 0; i < len; i++) {
         if (mEnv[i]->t >= tleft && mEnv[i]->t <= tright) {
            double v = mEnv[i]->val;
            int x = int ((mEnv[i]->t + mOffset - h) * pps) + r.x;
            int dy;

            if (dB)
               dy = int (toDB(v) * height);
            else
            dy = int (v * height);

            int y;
            if (upper)
               y = int (ctr - dy);
            else
            y = int (ctr + dy);

#ifndef SQR
#define SQR(X) ((X)*(X))
#endif

            int d =
                int (sqrt(SQR(x - event.m_x) + SQR(y - event.m_y)) + 0.5);
            if (d < bestDist) {
               bestNum = i;
               bestDist = d;
            }
         }
      }

      if (bestNum >= 0) {
         mDragPoint = bestNum;
      } else {
         // Create new point
         double when = h + (event.m_x - r.x) / pps - mOffset;

         int dy;
         if (upper)
            dy = ctr - event.m_y;
         else
            dy = event.m_y - ctr;

         double newVal;

         if (dB)
            newVal = fromDB(dy / double (height));
         else
            newVal = dy / double (height);

         if (newVal < 0.0)
            newVal = 0.0;
         if (newVal > 1.0)
            newVal = 1.0;

         mDragPoint = Insert(when, newVal);
         mDirty = true;
      }

      mUpper = upper;

      mInitialWhen = mEnv[mDragPoint]->t;
      mInitialVal = mEnv[mDragPoint]->val;

      mInitialX = event.m_x;
      mInitialY = event.m_y;

      return true;
   }

   if (event.Dragging() && mDragPoint >= 0) {
      mDirty = true;

      wxRect larger = r;
      larger.Inflate(5, 5);

      if (!mIsDeleting &&
          mDragPoint > 0 && mDragPoint < mEnv.Count() - 1 &&
          !larger.Inside(event.m_x, event.m_y)) {

         mEnv[mDragPoint]->t = mEnv[mDragPoint - 1]->t;
         mEnv[mDragPoint]->val = mEnv[mDragPoint - 1]->val;

         mIsDeleting = true;

         return true;
      }

      if (larger.Inside(event.m_x, event.m_y))
         mIsDeleting = false;

      if (mIsDeleting)
         return false;

      int y;
      if (mUpper)
         y = ctr - event.m_y;
      else
         y = event.m_y - ctr;

      double newVal;

      if (dB)
         newVal = fromDB(y / double (height));
      else
         newVal = y / double (height);

      if (newVal < 0.0)
         newVal = 0.0;
      if (newVal > 1.0)
         newVal = 1.0;

      double newWhen = mInitialWhen + (event.m_x - mInitialX) / pps;

      if (mDragPoint > 0 && newWhen < mEnv[mDragPoint - 1]->t)
         newWhen = mEnv[mDragPoint - 1]->t;

      if (mDragPoint < mEnv.Count() - 1
          && newWhen > mEnv[mDragPoint + 1]->t)
         newWhen = mEnv[mDragPoint + 1]->t;

      if (mDragPoint == 0)
         newWhen = 0;

      if (mDragPoint == mEnv.Count() - 1)
         newWhen = mTrackLen;

      mEnv[mDragPoint]->t = newWhen;
      mEnv[mDragPoint]->val = newVal;

      return true;
   }

   if (event.ButtonUp()) {
      if (mIsDeleting) {
         delete mEnv[mDragPoint];
         mEnv.RemoveAt(mDragPoint);
      }
      mDragPoint = -1;
      return true;
   }

   return false;
}
예제 #8
0
void PowerJuiceX2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames)
{
    const float* in1 = inputs[0];
    const float* in2 = inputs[1];
    float* out1 = outputs[0];
    float* out2 = outputs[1];
    float sum;
    float data;
    float difference;


    for (uint32_t i=0; i < frames; i++) {

        sum = 0.0f;
        data = 0.0f;
        difference = 0;
        //sanitizeDenormal(in1[i]); // FIXME - you cannot modify inputs
        //sanitizeDenormal(in2[i]); // FIXME - you cannot modify inputs

        /*   compute last RMS   */

        //store audio samples in an RMS buffer line
        RMSStack.data[RMSStack.start++] = std::max(in1[i], in2[i]);
	   
        if (RMSStack.start == kFloatRMSStackCount)
                RMSStack.start = 0;
        //compute RMS over last kFloatRMSStackCount samples
        for (int j=0; j < kFloatRMSStackCount; ++j) {
            data = RMSStack.data[(RMSStack.start+j) % kFloatRMSStackCount];
            sum += data * data;
        }
	   
        //root mean SQUARE
          float RMS = sqrt(sum / kFloatRMSStackCount);
        sanitizeDenormal(RMS);
		

        /*   compute gain reduction if needed   */
        float RMSDB = toDB(RMS);
	   
        if (RMSDB>threshold) {
            //attack stage
            float difference = (RMSDB-threshold);
		  
            //sanitizeDenormal(difference);
            targetGR = difference - difference/ratio;
            if (targetGR>difference/(ratio/4.0f)) {
                targetGR = difference - difference/(ratio*1.5f);
                //more power!
            }
		  //
            if (GR<targetGR) {
                //approach targetGR at attackSamples rate
                GR -= (GR-targetGR)/(attackSamples);
            } else {
                //approach targetGR at releaseSamples rate
                GR -= (GR-targetGR)/releaseSamples;
            }
		  
            sanitizeDenormal(GR);
        } else {
            //release stage
            //approach targetGR at releaseSamples rate, targetGR = 0.0f
            GR -= GR/releaseSamples;
        }
		
        //store audio in lookahead buffer
	   
        lookaheadStack.data[lookaheadStack.start++] = std::max(in1[i], in2[i]);
	   //printf("rms\n");
        if (lookaheadStack.start == kFloatLookaheadStackCount)
                lookaheadStack.start = 0;
		
        if (++averageCounter >= refreshSkip) {
		  
            //add relevant values to the shared memory
            rms.data[rms.start++] = RMSDB;
            gainReduction.data[gainReduction.start++] = GR;
		  

            //rewind stack reading heads if needed
            if (rms.start == kFloatStackCount)
                rms.start = 0;
            if (gainReduction.start == kFloatStackCount)
                gainReduction.start = 0;


            //saving in gfx format, for speed
            //share memory

            for (int j=0; j < kFloatStackCount; ++j)
                history.rms[j] = -toIEC(rms.data[(rms.start+j) % kFloatStackCount])/200*h +h +y;
            for (int j=0; j < kFloatStackCount; ++j) {
                history.gainReduction[j] = -toIEC(-gainReduction.data[(gainReduction.start+j) % kFloatStackCount])/200*h +h +y;
			
		  }
			
			repaintSkip++;
			if (repaintSkip>5) {
				repaintSkip = 0;
				newRepaint = true;
			}
			
            averageCounter = 0;
            inputMax = 0.0f;
        }

        /* compress, mix, done. */
	   float realGR = fromDB(-GR);
        float compressedSignal1 = in1[i]*realGR;
	   float compressedSignal2 = in2[i]*realGR;
        out1[i] = (compressedSignal1*makeupFloat*mix)+in1[i]*(1-mix);
	   out2[i] = (compressedSignal2*makeupFloat*mix)+in2[i]*(1-mix);
    }
}
예제 #9
0
void PowerJuiceX2Plugin::d_setProgram(uint32_t index)
{
    if (index != 0)
        return;

    /* Default parameter values */
    attack = 20.0f;
    release = 200.0f;
    threshold = 0.0f;
    ratio = 1.0f;
    makeup = 0.0f;
    mix = 1.0f;

    makeupFloat = fromDB(makeup);
    attackSamples = d_getSampleRate()*(attack/1000.0f);
    releaseSamples = d_getSampleRate()*(release/1000.0f);

	

    w = 563; //waveform plane size, size of the plane in pixels;
    w2 = 1126; //wavefowm array
    h = 121; //waveform plane height
    x = 27; //waveform plane positions
    y = 53;
    dc = 113; //0DC line y position
	
    /* Default variable values */
    averageCounter = 0;
    inputMax = 0.0f;

    balancer = 1.0f;
    GR = 1.0f;

	newRepaint = false;

    input.start = 0;
    rms.start = 0;
    gainReduction.start = 0;
    RMSStack.start = 0;
    lookaheadStack.start = 0;
    repaintSkip = 0;
    
    
    kFloatRMSStackCount = 400.0f/44100.0f*d_getSampleRate();
    RMSStack.data = (float*) calloc(kFloatRMSStackCount, sizeof(float));
    
    kFloatLookaheadStackCount = 800.0f/44100.0f*d_getSampleRate();
    lookaheadStack.data = (float*) calloc(kFloatLookaheadStackCount, sizeof(float));
    
    refreshSkip= 300.0f/44100.0f*d_getSampleRate();
    
    std::memset(rms.data, 0, sizeof(float)*kFloatStackCount);
    std::memset(gainReduction.data, 0, sizeof(float)*kFloatStackCount);
    std::memset(RMSStack.data, 0, sizeof(float)*kFloatRMSStackCount);
    std::memset(lookaheadStack.data, 0, sizeof(float)*kFloatLookaheadStackCount);
    
	for (int j=0; j < kFloatStackCount; ++j)
		history.rms[j] = h +y;
	for (int j=0; j < kFloatStackCount; ++j) 
		history.gainReduction[j] = h +y;

    d_activate();
    
}