libmedia/ffmpeg/VideoDecoderFfmpeg.cpp

   1 // VideoDecoderFfmpeg.cpp: Video decoding using the FFMPEG library.
   2 //
   3 //   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
   4 //   Free Software Foundation, Inc.
   5 //
   6 // This program 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 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program 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 this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19 //
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "gnashconfig.h"
  23 #endif
  24
  25 #include "VideoDecoderFfmpeg.h"
  26
  27 #include <boost/scoped_array.hpp>
  28 #include <boost/format.hpp>
  29 #include <algorithm>
  30
  31 #include "ffmpegHeaders.h"
  32 #include "MediaParserFfmpeg.h" // for ExtraVideoInfoFfmpeg
  33 #include "GnashException.h" // for MediaException
  34 #include "utility.h"
  35 #include "FLVParser.h"
  36
  37 #ifdef HAVE_VA_VA_H
  38 #  include "vaapi_utils.h"
  39 #  include "VideoDecoderFfmpegVaapi.h"
  40 #  include "GnashVaapiImage.h"
  41 #endif
  42
  43 namespace gnash {
  44 namespace media {
  45 namespace ffmpeg {
  46
  47 class VaapiContextFfmpeg;
  48
  49 // Forward declarations of VAAPI functions.
  50 namespace {
  51     VaapiContextFfmpeg* get_vaapi_context(AVCodecContext* avctx);
  52     void set_vaapi_context(AVCodecContext* avctx, VaapiContextFfmpeg* vactx);
  53     void clear_vaapi_context(AVCodecContext* avctx);
  54     void reset_context(AVCodecContext* avctx, VaapiContextFfmpeg* vactx = 0);
  55     PixelFormat get_format(AVCodecContext* avctx, const PixelFormat* fmt);
  56     int get_buffer(AVCodecContext* avctx, AVFrame* pic);
  57     int reget_buffer(AVCodecContext* avctx, AVFrame* pic);
  58     void release_buffer(AVCodecContext *avctx, AVFrame *pic);
  59 }
  60
  61 #ifdef HAVE_SWSCALE_H
  62
  63 /// A wrapper round an SwsContext that ensures it's
  64 /// freed on destruction.
  65 class SwsContextWrapper
  66 {
  67 public:
  68
  69     SwsContextWrapper(SwsContext* context)
  70         :
  71         _context(context)
  72     {}
  73
  74     ~SwsContextWrapper()
  75     {
  76          sws_freeContext(_context);
  77     }
  78
  79     SwsContext* getContext() const { return _context; }
  80
  81 private:
  82     SwsContext* _context;
  83
  84 };
  85 #endif
  86
  87
  88 // A Wrapper ensuring an AVCodecContext is closed and freed
  89 // on destruction.
  90 class CodecContextWrapper
  91 {
  92 public:
  93     CodecContextWrapper(AVCodecContext* context)
  94         :
  95         _codecCtx(context)
  96     {}
  97
  98     ~CodecContextWrapper()
  99     {
 100         if (_codecCtx)
 101         {
 102             avcodec_close(_codecCtx);
 103             clear_vaapi_context(_codecCtx);
 104             av_free(_codecCtx);
 105         }
 106     }
 107
 108     AVCodecContext* getContext() const { return _codecCtx; }
 109
 110 private:
 111     AVCodecContext* _codecCtx;
 112 };
 113
 114
 115 VideoDecoderFfmpeg::VideoDecoderFfmpeg(videoCodecType format, int width, int height)
 116     :
 117     _videoCodec(NULL)
 118 {
 119
 120     CodecID codec_id = flashToFfmpegCodec(format);
 121     init(codec_id, width, height);
 122
 123 }
 124
 125 VideoDecoderFfmpeg::VideoDecoderFfmpeg(const VideoInfo& info)
 126     :
 127     _videoCodec(NULL)
 128 {
 129
 130     CodecID codec_id = CODEC_ID_NONE;
 131
 132     if ( info.type == CODEC_TYPE_FLASH )
 133     {
 134         codec_id = flashToFfmpegCodec(static_cast<videoCodecType>(info.codec));
 135     }
 136     else codec_id = static_cast<CodecID>(info.codec);
 137
 138     // This would cause nasty segfaults.
 139     if (codec_id == CODEC_ID_NONE)
 140     {
 141         boost::format msg = boost::format(_("Cannot find suitable "
 142                 "decoder for flash codec %d")) % info.codec;
 143         throw MediaException(msg.str());
 144     }
 145
 146     boost::uint8_t* extradata=0;
 147     int extradataSize=0;
 148     if (info.extra.get())
 149     {
 150         if (dynamic_cast<ExtraVideoInfoFfmpeg*>(info.extra.get())) {
 151             const ExtraVideoInfoFfmpeg& ei =
 152                 static_cast<ExtraVideoInfoFfmpeg&>(*info.extra);
 153             extradata = ei.data;
 154             extradataSize = ei.dataSize;
 155         }
 156         else if (dynamic_cast<ExtraVideoInfoFlv*>(info.extra.get())) {
 157             const ExtraVideoInfoFlv& ei =
 158                 static_cast<ExtraVideoInfoFlv&>(*info.extra);
 159             extradata = ei.data.get();
 160             extradataSize = ei.size;
 161         }
 162         else {
 163             std::abort();
 164         }
 165     }
 166     init(codec_id, info.width, info.height, extradata, extradataSize);
 167 }
 168
 169 void
 170 VideoDecoderFfmpeg::init(enum CodecID codecId, int /*width*/, int /*height*/,
 171         boost::uint8_t* extradata, int extradataSize)
 172 {
 173     // Init the avdecoder-decoder
 174     avcodec_init();
 175     avcodec_register_all();// change this to only register need codec?
 176
 177     _videoCodec = avcodec_find_decoder(codecId);
 178
 179     if (!_videoCodec) {
 180         throw MediaException(_("libavcodec can't decode this video format"));
 181     }
 182
 183     _videoCodecCtx.reset(new CodecContextWrapper(avcodec_alloc_context()));
 184     if (!_videoCodecCtx->getContext()) {
 185         throw MediaException(_("libavcodec couldn't allocate context"));
 186     }
 187
 188     AVCodecContext* const ctx = _videoCodecCtx->getContext();
 189
 190     ctx->extradata = extradata;
 191     ctx->extradata_size = extradataSize;
 192
 193     ctx->get_format     = get_format;
 194     ctx->get_buffer     = get_buffer;
 195     ctx->reget_buffer   = reget_buffer;
 196     ctx->release_buffer = release_buffer;
 197
 198 #ifdef HAVE_VA_VA_H
 199     if (vaapi_is_enabled()) {
 200         VaapiContextFfmpeg *vactx = VaapiContextFfmpeg::create(codecId);
 201         if (vactx)
 202             reset_context(ctx, vactx);
 203     }
 204 #endif
 205
 206     int ret = avcodec_open(ctx, _videoCodec);
 207     if (ret < 0) {
 208         boost::format msg = boost::format(_("libavcodec "
 209                             "failed to initialize FFMPEG "
 210                             "codec %s (%d)")) %
 211                             _videoCodec->name % (int)codecId;
 212
 213         throw MediaException(msg.str());
 214     }
 215
 216     log_debug(_("VideoDecoder: initialized FFMPEG codec %s (%d)"),
 217                 _videoCodec->name, (int)codecId);
 218
 219 }
 220
 221 VideoDecoderFfmpeg::~VideoDecoderFfmpeg()
 222 {
 223 }
 224
 225 int
 226 VideoDecoderFfmpeg::width() const
 227 {
 228     if (!_videoCodecCtx.get()) return 0;
 229     return _videoCodecCtx->getContext()->width;
 230 }
 231
 232 int
 233 VideoDecoderFfmpeg::height() const
 234 {
 235     if (!_videoCodecCtx.get()) return 0;
 236     return _videoCodecCtx->getContext()->height;
 237 }
 238
 239 std::auto_ptr<image::GnashImage>
 240 VideoDecoderFfmpeg::frameToImage(AVCodecContext* srcCtx,
 241                                  const AVFrame& srcFrameRef)
 242 {
 243     const AVFrame *srcFrame = &srcFrameRef;
 244     PixelFormat srcPixFmt = srcCtx->pix_fmt;
 245
 246     const int width = srcCtx->width;
 247     const int height = srcCtx->height;
 248
 249 #ifdef FFMPEG_VP6A
 250     PixelFormat pixFmt = (srcCtx->codec->id == CODEC_ID_VP6A) ?
 251         PIX_FMT_RGBA : PIX_FMT_RGB24;
 252 #else
 253     PixelFormat pixFmt = PIX_FMT_RGB24;
 254 #endif
 255
 256     std::auto_ptr<image::GnashImage> im;
 257
 258 #ifdef HAVE_VA_VA_H
 259     VaapiContextFfmpeg * const vactx = get_vaapi_context(srcCtx);
 260     if (vactx) {
 261         VaapiSurfaceFfmpeg * const vaSurface = vaapi_get_surface(&srcFrameRef);
 262         if (!vaSurface) {
 263             im.reset();
 264             return im;
 265         }
 266         im.reset(new GnashVaapiImage(vaSurface->get(), image::TYPE_RGBA));
 267         return im;
 268     }
 269 #endif
 270
 271 #ifdef HAVE_SWSCALE_H
 272     // Check whether the context wrapper exists
 273     // already.
 274     if (!_swsContext.get()) {
 275
 276         _swsContext.reset(new SwsContextWrapper(
 277             sws_getContext(width, height, srcPixFmt, width, height,
 278                 pixFmt, SWS_BILINEAR, NULL, NULL, NULL)
 279         ));
 280
 281         // Check that the context was assigned.
 282         if (!_swsContext->getContext()) {
 283
 284             // This means we will try to assign the
 285             // context again next time.
 286             _swsContext.reset();
 287
 288             // Can't do anything now, though.
 289             return im;
 290         }
 291     }
 292 #endif
 293
 294     int bufsize = avpicture_get_size(pixFmt, width, height);
 295     if (bufsize == -1) return im;
 296
 297     switch (pixFmt)
 298     {
 299         case PIX_FMT_RGBA:
 300             im.reset(new image::ImageRGBA(width, height));
 301             break;
 302         case PIX_FMT_RGB24:
 303             im.reset(new image::ImageRGB(width, height));
 304             break;
 305         default:
 306             log_error(_("Pixel format not handled"));
 307             return im;
 308     }
 309
 310     AVPicture picture;
 311
 312     // Let ffmpeg write directly to the GnashImage data. It is an uninitialized
 313     // buffer here, so do not return the image if there is any error in
 314     // conversion.
 315     avpicture_fill(&picture, im->begin(), pixFmt, width, height);
 316
 317 #ifndef HAVE_SWSCALE_H
 318     img_convert(&picture, PIX_FMT_RGB24, (AVPicture*)srcFrame,
 319             srcPixFmt, width, height);
 320 #else
 321
 322     // Is it possible for the context to be reset
 323     // to NULL once it's been created?
 324     assert(_swsContext->getContext());
 325
 326     int rv = sws_scale(_swsContext->getContext(),
 327             const_cast<uint8_t**>(srcFrame->data),
 328             const_cast<int*>(srcFrame->linesize), 0, height, picture.data,
 329             picture.linesize);
 330
 331     if (rv == -1) {
 332         im.reset();
 333         return im;
 334     }
 335
 336 #endif
 337
 338     return im;
 339
 340 }
 341
 342 std::auto_ptr<image::GnashImage>
 343 VideoDecoderFfmpeg::decode(const boost::uint8_t* input,
 344         boost::uint32_t input_size)
 345 {
 346     // This object shouldn't exist if there's no codec, as it can'
 347     // do anything anyway.
 348     assert(_videoCodecCtx.get());
 349
 350     std::auto_ptr<image::GnashImage> ret;
 351
 352     AVFrame* frame = avcodec_alloc_frame();
 353     if ( ! frame ) {
 354         log_error(_("Out of memory while allocating avcodec frame"));
 355         return ret;
 356     }
 357
 358     int bytes = 0;
 359     // no idea why avcodec_decode_video wants a non-const input...
 360 #if LIBAVCODEC_VERSION_MAJOR >= 53
 361     AVPacket pkt;
 362     av_init_packet(&pkt);
 363     pkt.data = (uint8_t*) input;
 364     pkt.size = input_size;
 365     avcodec_decode_video2(_videoCodecCtx->getContext(), frame, &bytes,
 366             &pkt);
 367 #else
 368     avcodec_decode_video(_videoCodecCtx->getContext(), frame, &bytes,
 369             input, input_size);
 370 #endif
 371
 372     if (!bytes) {
 373         log_error(_("Decoding of a video frame failed"));
 374         av_free(frame);
 375         return ret;
 376     }
 377
 378     ret = frameToImage(_videoCodecCtx->getContext(), *frame);
 379
 380     // FIXME: av_free doesn't free frame->data!
 381     av_free(frame);
 382     return ret;
 383 }
 384
 385
 386 void
 387 VideoDecoderFfmpeg::push(const EncodedVideoFrame& buffer)
 388 {
 389     _video_frames.push_back(&buffer);
 390 }
 391
 392 std::auto_ptr<image::GnashImage>
 393 VideoDecoderFfmpeg::pop()
 394 {
 395     std::auto_ptr<image::GnashImage> ret;
 396
 397     for (std::vector<const EncodedVideoFrame*>::iterator it =
 398              _video_frames.begin(), end = _video_frames.end(); it != end; ++it) {
 399          ret = decode((*it)->data(), (*it)->dataSize());
 400     }
 401
 402     _video_frames.clear();
 403
 404     return ret;
 405 }
 406
 407 bool
 408 VideoDecoderFfmpeg::peek()
 409 {
 410     return (!_video_frames.empty());
 411 }
 412
 413 /* public static */
 414 enum CodecID
 415 VideoDecoderFfmpeg::flashToFfmpegCodec(videoCodecType format)
 416 {
 417         // Find the decoder and init the parser
 418         switch(format) {
 419                 case VIDEO_CODEC_H264:
 420                          return CODEC_ID_H264;
 421                 case VIDEO_CODEC_H263:
 422                          // CODEC_ID_H263I didn't work with Lavc51.50.0
 423                          // and NetStream-SquareTest.swf
 424                          return CODEC_ID_FLV1;
 425                 case VIDEO_CODEC_VP6:
 426                         return CODEC_ID_VP6F;
 427 #ifdef FFMPEG_VP6A
 428                 case VIDEO_CODEC_VP6A:
 429                         return CODEC_ID_VP6A;
 430 #endif
 431                 case VIDEO_CODEC_SCREENVIDEO:
 432                         return CODEC_ID_FLASHSV;
 433                 default:
 434                         log_error(_("Unsupported video codec %d"),
 435                                 static_cast<int>(format));
 436                         return CODEC_ID_NONE;
 437         }
 438 }
 439
 440 namespace {
 441
 442 inline VaapiContextFfmpeg*
 443 get_vaapi_context(AVCodecContext* avctx)
 444 {
 445 #ifdef HAVE_VA_VA_H
 446     return static_cast<VaapiContextFfmpeg *>(avctx->hwaccel_context);
 447 #else
 448     UNUSED(avctx);
 449         return 0;
 450 #endif
 451 }
 452
 453 inline void
 454 set_vaapi_context(AVCodecContext* avctx, VaapiContextFfmpeg* vactx)
 455 {
 456 #ifdef HAVE_VA_VA_H
 457     avctx->hwaccel_context = vactx;
 458 #else
 459     UNUSED(avctx), UNUSED(vactx);
 460 #endif
 461
 462 }
 463
 464 inline void
 465 clear_vaapi_context(AVCodecContext* avctx)
 466 {
 467 #ifdef HAVE_VA_VA_H
 468     VaapiContextFfmpeg* const vactx = get_vaapi_context(avctx);
 469     if (!vactx) return;
 470
 471     delete vactx;
 472     set_vaapi_context(avctx, NULL);
 473 #else
 474     UNUSED(avctx);
 475 #endif
 476 }
 477
 478 /// (Re)set AVCodecContext to sane values
 479 void
 480 reset_context(AVCodecContext* avctx, VaapiContextFfmpeg* vactx)
 481 {
 482     clear_vaapi_context(avctx);
 483     set_vaapi_context(avctx, vactx);
 484
 485     avctx->thread_count = 1;
 486     avctx->draw_horiz_band = 0;
 487     if (vactx) {
 488         avctx->slice_flags = SLICE_FLAG_CODED_ORDER|SLICE_FLAG_ALLOW_FIELD;
 489     }
 490     else avctx->slice_flags = 0;
 491 }
 492
 493 /// AVCodecContext.get_format() implementation
 494 PixelFormat
 495 get_format(AVCodecContext* avctx, const PixelFormat* fmt)
 496 {
 497 #ifdef HAVE_VA_VA_H
 498     VaapiContextFfmpeg* const vactx = get_vaapi_context(avctx);
 499
 500     if (vactx) {
 501         for (int i = 0; fmt[i] != PIX_FMT_NONE; i++) {
 502             if (fmt[i] != PIX_FMT_VAAPI_VLD) continue;
 503
 504             if (vactx->initDecoder(avctx->width, avctx->height)) {
 505                 return fmt[i];
 506             }
 507         }
 508     }
 509 #endif
 510
 511     reset_context(avctx);
 512     return avcodec_default_get_format(avctx, fmt);
 513 }
 514
 515 /// AVCodecContext.get_buffer() implementation
 516 int
 517 get_buffer(AVCodecContext* avctx, AVFrame* pic)
 518 {
 519     VaapiContextFfmpeg* const vactx = get_vaapi_context(avctx);
 520     if (!vactx) return avcodec_default_get_buffer(avctx, pic);
 521
 522 #ifdef HAVE_VA_VA_H
 523     if (!vactx->initDecoder(avctx->width, avctx->height)) return -1;
 524
 525     VaapiSurfaceFfmpeg * const surface = vactx->getSurface();
 526     if (!surface) return -1;
 527
 528     vaapi_set_surface(pic, surface);
 529
 530     static unsigned int pic_num = 0;
 531     pic->type = FF_BUFFER_TYPE_USER;
 532     pic->age  = ++pic_num - surface->getPicNum();
 533     surface->setPicNum(pic_num);
 534     return 0;
 535 #endif
 536     return -1;
 537 }
 538
 539 /// AVCodecContext.reget_buffer() implementation
 540 int
 541 reget_buffer(AVCodecContext* avctx, AVFrame* pic)
 542 {
 543     VaapiContextFfmpeg* const vactx = get_vaapi_context(avctx);
 544
 545     if (!vactx) return avcodec_default_reget_buffer(avctx, pic);
 546
 547     return get_buffer(avctx, pic);
 548 }
 549
 550 /// AVCodecContext.release_buffer() implementation
 551 void
 552 release_buffer(AVCodecContext *avctx, AVFrame *pic)
 553 {
 554     VaapiContextFfmpeg* const vactx = get_vaapi_context(avctx);
 555     if (!vactx) {
 556         avcodec_default_release_buffer(avctx, pic);
 557         return;
 558     }
 559
 560 #ifdef HAVE_VA_VA_H
 561     VaapiSurfaceFfmpeg* const surface = vaapi_get_surface(pic);
 562     delete surface;
 563
 564     pic->data[0] = NULL;
 565     pic->data[1] = NULL;
 566     pic->data[2] = NULL;
 567     pic->data[3] = NULL;
 568 #endif
 569 }
 570
 571 }
 572
 573 } // gnash.media.ffmpeg namespace
 574 } // gnash.media namespace
 575 } // gnash namespace