Mix.cpp File Reference

#include "Mix.h"
#include <math.h>
#include <wx/textctrl.h>
#include <wx/timer.h>
#include <wx/intl.h>
#include "Envelope.h"
#include "WaveTrack.h"
#include "Prefs.h"
#include "Resample.h"
#include "TimeTrack.h"
#include "float_cast.h"
#include "widgets/ProgressDialog.h"

Include dependency graph for Mix.cpp:

Go to the source code of this file.

Namespaces
	anonymous_namespace{Mix.cpp}

Functions
void	MixAndRender (TrackList *tracks, WaveTrackFactory *trackFactory, double rate, sampleFormat format, double startTime, double endTime, WaveTrack::Holder &uLeft, WaveTrack::Holder &uRight)
	Mixes together all input tracks, applying any envelopes, amplitude gain, panning, and real-time effects in the process. More...
static void	MixBuffers (unsigned numChannels, int *channelFlags, float *gains, const float *src, Floats *dests, int len, bool interleaved)
double	anonymous_namespace{Mix.cpp}::ComputeWarpFactor (const Envelope &env, double t0, double t1)
	Compute the integral warp factor between two non-warped time points. More...

Function Documentation

MixAndRender()

void MixAndRender	(	TrackList *	tracks,
		WaveTrackFactory *	factory,
		double	rate,
		sampleFormat	format,
		double	startTime,
		double	endTime,
		std::shared_ptr< WaveTrack > &	uLeft,
		std::shared_ptr< WaveTrack > &	uRight
	)

Mixes together all input tracks, applying any envelopes, amplitude gain, panning, and real-time effects in the process.

Takes one or more tracks as input; of all the WaveTrack s that are selected, it mixes them together, applying any envelopes, amplitude gain, panning, and real-time effects in the process. The resulting pair of tracks (stereo) are "rendered" and have no effects, gain, panning, or envelopes. Other sorts of tracks are ignored. If the start and end times passed are the same this is taken as meaning no explicit time range to process, and the whole occupied length of the input tracks is processed.

Definition at line 43 of file Mix.cpp.

