X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Faudio_decoder.cc;h=97a088791ad9bbe2c4b5e84cec227d016ce23175;hb=8d58a7c5f4320ad5c111e336c45e44d6b51ab509;hp=a9e01908c4782a6095821d080800b0568ce71214;hpb=50cb31af16240b248700dab1484d7f07656c66df;p=dcpomatic.git diff --git a/src/lib/audio_decoder.cc b/src/lib/audio_decoder.cc index a9e01908c..97a088791 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 @@ -21,6 +21,9 @@ #include "audio_buffers.h" #include "exceptions.h" #include "log.h" +#include "resampler.h" +#include "util.h" +#include "film.h" #include "i18n.h" @@ -28,139 +31,179 @@ 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 f, shared_ptr c) - : Decoder (f) - , _next_audio (0) - , _audio_content (c) +AudioDecoder::AudioDecoder (shared_ptr content) + : _audio_content (content) { - if (_audio_content->content_audio_frame_rate() != _audio_content->output_audio_frame_rate()) { - - shared_ptr film = _film.lock (); - assert (film); - - stringstream s; - s << String::compose ( - "Will resample audio from %1 to %2", - _audio_content->content_audio_frame_rate(), _audio_content->output_audio_frame_rate() - ); - - film->log()->log (s.str ()); - - /* We will be using planar float data when we call the - resampler. As far as I can see, the audio channel - layout is not necessary for our purposes; it seems - only to be used get the number of channels and - decide if rematrixing is needed. It won't be, since - input and output layouts are the same. - */ - - _swr_context = swr_alloc_set_opts ( - 0, - av_get_default_channel_layout (_audio_content->audio_channels ()), - AV_SAMPLE_FMT_FLTP, - _audio_content->output_audio_frame_rate(), - av_get_default_channel_layout (_audio_content->audio_channels ()), - AV_SAMPLE_FMT_FLTP, - _audio_content->content_audio_frame_rate(), - 0, 0 - ); - - swr_init (_swr_context); - } else { - _swr_context = 0; + 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 (); } -AudioDecoder::~AudioDecoder () +void +AudioDecoder::reset_decoded_audio () { - if (_swr_context) { - swr_free (&_swr_context); - } + _decoded_audio = ContentAudio (shared_ptr (new AudioBuffers (_audio_content->audio_channels(), 0)), 0); } - -#if 0 -void -AudioDecoder::process_end () +shared_ptr +AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate) { - if (_swr_context) { + shared_ptr dec; - shared_ptr film = _film.lock (); - assert (film); + AudioFrame const end = frame + length - 1; - shared_ptr out (new AudioBuffers (film->audio_mapping().dcp_channels(), 256)); - - while (1) { - int const frames = swr_convert (_swr_context, (uint8_t **) out->data(), 256, 0, 0); + 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); + } - if (frames < 0) { - throw EncodeError (_("could not run sample-rate converter")); - } + /* 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 */ + } - if (frames == 0) { - break; - } + /* 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; - out->set_frames (frames); - _writer->write (out); - } + /* 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)); } -#endif +/** 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. + * + * The time is passed in here so that after a seek we can set up our _audio_position. The + * time is ignored once this has been done. + */ void -AudioDecoder::audio (shared_ptr data, Time time) +AudioDecoder::audio (shared_ptr data, ContentTime time) { - /* Maybe resample */ - if (_swr_context) { - - /* Compute the resampled frames count and add 32 for luck */ - int const max_resampled_frames = ceil ( - (int64_t) data->frames() * _audio_content->output_audio_frame_rate() / _audio_content->content_audio_frame_rate() - ) + 32; - - shared_ptr resampled (new AudioBuffers (data->channels(), max_resampled_frames)); + if (_resampler) { + data = _resampler->run (data); + } - /* Resample audio */ - int const resampled_frames = swr_convert ( - _swr_context, (uint8_t **) resampled->data(), max_resampled_frames, (uint8_t const **) data->data(), data->frames() - ); - - if (resampled_frames < 0) { - throw EncodeError (_("could not run sample-rate converter")); + 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 (); + } - resampled->set_frames (resampled_frames); - - /* And point our variables at the resampled audio */ - data = resampled; + if (!_audio_position) { + _audio_position = time.frames (frame_rate); } - shared_ptr film = _film.lock (); - assert (film); + 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; + } - /* Remap channels */ - shared_ptr dcp_mapped (new AudioBuffers (film->dcp_audio_channels(), data->frames())); - dcp_mapped->make_silent (); - list > map = _audio_content->audio_mapping().content_to_dcp (); - for (list >::iterator i = map.begin(); i != map.end(); ++i) { - dcp_mapped->accumulate_channel (data.get(), i->first, i->second); + _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 (); +} + +/* XXX: called? */ +void +AudioDecoder::flush () +{ + if (!_resampler) { + return; } - Audio (dcp_mapped, time); - _next_audio = time + film->audio_frames_to_time (data->frames()); + /* + 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 (); + } + */ } -bool -AudioDecoder::audio_done () const +void +AudioDecoder::seek (ContentTime t, bool accurate) { - shared_ptr film = _film.lock (); - assert (film); - - return (_audio_content->length() - _next_audio) < film->audio_frames_to_time (1); + _audio_position.reset (); + reset_decoded_audio (); + if (accurate) { + _seek_reference = t; + } } -