Merge master.

[dcpomatic.git] / src / lib / audio_decoder.cc

diff --git a/src/lib/audio_decoder.cc b/src/lib/audio_decoder.cc
index 9606c378c62d3babd09cf28c94b131c312aeaf39..4a543cea9351af00cf652b6bcfd755ad013d2860 100644 (file)
--- a/src/lib/audio_decoder.cc
+++ b/src/lib/audio_decoder.cc
@@ -31,16 +31,25 @@ using std::stringstream;
 using std::list;
 using std::pair;
 using std::cout;
+using std::min;
+using std::max;
 using boost::optional;
 using boost::shared_ptr;
 
 AudioDecoder::AudioDecoder (shared_ptr<const AudioContent> content)
        : _audio_content (content)
-       , _decoded_audio (shared_ptr<AudioBuffers> (new AudioBuffers (content->audio_channels(), 0)), 0)
 {
-       if (content->output_audio_frame_rate() != content->content_audio_frame_rate() && content->audio_channels ()) {
-               _resampler.reset (new Resampler (content->content_audio_frame_rate(), content->output_audio_frame_rate(), content->audio_channels ()));
+       if (content->resampled_audio_frame_rate() != content->audio_frame_rate() && content->audio_channels ()) {
+               _resampler.reset (new Resampler (content->audio_frame_rate(), content->resampled_audio_frame_rate(), content->audio_channels ()));
        }
+
+       reset_decoded_audio ();
+}
+
+void
+AudioDecoder::reset_decoded_audio ()
+{
+       _decoded_audio = ContentAudio (shared_ptr<AudioBuffers> (new AudioBuffers (_audio_content->audio_channels(), 0)), 0);
 }
 
 shared_ptr<ContentAudio>
@@ -52,9 +61,14 @@ AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate)
                
        if (frame < _decoded_audio.frame || end > (_decoded_audio.frame + length * 4)) {
                /* Either we have no decoded data, or what we do have is a long way from what we want: seek */
-               seek (ContentTime::from_frames (frame, _audio_content->content_audio_frame_rate()), accurate);
+               seek (ContentTime::from_frames (frame, _audio_content->audio_frame_rate()), accurate);
        }
 
+       /* Offset of the data that we want from the start of _decoded_audio.audio
+          (to be set up shortly)
+       */
+       AudioFrame decoded_offset = 0;
+       
        /* Now enough pass() calls will either:
         *  (a) give us what we want, or
         *  (b) hit the end of the decoder.
@@ -63,20 +77,34 @@ AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate)
         * otherwise any frames will do.
         */
        if (accurate) {
-               while (!pass() && _decoded_audio.audio->frames() < length) {}
-       } else {
+               /* Keep stuffing data into _decoded_audio until we have enough data, or the subclass does not want to give us any more */
                while (!pass() && (_decoded_audio.frame > frame || (_decoded_audio.frame + _decoded_audio.audio->frames()) < end)) {}
+               decoded_offset = frame - _decoded_audio.frame;
+       } else {
+               while (!pass() && _decoded_audio.audio->frames() < length) {}
+               /* Use decoded_offset of 0, as we don't really care what frames we return */
        }
-       
-       /* Clean up decoded */
 
-       AudioFrame const decoded_offset = frame - _decoded_audio.frame;
-       AudioFrame const amount_left = _decoded_audio.audio->frames() - decoded_offset;
-       _decoded_audio.audio->move (decoded_offset, 0, amount_left);
-       _decoded_audio.audio->set_frames (amount_left);
+       /* The amount of data available in _decoded_audio.audio starting from `frame'.  This could be -ve
+          if pass() returned true before we got enough data.
+       */
+       AudioFrame const available = _decoded_audio.audio->frames() - decoded_offset;
+
+       /* We will return either that, or the requested amount, whichever is smaller */
+       AudioFrame const to_return = max ((AudioFrame) 0, min (available, length));
+
+       /* Copy our data to the output */
+       shared_ptr<AudioBuffers> out (new AudioBuffers (_decoded_audio.audio->channels(), to_return));
+       out->copy_from (_decoded_audio.audio.get(), to_return, decoded_offset, 0);
+
+       AudioFrame const remaining = max ((AudioFrame) 0, available - to_return);
 
-       shared_ptr<AudioBuffers> out (new AudioBuffers (_decoded_audio.audio->channels(), length));
-       out->copy_from (_decoded_audio.audio.get(), length, frame - _decoded_audio.frame, 0);
+       /* Clean up decoded; first, move the data after what we just returned to the start of the buffer */
+       _decoded_audio.audio->move (decoded_offset + to_return, 0, remaining);
+       /* And set up the number of frames we have left */
+       _decoded_audio.audio->set_frames (remaining);
+       /* Also bump where those frames are in terms of the content */
+       _decoded_audio.frame += decoded_offset + to_return;
 
        return shared_ptr<ContentAudio> (new ContentAudio (out, frame));
 }
@@ -98,13 +126,15 @@ AudioDecoder::audio (shared_ptr<const AudioBuffers> data, ContentTime time)
        }
 
        if (!_audio_position) {
-               _audio_position = time.frames (_audio_content->output_audio_frame_rate ());
+               _audio_position = time.frames (_audio_content->resampled_audio_frame_rate ());
        }
 
-       assert (_audio_position >= (_decoded_audio.frame + _decoded_audio.audio->frames()));
+       assert (_audio_position.get() >= (_decoded_audio.frame + _decoded_audio.audio->frames()));
 
        /* Resize _decoded_audio to fit the new data */
-       _decoded_audio.audio->ensure_size (_audio_position.get() + data->frames() - _decoded_audio.frame);
+       int const new_size = _audio_position.get() + data->frames() - _decoded_audio.frame;
+       _decoded_audio.audio->ensure_size (new_size);
+       _decoded_audio.audio->set_frames (new_size);
 
        /* Copy new data in */
        _decoded_audio.audio->copy_from (data.get(), data->frames(), 0, _audio_position.get() - _decoded_audio.frame);
@@ -132,4 +162,5 @@ void
 AudioDecoder::seek (ContentTime, bool)
 {
        _audio_position.reset ();
+       reset_decoded_audio ();
 }