X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fffmpeg_file_encoder.cc;h=533fd151c648cb083e6b6e57b3db80edf27ae19d;hb=b88874e34d429b4624965da09edfde3a56329e38;hp=d15bdabde676723922cba737d6c50839ab085805;hpb=5d3c9573914a61db10b24ce7e0cef00902c2912c;p=dcpomatic.git diff --git a/src/lib/ffmpeg_file_encoder.cc b/src/lib/ffmpeg_file_encoder.cc index d15bdabde..533fd151c 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,7 +18,9 @@ */ + #include "ffmpeg_encoder.h" +#include "ffmpeg_wrapper.h" #include "film.h" #include "job.h" #include "player.h" @@ -27,25 +29,34 @@ #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::make_shared; using std::pair; -using boost::shared_ptr; +using std::runtime_error; +using std::shared_ptr; +using std::string; +using std::weak_ptr; 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) @@ -54,16 +65,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; @@ -71,21 +80,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); } } @@ -94,46 +103,50 @@ 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); + } + + 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); } - av_packet_unref (&packet); - return flushed; + + 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) { 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); 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); @@ -174,31 +187,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; @@ -214,37 +222,31 @@ 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: _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: + case ExportFormat::H264_PCM: _sample_format = AV_SAMPLE_FMT_S32; _video_codec_name = "libx264"; _audio_codec_name = "pcm_s24le"; @@ -254,13 +256,9 @@ FFmpegFileEncoder::FFmpegFileEncoder ( 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 (); @@ -268,28 +266,14 @@ 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; + AVDictionary* options = nullptr; -#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 - - 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)); @@ -308,10 +292,10 @@ AVPixelFormat FFmpegFileEncoder::pixel_format (ExportFormat format) { switch (format) { - case EXPORT_FORMAT_PRORES: + case ExportFormat::PRORES: return AV_PIX_FMT_YUV422P10; - case EXPORT_FORMAT_H264_AAC: - case EXPORT_FORMAT_H264_PCM: + case ExportFormat::H264_AAC: + case ExportFormat::H264_PCM: return AV_PIX_FMT_YUV420P; default: DCPOMATIC_ASSERT (false); @@ -320,21 +304,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; @@ -343,18 +326,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); } } @@ -367,8 +351,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 ) ); } @@ -386,25 +370,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; } @@ -414,16 +398,19 @@ DCPOMATIC_ENABLE_WARNINGS av_write_trailer (_format_context); } + void FFmpegFileEncoder::video (shared_ptr video, DCPTime time) { - shared_ptr image = video->image ( + /* All our output formats are video range at the moment */ + auto image = video->image ( bind (&PlayerVideo::force, _1, _pixel_format), + VideoRange::VIDEO, true, false ); - AVFrame* frame = av_frame_alloc (); + auto frame = av_frame_alloc (); DCPOMATIC_ASSERT (frame); { @@ -432,7 +419,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]; @@ -445,28 +432,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) @@ -485,12 +467,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; } @@ -504,18 +487,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) {