X-Git-Url: https://git.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fffmpeg_file_encoder.cc;h=307a30aca340227cc9ec2ed5246aec8c162f73d1;hp=05b6b7fe51aaee8923b5deda1124b3e4d9a994d6;hb=1c57df596882f15403ee97d01862f8b76cfb797b;hpb=b057363e69b77119137c0c8b07402828096e03aa diff --git a/src/lib/ffmpeg_file_encoder.cc b/src/lib/ffmpeg_file_encoder.cc index 05b6b7fe5..307a30aca 100644 --- a/src/lib/ffmpeg_file_encoder.cc +++ b/src/lib/ffmpeg_file_encoder.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2017-2018 Carl Hetherington + Copyright (C) 2017-2021 Carl Hetherington This file is part of DCP-o-matic. @@ -18,37 +18,41 @@ */ + +#include "compose.hpp" +#include "cross.h" #include "ffmpeg_encoder.h" +#include "ffmpeg_wrapper.h" #include "film.h" +#include "image.h" #include "job.h" +#include "log.h" #include "player.h" #include "player_video.h" -#include "log.h" -#include "image.h" -#include "cross.h" -#include "compose.hpp" +extern "C" { +#include +} #include #include "i18n.h" -using std::string; -using std::runtime_error; + using std::cout; -using std::pair; -using boost::shared_ptr; +using std::make_shared; +using std::shared_ptr; +using std::string; using boost::bind; -using boost::weak_ptr; -using boost::optional; using namespace dcpomatic; #if BOOST_VERSION >= 106100 using namespace boost::placeholders; #endif + int FFmpegFileEncoder::_video_stream_index = 0; int FFmpegFileEncoder::_audio_stream_index_base = 1; -class ExportAudioStream : public boost::noncopyable +class ExportAudioStream { public: ExportAudioStream (string codec_name, int channels, int frame_rate, AVSampleFormat sample_format, AVFormatContext* format_context, int stream_index) @@ -57,16 +61,14 @@ public: { _codec = avcodec_find_encoder_by_name (codec_name.c_str()); if (!_codec) { - throw runtime_error (String::compose("could not find FFmpeg encoder %1", codec_name)); + throw EncodeError (String::compose("avcodec_find_encoder_by_name failed for %1", codec_name)); } _codec_context = avcodec_alloc_context3 (_codec); if (!_codec_context) { - throw runtime_error ("could not allocate FFmpeg audio context"); + throw std::bad_alloc (); } - avcodec_get_context_defaults3 (_codec_context, _codec); - /* XXX: configurable */ _codec_context->bit_rate = channels * 128 * 1024; _codec_context->sample_fmt = sample_format; @@ -74,21 +76,21 @@ public: _codec_context->channel_layout = av_get_default_channel_layout (channels); _codec_context->channels = channels; + int r = avcodec_open2 (_codec_context, _codec, 0); + if (r < 0) { + throw EncodeError (N_("avcodec_open2"), N_("ExportAudioStream::ExportAudioStream"), r); + } + _stream = avformat_new_stream (format_context, _codec); if (!_stream) { - throw runtime_error ("could not create FFmpeg output audio stream"); + throw EncodeError (N_("avformat_new_stream"), N_("ExportAudioStream::ExportAudioStream")); } _stream->id = stream_index; -DCPOMATIC_DISABLE_WARNINGS - _stream->codec = _codec_context; -DCPOMATIC_ENABLE_WARNINGS - - int r = avcodec_open2 (_codec_context, _codec, 0); + _stream->disposition |= AV_DISPOSITION_DEFAULT; + r = avcodec_parameters_from_context (_stream->codecpar, _codec_context); if (r < 0) { - char buffer[256]; - av_strerror (r, buffer, sizeof(buffer)); - throw runtime_error (String::compose("could not open FFmpeg audio codec (%1)", buffer)); + throw EncodeError (N_("avcodec_parameters_from_context"), N_("ExportAudioStream::ExportAudioStream"), r); } } @@ -97,46 +99,51 @@ DCPOMATIC_ENABLE_WARNINGS avcodec_close (_codec_context); } + ExportAudioStream (ExportAudioStream const&) = delete; + ExportAudioStream& operator= (ExportAudioStream const&) = delete; + int frame_size () const { return _codec_context->frame_size; } bool flush () { - AVPacket packet; - av_init_packet (&packet); - packet.data = 0; - packet.size = 0; - bool flushed = false; - - int got_packet; -DCPOMATIC_DISABLE_WARNINGS - avcodec_encode_audio2 (_codec_context, &packet, 0, &got_packet); -DCPOMATIC_ENABLE_WARNINGS - if (got_packet) { - packet.stream_index = 0; - av_interleaved_write_frame (_format_context, &packet); - } else { - flushed = true; + int r = avcodec_send_frame (_codec_context, nullptr); + if (r < 0 && r != AVERROR_EOF) { + /* We get EOF if we've already flushed the stream once */ + throw EncodeError (N_("avcodec_send_frame"), N_("ExportAudioStream::flush"), r); } - av_packet_unref (&packet); - return flushed; + + ffmpeg::Packet packet; + r = avcodec_receive_packet (_codec_context, packet.get()); + if (r == AVERROR_EOF) { + return true; + } else if (r < 0) { + throw EncodeError (N_("avcodec_receive_packet"), N_("ExportAudioStream::flush"), r); + } + + packet->stream_index = _stream_index; + av_interleaved_write_frame (_format_context, packet.get()); + return false; } - void write (int size, int channel_offset, int channels, float** data, int64_t sample_offset) + void write (int size, int channel_offset, int channels, float* const* data, int64_t sample_offset) { DCPOMATIC_ASSERT (size); - AVFrame* frame = av_frame_alloc (); + auto frame = av_frame_alloc (); DCPOMATIC_ASSERT (frame); - int const buffer_size = av_samples_get_buffer_size (0, channels, size, _codec_context->sample_fmt, 0); + int line_size; + int const buffer_size = av_samples_get_buffer_size (&line_size, channels, size, _codec_context->sample_fmt, 0); DCPOMATIC_ASSERT (buffer_size >= 0); - void* samples = av_malloc (buffer_size); + auto samples = av_malloc (buffer_size); DCPOMATIC_ASSERT (samples); frame->nb_samples = size; + frame->format = _codec_context->sample_fmt; + frame->channels = channels; int r = avcodec_fill_audio_frame (frame, channels, _codec_context->sample_fmt, (const uint8_t *) samples, buffer_size, 0); DCPOMATIC_ASSERT (r >= 0); @@ -163,10 +170,8 @@ DCPOMATIC_ENABLE_WARNINGS } case AV_SAMPLE_FMT_FLTP: { - float* q = reinterpret_cast (samples); for (int i = 0; i < channels; ++i) { - memcpy (q, data[i + channel_offset], sizeof(float) * size); - q += size; + memcpy (reinterpret_cast(static_cast(samples) + i * line_size), data[i + channel_offset], sizeof(float) * size); } break; } @@ -177,31 +182,26 @@ DCPOMATIC_ENABLE_WARNINGS DCPOMATIC_ASSERT (_codec_context->time_base.num == 1); frame->pts = sample_offset * _codec_context->time_base.den / _codec_context->sample_rate; - AVPacket packet; - av_init_packet (&packet); - packet.data = 0; - packet.size = 0; - int got_packet; - - DCPOMATIC_DISABLE_WARNINGS - if (avcodec_encode_audio2 (_codec_context, &packet, frame, &got_packet) < 0) { - throw EncodeError ("FFmpeg audio encode failed"); + r = avcodec_send_frame (_codec_context, frame); + av_free (samples); + av_frame_free (&frame); + if (r < 0) { + throw EncodeError (N_("avcodec_send_frame"), N_("ExportAudioStream::write"), r); } - DCPOMATIC_ENABLE_WARNINGS - if (got_packet && packet.size) { - packet.stream_index = _stream_index; - av_interleaved_write_frame (_format_context, &packet); - av_packet_unref (&packet); + ffmpeg::Packet packet; + r = avcodec_receive_packet (_codec_context, packet.get()); + if (r < 0 && r != AVERROR(EAGAIN)) { + throw EncodeError (N_("avcodec_receive_packet"), N_("ExportAudioStream::write"), r); + } else if (r >= 0) { + packet->stream_index = _stream_index; + av_interleaved_write_frame (_format_context, packet.get()); } - - av_free (samples); - av_frame_free (&frame); } private: AVFormatContext* _format_context; - AVCodec* _codec; + AVCodec const * _codec; AVCodecContext* _codec_context; AVStream* _stream; int _stream_index; @@ -217,53 +217,44 @@ FFmpegFileEncoder::FFmpegFileEncoder ( bool audio_stream_per_channel, int x264_crf, boost::filesystem::path output -#ifdef DCPOMATIC_VARIANT_SWAROOP - , optional key - , optional id -#endif ) : _audio_stream_per_channel (audio_stream_per_channel) - , _video_options (0) , _audio_channels (channels) , _output (output) , _video_frame_size (video_frame_size) , _video_frame_rate (video_frame_rate) , _audio_frame_rate (audio_frame_rate) - , _audio_frames (0) { _pixel_format = pixel_format (format); switch (format) { - case EXPORT_FORMAT_PRORES: + case ExportFormat::PRORES_4444: + _sample_format = AV_SAMPLE_FMT_S16; + _video_codec_name = "prores_ks"; + _audio_codec_name = "pcm_s16le"; + av_dict_set(&_video_options, "profile", "4", 0); + av_dict_set(&_video_options, "threads", "auto", 0); + break; + case ExportFormat::PRORES_HQ: _sample_format = AV_SAMPLE_FMT_S16; _video_codec_name = "prores_ks"; _audio_codec_name = "pcm_s16le"; av_dict_set (&_video_options, "profile", "3", 0); av_dict_set (&_video_options, "threads", "auto", 0); break; - case EXPORT_FORMAT_H264_AAC: + case ExportFormat::H264_AAC: _sample_format = AV_SAMPLE_FMT_FLTP; _video_codec_name = "libx264"; _audio_codec_name = "aac"; av_dict_set_int (&_video_options, "crf", x264_crf, 0); break; - case EXPORT_FORMAT_H264_PCM: - _sample_format = AV_SAMPLE_FMT_S32; - _video_codec_name = "libx264"; - _audio_codec_name = "pcm_s24le"; - av_dict_set_int (&_video_options, "crf", x264_crf, 0); - break; default: DCPOMATIC_ASSERT (false); } -#ifdef DCPOMATIC_VARIANT_SWAROOP - int r = avformat_alloc_output_context2 (&_format_context, av_guess_format("mov", 0, 0), 0, 0); -#else int r = avformat_alloc_output_context2 (&_format_context, 0, 0, _output.string().c_str()); -#endif if (!_format_context) { - throw runtime_error (String::compose("could not allocate FFmpeg format context (%1)", r)); + throw EncodeError (N_("avformat_alloc_output_context2"), "FFmpegFileEncoder::FFmpegFileEncoder", r); } setup_video (); @@ -271,31 +262,17 @@ FFmpegFileEncoder::FFmpegFileEncoder ( r = avio_open_boost (&_format_context->pb, _output, AVIO_FLAG_WRITE); if (r < 0) { - throw runtime_error (String::compose("could not open FFmpeg output file %1 (%2)", _output.string(), r)); + throw EncodeError (String::compose(_("Could not open output file %1 (%2)"), _output.string(), r)); } - AVDictionary* options = 0; - -#ifdef DCPOMATIC_VARIANT_SWAROOP - if (key) { - av_dict_set (&options, "encryption_key", key->hex().c_str(), 0); - /* XXX: is this OK? */ - av_dict_set (&options, "encryption_kid", "00000000000000000000000000000000", 0); - av_dict_set (&options, "encryption_scheme", "cenc-aes-ctr", 0); - } - - if (id) { - if (av_dict_set(&_format_context->metadata, SWAROOP_ID_TAG, id->c_str(), 0) < 0) { - throw runtime_error ("Could not write ID to output"); - } - } -#endif + AVDictionary* options = nullptr; - if (avformat_write_header (_format_context, &options) < 0) { - throw runtime_error ("could not write header to FFmpeg output file"); + r = avformat_write_header (_format_context, &options); + if (r < 0) { + throw EncodeError (N_("avformat_write_header"), N_("FFmpegFileEncoder::FFmpegFileEncoder"), r); } - _pending_audio.reset (new AudioBuffers(channels, 0)); + _pending_audio = make_shared(channels, 0); } @@ -311,10 +288,11 @@ AVPixelFormat FFmpegFileEncoder::pixel_format (ExportFormat format) { switch (format) { - case EXPORT_FORMAT_PRORES: + case ExportFormat::PRORES_4444: + return AV_PIX_FMT_YUV444P10; + case ExportFormat::PRORES_HQ: return AV_PIX_FMT_YUV422P10; - case EXPORT_FORMAT_H264_AAC: - case EXPORT_FORMAT_H264_PCM: + case ExportFormat::H264_AAC: return AV_PIX_FMT_YUV420P; default: DCPOMATIC_ASSERT (false); @@ -323,21 +301,20 @@ FFmpegFileEncoder::pixel_format (ExportFormat format) return AV_PIX_FMT_YUV422P10; } + void FFmpegFileEncoder::setup_video () { _video_codec = avcodec_find_encoder_by_name (_video_codec_name.c_str()); if (!_video_codec) { - throw runtime_error (String::compose ("could not find FFmpeg encoder %1", _video_codec_name)); + throw EncodeError (String::compose("avcodec_find_encoder_by_name failed for %1", _video_codec_name)); } _video_codec_context = avcodec_alloc_context3 (_video_codec); if (!_video_codec_context) { - throw runtime_error ("could not allocate FFmpeg video context"); + throw std::bad_alloc (); } - avcodec_get_context_defaults3 (_video_codec_context, _video_codec); - /* Variable quantisation */ _video_codec_context->global_quality = 0; _video_codec_context->width = _video_frame_size.width; @@ -346,18 +323,19 @@ FFmpegFileEncoder::setup_video () _video_codec_context->pix_fmt = _pixel_format; _video_codec_context->flags |= AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_GLOBAL_HEADER; + if (avcodec_open2 (_video_codec_context, _video_codec, &_video_options) < 0) { + throw EncodeError (N_("avcodec_open"), N_("FFmpegFileEncoder::setup_video")); + } + _video_stream = avformat_new_stream (_format_context, _video_codec); if (!_video_stream) { - throw runtime_error ("could not create FFmpeg output video stream"); + throw EncodeError (N_("avformat_new_stream"), N_("FFmpegFileEncoder::setup_video")); } -DCPOMATIC_DISABLE_WARNINGS _video_stream->id = _video_stream_index; - _video_stream->codec = _video_codec_context; -DCPOMATIC_ENABLE_WARNINGS - - if (avcodec_open2 (_video_codec_context, _video_codec, &_video_options) < 0) { - throw runtime_error ("could not open FFmpeg video codec"); + int r = avcodec_parameters_from_context (_video_stream->codecpar, _video_codec_context); + if (r < 0) { + throw EncodeError (N_("avcodec_parameters_from_context"), N_("FFmpegFileEncoder::setup_video"), r); } } @@ -370,8 +348,8 @@ FFmpegFileEncoder::setup_audio () for (int i = 0; i < streams; ++i) { _audio_streams.push_back( - shared_ptr( - new ExportAudioStream(_audio_codec_name, channels_per_stream, _audio_frame_rate, _sample_format, _format_context, _audio_stream_index_base + i) + make_shared( + _audio_codec_name, channels_per_stream, _audio_frame_rate, _sample_format, _format_context, _audio_stream_index_base + i ) ); } @@ -389,25 +367,25 @@ FFmpegFileEncoder::flush () bool flushed_audio = false; while (!flushed_video || !flushed_audio) { - AVPacket packet; - av_init_packet (&packet); - packet.data = 0; - packet.size = 0; - - int got_packet; -DCPOMATIC_DISABLE_WARNINGS - avcodec_encode_video2 (_video_codec_context, &packet, 0, &got_packet); -DCPOMATIC_ENABLE_WARNINGS - if (got_packet) { - packet.stream_index = 0; - av_interleaved_write_frame (_format_context, &packet); - } else { + int r = avcodec_send_frame (_video_codec_context, nullptr); + if (r < 0 && r != AVERROR_EOF) { + /* We get EOF if we've already flushed the stream once */ + throw EncodeError (N_("avcodec_send_frame"), N_("FFmpegFileEncoder::flush"), r); + } + + ffmpeg::Packet packet; + r = avcodec_receive_packet (_video_codec_context, packet.get()); + if (r == AVERROR_EOF) { flushed_video = true; + } else if (r < 0) { + throw EncodeError (N_("avcodec_receive_packet"), N_("FFmpegFileEncoder::flush"), r); + } else { + packet->stream_index = _video_stream_index; + av_interleaved_write_frame (_format_context, packet.get()); } - av_packet_unref (&packet); flushed_audio = true; - BOOST_FOREACH (shared_ptr i, _audio_streams) { + for (auto i: _audio_streams) { if (!i->flush()) { flushed_audio = false; } @@ -417,18 +395,18 @@ DCPOMATIC_ENABLE_WARNINGS av_write_trailer (_format_context); } + void FFmpegFileEncoder::video (shared_ptr video, DCPTime time) { /* All our output formats are video range at the moment */ - shared_ptr image = video->image ( - bind (&PlayerVideo::force, _1, _pixel_format), - VIDEO_RANGE_VIDEO, - true, + auto image = video->image ( + bind (&PlayerVideo::force, _pixel_format), + VideoRange::VIDEO, false ); - AVFrame* frame = av_frame_alloc (); + auto frame = av_frame_alloc (); DCPOMATIC_ASSERT (frame); { @@ -437,7 +415,7 @@ FFmpegFileEncoder::video (shared_ptr video, DCPTime time) } for (int i = 0; i < 3; ++i) { - AVBufferRef* buffer = av_buffer_create(image->data()[i], image->stride()[i] * image->size().height, &buffer_free, this, 0); + auto buffer = av_buffer_create(image->data()[i], image->stride()[i] * image->size().height, &buffer_free, this, 0); frame->buf[i] = av_buffer_ref (buffer); frame->data[i] = buffer->data; frame->linesize[i] = image->stride()[i]; @@ -450,28 +428,23 @@ FFmpegFileEncoder::video (shared_ptr video, DCPTime time) DCPOMATIC_ASSERT (_video_stream->time_base.num == 1); frame->pts = time.get() * _video_stream->time_base.den / DCPTime::HZ; - AVPacket packet; - av_init_packet (&packet); - packet.data = 0; - packet.size = 0; - - int got_packet; -DCPOMATIC_DISABLE_WARNINGS - if (avcodec_encode_video2 (_video_codec_context, &packet, frame, &got_packet) < 0) { - throw EncodeError ("FFmpeg video encode failed"); + int r = avcodec_send_frame (_video_codec_context, frame); + av_frame_free (&frame); + if (r < 0) { + throw EncodeError (N_("avcodec_send_frame"), N_("FFmpegFileEncoder::video"), r); } -DCPOMATIC_ENABLE_WARNINGS - if (got_packet && packet.size) { - packet.stream_index = _video_stream_index; - av_interleaved_write_frame (_format_context, &packet); - av_packet_unref (&packet); + ffmpeg::Packet packet; + r = avcodec_receive_packet (_video_codec_context, packet.get()); + if (r < 0 && r != AVERROR(EAGAIN)) { + throw EncodeError (N_("avcodec_receive_packet"), N_("FFmpegFileEncoder::video"), r); + } else if (r >= 0) { + packet->stream_index = _video_stream_index; + av_interleaved_write_frame (_format_context, packet.get()); } - - av_frame_free (&frame); - } + /** Called when the player gives us some audio */ void FFmpegFileEncoder::audio (shared_ptr audio) @@ -490,12 +463,13 @@ FFmpegFileEncoder::audio (shared_ptr audio) } } + void FFmpegFileEncoder::audio_frame (int size) { if (_audio_stream_per_channel) { int offset = 0; - BOOST_FOREACH (shared_ptr i, _audio_streams) { + for (auto i: _audio_streams) { i->write (size, offset, 1, _pending_audio->data(), _audio_frames); ++offset; } @@ -509,18 +483,21 @@ FFmpegFileEncoder::audio_frame (int size) _audio_frames += size; } + void FFmpegFileEncoder::subtitle (PlayerText, DCPTimePeriod) { } + void FFmpegFileEncoder::buffer_free (void* opaque, uint8_t* data) { reinterpret_cast(opaque)->buffer_free2(data); } + void FFmpegFileEncoder::buffer_free2 (uint8_t* data) {