X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Faudio_decoder.cc;h=2c0388fc39318851242b96a7a672b014ba5fca27;hb=f0edd6ab35c3c2b7800a26ec8206adab75e5f633;hp=b0d0cc22f87802de3f34162b44e1deb7deee1546;hpb=79ce26d031d109177ba4b0f637fa2960345a37a3;p=dcpomatic.git diff --git a/src/lib/audio_decoder.cc b/src/lib/audio_decoder.cc index b0d0cc22f..2c0388fc3 100644 --- a/src/lib/audio_decoder.cc +++ b/src/lib/audio_decoder.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-2014 Carl Hetherington This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -31,19 +31,87 @@ 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 film, shared_ptr content) - : Decoder (film) - , _audio_content (content) +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 ())); } + + reset_decoded_audio (); +} + +void +AudioDecoder::reset_decoded_audio () +{ + _decoded_audio = ContentAudio (shared_ptr (new AudioBuffers (_audio_content->audio_channels(), 0)), 0); +} + +shared_ptr +AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate) +{ + shared_ptr dec; + + AudioFrame const end = frame + length - 1; + + 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->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. + * + * If we are being accurate, we want the right frames, + * otherwise any frames will do. + */ + if (accurate) { + /* 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 */ + } + + /* 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); + + 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)); } -/** Audio timestamping is made hard by many factors, but the final nail in the coffin is resampling. +/** Called by subclasses when audio data is ready. + * + * Audio timestamping is made hard by many factors, but perhaps the most entertaining is resampling. * We have to assume that we are feeding continuous data into the resampler, and so we get continuous * data out. Hence we do the timestamping here, post-resampler, just by counting samples. * @@ -58,15 +126,31 @@ AudioDecoder::audio (shared_ptr data, ContentTime time) } if (!_audio_position) { - shared_ptr film = _film.lock (); - assert (film); - _audio_position = time; + _audio_position = time.frames (_audio_content->resampled_audio_frame_rate ()); + } + + assert (_audio_position.get() >= (_decoded_audio.frame + _decoded_audio.audio->frames())); + + /* Resize _decoded_audio to fit the new data */ + 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); - _pending.push_back (shared_ptr (new DecodedAudio (_audio_position.get (), data))); - _audio_position = _audio_position.get() + ContentTime (data->frames (), _audio_content->output_audio_frame_rate ()); + /* 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 (); } +/* XXX: called? */ void AudioDecoder::flush () { @@ -74,15 +158,18 @@ AudioDecoder::flush () return; } + /* shared_ptr b = _resampler->flush (); if (b) { - _pending.push_back (shared_ptr (new DecodedAudio (_audio_position.get (), b))); - _audio_position = _audio_position.get() + ContentTime (b->frames (), _audio_content->output_audio_frame_rate ()); + _pending.push_back (shared_ptr (new DecodedAudio (b, _audio_position.get ()))); + _audio_position = _audio_position.get() + b->frames (); } + */ } void AudioDecoder::seek (ContentTime, bool) { _audio_position.reset (); + reset_decoded_audio (); }