equalization.cpp

Audacity是一款用於錄音和編輯聲音的、免費的開放源碼軟體。它可以執行於Mac OS X、Microsoft Windows、GNU/Linux和其它作業系統

   wxColour bkgnd = GetBackgroundColour();
   wxBrush bkgndBrush(bkgnd, wxSOLID);

   wxMemoryDC memDC;
   memDC.SelectObject(*mBitmap);

   wxRect bkgndRect;
   bkgndRect.x = 0;
   bkgndRect.y = 0;
   bkgndRect.width = 40;
   bkgndRect.height = mHeight;
   memDC.SetBrush(bkgndBrush);
   memDC.SetPen(*wxTRANSPARENT_PEN);
   memDC.DrawRectangle(bkgndRect);

   bkgndRect.y = mHeight - 20;
   bkgndRect.width = mWidth;
   bkgndRect.height = 20;
   memDC.DrawRectangle(bkgndRect);

   wxRect border;
   border.x = 40;
   border.y = 0;
   border.width = mWidth;
   border.height = mHeight - 20;

   memDC.SetBrush(*wxWHITE_BRUSH);
   memDC.SetPen(*wxBLACK_PEN);
   memDC.DrawRectangle(border);

   mEnvRect.x = 44;
   mEnvRect.width = mWidth - 50;
   mEnvRect.y = 3;
   mEnvRect.height = mHeight - 26;

   // Pure blue x-axis line
   memDC.SetPen(wxPen(wxColour(0, 0, 255), 1, wxSOLID));
   int center = mEnvRect.height/2;
   memDC.DrawLine(mEnvRect.x, mEnvRect.y + center,
                  mEnvRect.x + mEnvRect.width, mEnvRect.y + center);

   // Med-blue envelope line
   memDC.SetPen(wxPen(wxColour(110, 110, 220), 3, wxSOLID));

   // Draw envelope
   double *values = new double[mEnvRect.width];
   mEnvelope->GetValues(values, mEnvRect.width, 0.0, 1.0/mEnvRect.width);
   int x, y, xlast = 0, ylast = 0;
   for(int i=0; i<mEnvRect.width; i++) {
      x = mEnvRect.x + i;
      y = (int)(mEnvRect.height-mEnvRect.height*values[i]);
      if (i != 0) {
         memDC.DrawLine(xlast, ylast,
                        x, mEnvRect.y + y);
      }
      xlast = x;
      ylast = y;
   }
   delete[] values;

   memDC.SetPen(*wxBLACK_PEN);
   mEnvRect.y -= 5;
   mEnvelope->Draw(memDC, mEnvRect, 0.0, mEnvRect.width, false, 0.0, 1.0);
   mEnvRect.y += 5;

   // Paint border again
   memDC.SetBrush(*wxTRANSPARENT_BRUSH);
   memDC.SetPen(*wxBLACK_PEN);
   memDC.DrawRectangle(border);

   // Ruler

   Ruler dbRuler;
   dbRuler.SetBounds(0, 0, 40, mHeight-21);
   dbRuler.SetOrientation(wxVERTICAL);
   dbRuler.SetRange(30, -30);
   dbRuler.SetFormat(Ruler::LinearDBFormat);
   dbRuler.SetUnits(wxT("dB"));
   dbRuler.Draw(memDC);

   Ruler freqRuler;
   freqRuler.SetBounds(41, mHeight-20, mWidth, mHeight);
   freqRuler.SetOrientation(wxHORIZONTAL);
   freqRuler.SetLog(true);
   freqRuler.SetRange(mLoFreq, mHiFreq);
   freqRuler.SetFormat(Ruler::IntFormat);
   freqRuler.SetUnits(wxT("Hz"));
   freqRuler.SetFlip(true);
   freqRuler.Draw(memDC);

   dc.Blit(0, 0, mWidth, mHeight,
           &memDC, 0, 0, wxCOPY, FALSE);
}

void EqualizationPanel::OnMouseEvent(wxMouseEvent & event)
{
   if (event.ButtonDown()) {
      CaptureMouse();
   }

   if (mEnvelope->MouseEvent(event, mEnvRect, 0.0, mEnvRect.width, false,
                             0.0, 1.0))
      Refresh(false);

   if (event.ButtonUp()) {
      ReleaseMouse();
   }
}

// WDR: class implementations

//----------------------------------------------------------------------------
// EqualizationDialog
//----------------------------------------------------------------------------

// WDR: event table for EqualizationDialog

