~ubuntu-branches/ubuntu/gutsy/audacity/gutsy-backports

#include <wx/sstream.h>

#include <wx/txtstrm.h>

#include "Project.h"

#include "toolbars/ControlToolBar.h"

#include "../Experimental.h"

   if (mPortMixer) {

         mPreviousHWPlaythrough = -1.0;

      mPortMixer = NULL;

   if (IsStreamActive())

   if (mPortMixer) {

      #if __WXMAC__

      if (Px_SupportsPlaythrough(mPortMixer) && mPreviousHWPlaythrough >= 0.0)

         Px_SetPlaythrough(mPortMixer, mPreviousHWPlaythrough);

         mPreviousHWPlaythrough = -1.0;

      #endif

      mPortMixer = NULL;

   }

         Pa_GetDeviceInfo(recDeviceNum)->defaultLowInputLatency;

#ifdef EXPERIMENTAL_SMART_RECORD

   gPrefs->Read(wxT("/AudioIO/PauseRecOnSilence"), &mPauseRec, false);

   int silenceLevelDB;

   gPrefs->Read(wxT("/AudioIO/SilenceLevel"), &silenceLevelDB, -50);

   mSilenceLevel = (silenceLevelDB + 60.)/60.;  // meter goes -60dB -> 0dB

#endif

 

   mTimeTrack = timeTrack;

   double factor = 1.0;

   if (mTimeTrack) {

      factor = mTimeTrack->GetEnvelope()->Average(mT0, mT1);

      factor = (mTimeTrack->GetRangeLower() *

               (1 - factor) +

               factor *

               mTimeTrack->GetRangeUpper()) / 

               100.0;

   mWarpedT1 = factor >= 1 ? mT1 : mT0 + ((mT1 - mT0) / factor);

                                         mTimeTrack, mT0, mWarpedT1, 1,

         mPreviousHWPlaythrough = -1.0;

         //

         // We only apply latency correction when we actually played back

         // tracks during the recording. If we did not play back tracks,

         // there's nothing we could be out of sync with. This also covers the

         // case that we do not apply latency correction when recording the

         // first track in a project.

         //

         double latencyCorrection = 0;

         gPrefs->Read(wxT("/AudioIO/LatencyCorrection"), &latencyCorrection);

         

         double recordingOffset =

            mLastRecordingOffset + latencyCorrection / 1000.0;

 

               

               WaveTrack* track = mCaptureTracks[i];

               track->Flush();

 

               if (mPlaybackTracks.GetCount() > 0)

               {  // only do latency correction if some tracks are being played back

                  WaveTrackArray playbackTracks;

                  AudacityProject *p = GetActiveProject();

                  // we need to get this as mPlaybackTracks does not contain tracks being recorded into

                  playbackTracks = p->GetTracks()->GetWaveTrackArray(false);

                  bool appendRecord = false;

                  for( unsigned int j = 0; j < playbackTracks.GetCount(); j++)

                  {  // find if we are recording into an existing track (append-record)

                     WaveTrack* trackP = playbackTracks[j];

                     if( track == trackP )

                     {

                        if( track->GetStartTime() != mT0 )  // in a new track if these are equal

                        {

                           appendRecord = true;

                           break;

                        }

                     }

                  }

                  if( appendRecord )

                  {  // append-recording

                     if (recordingOffset < 0)

                        track->Clear(mT0, mT0 - recordingOffset); // cut the latency out

                     else

                        track->InsertSilence(mT0, recordingOffset); // put silence in

                  }

                  else

                  {  // recording into a new track

                     track->SetOffset(track->GetStartTime() + recordingOffset);

                     if(track->GetEndTime() < 0.)

                     {

                        wxMessageDialog m(NULL, _("Latency setting has caused the recorded audio to be hidden before zero.\nAudacity has brought it back to start at zero.\nYou may have to use the Time Shift Tool (<---> or F5) to drag the track to the right place."), _("Latency problem"), wxOK);

                        m.ShowModal();

                        track->SetOffset(0.);

                     }

                  }

               }

   if (absoluteTime > mT1)

      absoluteTime = mT1;

wxString AudioIO::GetDeviceInfo()

{

   wxStringOutputStream o;

   wxTextOutputStream s(o, wxEOL_UNIX);

   wxString e(wxT("\n"));

 

   if (IsStreamActive()) {

      return wxT("Stream is active ... unable to gather information.");

   }

 

#if defined(USE_PORTMIXER)

   const PaDeviceInfo* info;

 

#if USE_PORTAUDIO_V19

   int recDeviceNum = Pa_GetDefaultInputDevice();

   int playDeviceNum = Pa_GetDefaultOutputDevice();

#else

   int recDeviceNum = Pa_GetDefaultInputDeviceID();

   int playDeviceNum = Pa_GetDefaultOutputDeviceID();

#endif

 

   s << wxT("==============================") << e;

   s << wxT("Default capture device number: ") << recDeviceNum << e;

   s << wxT("Default playback device number: ") << playDeviceNum << e;

 

   // Sometimes PortAudio returns -1 if it cannot find a suitable default

   // device, so we just use the first one available

   if (recDeviceNum < 0)

      recDeviceNum = 0;

   if (playDeviceNum < 0)

      playDeviceNum = 0;

      

   wxString recDevice = gPrefs->Read(wxT("/AudioIO/RecordingDevice"), wxT(""));

   wxString playDevice = gPrefs->Read(wxT("/AudioIO/PlaybackDevice"), wxT(""));

   int j;

 

   // msmeyer: This tries to open the device with the highest samplerate

   // available on this device, using 44.1kHz as the default, if the info

   // cannot be fetched.

 

#if USE_PORTAUDIO_V19

   int cnt = Pa_GetDeviceCount();

#else

   int cnt = Pa_CountDevices();

#endif

 

   if (cnt <= 0) {

      s << wxT("No devices found\n");

      return o.GetString();

   }

      

   for (j = 0; j < cnt; j++) {

      s << wxT("==============================") << e;

 

      info = Pa_GetDeviceInfo(j);

      if (!info) {

         s << wxT("Device info unavailable for: ") << j << wxT("\n");

         continue;

      }

 

      wxString name = DeviceName(info);

 

      s << wxT("Device ID: ") << j << e;

      s << wxT("Device name: ") << name << e;

      s << wxT("Input channels: ") << info->maxInputChannels << e;

      s << wxT("Output channels: ") << info->maxOutputChannels << e;

      s << wxT("Low Input Latency: ") << info->defaultLowInputLatency << e;

      s << wxT("Low Output Latency: ") << info->defaultLowOutputLatency << e;

      s << wxT("High Input Latency: ") << info->defaultHighInputLatency << e;

      s << wxT("High Output Latency: ") << info->defaultHighOutputLatency << e;

 

      wxArrayLong rates = GetSupportedPlaybackRates(name, 0.0);

 

      s << wxT("Supported Rates:") << e;

      for (int k = 0; k < (int) rates.GetCount(); k++) {

         s << wxT("    ") << (int)rates[k] << e;

      }

 

      if (name == playDevice && info->maxOutputChannels > 0)

         playDeviceNum = j;

 

      if (name == recDevice && info->maxInputChannels > 0)

         recDeviceNum = j;

   }

 

   s << wxT("==============================") << e;

   s << wxT("Selected capture device: ") << recDeviceNum << wxT(" - ") << recDevice << e;

   s << wxT("Selected playback device: ") << playDeviceNum << wxT(" - ") << playDevice << e;

 

   wxArrayLong supportedSampleRates = GetSupportedSampleRates(playDevice, recDevice);

 

   s << wxT("Supported Rates:");

   for (int k = 0; k < (int) supportedSampleRates.GetCount(); k++) {

      s << wxT("    ") << (int)supportedSampleRates[k] << e;

   }

 

   int highestSampleRate = supportedSampleRates[supportedSampleRates.GetCount() - 1];

   bool EmulateMixerInputVol = true;

   bool EmulateMixerOutputVol = true;

   float MixerInputVol = 1.0;

   float MixerOutputVol = 1.0;

 

   int error;

 

#if USE_PORTAUDIO_V19

 

   PaStream *stream;

 

   PaStreamParameters playbackParameters;

 

   playbackParameters.device = playDeviceNum;

   playbackParameters.sampleFormat = paFloat32;

   playbackParameters.hostApiSpecificStreamInfo = NULL;

   playbackParameters.channelCount = 2;

   if (Pa_GetDeviceInfo(playDeviceNum))

      playbackParameters.suggestedLatency =

         Pa_GetDeviceInfo(playDeviceNum)->defaultLowOutputLatency;

   else

      playbackParameters.suggestedLatency = 100; // we're just probing anyway

 

   PaStreamParameters captureParameters;

 

   captureParameters.device = recDeviceNum;

   captureParameters.sampleFormat = paFloat32;;

   captureParameters.hostApiSpecificStreamInfo = NULL;

   captureParameters.channelCount = 2;

   if (Pa_GetDeviceInfo(recDeviceNum))

      captureParameters.suggestedLatency =

         Pa_GetDeviceInfo(recDeviceNum)->defaultLowInputLatency;

   else

      captureParameters.suggestedLatency = 100; // we're just probing anyway

 

   error = Pa_OpenStream(&stream,

                         &captureParameters, &playbackParameters,

                         highestSampleRate, paFramesPerBufferUnspecified,

                         paClipOff | paDitherOff,

                         audacityAudioCallback, NULL);

 

   if (error) {

      error = Pa_OpenStream(&stream,

                            &captureParameters, NULL,

                            highestSampleRate, paFramesPerBufferUnspecified,

                            paClipOff | paDitherOff,

                            audacityAudioCallback, NULL);

   }

  

#else

 

   PortAudioStream *stream;

 

   error = Pa_OpenStream(&stream, recDeviceNum, 2, paFloat32, NULL,

                         playDeviceNum, 2, paFloat32, NULL,

                         highestSampleRate, 512, 1, paClipOff | paDitherOff,

                         audacityAudioCallback, NULL);

 

   if (error) {

      error = Pa_OpenStream(&stream, recDeviceNum, 2, paFloat32, NULL,

                            paNoDevice, 0, paFloat32, NULL,

                            highestSampleRate, 512, 1, paClipOff | paDitherOff,

                            audacityAudioCallback, NULL);

   }

 

#endif

 

   if (error) {

      s << wxT("Recieved ") << error << wxT(" while opening devices") << e;

      return o.GetString();

   }

 

   PxMixer *PortMixer = Px_OpenMixer(stream, 0);

 

   if (!PortMixer) {

      s << wxT("Unable to open Portmixer") << e;

      Pa_CloseStream(stream);

      return o.GetString();

   }

 

   s << wxT("==============================") << e;

   s << wxT("Available mixers:") << e;

 

   cnt = Px_GetNumMixers(stream);

   for (int i = 0; i < cnt; i++) {

      wxString name(Px_GetMixerName(stream, i), wxConvLocal);

      s << i << wxT(" - ") << name << e;

   }

 

   s << wxT("==============================") << e;

   s << wxT("Available capture sources:") << e;

   cnt = Px_GetNumInputSources(PortMixer);

   for (int i = 0; i < cnt; i++) {

      wxString name(Px_GetInputSourceName(PortMixer, i), wxConvLocal);

      s << i << wxT(" - ") << name << e;

   }

 

   s << wxT("==============================") << e;

   s << wxT("Available playback volumes:") << e;

   cnt = Px_GetNumOutputVolumes(PortMixer);

   for (int i = 0; i < cnt; i++) {

      wxString name(Px_GetOutputVolumeName(PortMixer, i), wxConvLocal);

      s << i << wxT(" - ") << name << e;

   }

 

   // Determine mixer capabilities - it it doesn't support either

   // input or output, we emulate them (by multiplying this value

   // by all incoming/outgoing samples)

 

   MixerOutputVol = Px_GetPCMOutputVolume(PortMixer);

   EmulateMixerOutputVol = false;

   Px_SetPCMOutputVolume(PortMixer, 0.0);

   if (Px_GetPCMOutputVolume(PortMixer) > 0.1)

      EmulateMixerOutputVol = true;

   Px_SetPCMOutputVolume(PortMixer, 0.2f);

   if (Px_GetPCMOutputVolume(PortMixer) < 0.1 ||

       Px_GetPCMOutputVolume(PortMixer) > 0.3)

      EmulateMixerOutputVol = true;

   Px_SetPCMOutputVolume(PortMixer, MixerOutputVol);

 

   MixerInputVol = Px_GetInputVolume(PortMixer);

   EmulateMixerInputVol = false;

   Px_SetInputVolume(PortMixer, 0.0);

   if (Px_GetInputVolume(PortMixer) > 0.1)

      EmulateMixerInputVol = true;

   Px_SetInputVolume(PortMixer, 0.2f);

   if (Px_GetInputVolume(PortMixer) < 0.1 ||

       Px_GetInputVolume(PortMixer) > 0.3)

      EmulateMixerInputVol = true;

   Px_SetInputVolume(PortMixer, MixerInputVol);

 

   Pa_CloseStream(stream);

 

   s << wxT("==============================") << e;

   s << wxT("Capture volume is ") << (EmulateMixerInputVol? wxT("emulated"): wxT("native")) << e;

   s << wxT("Capture volume is ") << (EmulateMixerOutputVol? wxT("emulated"): wxT("native")) << e;

 

   Px_CloseMixer(PortMixer);

 

#endif

 

   return o.GetString();

}

 

 

   // Send data to VU meters

 

   // It's critical that we don't update the meters while

   // StopStream is trying to stop PortAudio, otherwise it can

   // lead to a freeze.  We use two variables to synchronize:

   // mUpdatingMeters tells StopStream when the callback is about

   // to enter the code where it might update the meters, and

   // mUpdateMeters is how the rest of the code tells the callback

   // when it is allowed to actually do the updating.  Note that

   // mUpdatingMeters must be set first to avoid a race condition.

   gAudioIO->mUpdatingMeters = true;

   if (gAudioIO->mUpdateMeters) {

 

      if (gAudioIO->mOutputMeter && 

          !gAudioIO->mOutputMeter->IsMeterDisabled() &&

          outputBuffer) {

         gAudioIO->mOutputMeter->UpdateDisplay(numPlaybackChannels,

                                               framesPerBuffer,

                                               (float *)outputBuffer);

      }

 

      if (gAudioIO->mInputMeter &&

          !gAudioIO->mInputMeter->IsMeterDisabled() &&

          inputBuffer) {

         if (gAudioIO->mCaptureFormat == floatSample)

            gAudioIO->mInputMeter->UpdateDisplay(numCaptureChannels,

                                                 framesPerBuffer,

                                                 (float *)inputBuffer);

         else {

            CopySamples((samplePtr)inputBuffer, gAudioIO->mCaptureFormat,

                        (samplePtr)tempFloats, floatSample,

                        framesPerBuffer * numCaptureChannels);

            gAudioIO->mInputMeter->UpdateDisplay(numCaptureChannels,

                                                 framesPerBuffer,

                                                 tempFloats);

         }

      }

   }

   gAudioIO->mUpdatingMeters = false;

 

#ifdef EXPERIMENTAL_SMART_RECORD

   // Stop recording if 'silence' is detected

   if(gAudioIO->mPauseRec && inputBuffer) {

      if(gAudioIO->mInputMeter->GetMaxPeak() < gAudioIO->mSilenceLevel ) {

         if(!gAudioIO->IsPaused()) {

            AudacityProject *p = GetActiveProject();

            wxCommandEvent dummyEvt;

            p->GetControlToolBar()->OnPause(dummyEvt);

         }

      }

      else {

         if(gAudioIO->IsPaused()) {

            AudacityProject *p = GetActiveProject();

            wxCommandEvent dummyEvt;

            p->GetControlToolBar()->OnPause(dummyEvt);

         }

      }

   }

#endif

 

            gAudioIO->mT = gAudioIO->mT0 + ((gAudioIO->mTime - gAudioIO->mT0));

               gAudioIO->mPlaybackMixers[i]->Reposition(gAudioIO->mT);

               gAudioIO->mPlaybackBuffers[i]->Discard(gAudioIO->mPlaybackBuffers[i]->AvailForGet());

 

      // Calcuate the warp factor for this time position

      double factor = 1.0;

      if (gAudioIO->mTimeTrack) {

         factor = gAudioIO->mTimeTrack->GetEnvelope()->GetValue(gAudioIO->mTime);

         factor = (gAudioIO->mTimeTrack->GetRangeLower() *

                  (1 - factor) +

                  factor *

                  gAudioIO->mTimeTrack->GetRangeUpper()) / 

                  100.0;

      }

 

      // Wrap to start if looping

      if (gAudioIO->mPlayLooped && gAudioIO->mTime >= gAudioIO->mT1)

      {

         // LL:  This is not exactly right, but I'm at my wits end trying to

         //      figure it out.  Feel free to fix it.  :-)

         gAudioIO->mTime = gAudioIO->mT0 - ((gAudioIO->mTime - gAudioIO->mT1) * factor);

      }

 

      gAudioIO->mTime += ((framesPerBuffer / gAudioIO->mRate) * factor);