Collaboration diagram for AudioIoCallback::ScrubState::Data:

[legend]

Public Member Functions
	Data ()

bool	Init (Data &rPrevious, sampleCount s0, sampleCount s1, sampleCount duration, const ScrubbingOptions &options, double rate)

Public Attributes
sampleCount	mS0

sampleCount	mS1

sampleCount	mGoal

sampleCount	mDuration

sampleCount	mSilence

Detailed Description

Definition at line 650 of file AudioIO.cpp.

Constructor & Destructor Documentation

◆ Data()

AudioIoCallback::ScrubState::Data::Data ( )

inline

Definition at line 652 of file AudioIO.cpp.

          : mS0(0)
          , mS1(0)
          , mGoal(0)
          , mDuration(0)
          , mSilence(0)
       {}

Member Function Documentation

◆ Init()

bool AudioIoCallback::ScrubState::Data::Init	(	Data &	rPrevious,
		sampleCount	s0,
		sampleCount	s1,
		sampleCount	duration,
		const ScrubbingOptions &	options,
		double	rate
	)

inline

Definition at line 660 of file AudioIO.cpp.

       {
          auto previous = &rPrevious;
          auto origDuration = duration;
          mSilence = 0;
  
          const bool &adjustStart = options.adjustStart;
  
          wxASSERT(duration > 0);
          double speed =
             (std::abs((s1 - s0).as_long_long())) / duration.as_double();
          bool adjustedSpeed = false;
  
          auto minSpeed = std::min(options.minSpeed, options.maxSpeed);
          wxASSERT(minSpeed == options.minSpeed);
  
          // May change the requested speed and duration
          if (!adjustStart && speed > options.maxSpeed)
          {
             // Reduce speed to the maximum selected in the user interface.
             speed = options.maxSpeed;
             mGoal = s1;
             adjustedSpeed = true;
          }
          else if (!adjustStart &&
             previous->mGoal >= 0 &&
             previous->mGoal == s1)
          {
             // In case the mouse has not moved, and playback
             // is catching up to the mouse at maximum speed,
             // continue at no less than maximum.  (Without this
             // the final catch-up can make a slow scrub interval
             // that drops the pitch and sounds wrong.)
             minSpeed = options.maxSpeed;
             mGoal = s1;
             adjustedSpeed = true;
          }
          else
             mGoal = -1;
  
          if (speed < minSpeed) {
             if (s0 != s1 && adjustStart)
                // Do not trim the duration.
                ;
             else
                // Trim the duration.
                duration =
                   std::max(0L, lrint(speed * duration.as_double() / minSpeed));
  
             speed = minSpeed;
             adjustedSpeed = true;
          }
  
          if (speed < ScrubbingOptions::MinAllowedScrubSpeed()) {
             // Mixers were set up to go only so slowly, not slower.
             // This will put a request for some silence in the work queue.
             adjustedSpeed = true;
             speed = 0.0;
          }
  
          // May change s1 or s0 to match speed change or stay in bounds of the project
  
          if (adjustedSpeed && !adjustStart)
          {
             // adjust s1
             const sampleCount diff = lrint(speed * duration.as_double());
             if (s0 < s1)
                s1 = s0 + diff;
             else
                s1 = s0 - diff;
          }
  
          bool silent = false;
  
          // Adjust s1 (again), and duration, if s1 is out of bounds,
          // or abandon if a stutter is too short.
          // (Assume s0 is in bounds, because it equals the last scrub's s1 which was checked.)
          if (s1 != s0)
          {
             // When playback follows a fast mouse movement by "stuttering"
             // at maximum playback, don't make stutters too short to be useful.
             if (options.adjustStart &&
                 duration < llrint( options.minStutterTime * rate ) )
                return false;
  
             sampleCount minSample { llrint(options.minTime * rate) };
             sampleCount maxSample { llrint(options.maxTime * rate) };
             auto newDuration = duration;
             const auto newS1 = std::max(minSample, std::min(maxSample, s1));
             if(s1 != newS1)
                newDuration = std::max( sampleCount{ 0 },
                   sampleCount(
                      duration.as_double() * (newS1 - s0).as_double() /
                         (s1 - s0).as_double()
                   )
                );
             if (newDuration == 0) {
                // A silent scrub with s0 == s1
                silent = true;
                s1 = s0;
             }
             else if (s1 != newS1) {
                // Shorten
                duration = newDuration;
                s1 = newS1;
             }
          }
  
          if (adjustStart && !silent)
          {
             // Limit diff because this is seeking.
             const sampleCount diff =
                lrint(std::min(options.maxSpeed, speed) * duration.as_double());
             if (s0 < s1)
                s0 = s1 - diff;
             else
                s0 = s1 + diff;
          }
  
          mS0 = s0;
          mS1 = s1;
          mDuration = duration;
          if (duration < origDuration)
             mSilence = origDuration - duration;
  
          return true;
       }