BEGIN_EVENT_TABLE(EqualizationDialog,wxDialog)
   EVT_BUTTON( wxID_OK, EqualizationDialog::OnOk )
   EVT_BUTTON( wxID_CANCEL, EqualizationDialog::OnCancel )
   EVT_SIZE( EqualizationDialog::OnSize )
   EVT_BUTTON( ID_CLEAR, EqualizationDialog::OnClear )
   EVT_BUTTON( ID_LOADCURVE, EqualizationDialog::OnLoadCurve )
	EVT_BUTTON(ID_BUTTON_PREVIEW, EqualizationDialog::OnPreview)
END_EVENT_TABLE()

EqualizationDialog::EqualizationDialog(EffectEqualization * effect,
					double loFreq, double hiFreq,
					float *filterFunc,
					long windowSize,
					wxWindow *parent, wxWindowID id,
					const wxString &title,
					const wxPoint &position,
					const wxSize& size,
					long style):
   wxDialog( parent, id, title, position, size, style | wxRESIZE_BORDER )
{
	m_pEffect = effect;

   mEnvelope = new Envelope();
   mEnvelope->SetInterpolateDB(false);
   mEnvelope->Mirror(false);

   MakeEqualizationDialog(loFreq, hiFreq,
			  mEnvelope,
			  &mPanel,
			  this);

   mLoFreq = loFreq;
   mHiFreq = hiFreq;

   mFilterFunc = filterFunc;
   mWindowSize = windowSize;
}

bool EqualizationDialog::Validate()
{
   return TRUE;
}

bool EqualizationDialog::TransferDataToWindow()
{
   return TRUE;
}

bool EqualizationDialog::TransferDataFromWindow()
{
   double loLog = log10(mLoFreq);
   double hiLog = log10(mHiFreq);
   double denom = hiLog - loLog;

   double delta = mHiFreq / ((double)(mWindowSize/2.));
   double val0 = 30.*((mEnvelope->GetValue(0.0))-0.5);
   double val1 = 30.*((mEnvelope->GetValue(1.0))-0.5);

   mFilterFunc[0] = val0;
   double freq = delta;

   int i;
   for(i=1; i<=mWindowSize/2; i++) {
      double when = (log10(freq) - loLog)/denom;
      if(when < 0.) {
         mFilterFunc[i] = val0;
      }
      else if(when > 1.0) {
	 mFilterFunc[i] = val1;
      }
      else {
	 mFilterFunc[i] = 30.*((mEnvelope->GetValue(when))-0.5);
      }
      freq += delta;
   }

   for(i=0;i<mWindowSize/2;i++) {
      mFilterFunc[i] = (float)(pow(10., mFilterFunc[i]/20.));
   }

   return TRUE;
}

// WDR: handler implementations for EqualizationDialog

void EqualizationDialog::OnClear( wxCommandEvent &event )
{
   mEnvelope->Flatten(0.5);
   mEnvelope->SetTrackLen(1.0);
   mPanel->Refresh(false);
}

void EqualizationDialog::OnSize(wxSizeEvent &event)
{
   event.Skip();
}

void EqualizationDialog::OnPreview(wxCommandEvent &event)
{
   TransferDataFromWindow();
	m_pEffect->Preview();
	//v Restore previous values?
}

void EqualizationDialog::OnOk(wxCommandEvent &event)
{
   TransferDataFromWindow();

   if (Validate()) {
     if(mEnvelope)
        delete mEnvelope;
     mEnvelope = NULL;
     mPanel = NULL;

     EndModal(true);
   }
   else {
      event.Skip();
   }
}

void EqualizationDialog::OnCancel(wxCommandEvent &event)
{
   if(mEnvelope)
     delete mEnvelope;
   mEnvelope = NULL;
   mPanel = NULL;

   EndModal(false);
}


void EqualizationDialog::OnLoadCurve(wxCommandEvent &event)
{
   setCurve(mEnvelope, predefined->GetSelection());
   mPanel->Refresh(false);
}


void EqualizationDialog::setCurve(Envelope *env, int currentCurve)
{
   env->Flatten(0.5);
   env->SetTrackLen(1.0);

   double when = 0.;
   double value = (EffectEqualization::curvey[currentCurve][0]/60.) + 0.5;
   env->Move(when, value);
   double loLog = log10(20.);
   double hiLog = log10(mHiFreq);
   double denom = hiLog - loLog;
   int i;
   for(i=0;i<EffectEqualization::nCurvePoints;i++) {
      when = (log10(EffectEqualization::curvex[i]) - loLog)/denom;
      value = (EffectEqualization::curvey[currentCurve][i]/60.) + 0.5;
      if(when < 1)
	 env->Insert(when, value);
      else
	 break;
   }
   i--;
   when = 1.;
   value = (EffectEqualization::curvey[currentCurve][i]/60.) + 0.5;
   env->Move(when, value);
}