{
   uLeft.reset(), uRight.reset();
 
   // This function was formerly known as "Quick Mix".
   bool mono = false;   /* flag if output can be mono without losing anything*/
   bool oneinput = false;  /* flag set to true if there is only one input track
                              (mono or stereo) */
 
   const auto trackRange = tracks->Selected< const WaveTrack >();
   auto first = *trackRange.begin();
   // this only iterates tracks which are relevant to this function, i.e.
   // selected WaveTracks. The tracklist is (confusingly) the list of all
   // tracks in the project
 
   int numWaves = 0; /* number of wave tracks in the selection */
   int numMono = 0;  /* number of mono, centre-panned wave tracks in selection*/
   for(auto wt : trackRange) {
      numWaves++;
      float pan = wt->GetPan();
      if (wt->GetChannel() == Track::MonoChannel && pan == 0)
         numMono++;
   }
 
   if (numMono == numWaves)
      mono = true;
 
   /* the next loop will do two things at once:
    * 1. build an array of all the wave tracks were are trying to process
    * 2. determine when the set of WaveTracks starts and ends, in case we
    *    need to work out for ourselves when to start and stop rendering.
    */
 
   double mixStartTime = 0.0;    /* start time of first track to start */
   bool gotstart = false;  // flag indicates we have found a start time
   double mixEndTime = 0.0;   /* end time of last track to end */
   double tstart, tend;    // start and end times for one track.
 
   WaveTrackConstArray waveArray;
 
   for(auto wt : trackRange) {
      waveArray.push_back( wt->SharedPointer< const WaveTrack >() );
      tstart = wt->GetStartTime();
      tend = wt->GetEndTime();
      if (tend > mixEndTime)
         mixEndTime = tend;
      // try and get the start time. If the track is empty we will get 0,
      // which is ambiguous because it could just mean the track starts at
      // the beginning of the project, as well as empty track. The give-away
      // is that an empty track also ends at zero.
 
      if (tstart != tend) {
         // we don't get empty tracks here
         if (!gotstart) {
            // no previous start, use this one unconditionally
            mixStartTime = tstart;
            gotstart = true;
         } else if (tstart < mixStartTime)
            mixStartTime = tstart;  // have a start, only make it smaller
      }  // end if start and end are different
   }
 
   /* create the destination track (NEW track) */
   if (numWaves == (int)TrackList::Channels(first).size())
      oneinput = true;
   // only one input track (either 1 mono or one linked stereo pair)
 
   auto mixLeft = trackFactory->NewWaveTrack(format, rate);
   if (oneinput)
      mixLeft->SetName(first->GetName()); /* set name of output track to be the same as the sole input track */
   else
      /* i18n-hint: noun, means a track, made by mixing other tracks */
      mixLeft->SetName(_("Mix"));
   mixLeft->SetOffset(mixStartTime);
 
   // TODO: more-than-two-channels
   decltype(mixLeft) mixRight{};
   if ( !mono ) {
      mixRight = trackFactory->NewWaveTrack(format, rate);
      if (oneinput) {
         auto channels = TrackList::Channels(first);
         if (channels.size() > 1)
            mixRight->SetName((*channels.begin().advance(1))->GetName()); /* set name to match input track's right channel!*/
         else
            mixRight->SetName(first->GetName());   /* set name to that of sole input channel */
      }
      else
         mixRight->SetName(_("Mix"));
      mixRight->SetOffset(mixStartTime);
   }
 
 
   auto maxBlockLen = mixLeft->GetIdealBlockSize();
 
   // If the caller didn't specify a time range, use the whole range in which
   // any input track had clips in it.
   if (startTime == endTime) {
      startTime = mixStartTime;
      endTime = mixEndTime;
   }
 
   Mixer mixer(waveArray,
      // Throw to abort mix-and-render if read fails:
      true,
      Mixer::WarpOptions{*tracks},
      startTime, endTime, mono ? 1 : 2, maxBlockLen, false,
      rate, format);
 
   ::wxSafeYield();
 
   auto updateResult = ProgressResult::Success;
   {
      ProgressDialog progress(XO("Mix and Render"),
         XO("Mixing and rendering tracks"));
 
      while (updateResult == ProgressResult::Success) {
         auto blockLen = mixer.Process(maxBlockLen);
 
         if (blockLen == 0)
            break;
 
         if (mono) {
            auto buffer = mixer.GetBuffer();
            mixLeft->Append(buffer, format, blockLen);
         }
         else {
            auto buffer = mixer.GetBuffer(0);
            mixLeft->Append(buffer, format, blockLen);
            buffer = mixer.GetBuffer(1);
            mixRight->Append(buffer, format, blockLen);
         }
 
         updateResult = progress.Update(mixer.MixGetCurrentTime() - startTime, endTime - startTime);
      }
   }
 
   mixLeft->Flush();
   if (!mono)
      mixRight->Flush();
   if (updateResult == ProgressResult::Cancelled || updateResult == ProgressResult::Failed)
   {
      return;
   }
   else {
      uLeft = mixLeft, uRight = mixRight;
#if 0
   int elapsedMS = wxGetElapsedTime();
   double elapsedTime = elapsedMS * 0.001;
   double maxTracks = totalTime / (elapsedTime / numWaves);
 
   // Note: these shouldn't be translated - they're for debugging
   // and profiling only.
   wxPrintf("      Tracks: %d\n", numWaves);
   wxPrintf("  Mix length: %f sec\n", totalTime);
   wxPrintf("Elapsed time: %f sec\n", elapsedTime);
   wxPrintf("Max number of tracks to mix in real time: %f\n", maxTracks);
#endif
   }
}

References _, RefreshCode::Cancelled, TrackList::Channels(), format, Track::GetName(), WaveTrack::GetPan(), Track::MonoChannel, WaveTrackFactory::NewWaveTrack(), TrackList::Selected(), BasicUI::Success, ProgressDialog::Update(), and XO.

Referenced by anonymous_namespace{TrackMenus.cpp}::DoMixAndRender(), and Effect::Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

MixBuffers()

static void MixBuffers ( unsigned  numChannels, int *  channelFlags, float *  gains, const float *  src, Floats *  dests, int  len, bool  interleaved  )

static

Definition at line 363 of file Mix.cpp.

{
   for (unsigned int c = 0; c < numChannels; c++) {
      if (!channelFlags[c])
         continue;
 
      float *dest;
      unsigned skip;
 
      if (interleaved) {
         dest = dests[0].get() + c;
         skip = numChannels;
      } else {
         dest = dests[c].get();
         skip = 1;
      }
 
      float gain = gains[c];
      for (int j = 0; j < len; j++) {
         *dest += src[j] * gain;   // the actual mixing process
         dest += skip;
      }
   }
}

Referenced by Mixer::MixSameRate(), and Mixer::MixVariableRates().

Here is the caller graph for this function: