X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fdecoder.cc;h=045c1b818270052d58a93249377a7e2a6f5c6e27;hb=44b57d623dec97a3f9955082f0b8a7a8d27b7518;hp=15d74022cf95cb0797c383bf94aac84de8f32a22;hpb=d382f34db155ddaf4bb61538c18b87c7564e00b2;p=dcpomatic.git diff --git a/src/lib/decoder.cc b/src/lib/decoder.cc index 15d74022c..045c1b818 100644 --- a/src/lib/decoder.cc +++ b/src/lib/decoder.cc @@ -48,6 +48,7 @@ extern "C" { #include "filter.h" #include "delay_line.h" #include "ffmpeg_compatibility.h" +#include "subtitle.h" using namespace std; using namespace boost; @@ -75,7 +76,7 @@ Decoder::Decoder (boost::shared_ptr s, boost::shared_ptrdecode_video_frequency != 0 && _fs->length == 0) { + if (_opt->decode_video_frequency != 0 && _fs->length() == 0) { throw DecodeError ("cannot do a partial decode if length == 0"); } } @@ -89,7 +90,7 @@ Decoder::~Decoder () void Decoder::process_begin () { - _delay_in_bytes = _fs->audio_delay * _fs->audio_sample_rate * _fs->audio_channels * _fs->bytes_per_sample() / 1000; + _delay_in_bytes = _fs->audio_delay() * _fs->audio_sample_rate() * _fs->audio_channels() * bytes_per_audio_sample() / 1000; delete _delay_line; _delay_line = new DelayLine (_delay_in_bytes); @@ -103,33 +104,42 @@ Decoder::process_end () if (_delay_in_bytes < 0) { uint8_t remainder[-_delay_in_bytes]; _delay_line->get_remaining (remainder); - _audio_frames_processed += _delay_in_bytes / (_fs->audio_channels * _fs->bytes_per_sample()); - Audio (remainder, _delay_in_bytes); + _audio_frames_processed += _delay_in_bytes / (_fs->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 audio_short_by_frames = - ((int64_t) _fs->dcp_length() * _fs->target_sample_rate() / _fs->frames_per_second) - - _audio_frames_processed; + int64_t const video_length_in_audio_frames = ((int64_t) _fs->dcp_length() * _fs->audio_sample_rate() / _fs->frames_per_second()); + int64_t const audio_short_by_frames = video_length_in_audio_frames - _audio_frames_processed; - if (audio_short_by_frames >= 0) { + _log->log ( + String::compose ("DCP length is %1 (%2 audio frames); %3 frames of audio processed.", + _fs->dcp_length(), + video_length_in_audio_frames, + _audio_frames_processed) + ); + + if (audio_short_by_frames >= 0 && _opt->decode_audio) { + + _log->log (String::compose ("DCP length is %1; %2 frames of audio processed.", _fs->dcp_length(), _audio_frames_processed)); + _log->log (String::compose ("Adding %1 frames of silence to the end.", audio_short_by_frames)); - stringstream s; - s << "Adding " << audio_short_by_frames << " frames of silence to the end."; - _log->log (s.str ()); + /* XXX: this is slightly questionable; does memset () give silence with all + sample formats? + */ - int64_t bytes = audio_short_by_frames * _fs->audio_channels * _fs->bytes_per_sample(); + int64_t bytes = audio_short_by_frames * _fs->audio_channels() * bytes_per_audio_sample(); - int64_t const silence_size = 64 * 1024; + int64_t const silence_size = 16 * 1024 * _fs->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); - Audio (silence, t); + emit_audio (silence, t); bytes -= t; } } @@ -166,7 +176,7 @@ Decoder::pass () _have_setup_video_filters = true; } - if (_video_frame >= _fs->dcp_length()) { + if (!_ignore_length && _video_frame >= _fs->dcp_length()) { return true; } @@ -174,53 +184,91 @@ Decoder::pass () } /** Called by subclasses to tell the world that some audio data is ready - * @param data Interleaved audio data, in FilmState::audio_sample_format. + * @param data Audio data, in FilmState::audio_sample_format. * @param size Number of bytes of data. */ void Decoder::process_audio (uint8_t* data, int size) { - /* Samples per channel */ - int const samples = size / _fs->bytes_per_sample(); + /* Push into the delay line */ + size = _delay_line->feed (data, size); + + emit_audio (data, size); +} + +void +Decoder::emit_audio (uint8_t* data, int size) +{ + /* Deinterleave and convert to float */ + + assert ((size % (bytes_per_audio_sample() * _fs->audio_channels())) == 0); + + int const total_samples = size / bytes_per_audio_sample(); + int const frames = total_samples / _fs->audio_channels(); + shared_ptr audio (new AudioBuffers (_fs->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 == _fs->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 == _fs->audio_channels()) { + channel = 0; + ++sample; + } + } + } + + case AV_SAMPLE_FMT_FLTP: + { + float* p = reinterpret_cast (data); + for (int i = 0; i < _fs->audio_channels(); ++i) { + memcpy (audio->data(i), p, frames * sizeof(float)); + p += frames; + } + } + break; + + default: + assert (false); + } /* Maybe apply gain */ - if (_fs->audio_gain != 0) { - float const linear_gain = pow (10, _fs->audio_gain / 20); - uint8_t* p = data; - 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 */ - - /* unsigned sample */ - int const ou = p[0] | (p[1] << 8); - - /* signed sample */ - int const os = ou >= 0x8000 ? (- 0x10000 + ou) : ou; - - /* signed sample with altered gain */ - int const gs = int (os * linear_gain); - - /* unsigned sample with altered gain */ - int const gu = gs > 0 ? gs : (0x10000 + gs); - - /* write it back */ - p[0] = gu & 0xff; - p[1] = (gu & 0xff00) >> 8; - p += 2; + if (_fs->audio_gain() != 0) { + float const linear_gain = pow (10, _fs->audio_gain() / 20); + for (int i = 0; i < _fs->audio_channels(); ++i) { + for (int j = 0; j < frames; ++j) { + audio->data(i)[j] *= linear_gain; } - break; - default: - assert (false); } } /* Update the number of audio frames we've pushed to the encoder */ - _audio_frames_processed += size / (_fs->audio_channels * _fs->bytes_per_sample ()); + _audio_frames_processed += audio->frames (); - /* Push into the delay line and then tell the world what we've got */ - int available = _delay_line->feed (data, size); - Audio (data, available); + Audio (audio); } /** Called by subclasses to tell the world that some video data is ready. @@ -239,7 +287,7 @@ Decoder::process_video (AVFrame* frame) int gap = 0; if (_opt->decode_video_frequency != 0) { - gap = _fs->length / _opt->decode_video_frequency; + gap = _fs->length() / _opt->decode_video_frequency; } if (_opt->decode_video_frequency != 0 && gap != 0 && (_video_frame % gap) != 0) { @@ -303,10 +351,13 @@ Decoder::process_video (AVFrame* frame) image->make_black (); } - overlay (image); + shared_ptr sub; + if (_timed_subtitle && _timed_subtitle->displayed_at (double (last_video_frame()) / _fs->frames_per_second())) { + sub = _timed_subtitle->subtitle (); + } TIMING ("Decoder emits %1", _video_frame); - Video (image, _video_frame); + Video (image, _video_frame, sub); ++_video_frame; } } @@ -324,13 +375,13 @@ Decoder::setup_video_filters () if (_opt->apply_crop) { size_after_crop = _fs->cropped_size (native_size ()); - fs << crop_string (Position (_fs->crop.left, _fs->crop.top), size_after_crop); + fs << crop_string (Position (_fs->crop().left, _fs->crop().top), 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; + string filters = Filter::ffmpeg_strings (_fs->filters()).first; if (!filters.empty ()) { filters += ","; } @@ -407,3 +458,20 @@ Decoder::setup_video_filters () /* XXX: leaking `inputs' / `outputs' ? */ } +void +Decoder::process_subtitle (shared_ptr s) +{ + _timed_subtitle = s; + + if (_timed_subtitle && _opt->apply_crop) { + Position const p = _timed_subtitle->subtitle()->position (); + _timed_subtitle->subtitle()->set_position (Position (p.x - _fs->crop().left, p.y - _fs->crop().top)); + } +} + + +int +Decoder::bytes_per_audio_sample () const +{ + return av_get_bytes_per_sample (audio_sample_format ()); +}