Merge master.

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

diff --git a/src/lib/audio_decoder.cc b/src/lib/audio_decoder.cc
index 4a543cea9351af00cf652b6bcfd755ad013d2860..f425cf2808cfbf70d53f3ff2bf097a24ab0ba035 100644 (file)
--- a/src/lib/audio_decoder.cc
+++ b/src/lib/audio_decoder.cc
@@ -19,15 +19,12 @@
 
 #include "audio_decoder.h"
 #include "audio_buffers.h"
-#include "exceptions.h"
-#include "log.h"
+#include "audio_processor.h"
 #include "resampler.h"
 #include "util.h"
-#include "film.h"
 
 #include "i18n.h"
 
-using std::stringstream;
 using std::list;
 using std::pair;
 using std::cout;
@@ -43,13 +40,17 @@ AudioDecoder::AudioDecoder (shared_ptr<const AudioContent> content)
                _resampler.reset (new Resampler (content->audio_frame_rate(), content->resampled_audio_frame_rate(), content->audio_channels ()));
        }
 
+       if (content->audio_processor ()) {
+               _processor = content->audio_processor()->clone (content->resampled_audio_frame_rate ());
+       }
+
        reset_decoded_audio ();
 }
 
 void
 AudioDecoder::reset_decoded_audio ()
 {
-       _decoded_audio = ContentAudio (shared_ptr<AudioBuffers> (new AudioBuffers (_audio_content->audio_channels(), 0)), 0);
+       _decoded_audio = ContentAudio (shared_ptr<AudioBuffers> (new AudioBuffers (_audio_content->processed_audio_channels(), 0)), 0);
 }
 
 shared_ptr<ContentAudio>
@@ -125,23 +126,81 @@ AudioDecoder::audio (shared_ptr<const AudioBuffers> data, ContentTime time)
                data = _resampler->run (data);
        }
 
+       if (_processor) {
+               data = _processor->run (data);
+       }
+
+       AudioFrame const frame_rate = _audio_content->resampled_audio_frame_rate ();
+
+       if (_seek_reference) {
+               /* We've had an accurate seek and now we're seeing some data */
+               ContentTime const delta = time - _seek_reference.get ();
+               AudioFrame const delta_frames = delta.frames (frame_rate);
+               if (delta_frames > 0) {
+                       /* This data comes after the seek time.  Pad the data with some silence. */
+                       shared_ptr<AudioBuffers> padded (new AudioBuffers (data->channels(), data->frames() + delta_frames));
+                       padded->make_silent ();
+                       padded->copy_from (data.get(), data->frames(), 0, delta_frames);
+                       data = padded;
+                       time -= delta;
+               } else if (delta_frames < 0) {
+                       /* This data comes before the seek time.  Throw some data away */
+                       AudioFrame const to_discard = min (-delta_frames, static_cast<AudioFrame> (data->frames()));
+                       AudioFrame const to_keep = data->frames() - to_discard;
+                       if (to_keep == 0) {
+                               /* We have to throw all this data away, so keep _seek_reference and
+                                  try again next time some data arrives.
+                               */
+                               return;
+                       }
+                       shared_ptr<AudioBuffers> trimmed (new AudioBuffers (data->channels(), to_keep));
+                       trimmed->copy_from (data.get(), to_keep, to_discard, 0);
+                       data = trimmed;
+                       time += ContentTime::from_frames (to_discard, frame_rate);
+               }
+               _seek_reference = optional<ContentTime> ();
+       }
+
        if (!_audio_position) {
-               _audio_position = time.frames (_audio_content->resampled_audio_frame_rate ());
+               _audio_position = time.frames (frame_rate);
        }
 
        assert (_audio_position.get() >= (_decoded_audio.frame + _decoded_audio.audio->frames()));
 
+       add (data);
+}
+
+void
+AudioDecoder::add (shared_ptr<const AudioBuffers> data)
+{
        /* Resize _decoded_audio to fit the new data */
-       int const new_size = _audio_position.get() + data->frames() - _decoded_audio.frame;
+       int new_size = 0;
+       if (_decoded_audio.audio->frames() == 0) {
+               /* There's nothing in there, so just store the new data */
+               new_size = data->frames ();
+               _decoded_audio.frame = _audio_position.get ();
+       } else {
+               /* Otherwise we need to extend _decoded_audio to include the new stuff */
+               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);
        _audio_position = _audio_position.get() + data->frames ();
+
+       /* Limit the amount of data we keep in case nobody is asking for it */
+       int const max_frames = _audio_content->resampled_audio_frame_rate () * 10;
+       if (_decoded_audio.audio->frames() > max_frames) {
+               int const to_remove = _decoded_audio.audio->frames() - max_frames;
+               _decoded_audio.frame += to_remove;
+               _decoded_audio.audio->move (to_remove, 0, max_frames);
+               _decoded_audio.audio->set_frames (max_frames);
+       }
 }
 
-/* XXX: called? */
 void
 AudioDecoder::flush ()
 {
@@ -149,18 +208,21 @@ AudioDecoder::flush ()
                return;
        }
 
-       /*
        shared_ptr<const AudioBuffers> b = _resampler->flush ();
        if (b) {
-               _pending.push_back (shared_ptr<DecodedAudio> (new DecodedAudio (b, _audio_position.get ())));
-               _audio_position = _audio_position.get() + b->frames ();
+               add (b);
        }
-       */
 }
 
 void
-AudioDecoder::seek (ContentTime, bool)
+AudioDecoder::seek (ContentTime t, bool accurate)
 {
        _audio_position.reset ();
        reset_decoded_audio ();
+       if (accurate) {
+               _seek_reference = t;
+       }
+       if (_processor) {
+               _processor->flush ();
+       }
 }