Ticket #2265: audiooutputca.cpp.v2.diff

audiooutputca.cpp

@@ -226 +226 @@
     return bufferedBytes;
 }
 
+int AudioOutputCA::GetAudiotime(void)
+{
+    /* Returns the current timecode of audio leaving the soundcard, based
+       on the 'audiotime' computed earlier, and the delay since it was computed.
+
+       This is a little roundabout...
+
+       The reason is that computing 'audiotime' requires acquiring the audio 
+       lock, which the video thread should not do. So, we call 'SetAudioTime()'
+       from the audio thread, and then call this from the video thread. */
+    int ret;
+
+    if (GetBaseAudioTime() == 0)
+        return 0;
+
+        UInt64 hostNanos = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
+        ret = (hostNanos / 1000000) - CA_audiotime_updated;
+        
+    ret += GetBaseAudioTime();
+
+    return ret;
+}
+
+void AudioOutputCA::SetAudiotime(void)
+{
+    if (GetBaseAudBufTimeCode() == 0)
+        return;
+
+    int soundcard_buffer = 0;
+    int totalbuffer;
+
+    /* We want to calculate 'audiotime', which is the timestamp of the audio
+       which is leaving the sound card at this instant.
+
+       We use these variables:
+
+       'effdsp' is samples/sec, multiplied by 100.
+       Bytes per sample is assumed to be 4.
+
+       'audiotimecode' is the timecode of the audio that has just been 
+       written into the buffer.
+
+       'totalbuffer' is the total # of bytes in our audio buffer, and the
+       sound card's buffer.
+
+       'ms/byte' is given by '25000/effdsp'...
+     */
+
+    soundcard_buffer = getBufferedOnSoundcard(); // bytes
+    totalbuffer = audiolen(false) + soundcard_buffer;
+ 
+    // include algorithmic latencies
+    if (GetSoundStretch())
+    {
+        // add the effect of unprocessed samples in time stretch algo
+        totalbuffer += (int)((GetSoundStretch()->numUnprocessedSamples() *
+                              audio_bytes_per_sample) / audio_stretchfactor);
+    }
+               
+    SetBaseAudioTime(GetBaseAudBufTimeCode() - (int)(totalbuffer * 100000.0 /
+                                   (audio_bytes_per_sample * effdspstretched)));
+ 
+        // We also store here the host time stamp of when the update occurred.  
+        // That way when asked later for the audio time we can use the sum of 
+        // the output time code info calculated here and the delta since when it
+        // was calculated and when we asked.
+        
+        // Note that since we're using a single 32bit variable here there is no need to
+        // use a lock or similar since the 32 bit accesses are atomic. Also we use
+        // AudioHost time here so that we're all referring to the same clock.
+        UInt64 hostNanos = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
+        CA_audiotime_updated = hostNanos / 1000000;
+
+}
+
 void AudioOutputCA::StartOutputThread(void)
 {
     return;     // no thread for CA