wxSizer * MakeEqualizationDialog(
				 double loFreq, double hiFreq,
				 Envelope *env,
				 EqualizationPanel **pan,
				 wxWindow *parent, bool call_fit,
				 bool set_sizer )
{
   wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );

	wxStaticText *item1 =
		new wxStaticText(parent, -1,
							  _("Equalization, by Mitch Golden && Vaughan Johnson"),
							  wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER);
	item0->Add( item1, 0, wxALIGN_CENTRE|wxALL, 4 );

   (*pan) = new EqualizationPanel( loFreq, hiFreq,
				   env,
				   parent, ID_FILTERPANEL,
				   wxDefaultPosition, wxSize(100,80) );
   wxWindow *item2 = (*pan);
   wxASSERT( item2 );
   item0->Add( item2, 1, wxGROW|wxALIGN_CENTRE|wxALL, 4);


   wxBoxSizer *item3 = new wxBoxSizer( wxHORIZONTAL );

   wxButton *item4a = new wxButton( parent, ID_LOADCURVE, _("Load Predefined Curve"),
                       wxDefaultPosition, wxDefaultSize, 0 );
   item3->Add( item4a, 0, wxALIGN_CENTRE|wxLEFT, 4);

   item3->Add(80, 4); // horizontal spacer

   wxButton *item4b = new wxButton( parent, ID_CLEAR, _("Clear"),
                       wxDefaultPosition, wxDefaultSize, 0 );
   item3->Add( item4b, 0, wxALIGN_CENTRE|wxRIGHT, 4);

   item0->Add( item3, 0, wxALIGN_CENTER | wxALL, 0);


	// predefined curves
	wxBoxSizer *item9 = new wxBoxSizer( wxVERTICAL );

   wxString formats[EffectEqualization::nCurveTypes];
   int i;

   for(i=0;i<EffectEqualization::nCurveTypes;i++) {
     formats[i] = EffectEqualization::curveNames[i];
   }

   wxRadioBox *predefined = new wxRadioBox(parent, -1, _("Predefined:"),
			       wxDefaultPosition, wxDefaultSize,
			       EffectEqualization::nCurveTypes,
			       formats,
			       3,
			       wxRA_SPECIFY_COLS);

   ((EqualizationDialog *)parent)->predefined = predefined;

   item9->Add(predefined, 0, wxALIGN_CENTER | wxALL, 4);

   item0->Add( item9, 0, wxGROW|wxALIGN_CENTER, 4);


	// Preview, OK, & Cancel buttons
   wxBoxSizer * pBoxSizer_OK = new wxBoxSizer(wxHORIZONTAL);

   wxButton * pButton_Preview =
		new wxButton(parent, ID_BUTTON_PREVIEW,
							_("Preview"), //v Should be m_pEffect->GetPreviewName());
							wxDefaultPosition, wxDefaultSize, 0);
   pBoxSizer_OK->Add(pButton_Preview, 0, wxALIGN_LEFT | wxALL, 4);

   pBoxSizer_OK->Add(80, 4); // horizontal spacer

   wxButton * pButton_Cancel =
       new wxButton(parent, wxID_CANCEL, _("Cancel"),
							wxDefaultPosition, wxDefaultSize, 0);
   pBoxSizer_OK->Add(pButton_Cancel, 0, wxALIGN_RIGHT | wxALL, 4);

   wxButton * pButton_OK =
		new wxButton(parent, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0);
   pButton_OK->SetDefault();
   pButton_OK->SetFocus();
   pBoxSizer_OK->Add(pButton_OK, 0, wxALIGN_RIGHT | wxALL, 4);

   item0->Add(pBoxSizer_OK, 0, wxALIGN_CENTER | wxALL, 4);


   if (set_sizer)
      {
         parent->SetSizer( item0 );
         if (call_fit)
            {
               item0->Fit( parent );
               item0->SetSizeHints( parent );
            }
      }

   return item0;
}

// Indentation settings for Vim and Emacs and unique identifier for Arch, a
// version control system. Please do not modify past this point.
//
// Local Variables:
// c-basic-offset: 3
// indent-tabs-mode: nil
// End:
//
// vim: et sts=3 sw=3
// arch-tag: 65b35bfa-632c-46fe-9170-840a158b3c97