src/lib/ffmpeg_encoder.cc

   1 /*
   2     Copyright (C) 2017 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21 #include "ffmpeg_encoder.h"
  22 #include "film.h"
  23 #include "job.h"
  24 #include "player.h"
  25 #include "player_video.h"
  26 #include "log.h"
  27 #include "image.h"
  28 #include "compose.hpp"
  29 #include <iostream>
  30
  31 #include "i18n.h"
  32
  33 using std::string;
  34 using std::runtime_error;
  35 using std::cout;
  36 using boost::shared_ptr;
  37 using boost::bind;
  38 using boost::weak_ptr;
  39
  40 static AVPixelFormat
  41 force_pixel_format (AVPixelFormat, AVPixelFormat out)
  42 {
  43         return out;
  44 }
  45
  46 FFmpegEncoder::FFmpegEncoder (shared_ptr<const Film> film, weak_ptr<Job> job, boost::filesystem::path output, Format format)
  47         : Encoder (film, job)
  48         , _history (1000)
  49         , _output (output)
  50 {
  51         switch (format) {
  52         case FORMAT_PRORES:
  53                 _pixel_format = AV_PIX_FMT_YUV422P10;
  54                 _codec_name = "prores_ks";
  55                 break;
  56         case FORMAT_H264:
  57                 _pixel_format = AV_PIX_FMT_YUV420P;
  58                 _codec_name = "libx264";
  59                 break;
  60         }
  61 }
  62
  63 void
  64 FFmpegEncoder::go ()
  65 {
  66         AVCodec* codec = avcodec_find_encoder_by_name (_codec_name.c_str());
  67         if (!codec) {
  68                 throw runtime_error (String::compose ("could not find FFmpeg encoder %1", _codec_name));
  69         }
  70
  71         _codec_context = avcodec_alloc_context3 (codec);
  72         if (!_codec_context) {
  73                 throw runtime_error ("could not allocate FFmpeg context");
  74         }
  75
  76         avcodec_get_context_defaults3 (_codec_context, codec);
  77
  78         /* Variable quantisation */
  79         _codec_context->global_quality = 0;
  80         _codec_context->width = _film->frame_size().width;
  81         _codec_context->height = _film->frame_size().height;
  82         _codec_context->time_base = (AVRational) { 1, _film->video_frame_rate() };
  83         _codec_context->pix_fmt = _pixel_format;
  84         _codec_context->flags |= CODEC_FLAG_QSCALE | CODEC_FLAG_GLOBAL_HEADER;
  85
  86         avformat_alloc_output_context2 (&_format_context, 0, 0, _output.string().c_str());
  87         if (!_format_context) {
  88                 throw runtime_error ("could not allocate FFmpeg format context");
  89         }
  90
  91         _video_stream = avformat_new_stream (_format_context, codec);
  92         if (!_video_stream) {
  93                 throw runtime_error ("could not create FFmpeg output video stream");
  94         }
  95
  96         /* Note: needs to increment with each stream */
  97         _video_stream->id = 0;
  98         _video_stream->codec = _codec_context;
  99
 100         AVDictionary* options = 0;
 101         av_dict_set (&options, "profile", "3", 0);
 102         av_dict_set (&options, "threads", "auto", 0);
 103
 104         if (avcodec_open2 (_codec_context, codec, &options) < 0) {
 105                 throw runtime_error ("could not open FFmpeg codec");
 106         }
 107
 108         if (avio_open (&_format_context->pb, _output.c_str(), AVIO_FLAG_WRITE) < 0) {
 109                 throw runtime_error ("could not open FFmpeg output file");
 110         }
 111
 112         if (avformat_write_header (_format_context, &options) < 0) {
 113                 throw runtime_error ("could not write header to FFmpeg output file");
 114         }
 115
 116         {
 117                 shared_ptr<Job> job = _job.lock ();
 118                 DCPOMATIC_ASSERT (job);
 119                 job->sub (_("Encoding"));
 120         }
 121
 122         while (!_player->pass ()) {}
 123
 124         while (true) {
 125                 AVPacket packet;
 126                 av_init_packet (&packet);
 127                 packet.data = 0;
 128                 packet.size = 0;
 129
 130                 int got_packet;
 131                 avcodec_encode_video2 (_codec_context, &packet, 0, &got_packet);
 132                 if (!got_packet) {
 133                         break;
 134                 }
 135
 136                 packet.stream_index = 0;
 137                 av_interleaved_write_frame (_format_context, &packet);
 138                 av_packet_unref (&packet);
 139         }
 140
 141         av_write_trailer (_format_context);
 142
 143         avcodec_close (_codec_context);
 144         avio_close (_format_context->pb);
 145         avformat_free_context (_format_context);
 146 }
 147
 148 void
 149 FFmpegEncoder::video (shared_ptr<PlayerVideo> video, DCPTime time)
 150 {
 151         shared_ptr<Image> image = video->image (
 152                 bind (&Log::dcp_log, _film->log().get(), _1, _2),
 153                 bind (&force_pixel_format, _1, _pixel_format),
 154                 true,
 155                 false
 156                 );
 157
 158         AVFrame* frame = av_frame_alloc ();
 159
 160         for (int i = 0; i < 3; ++i) {
 161                 size_t const size = image->stride()[i] * image->size().height;
 162                 AVBufferRef* buffer = av_buffer_alloc (size);
 163                 /* XXX: inefficient */
 164                 memcpy (buffer->data, image->data()[i], size);
 165                 frame->buf[i] = av_buffer_ref (buffer);
 166                 frame->data[i] = buffer->data;
 167                 frame->linesize[i] = image->stride()[i];
 168                 av_buffer_unref (&buffer);
 169         }
 170
 171         frame->width = image->size().width;
 172         frame->height = image->size().height;
 173         frame->format = _pixel_format;
 174         frame->pts = time.seconds() / av_q2d (_video_stream->time_base);
 175
 176         AVPacket packet;
 177         av_init_packet (&packet);
 178         packet.data = 0;
 179         packet.size = 0;
 180
 181         int got_packet;
 182         if (avcodec_encode_video2 (_codec_context, &packet, frame, &got_packet) < 0) {
 183                 throw EncodeError ("FFmpeg video encode failed");
 184         }
 185
 186         if (got_packet && packet.size) {
 187                 /* XXX: this should not be hard-wired */
 188                 packet.stream_index = 0;
 189                 av_interleaved_write_frame (_format_context, &packet);
 190                 av_packet_unref (&packet);
 191         }
 192
 193         av_frame_free (&frame);
 194
 195         _history.event ();
 196
 197         {
 198                 boost::mutex::scoped_lock lm (_mutex);
 199                 _last_time = time;
 200         }
 201
 202         shared_ptr<Job> job = _job.lock ();
 203         if (job) {
 204                 job->set_progress (float(time.get()) / _film->length().get());
 205         }
 206 }
 207
 208 void
 209 FFmpegEncoder::audio (shared_ptr<AudioBuffers> audio, DCPTime time)
 210 {
 211
 212 }
 213
 214 void
 215 FFmpegEncoder::subtitle (PlayerSubtitles subs, DCPTimePeriod period)
 216 {
 217
 218 }
 219
 220 float
 221 FFmpegEncoder::current_rate () const
 222 {
 223         return _history.rate ();
 224 }
 225
 226 Frame
 227 FFmpegEncoder::frames_done () const
 228 {
 229         boost::mutex::scoped_lock lm (_mutex);
 230         return _last_time.frames_round (_film->video_frame_rate ());
 231 }