src/moviemaker.cc

   1 //
   2 //  moviemaker.cc
   3 //
   4 //  Class for writing movies from Aven.
   5 //
   6 //  Copyright (C) 2004,2011,2012,2013,2014,2015,2016 Olly Betts
   7 //
   8 //  This program is free software; you can redistribute it and/or modify
   9 //  it under the terms of the GNU General Public License as published by
  10 //  the Free Software Foundation; either version 2 of the License, or
  11 //  (at your option) any later version.
  12 //
  13 //  This program is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 //  GNU General Public License for more details.
  17 //
  18 //  You should have received a copy of the GNU General Public License
  19 //  along with this program; if not, write to the Free Software
  20 //  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21 //
  22
  23 /* Based on output-example.c:
  24  *
  25  * Libavformat API example: Output a media file in any supported
  26  * libavformat format. The default codecs are used.
  27  *
  28  * Copyright (c) 2003 Fabrice Bellard
  29  *
  30  * Permission is hereby granted, free of charge, to any person obtaining a copy
  31  * of this software and associated documentation files (the "Software"), to deal
  32  * in the Software without restriction, including without limitation the rights
  33  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  34  * copies of the Software, and to permit persons to whom the Software is
  35  * furnished to do so, subject to the following conditions:
  36  *
  37  * The above copyright notice and this permission notice shall be included in
  38  * all copies or substantial portions of the Software.
  39  *
  40  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  41  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  42  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  43  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  44  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  45  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  46  * THE SOFTWARE.
  47  */
  48
  49 #ifdef HAVE_CONFIG_H
  50 #include <config.h>
  51 #endif
  52
  53 #define __STDC_CONSTANT_MACROS
  54
  55 #include <assert.h>
  56 #include <stdlib.h>
  57 #include <string.h>
  58
  59 #include "moviemaker.h"
  60
  61 #ifdef WITH_LIBAV
  62 extern "C" {
  63 # include <libavutil/imgutils.h>
  64 # include <libavutil/mathematics.h>
  65 # include <libavformat/avformat.h>
  66 # include <libswscale/swscale.h>
  67 }
  68 # ifndef AV_PKT_FLAG_KEY
  69 #  define AV_PKT_FLAG_KEY PKT_FLAG_KEY
  70 # endif
  71 # ifndef HAVE_AV_GUESS_FORMAT
  72 #  define av_guess_format guess_format
  73 # endif
  74 # ifndef HAVE_AVIO_OPEN
  75 #  define avio_open url_fopen
  76 # endif
  77 # ifndef HAVE_AVIO_CLOSE
  78 #  define avio_close url_fclose
  79 # endif
  80 # ifndef HAVE_AV_FRAME_ALLOC
  81 static inline AVFrame * av_frame_alloc() {
  82     return avcodec_alloc_frame();
  83 }
  84 # endif
  85 # ifndef HAVE_AV_FRAME_FREE
  86 #  ifdef HAVE_AVCODEC_FREE_FRAME
  87 static inline void av_frame_free(AVFrame ** frame) {
  88     avcodec_free_frame(frame);
  89 }
  90 #  else
  91 static inline void av_frame_free(AVFrame ** frame) {
  92     free((*frame)->data[0]);
  93     free(*frame);
  94     *frame = NULL;
  95 }
  96 #  endif
  97 # endif
  98 # ifndef HAVE_AVCODEC_OPEN2
  99 // We always pass NULL for OPTS below.
 100 #  define avcodec_open2(CTX, CODEC, OPTS) avcodec_open(CTX, CODEC)
 101 # endif
 102 # ifndef HAVE_AVFORMAT_NEW_STREAM
 103 // We always pass NULL for CODEC below.
 104 #  define avformat_new_stream(S, CODEC) av_new_stream(S, 0)
 105 # endif
 106 # if !HAVE_DECL_AVMEDIA_TYPE_VIDEO
 107 #  define AVMEDIA_TYPE_VIDEO CODEC_TYPE_VIDEO
 108 # endif
 109 # if !HAVE_DECL_AV_CODEC_ID_NONE
 110 #  define AV_CODEC_ID_NONE CODEC_ID_NONE
 111 # endif
 112 # if !HAVE_DECL_AV_PIX_FMT_RGB24
 113 #  define AV_PIX_FMT_RGB24 PIX_FMT_RGB24
 114 # endif
 115 # if !HAVE_DECL_AV_PIX_FMT_YUV420P
 116 #  define AV_PIX_FMT_YUV420P PIX_FMT_YUV420P
 117 # endif
 118 # ifndef AVIO_FLAG_WRITE
 119 #  define AVIO_FLAG_WRITE URL_WRONLY
 120 # endif
 121
 122 enum {
 123     MOVIE_NO_SUITABLE_FORMAT = 1,
 124     MOVIE_AUDIO_ONLY,
 125     MOVIE_FILENAME_TOO_LONG
 126 };
 127
 128 # ifndef HAVE_AVCODEC_ENCODE_VIDEO2
 129 const int OUTBUF_SIZE = 200000;
 130 # endif
 131 #endif
 132
 133 MovieMaker::MovieMaker()
 134 #ifdef WITH_LIBAV
 135     : oc(0), video_st(0), frame(0), outbuf(0), pixels(0), sws_ctx(0), averrno(0)
 136 #endif
 137 {
 138 #ifdef WITH_LIBAV
 139     static bool initialised_ffmpeg = false;
 140     if (initialised_ffmpeg) return;
 141
 142     // FIXME: register only the codec(s) we want to use...
 143     avcodec_register_all();
 144     av_register_all();
 145
 146     initialised_ffmpeg = true;
 147 #endif
 148 }
 149
 150 #ifdef WITH_LIBAV
 151 static int
 152 write_packet(void *opaque, uint8_t *buf, int buf_size) {
 153     FILE * fh = (FILE*)opaque;
 154     size_t res = fwrite(buf, 1, buf_size, fh);
 155     return res > 0 ? res : -1;
 156 }
 157 #endif
 158
 159 #define MAX_EXTENSION_LEN 8
 160
 161 bool MovieMaker::Open(FILE* fh, const char * ext, int width, int height)
 162 {
 163 #ifdef WITH_LIBAV
 164     fh_to_close = fh;
 165
 166     AVOutputFormat * fmt = NULL;
 167     char dummy_filename[MAX_EXTENSION_LEN + 3] = "x.";
 168     if (strlen(ext) <= MAX_EXTENSION_LEN) {
 169         strcpy(dummy_filename + 2, ext);
 170         // Pass "x." + extension to av_guess_format() to avoid having to deal
 171         // with wide character filenames.
 172         fmt = av_guess_format(NULL, dummy_filename, NULL);
 173     }
 174     if (!fmt) {
 175         // We couldn't deduce the output format from file extension so default
 176         // to MPEG.
 177         fmt = av_guess_format("mpeg", NULL, NULL);
 178         if (!fmt) {
 179             averrno = MOVIE_NO_SUITABLE_FORMAT;
 180             return false;
 181         }
 182         strcpy(dummy_filename + 2, "mpg");
 183     }
 184     if (fmt->video_codec == AV_CODEC_ID_NONE) {
 185         averrno = MOVIE_AUDIO_ONLY;
 186         return false;
 187     }
 188
 189     /* Allocate the output media context. */
 190     oc = avformat_alloc_context();
 191     if (!oc) {
 192         averrno = AVERROR(ENOMEM);
 193         return false;
 194     }
 195     oc->oformat = fmt;
 196     strcpy(oc->filename, dummy_filename);
 197
 198     /* find the video encoder */
 199     AVCodec *codec = avcodec_find_encoder(fmt->video_codec);
 200     if (!codec) {
 201         // FIXME : Erm - internal ffmpeg library problem?
 202         averrno = AVERROR(ENOMEM);
 203         return false;
 204     }
 205
 206     // Add the video stream.
 207     video_st = avformat_new_stream(oc, codec);
 208     if (!video_st) {
 209         averrno = AVERROR(ENOMEM);
 210         return false;
 211     }
 212
 213     // Set sample parameters.
 214     AVCodecContext *c = video_st->codec;
 215     c->bit_rate = 400000;
 216     /* Resolution must be a multiple of two. */
 217     c->width = width;
 218     c->height = height;
 219     /* timebase: This is the fundamental unit of time (in seconds) in terms
 220      * of which frame timestamps are represented. For fixed-fps content,
 221      * timebase should be 1/framerate and timestamp increments should be
 222      * identical to 1. */
 223 #if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(55, 44, 0)
 224     // Old way, which now causes deprecation warnings.
 225     c->time_base.den = 25; // Frames per second.
 226     c->time_base.num = 1;
 227 #else
 228     video_st->time_base.den = 25; // Frames per second.
 229     video_st->time_base.num = 1;
 230     c->time_base = video_st->time_base;
 231 #endif
 232     c->gop_size = 12; /* emit one intra frame every twelve frames at most */
 233     c->pix_fmt = AV_PIX_FMT_YUV420P;
 234     c->rc_buffer_size = c->bit_rate * 4; // Enough for 4 seconds
 235     c->rc_max_rate = c->bit_rate * 2;
 236     // B frames are backwards predicted - they can improve compression,
 237     // but may slow encoding and decoding.
 238     // if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
 239     //     c->max_b_frames = 2;
 240     // }
 241
 242     /* Some formats want stream headers to be separate. */
 243     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 244         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
 245
 246     int retval;
 247 #ifndef HAVE_AVFORMAT_WRITE_HEADER
 248     // Set the output parameters (must be done even if no parameters).
 249     retval = av_set_parameters(oc, NULL);
 250     if (retval < 0) {
 251         averrno = retval;
 252         return false;
 253     }
 254 #endif
 255
 256     retval = avcodec_open2(c, NULL, NULL);
 257     if (retval < 0) {
 258         averrno = retval;
 259         return false;
 260     }
 261
 262 #ifndef HAVE_AVCODEC_ENCODE_VIDEO2
 263     outbuf = NULL;
 264     if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
 265         outbuf = (unsigned char *)av_malloc(OUTBUF_SIZE);
 266         if (!outbuf) {
 267             averrno = AVERROR(ENOMEM);
 268             return false;
 269         }
 270     }
 271 #endif
 272
 273     /* Allocate the encoded raw picture. */
 274     frame = av_frame_alloc();
 275     if (!frame) {
 276         averrno = AVERROR(ENOMEM);
 277         return false;
 278     }
 279     retval = av_image_alloc(frame->data, frame->linesize,
 280                             c->width, c->height, c->pix_fmt, 1);
 281     if (retval < 0) {
 282         averrno = retval;
 283         return false;
 284     }
 285
 286     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 287         // FIXME need to allocate another frame for this case if we stop
 288         // hardcoding AV_PIX_FMT_YUV420P.
 289         abort();
 290     }
 291
 292     frame->format = c->pix_fmt;
 293     frame->width = c->width;
 294     frame->height = c->height;
 295
 296     pixels = (unsigned char *)av_malloc(width * height * 6);
 297     if (!pixels) {
 298         averrno = AVERROR(ENOMEM);
 299         return false;
 300     }
 301
 302     // Show the format we've ended up with (for debug purposes).
 303     // av_dump_format(oc, 0, fnm, 1);
 304
 305     av_free(sws_ctx);
 306     sws_ctx = sws_getContext(width, height, AV_PIX_FMT_RGB24,
 307                              width, height, c->pix_fmt, SWS_BICUBIC,
 308                              NULL, NULL, NULL);
 309     if (sws_ctx == NULL) {
 310         fprintf(stderr, "Cannot initialize the conversion context!\n");
 311         averrno = AVERROR(ENOMEM);
 312         return false;
 313     }
 314
 315     if (!(fmt->flags & AVFMT_NOFILE)) {
 316         const int buf_size = 8192;
 317         void * buf = av_malloc(buf_size);
 318         oc->pb = avio_alloc_context(static_cast<uint8_t*>(buf), buf_size, 1,
 319                                     fh, NULL, write_packet, NULL);
 320         if (!oc->pb) {
 321             averrno = AVERROR(ENOMEM);
 322             return false;
 323         }
 324     }
 325
 326     // Write the stream header, if any.
 327 #ifdef HAVE_AVFORMAT_WRITE_HEADER
 328     retval = avformat_write_header(oc, NULL);
 329 #else
 330     retval = av_write_header(oc);
 331 #endif
 332     if (retval < 0) {
 333         averrno = retval;
 334         return false;
 335     }
 336
 337     averrno = 0;
 338     return true;
 339 #else
 340     (void)fh;
 341     (void)ext;
 342     (void)width;
 343     (void)height;
 344     return false;
 345 #endif
 346 }
 347
 348 unsigned char * MovieMaker::GetBuffer() const {
 349 #ifdef WITH_LIBAV
 350     return pixels + GetWidth() * GetHeight() * 3;
 351 #else
 352     return NULL;
 353 #endif
 354 }
 355
 356 int MovieMaker::GetWidth() const {
 357 #ifdef WITH_LIBAV
 358     assert(video_st);
 359     AVCodecContext *c = video_st->codec;
 360     return c->width;
 361 #else
 362     return 0;
 363 #endif
 364 }
 365
 366 int MovieMaker::GetHeight() const {
 367 #ifdef WITH_LIBAV
 368     assert(video_st);
 369     AVCodecContext *c = video_st->codec;
 370     return c->height;
 371 #else
 372     return 0;
 373 #endif
 374 }
 375
 376 bool MovieMaker::AddFrame()
 377 {
 378 #ifdef WITH_LIBAV
 379     AVCodecContext * c = video_st->codec;
 380
 381     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 382         // FIXME convert...
 383         abort();
 384     }
 385
 386     int len = 3 * c->width;
 387     {
 388         // Flip image vertically
 389         int h = c->height;
 390         unsigned char * src = pixels + h * len;
 391         unsigned char * dest = src - len;
 392         while (h--) {
 393             memcpy(dest, src, len);
 394             src += len;
 395             dest -= len;
 396         }
 397     }
 398     sws_scale(sws_ctx, &pixels, &len, 0, c->height, frame->data, frame->linesize);
 399
 400     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
 401         abort();
 402     }
 403
 404     // Encode this frame.
 405 #ifdef HAVE_AVCODEC_ENCODE_VIDEO2
 406     AVPacket pkt;
 407     int got_packet;
 408     av_init_packet(&pkt);
 409     pkt.data = NULL;
 410
 411     int ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
 412     if (ret < 0) {
 413         averrno = ret;
 414         return false;
 415     }
 416     if (got_packet && pkt.size) {
 417         // Write the compressed frame to the media file.
 418         if (pkt.pts != int64_t(AV_NOPTS_VALUE)) {
 419             pkt.pts = av_rescale_q(pkt.pts,
 420                                    c->time_base, video_st->time_base);
 421         }
 422         if (pkt.dts != int64_t(AV_NOPTS_VALUE)) {
 423             pkt.dts = av_rescale_q(pkt.dts,
 424                                    c->time_base, video_st->time_base);
 425         }
 426         pkt.stream_index = video_st->index;
 427
 428         /* Write the compressed frame to the media file. */
 429         ret = av_interleaved_write_frame(oc, &pkt);
 430         if (ret < 0) {
 431             averrno = ret;
 432             return false;
 433         }
 434     }
 435 #else
 436     out_size = avcodec_encode_video(c, outbuf, OUTBUF_SIZE, frame);
 437     // outsize == 0 means that this frame has been buffered, so there's nothing
 438     // to write yet.
 439     if (out_size) {
 440         // Write the compressed frame to the media file.
 441         AVPacket pkt;
 442         av_init_packet(&pkt);
 443
 444         if (c->coded_frame->pts != (int64_t)AV_NOPTS_VALUE)
 445             pkt.pts = av_rescale_q(c->coded_frame->pts, c->time_base, video_st->time_base);
 446         if (c->coded_frame->key_frame)
 447             pkt.flags |= AV_PKT_FLAG_KEY;
 448         pkt.stream_index = video_st->index;
 449         pkt.data = outbuf;
 450         pkt.size = out_size;
 451
 452         /* Write the compressed frame to the media file. */
 453         int ret = av_interleaved_write_frame(oc, &pkt);
 454         if (ret < 0) {
 455             averrno = ret;
 456             return false;
 457         }
 458     }
 459 #endif
 460 #endif
 461     return true;
 462 }
 463
 464 bool
 465 MovieMaker::Close()
 466 {
 467 #ifdef WITH_LIBAV
 468     if (video_st && averrno == 0) {
 469         // No more frames to compress.  The codec may have a few frames
 470         // buffered if we're using B frames, so write those too.
 471         AVCodecContext * c = video_st->codec;
 472
 473 #ifdef HAVE_AVCODEC_ENCODE_VIDEO2
 474         while (1) {
 475             AVPacket pkt;
 476             int got_packet;
 477             av_init_packet(&pkt);
 478             pkt.data = NULL;
 479             pkt.size = 0;
 480
 481             int ret = avcodec_encode_video2(c, &pkt, NULL, &got_packet);
 482             if (ret < 0) {
 483                 release();
 484                 averrno = ret;
 485                 return false;
 486             }
 487             if (!got_packet) break;
 488             if (!pkt.size) continue;
 489
 490             // Write the compressed frame to the media file.
 491             if (pkt.pts != int64_t(AV_NOPTS_VALUE)) {
 492                 pkt.pts = av_rescale_q(pkt.pts,
 493                                        c->time_base, video_st->time_base);
 494             }
 495             if (pkt.dts != int64_t(AV_NOPTS_VALUE)) {
 496                 pkt.dts = av_rescale_q(pkt.dts,
 497                                        c->time_base, video_st->time_base);
 498             }
 499             pkt.stream_index = video_st->index;
 500
 501             /* Write the compressed frame to the media file. */
 502             ret = av_interleaved_write_frame(oc, &pkt);
 503             if (ret < 0) {
 504                 release();
 505                 averrno = ret;
 506                 return false;
 507             }
 508         }
 509 #else
 510         while (out_size) {
 511             out_size = avcodec_encode_video(c, outbuf, OUTBUF_SIZE, NULL);
 512             if (out_size) {
 513                 // Write the compressed frame to the media file.
 514                 AVPacket pkt;
 515                 av_init_packet(&pkt);
 516
 517                 if (c->coded_frame->pts != (int64_t)AV_NOPTS_VALUE)
 518                     pkt.pts = av_rescale_q(c->coded_frame->pts, c->time_base, video_st->time_base);
 519                 if (c->coded_frame->key_frame)
 520                     pkt.flags |= AV_PKT_FLAG_KEY;
 521                 pkt.stream_index = video_st->index;
 522                 pkt.data = outbuf;
 523                 pkt.size = out_size;
 524
 525                 /* write the compressed frame in the media file */
 526                 int ret = av_interleaved_write_frame(oc, &pkt);
 527                 if (ret < 0) {
 528                     release();
 529                     averrno = ret;
 530                     return false;
 531                 }
 532             }
 533         }
 534 #endif
 535
 536         av_write_trailer(oc);
 537     }
 538
 539     release();
 540 #endif
 541     return true;
 542 }
 543
 544 #ifdef WITH_LIBAV
 545 void
 546 MovieMaker::release()
 547 {
 548     if (video_st) {
 549         // Close codec.
 550         avcodec_close(video_st->codec);
 551         video_st = NULL;
 552     }
 553
 554     if (frame) {
 555         av_frame_free(&frame);
 556     }
 557     av_free(pixels);
 558     pixels = NULL;
 559     av_free(outbuf);
 560     outbuf = NULL;
 561     av_free(sws_ctx);
 562     sws_ctx = NULL;
 563
 564     if (oc) {
 565         // Free the streams.
 566         for (size_t i = 0; i < oc->nb_streams; ++i) {
 567             av_freep(&oc->streams[i]->codec);
 568             av_freep(&oc->streams[i]);
 569         }
 570
 571         if (!(oc->oformat->flags & AVFMT_NOFILE)) {
 572             // Release the AVIOContext.
 573             av_free(oc->pb);
 574         }
 575
 576         // Free the stream.
 577         av_free(oc);
 578         oc = NULL;
 579     }
 580     if (fh_to_close) {
 581         fclose(fh_to_close);
 582         fh_to_close = NULL;
 583     }
 584 }
 585 #endif
 586
 587 MovieMaker::~MovieMaker()
 588 {
 589 #ifdef WITH_LIBAV
 590     release();
 591 #endif
 592 }
 593
 594 const char *
 595 MovieMaker::get_error_string() const
 596 {
 597 #ifdef WITH_LIBAV
 598     switch (averrno) {
 599         case AVERROR(EIO):
 600             return "I/O error";
 601         case AVERROR(EDOM):
 602             return "Number syntax expected in filename";
 603         case AVERROR_INVALIDDATA:
 604             /* same as AVERROR_UNKNOWN: return "unknown error"; */
 605             return "invalid data found";
 606         case AVERROR(ENOMEM):
 607             return "not enough memory";
 608         case AVERROR(EILSEQ):
 609             return "unknown format";
 610         case AVERROR(ENOSYS):
 611             return "Operation not supported";
 612         case AVERROR(ENOENT):
 613             return "No such file or directory";
 614         case AVERROR_EOF:
 615             return "End of file";
 616         case AVERROR_PATCHWELCOME:
 617             return "Not implemented in FFmpeg";
 618         case 0:
 619             return "No error";
 620         case MOVIE_NO_SUITABLE_FORMAT:
 621             return "Couldn't find a suitable output format";
 622         case MOVIE_AUDIO_ONLY:
 623             return "Audio-only format specified";
 624         case MOVIE_FILENAME_TOO_LONG:
 625             return "Filename too long";
 626     }
 627 #endif
 628     return "Unknown error";
 629 }