Ticket #8500: accurate_audiots.patch

mythtv/libs/libmyth/audiooutput.h

@@ -3 +3 @@
 
 #include <QString>
 
+#include "compat.h"
 #include "audiosettings.h"
 #include "mythcorecontext.h"
 #include "volumebase.h"
@@ -42 +43 @@
 
     virtual void Reset(void) = 0;
 
-    virtual bool AddSamples(void *buffer, int samples, long long timecode) = 0;
+    virtual bool AddSamples(void *buffer, int samples, int64_t timecode) = 0;
 
-    virtual void SetTimecode(long long timecode) = 0;
+    virtual void SetTimecode(int64_t timecode) = 0;
     virtual bool IsPaused(void) const = 0;
     virtual void Pause(bool paused) = 0;
     virtual void PauseUntilBuffered(void) = 0;
@@ -52 +53 @@
     // Wait for all data to finish playing
     virtual void Drain(void) = 0;
 
-    virtual int GetAudiotime(void) = 0;
+    virtual int64_t GetAudiotime(void) = 0;
 
     /// report amount of audio buffered in milliseconds.
-    virtual int GetAudioBufferedTime(void) { return 0; }
+    virtual int64_t GetAudioBufferedTime(void) { return 0; }
 
     virtual void SetSourceBitrate(int ) { }
 

mythtv/libs/libmyth/audiooutputbase.cpp

@@ -56 +56 @@
     passthru(false),            enc(false),
     reenc(false),
     stretchfactor(1.0f),
+    eff_stretchfactor(100000),
 
     source(settings.source),    killaudio(false),
 
@@ -179 +180 @@
         return;
 
     stretchfactor = lstretchfactor;
