X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Faudio_decoder.cc;h=12580c5f64972fd64498697e1f5dce7b4635af3d;hb=6de35d058821acc092d2aae75543024a97026b8a;hp=17a534aa477489289308a8ff6e31706229ad2ca3;hpb=7f2e74604a51b984e4c8cbb5d5f4bb642677ec00;p=dcpomatic.git diff --git a/src/lib/audio_decoder.cc b/src/lib/audio_decoder.cc index 17a534aa4..12580c5f6 100644 --- a/src/lib/audio_decoder.cc +++ b/src/lib/audio_decoder.cc @@ -19,27 +19,29 @@ #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; using std::min; +using std::max; using boost::optional; using boost::shared_ptr; AudioDecoder::AudioDecoder (shared_ptr content) : _audio_content (content) { - 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 ())); + } + + if (content->audio_processor ()) { + _processor = content->audio_processor()->clone (content->resampled_audio_frame_rate ()); } reset_decoded_audio (); @@ -48,7 +50,7 @@ AudioDecoder::AudioDecoder (shared_ptr content) void AudioDecoder::reset_decoded_audio () { - _decoded_audio = ContentAudio (shared_ptr (new AudioBuffers (_audio_content->audio_channels(), 0)), 0); + _decoded_audio = ContentAudio (shared_ptr (new AudioBuffers (_audio_content->processed_audio_channels(), 0)), 0); } shared_ptr @@ -60,9 +62,12 @@ 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: @@ -73,22 +78,34 @@ AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate) * otherwise any frames will do. */ if (accurate) { - while (!pass() && _decoded_audio.audio->frames() < length) {} - /* Use decoded_offset of 0, as we don't really care what frames we return */ - } else { - while (!pass() && (_decoded_audio.frame > frame || (_decoded_audio.frame + _decoded_audio.audio->frames()) < end)) {} + /* Keep stuffing data into _decoded_audio until we have enough data, or the subclass does not want to give us any more */ + while (_decoded_audio.frame > frame || (_decoded_audio.frame + _decoded_audio.audio->frames()) < end && !pass ()) {} decoded_offset = frame - _decoded_audio.frame; + } else { + while (_decoded_audio.audio->frames() < length && !pass ()) {} + /* Use decoded_offset of 0, as we don't really care what frames we return */ } - AudioFrame const amount_left = _decoded_audio.audio->frames() - decoded_offset; - - AudioFrame const to_return = min (amount_left, length); + /* 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 out (new AudioBuffers (_decoded_audio.audio->channels(), to_return)); out->copy_from (_decoded_audio.audio.get(), to_return, decoded_offset, 0); - - /* Clean up decoded */ - _decoded_audio.audio->move (decoded_offset + to_return, 0, amount_left - to_return); - _decoded_audio.audio->set_frames (amount_left - to_return); + + AudioFrame const remaining = max ((AudioFrame) 0, available - to_return); + + /* 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 (new ContentAudio (out, frame)); } @@ -109,23 +126,81 @@ AudioDecoder::audio (shared_ptr 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 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 (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 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 (); + } + if (!_audio_position) { - _audio_position = time.frames (_audio_content->output_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 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 () { @@ -133,18 +208,21 @@ AudioDecoder::flush () return; } - /* shared_ptr b = _resampler->flush (); if (b) { - _pending.push_back (shared_ptr (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 (); + } }