X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fdecoder.cc;h=6568ad08915e108e194a966957c7d689ad10da71;hb=e3636952b0d443f61c2966450cc68bc25480dfe2;hp=df3a4dda6bf504f753b3f319fe751bfbff3b42ce;hpb=2525b527f279a130155d40b7ee57057897270915;p=dcpomatic.git diff --git a/src/lib/decoder.cc b/src/lib/decoder.cc index df3a4dda6..6568ad089 100644 --- a/src/lib/decoder.cc +++ b/src/lib/decoder.cc @@ -23,52 +23,46 @@ #include #include -extern "C" { -#include -#include -#include -} +#include #include "film.h" #include "format.h" #include "job.h" -#include "film_state.h" #include "options.h" #include "exceptions.h" #include "image.h" #include "util.h" #include "log.h" #include "decoder.h" -#include "filter.h" #include "delay_line.h" -#include "ffmpeg_compatibility.h" +#include "subtitle.h" +#include "filter_graph.h" -using namespace std; -using namespace boost; +using std::string; +using std::stringstream; +using std::min; +using std::list; +using boost::shared_ptr; -/** @param s FilmState of the Film. +/** @param f Film. * @param o Options. * @param j Job that we are running within, or 0 - * @param l Log to use. * @param minimal true to do the bare minimum of work; just run through the content. Useful for acquiring * accurate frame counts as quickly as possible. This generates no video or audio output. * @param ignore_length Ignore the content's claimed length when computing progress. */ -Decoder::Decoder (boost::shared_ptr s, boost::shared_ptr o, Job* j, Log* l, bool minimal, bool ignore_length) - : _fs (s) +Decoder::Decoder (boost::shared_ptr f, boost::shared_ptr o, Job* j, bool minimal, bool ignore_length) + : _film (f) , _opt (o) , _job (j) - , _log (l) , _minimal (minimal) , _ignore_length (ignore_length) , _video_frame (0) - , _buffer_src_context (0) - , _buffer_sink_context (0) - , _have_setup_video_filters (false) , _delay_line (0) , _delay_in_bytes (0) + , _audio_frames_processed (0) { - if (_opt->decode_video_frequency != 0 && _fs->length == 0) { - throw DecodeError ("cannot do a partial decode if length == 0"); + if (_opt->decode_video_frequency != 0 && !_film->length()) { + throw DecodeError ("cannot do a partial decode if length is unknown"); } } @@ -77,22 +71,62 @@ Decoder::~Decoder () delete _delay_line; } +/** Start off a decode processing run */ void Decoder::process_begin () { - /* This assumes 2 bytes per sample */ - _delay_in_bytes = _fs->audio_delay * _fs->audio_sample_rate * _fs->audio_channels * 2 / 1000; + _delay_in_bytes = _film->audio_delay() * audio_sample_rate() * audio_channels() * bytes_per_audio_sample() / 1000; delete _delay_line; _delay_line = new DelayLine (_delay_in_bytes); + + _audio_frames_processed = 0; } +/** Finish off a decode processing run */ void Decoder::process_end () { if (_delay_in_bytes < 0) { uint8_t remainder[-_delay_in_bytes]; _delay_line->get_remaining (remainder); - Audio (remainder, _delay_in_bytes); + _audio_frames_processed += _delay_in_bytes / (audio_channels() * bytes_per_audio_sample()); + emit_audio (remainder, -_delay_in_bytes); + } + + /* If we cut the decode off, the audio may be short; push some silence + in to get it to the right length. + */ + + int64_t const video_length_in_audio_frames = ((int64_t) video_frame() * audio_sample_rate() / frames_per_second()); + int64_t const audio_short_by_frames = video_length_in_audio_frames - _audio_frames_processed; + + _film->log()->log ( + String::compose ("DCP length is %1 (%2 audio frames); %3 frames of audio processed.", + video_frame(), + video_length_in_audio_frames, + _audio_frames_processed) + ); + + if (audio_short_by_frames >= 0 && _opt->decode_audio) { + + _film->log()->log (String::compose ("DCP length is %1; %2 frames of audio processed.", video_frame(), _audio_frames_processed)); + _film->log()->log (String::compose ("Adding %1 frames of silence to the end.", audio_short_by_frames)); + + /* XXX: this is slightly questionable; does memset () give silence with all + sample formats? + */ + + int64_t bytes = audio_short_by_frames * _film->audio_channels() * bytes_per_audio_sample(); + + int64_t const silence_size = 16 * 1024 * _film->audio_channels() * bytes_per_audio_sample(); + uint8_t silence[silence_size]; + memset (silence, 0, silence_size); + + while (bytes) { + int64_t const t = min (bytes, silence_size); + emit_audio (silence, t); + bytes -= t; + } } } @@ -102,30 +136,19 @@ Decoder::go () { process_begin (); - if (_job && _ignore_length) { + if (_job && !_film->dcp_length()) { _job->set_progress_unknown (); } while (pass () == false) { - if (_job && !_ignore_length) { - _job->set_progress (float (_video_frame) / decoding_frames ()); + if (_job && _film->dcp_length()) { + _job->set_progress (float (_video_frame) / _film->dcp_length().get()); } } process_end (); } -/** @return Number of frames that we will be decoding */ -int -Decoder::decoding_frames () const -{ - if (_opt->num_frames > 0) { - return _opt->num_frames; - } - - return _fs->length; -} - /** Run one pass. This may or may not generate any actual video / audio data; * some decoders may require several passes to generate a single frame. * @return true if we have finished processing all data; otherwise false. @@ -133,46 +156,99 @@ Decoder::decoding_frames () const bool Decoder::pass () { - if (!_have_setup_video_filters) { - setup_video_filters (); - _have_setup_video_filters = true; - } - - if (_opt->num_frames != 0 && _video_frame >= _opt->num_frames) { + if (!_ignore_length && _video_frame >= _film->dcp_length()) { return true; } return do_pass (); } -/** Called by subclasses to tell the world that some audio data is ready */ +/** Called by subclasses to tell the world that some audio data is ready + * @param data Audio data, in Film::audio_sample_format. + * @param size Number of bytes of data. + */ +void +Decoder::process_audio (uint8_t* data, int size) +{ + /* Push into the delay line */ + size = _delay_line->feed (data, size); + + emit_audio (data, size); +} + void -Decoder::process_audio (uint8_t* data, int channels, int size) +Decoder::emit_audio (uint8_t* data, int size) { - if (_fs->audio_gain != 0) { - float const linear_gain = pow (10, _fs->audio_gain / 20); - uint8_t* p = data; - int const samples = size / 2; - switch (_fs->audio_sample_format) { - case AV_SAMPLE_FMT_S16: - for (int i = 0; i < samples; ++i) { - /* XXX: assumes little-endian; also we should probably be dithering here */ - int const ou = p[0] | (p[1] << 8); - int const os = ou >= 0x8000 ? (- 0x10000 + ou) : ou; - int const gs = int (os * linear_gain); - int const gu = gs > 0 ? gs : (0x10000 + gs); - p[0] = gu & 0xff; - p[1] = (gu & 0xff00) >> 8; - p += 2; + /* Deinterleave and convert to float */ + + assert ((size % (bytes_per_audio_sample() * audio_channels())) == 0); + + int const total_samples = size / bytes_per_audio_sample(); + int const frames = total_samples / _film->audio_channels(); + shared_ptr audio (new AudioBuffers (audio_channels(), frames)); + + switch (audio_sample_format()) { + case AV_SAMPLE_FMT_S16: + { + int16_t* p = (int16_t *) data; + int sample = 0; + int channel = 0; + for (int i = 0; i < total_samples; ++i) { + audio->data(channel)[sample] = float(*p++) / (1 << 15); + + ++channel; + if (channel == _film->audio_channels()) { + channel = 0; + ++sample; + } + } + } + break; + + case AV_SAMPLE_FMT_S32: + { + int32_t* p = (int32_t *) data; + int sample = 0; + int channel = 0; + for (int i = 0; i < total_samples; ++i) { + audio->data(channel)[sample] = float(*p++) / (1 << 31); + + ++channel; + if (channel == _film->audio_channels()) { + channel = 0; + ++sample; + } + } + } + + case AV_SAMPLE_FMT_FLTP: + { + float* p = reinterpret_cast (data); + for (int i = 0; i < _film->audio_channels(); ++i) { + memcpy (audio->data(i), p, frames * sizeof(float)); + p += frames; + } + } + break; + + default: + assert (false); + } + + /* Maybe apply gain */ + if (_film->audio_gain() != 0) { + float const linear_gain = pow (10, _film->audio_gain() / 20); + for (int i = 0; i < _film->audio_channels(); ++i) { + for (int j = 0; j < frames; ++j) { + audio->data(i)[j] *= linear_gain; } - break; - default: - assert (false); } } - int available = _delay_line->feed (data, size); - Audio (data, available); + /* Update the number of audio frames we've pushed to the encoder */ + _audio_frames_processed += audio->frames (); + + Audio (audio); } /** Called by subclasses to tell the world that some video data is ready. @@ -187,11 +263,11 @@ Decoder::process_video (AVFrame* frame) return; } - /* Use FilmState::length here as our one may be wrong */ + /* Use Film::length here as our one may be wrong */ int gap = 0; if (_opt->decode_video_frequency != 0) { - gap = _fs->length / _opt->decode_video_frequency; + gap = _film->length().get() / _opt->decode_video_frequency; } if (_opt->decode_video_frequency != 0 && gap != 0 && (_video_frame % gap) != 0) { @@ -199,138 +275,53 @@ Decoder::process_video (AVFrame* frame) return; } -#ifdef DVDOMATIC_FFMPEG_0_8_3 - - AVRational par; - par.num = sample_aspect_ratio_numerator (); - par.den = sample_aspect_ratio_denominator (); + shared_ptr graph; - if (av_vsrc_buffer_add_frame (_buffer_src_context, frame, 0, par) < 0) { - throw DecodeError ("could not push buffer into filter chain."); + list >::iterator i = _filter_graphs.begin(); + while (i != _filter_graphs.end() && !(*i)->can_process (Size (frame->width, frame->height), (AVPixelFormat) frame->format)) { + ++i; } -#else - - if (av_vsrc_buffer_add_frame (_buffer_src_context, frame, 0) < 0) { - throw DecodeError ("could not push buffer into filter chain."); + if (i == _filter_graphs.end ()) { + graph.reset (new FilterGraph (_film, this, _opt->apply_crop, Size (frame->width, frame->height), (AVPixelFormat) frame->format)); + _filter_graphs.push_back (graph); + _film->log()->log (String::compose ("New graph for %1x%2, pixel format %3", frame->width, frame->height, frame->format)); + } else { + graph = *i; } -#endif - - while (avfilter_poll_frame (_buffer_sink_context->inputs[0])) { - -#ifdef DVDOMATIC_FFMPEG_0_8_3 + list > images = graph->process (frame); - int r = avfilter_request_frame (_buffer_sink_context->inputs[0]); - if (r < 0) { - throw DecodeError ("could not request filtered frame"); + for (list >::iterator i = images.begin(); i != images.end(); ++i) { + if (_opt->black_after > 0 && _video_frame > _opt->black_after) { + (*i)->make_black (); } - AVFilterBufferRef* filter_buffer = _buffer_sink_context->inputs[0]->cur_buf; - -#else - - AVFilterBufferRef* filter_buffer; - if (avbuffersink_get_buffer_ref (_buffer_sink_context, &filter_buffer, 0) < 0) { - filter_buffer = 0; + shared_ptr sub; + if (_timed_subtitle && _timed_subtitle->displayed_at (double (video_frame()) / _film->frames_per_second())) { + sub = _timed_subtitle->subtitle (); } - -#endif - if (filter_buffer) { - /* This takes ownership of filter_buffer */ - shared_ptr image (new FilterBufferImage ((PixelFormat) frame->format, filter_buffer)); - - if (_opt->black_after > 0 && _video_frame > _opt->black_after) { - image->make_black (); - } - - Video (image, _video_frame); - ++_video_frame; - } + TIMING ("Decoder emits %1", _video_frame); + Video ((*i), _video_frame, sub); + ++_video_frame; } } void -Decoder::setup_video_filters () +Decoder::process_subtitle (shared_ptr s) { - stringstream fs; - Size size_after_crop; - - if (_opt->apply_crop) { - size_after_crop = _fs->cropped_size (native_size ()); - fs << crop_string (Position (_fs->left_crop, _fs->top_crop), size_after_crop); - } else { - size_after_crop = native_size (); - fs << crop_string (Position (0, 0), size_after_crop); - } - - string filters = Filter::ffmpeg_strings (_fs->filters).first; - if (!filters.empty ()) { - filters += ","; - } - - filters += fs.str (); - - avfilter_register_all (); + _timed_subtitle = s; - AVFilterGraph* graph = avfilter_graph_alloc(); - if (graph == 0) { - throw DecodeError ("Could not create filter graph."); - } - - AVFilter* buffer_src = avfilter_get_by_name("buffer"); - if (buffer_src == 0) { - throw DecodeError ("Could not find buffer src filter"); - } - - AVFilter* buffer_sink = get_sink (); - - stringstream a; - a << native_size().width << ":" - << native_size().height << ":" - << pixel_format() << ":" - << time_base_numerator() << ":" - << time_base_denominator() << ":" - << sample_aspect_ratio_numerator() << ":" - << sample_aspect_ratio_denominator(); - - int r; - if ((r = avfilter_graph_create_filter (&_buffer_src_context, buffer_src, "in", a.str().c_str(), 0, graph)) < 0) { - throw DecodeError ("could not create buffer source"); - } - - enum PixelFormat pixel_formats[] = { pixel_format(), PIX_FMT_NONE }; - if (avfilter_graph_create_filter (&_buffer_sink_context, buffer_sink, "out", 0, pixel_formats, graph) < 0) { - throw DecodeError ("could not create buffer sink."); + if (_timed_subtitle && _opt->apply_crop) { + Position const p = _timed_subtitle->subtitle()->position (); + _timed_subtitle->subtitle()->set_position (Position (p.x - _film->crop().left, p.y - _film->crop().top)); } +} - AVFilterInOut* outputs = avfilter_inout_alloc (); - outputs->name = av_strdup("in"); - outputs->filter_ctx = _buffer_src_context; - outputs->pad_idx = 0; - outputs->next = 0; - - AVFilterInOut* inputs = avfilter_inout_alloc (); - inputs->name = av_strdup("out"); - inputs->filter_ctx = _buffer_sink_context; - inputs->pad_idx = 0; - inputs->next = 0; - - _log->log ("Using filter chain `" + filters + "'"); -#ifdef DVDOMATIC_FFMPEG_0_8_3 - if (avfilter_graph_parse (graph, filters.c_str(), inputs, outputs, 0) < 0) { -#else - if (avfilter_graph_parse (graph, filters.c_str(), &inputs, &outputs, 0) < 0) { -#endif - - throw DecodeError ("could not set up filter graph."); - } - if (avfilter_graph_config (graph, 0) < 0) { - throw DecodeError ("could not configure filter graph."); - } - - /* XXX: leaking `inputs' / `outputs' ? */ +int +Decoder::bytes_per_audio_sample () const +{ + return av_get_bytes_per_sample (audio_sample_format ()); } -