+    eff_stretchfactor = (int)(100000.0f * lstretchfactor + 0.5);
     if (pSoundStretch)
     {
         VBGENERAL(QString("Changing time stretch to %1").arg(stretchfactor));
@@ -596 +598 @@
  * Used by mythmusic for seeking since it doesn't provide timecodes to
  * AddSamples()
  */
-void AudioOutputBase::SetTimecode(long long timecode)
+void AudioOutputBase::SetTimecode(int64_t timecode)
 {
     audbuf_timecode = audiotime = timecode;
-    frames_buffered = (long long)((timecode * source_samplerate) / 1000);
+    frames_buffered = (int64_t)((timecode * source_samplerate) / 1000);
 }
 
 /**
@@ -654 +656 @@
 /**
  * Calculate the timecode of the samples that are about to become audible
  */
-int AudioOutputBase::GetAudiotime(void)
+int64_t AudioOutputBase::GetAudiotime(void)
 {
     if (audbuf_timecode == 0)
         return 0;
 
-    int soundcard_buffer = 0;
     int obpf = output_bytes_per_frame;
-    int totalbuffer;
-    long long oldaudiotime;
+    int64_t oldaudiotime;
 
     /* We want to calculate 'audiotime', which is the timestamp of the audio
-       which is leaving the sound card at this instant.
+       Which is leaving the sound card at this instant.
 
        We use these variables:
 
@@ -677 +677 @@
        'totalbuffer' is the total # of bytes in our audio buffer, and the
        sound card's buffer. */
 
-    soundcard_buffer = GetBufferedOnSoundcard(); // bytes
 
     QMutexLocker lockav(&avsync_lock);
 
+    int64_t soundcard_buffer = GetBufferedOnSoundcard(); // bytes
+    int64_t main_buffer = audioready();
+
     /* audioready tells us how many bytes are in audiobuffer
        scaled appropriately if output format != internal format */
-    totalbuffer = audioready() + soundcard_buffer;
-
-    if (needs_upmix && upmixer)
-        totalbuffer += upmixer->frameLatency() * obpf;
-
-    if (pSoundStretch)
-    {
-        totalbuffer += pSoundStretch->numUnprocessedSamples() * obpf /
-                       stretchfactor;
-        totalbuffer += pSoundStretch->numSamples() * obpf;
-    }
-
-    if (encoder)
-        totalbuffer += encoder->Buffered();
 
     oldaudiotime = audiotime;
 
-    audiotime = audbuf_timecode - (long long)(totalbuffer) * 100000 *
-                                        stretchfactor / (obpf * effdsp);
+    // timecode is the stretch adjusted version
+    // of major post-stretched buffer contents
+    // processing latencies are catered for in AddSamples/SetAudiotime to eliminate
+    // race
+    audiotime = audbuf_timecode - (( (main_buffer + soundcard_buffer) * eff_stretchfactor ) / (effdsp * obpf));
 
     /* audiotime should never go backwards, but we might get a negative
        value if GetBufferedOnSoundcard() isn't updated by the driver very
@@ -709 +700 @@
     if (audiotime < oldaudiotime)
         audiotime = oldaudiotime;
 
-    VBAUDIOTS(QString("GetAudiotime audt=%3 atc=%4 tb=%5 sb=%6 "
-                      "sr=%7 obpf=%8 sf=%9")
+    VBAUDIOTS(QString("GetAudiotime audt=%1 atc=%2 mb=%3 sb=%4 tb=%5 "
+                      "sr=%6 obpf=%7 bpf=%8 sf=%9 %10 %11")
               .arg(audiotime).arg(audbuf_timecode)
-              .arg(totalbuffer).arg(soundcard_buffer)
-              .arg(samplerate).arg(obpf).arg(stretchfactor));
+              .arg(main_buffer)
+              .arg(soundcard_buffer)
+              .arg(main_buffer+soundcard_buffer)
+              .arg(samplerate).arg(obpf).arg(bytes_per_frame).arg(stretchfactor)
+              .arg((main_buffer + soundcard_buffer) * eff_stretchfactor)
+              .arg(( (main_buffer + soundcard_buffer) * eff_stretchfactor ) / (effdsp * obpf))
+              );
+
+    return audiotime;
+}
+
+/**
+ * Set the timecode of the top of the ringbuffer
+ * Exclude all other processing elements as they dont vary
+ * between AddSamples calls
+ */
+void AudioOutputBase::SetAudiotime(int frames, int64_t timecode)
+{
+    int64_t processframes_stretched = 0;
+    int64_t processframes_unstretched = 0;
+
+    if (needs_upmix && upmixer)
+        processframes_unstretched -= upmixer->frameLatency();
+
+    if (pSoundStretch)
+    {
+        processframes_unstretched -= pSoundStretch->numUnprocessedSamples();
+        processframes_stretched -= pSoundStretch->numSamples();
+    }
 
-    return (int)audiotime;
+    if (encoder)
+        // the input buffered data is still in audio_bytes_per_sample format
+        processframes_stretched -= encoder->Buffered() / output_bytes_per_frame;
+
+    audbuf_timecode = timecode + 
+                (((frames + processframes_unstretched) * 100000) +
+                  (processframes_stretched * eff_stretchfactor )) / effdsp;
+
+    VBAUDIOTS(QString("SetAudiotime atc=%1 tc=%2 f=%3 pfu=%4 pfs=%5")
+              .arg(audbuf_timecode)
+              .arg(timecode)
+              .arg(frames)
+              .arg(processframes_unstretched)
+              .arg(processframes_stretched));
+#ifdef AUDIOTSTESTING
+    GetAudiotime();
+#endif
 }
 
 /**
@@ -723 +757 @@
  * audible and the samples most recently added to the audiobuffer, i.e. the
  * time in ms representing the sum total of buffered samples
  */
-int AudioOutputBase::GetAudioBufferedTime(void)
+int64_t AudioOutputBase::GetAudioBufferedTime(void)
 {
     int ret = audbuf_timecode - GetAudiotime();
     // Pulse can give us values that make this -ve
@@ -869 +903 @@
  *
  * Returns false if there's not enough space right now
  */
-bool AudioOutputBase::AddSamples(void *buffer, int frames, long long timecode)
+bool AudioOutputBase::AddSamples(void *buffer, int in_frames, int64_t timecode)
 {
     int org_waud = waud,               afree = audiofree();
-    int bpf      = bytes_per_frame,    len   = frames * source_bytes_per_frame;
+    int frames = in_frames;
+    int bpf      = bytes_per_frame,    len   = in_frames * source_bytes_per_frame;
     int used     = kAudioRingBufferSize - afree;
     bool music   = false;
+    int bdiff;
 
     VBAUDIOTS(QString("AddSamples frames=%1, bytes=%2, used=%3, free=%4, "
                       "timecode=%5 needsupmix=%6")
@@ -896 +932 @@
     if (timecode < 0)
     {
         // Send original samples to mythmusic visualisation
-        timecode = (long long)(frames_buffered) * 1000 / source_samplerate;
+        timecode = (int64_t)(frames_buffered) * 1000 / source_samplerate;
         frames_buffered += frames;
         dispatchVisual((uchar *)buffer, len, timecode, source_channels,
                        output_settings->FormatToBits(format));
@@ -949 +985 @@
                     .arg(src_strerror(error)));
 
         buffer = src_out;
-        frames = src_data.output_frames_gen;
+        in_frames = frames = src_data.output_frames_gen;
     }
     else if (processing)
         buffer = src_in;
@@ -957 +993 @@
     /* we want the timecode of the last sample added but we are given the
        timecode of the first - add the time in ms that the frames added
        represent */
-    audbuf_timecode = timecode + ((long long)(frames) * 100000 / effdsp);
+    //audbuf_timecode = timecode + ((int64_t)((frames) * 100000) / effdsp);
 
     // Copy samples into audiobuffer, with upmix if necessary
     if ((len = CopyWithUpmix((char *)buffer, frames, org_waud)) <= 0)
-        return true;
+    {
+        //return true;
+        goto done;
+    }
 
     frames = len / bpf;
 
-    int bdiff = kAudioRingBufferSize - waud;
+    bdiff = kAudioRingBufferSize - waud;
 
     if (pSoundStretch)
     {
@@ -1043 +1082 @@
 
     waud = org_waud;
 
+done:
+    SetAudiotime(in_frames, timecode);
+
     return true;
 }
 
@@ -1090 +1132 @@
     uchar *fragment_buf = new uchar[fragment_size + 16];
     uchar *fragment     = (uchar *)AOALIGN(fragment_buf[0]);
 
+    // to reduce startup latency, write silence in 8ms chunks
+    int zero_fragment_size = (int)(0.008*samplerate/channels);
+    zero_fragment_size *= bytes_per_frame;   // make sure its a multiple of bytes_per_frame
+    if (zero_fragment_size > fragment_size)
+        zero_fragment_size = fragment_size;
+
     bzero(zeros, fragment_size);
 
     while (!killaudio)
@@ -1138 +1186 @@
             continue;
         }
 
+#ifdef AUDIOTSTESTING
+        VBAUDIOTS("WriteAudio Start");
+#endif
         Status();
 
-        if (GetAudioData(fragment, fragment_size, true))
+        // delay setting raud until after phys buffer is filled
+        // so GetAudiotime will be accurate without locking
+        int next_raud = raud;
+        if (GetAudioData(fragment, fragment_size, true, &next_raud))
+        {
             WriteAudio(fragment, fragment_size);
+            raud = next_raud;
+        }
+#ifdef AUDIOTSTESTING
+        GetAudiotime();
+        VBAUDIOTS("WriteAudio Done");
+#endif
+
     }
 
     delete[] zeros;
@@ -1158 +1220 @@
  * nothing. Otherwise, we'll copy less than 'size' bytes if that's all that's
  * available. Returns the number of bytes copied.
  */
-int AudioOutputBase::GetAudioData(uchar *buffer, int size, bool full_buffer)
+int AudioOutputBase::GetAudioData(uchar *buffer, int size, bool full_buffer, int *local_raud)
 {
 
+#define LRPOS audiobuffer + *local_raud
     // re-check audioready() in case things changed.
     // for example, ClearAfterSeek() might have run
     int avail_size   = audioready();
     int frag_size    = size;
     int written_size = size;
 
+    if (local_raud == NULL)
+        local_raud = &raud;
+
     if (!full_buffer && (size > avail_size))
     {
         // when full_buffer is false, return any available data
@@ -1192 +1258 @@
     {
         if (fromFloats)
             off = AudioOutputUtil::fromFloat(output_format, buffer,
-                                             RPOS, bdiff);
+                                             LRPOS, bdiff);
         else
         {
-            memcpy(buffer, RPOS, bdiff);
+            memcpy(buffer, LRPOS, bdiff);
             off = bdiff;
         }
 
         frag_size -= bdiff;
-        raud = 0;
+        *local_raud = 0;
     }
     if (frag_size > 0)
     {
         if (fromFloats)
             AudioOutputUtil::fromFloat(output_format, buffer + off,
-                                       RPOS, frag_size);
+                                       LRPOS, frag_size);
         else
-            memcpy(buffer + off, RPOS, frag_size);
+            memcpy(buffer + off, LRPOS, frag_size);
     }
 
-    raud += frag_size;
+    *local_raud += frag_size;
 
     // Mute individual channels through mono->stereo duplication
     MuteState mute_state = GetMuteState();

mythtv/libs/libmyth/audiooutputbase.h

@@ -57 +57 @@
     int GetSWVolume(void);
 
     // timecode is in milliseconds.
-    virtual bool AddSamples(void *buffer, int frames, long long timecode);
+    virtual bool AddSamples(void *buffer, int frames, int64_t timecode);
 
-    virtual void SetTimecode(long long timecode);
+    virtual void SetTimecode(int64_t timecode);
     virtual bool IsPaused(void) const { return actually_paused; }
     virtual void Pause(bool paused);
     void PauseUntilBuffered(void);
@@ -67 +67 @@
     // Wait for all data to finish playing
     virtual void Drain(void);
 
-    virtual int GetAudiotime(void);
-    virtual int GetAudioBufferedTime(void);
+    virtual int64_t GetAudiotime(void);
+    virtual int64_t GetAudioBufferedTime(void);
 
     // Send output events showing current progress
     virtual void Status(void);
@@ -83 +83 @@
 
     static const uint kAudioSRCInputSize  = 16384<<1;
     static const uint kAudioSRCOutputSize = 16384<<3;
-    /// Audio Buffer Size -- should be divisible by 12,10,8,6,4,2..
-    static const uint kAudioRingBufferSize   = 1536000;
+    /// Audio Buffer Size -- should be divisible by 32,24,16,12,10,8,6,4,2..
+    static const uint kAudioRingBufferSize   = 3072000;
 
  protected:
     // You need to implement the following functions
@@ -102 +102 @@
     virtual bool StartOutputThread(void);
     virtual void StopOutputThread(void);
 
-    int GetAudioData(uchar *buffer, int buf_size, bool fill_buffer);
+    int GetAudioData(uchar *buffer, int buf_size, bool fill_buffer, int *local_raud = NULL);
 
     void OutputAudioLoop(void);
 
@@ -138 +138 @@
     bool passthru, enc, reenc;
 
     float stretchfactor;
+    int  eff_stretchfactor;     // scaled to 100000 as effdsp is
     AudioOutputSource source;
 
     bool killaudio;
@@ -153 +154 @@
 
  private:
     int CopyWithUpmix(char *buffer, int frames, int &org_waud);
+    void SetAudiotime(int frames, int64_t timecode);
     AudioOutputSettings *output_settings;
     bool need_resampler;
     SRC_STATE *src_ctx;
@@ -175 +177 @@
 
     bool processing;
 
-    long long frames_buffered;
+    int64_t frames_buffered;
 
     bool audio_thread_exists;
 
@@ -188 +190 @@
     QMutex avsync_lock;
 
     // timecode of audio leaving the soundcard (same units as timecodes)
-    long long audiotime;
+    int64_t audiotime;
 
     /* Audio circular buffer */
     int raud, waud;     /* read and write positions */
     // timecode of audio most recently placed into buffer
-    long long audbuf_timecode;
+    int64_t audbuf_timecode;
 
     QMutex killAudioLock;
 

mythtv/libs/libmythfreesurround/freesurround.cpp

@@ -29 +29 @@
 using namespace std;
 
 #include "compat.h"
+#include "mythverbose.h"
 #include "freesurround.h"
 #include "el_processor.h"
 
 #include <QString>
 #include <QDateTime>
 
-#if 0
-#define VERBOSE(args...) \
-    do { \
-        QDateTime dtmp = QDateTime::currentDateTime(); \
-        QString dtime = dtmp.toString("yyyy-MM-dd hh:mm:ss.zzz"); \
-        std::cout << dtime.toLocal8Bit().constData() << " " \
-            << QString(args).toLocal8Bit().constData() << std::endl; \
-    } while (0)
-#else
-#define VERBOSE(args...)
-#endif
-#if 0
-#define VERBOSE1(args...) \
-    do { \
-        QDateTime dtmp = QDateTime::currentDateTime(); \
-        QString dtime = dtmp.toString("yyyy-MM-dd hh:mm:ss.zzz"); \
-        std::cout << dtime.toLocal8Bit().constData() << " " \
-            << QString(args).toLocal8Bit().constData() << std::endl; \
-    } while (0)
-#else
-#define VERBOSE1(args...)
-#endif
-
 // our default internal block size, in floats
 static const unsigned default_block_size = 8192;
 // Gain of center and lfe channels in passive mode (sqrt 0.5)
@@ -161 +139 @@
     processed_size(0),
     surround_mode(smode)
 {
-    VERBOSE(QString("FreeSurround::FreeSurround rate %1 moviemode %2")
+    VERBOSE(VB_AUDIO+VB_EXTRA, QString("FreeSurround::FreeSurround rate %1 moviemode %2")
             .arg(srate).arg(moviemode));
 
     if (moviemode)
@@ -193 +171 @@
     channel_select++;
     if (channel_select>=6)
         channel_select = 0;
-    VERBOSE(QString("FreeSurround::FreeSurround channel_select %1")
+    VERBOSE(VB_AUDIO+VB_EXTRA, QString("FreeSurround::FreeSurround channel_select %1")
             .arg(channel_select));
 #endif
-    VERBOSE(QString("FreeSurround::FreeSurround done"));
+    VERBOSE(VB_AUDIO+VB_EXTRA, QString("FreeSurround::FreeSurround done"));
 }
 
 void FreeSurround::SetParams()
@@ -224 +202 @@
 
 FreeSurround::~FreeSurround()
 {
-    VERBOSE(QString("FreeSurround::~FreeSurround"));
+    VERBOSE(VB_AUDIO+VB_EXTRA, QString("FreeSurround::~FreeSurround"));
     close();
     if (bufs)
     {
         bp.release((void*)1);
         bufs = NULL;
     }
-    VERBOSE(QString("FreeSurround::~FreeSurround done"));
+    VERBOSE(VB_AUDIO+VB_EXTRA, QString("FreeSurround::~FreeSurround done"));
 }
 
 uint FreeSurround::putFrames(void* buffer, uint numFrames, uint numChannels)
@@ -289 +267 @@
                     break;
             }
             ic += numFrames;
-            in_count = ic;
             processed = process;
             if (ic != bs)
+            {
+                // dont modify unless no processing is to be done
+                // for audiotime consistency
+                in_count = ic;
                 break;
-            in_count = 0;
+            }
+            // process_block takes some time so dont update in and out count
+            // before its finished so that Audiotime is correctly calculated
             if (process)
                 process_block();
+            in_count = 0;
             out_count = bs;
             processed_size = bs;
             break;
     }
 
-    VERBOSE1(QString("FreeSurround::putFrames %1 %2 used %4 generated %5")
+    VERBOSE(VB_AUDIO+VB_TIMESTAMP+VB_EXTRA, QString("FreeSurround::putFrames %1 #ch %2 used %4 generated %5")
             .arg(numFrames).arg(numChannels).arg(i).arg(out_count));
 
     return i;
@@ -318 +302 @@
     switch (surround_mode)
     {
         case SurroundModePassive:
-            for (uint i = 0; i < maxFrames; i++) 
+            for (i = 0; i < maxFrames; i++) 
             {
                 *output++ = bufs->l[outindex];
                 *output++ = bufs->r[outindex];
@@ -341 +325 @@
                 float *ls  = &outputs[3][outindex];
                 float *rs  = &outputs[4][outindex];
                 float *lfe = &outputs[5][outindex];
-                for (uint i = 0; i < maxFrames; i++) 
+                for (i = 0; i < maxFrames; i++) 
                 {
                     *output++ = *l++;
                     *output++ = *r++;
@@ -361 +345 @@
                 float *ls  = &bufs->ls[outindex];
                 float *rs  = &bufs->rs[outindex];
                 float *lfe = &bufs->lfe[outindex];
-                for (uint i = 0; i < maxFrames; i++) 
+                for (i = 0; i < maxFrames; i++) 
                 {
                     *output++ = *l++;
                     *output++ = *r++;
@@ -376 +360 @@
             break;
     }
     out_count = oc;
-    VERBOSE1(QString("FreeSurround::receiveFrames %1").arg(maxFrames));
+    VERBOSE(VB_AUDIO+VB_TIMESTAMP+VB_EXTRA, QString("FreeSurround::receiveFrames %1").arg(maxFrames));
     return maxFrames;
 }