Add CDM video decoder.

webkit/media/crypto/ppapi/ffmpeg_cdm_video_decoder.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "webkit/media/crypto/ppapi/ffmpeg_cdm_video_decoder.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "media/base/buffers.h"
+#include "media/base/limits.h"
+#include "media/ffmpeg/ffmpeg_common.h"
+#include "webkit/media/crypto/ppapi/content_decryption_module.h"
+#include "webkit/media/crypto/ppapi/ffmpeg_cdm_video_frame.h"
+
+// Include FFmpeg header files.
+extern "C" {
+// Temporarily disable possible loss of data warning.
+MSVC_PUSH_DISABLE_WARNING(4244);
+#include <libavcodec/avcodec.h>

[xhwang, 2012/10/17 18:43:00]

should we use "" instead of <>?

[Tom Finegan, 2012/10/17 19:55:44]

This is consistent with media, and I think it's required if the build is set to
use system ffmpeg.

+MSVC_POP_WARNING();
+}  // extern "C"
+
+namespace webkit_media {
+
+namespace {
+
+cdm::VideoFormat PixelFormatToCdmVideoFormat(PixelFormat pixel_format) {
+  switch (pixel_format) {
+    case PIX_FMT_YUV420P:
+      return cdm::kYv12;
+    default:
+      DVLOG(1) << "Unsupported PixelFormat: " << pixel_format;
+  }
+  return cdm::kUnknownVideoFormat;
+}
+
+PixelFormat CdmVideoFormatToPixelFormat(cdm::VideoFormat video_format) {
+  switch (video_format) {
+    case cdm::kYv12:
+    case cdm::kI420:
+      return PIX_FMT_YUV420P;
+    case cdm::kUnknownVideoFormat:
+    default:
+      DVLOG(1) << "Unsupported cdm::VideoFormat: " << video_format;
+  }
+  return PIX_FMT_NONE;
+}
+
+CodecID CdmVideoCodecToCodecID(
+    cdm::VideoDecoderConfig::VideoCodec video_codec) {
+  switch (video_codec) {
+    case cdm::VideoDecoderConfig::kCodecVP8:
+      return CODEC_ID_VP8;
+    case cdm::kUnknownVideoFormat:
+    default:
+      DVLOG(1) << "Unsupported cdm::VideoCodec: " << video_codec;
+  }
+  NOTREACHED() << "Unsupported video_codec: " << video_codec;
+  return CODEC_ID_NONE;
+}
+
+void CdmVideoDecoderConfigToAVCodecContext(
+    const cdm::VideoDecoderConfig& config,
+    AVCodecContext* codec_context) {
+  codec_context->codec_type = AVMEDIA_TYPE_VIDEO;
+  codec_context->codec_id = CdmVideoCodecToCodecID(config.codec);
+  codec_context->profile = FF_PROFILE_UNKNOWN;
+  codec_context->coded_width = config.coded_size.width;
+  codec_context->coded_height = config.coded_size.height;
+  codec_context->pix_fmt = CdmVideoFormatToPixelFormat(config.format);
+
+  if (config.extra_data) {
+    codec_context->extradata_size = config.extra_data_size;
+    codec_context->extradata = reinterpret_cast<uint8_t*>(
+        av_malloc(config.extra_data_size + FF_INPUT_BUFFER_PADDING_SIZE));
+    memcpy(codec_context->extradata, config.extra_data,
+           config.extra_data_size);
+    memset(codec_context->extradata + config.extra_data_size, '\0',

[xhwang, 2012/10/17 18:43:00]

Not sure about ffmpeg, but s/'\0'/0 since it's binary data not text?

[Tom Finegan, 2012/10/17 19:55:44]

This was copy/pasted from media... Done.

+           FF_INPUT_BUFFER_PADDING_SIZE);
+  } else {
+    codec_context->extradata = NULL;
+    codec_context->extradata_size = 0;
+  }
+
+}
+
+cdm::VideoFrame::VideoPlane VideoPlane(int32_t plane_index) {
+  DCHECK(plane_index >= cdm::VideoFrame::kYPlane &&
+         plane_index <  cdm::VideoFrame::kMaxPlanes);
+  return static_cast<cdm::VideoFrame::VideoPlane>(plane_index);
+}
+
+uint8_t* PlanePointer(FFmpegCdmVideoFrame* frame, int plane_index) {
+  DCHECK(frame);
+  return frame->frame_buffer()->data() +
+         frame->plane_offset(VideoPlane(plane_index));
+}
+
+}  // namespace

[xhwang, 2012/10/17 18:43:00]

Can we make all functions above static instead of defining them in an anonymous
namespace?

[Tom Finegan, 2012/10/17 19:55:44]

Done.

+
+static int GetCdmVideoBufferImpl(AVCodecContext* context,
+                                 AVFrame* frame) {
+  DVLOG(3) << "GetCdmVideoBufferImpl()";
+  FFmpegCdmVideoDecoder* video_decoder =
+      static_cast<FFmpegCdmVideoDecoder*>(context->opaque);
+  DCHECK(video_decoder);
+  return video_decoder->GetVideoBuffer(context, frame);
+}
+
+static void ReleaseCdmVideoBufferImpl(AVCodecContext* /* context */,
+                                      AVFrame* frame) {
+  DVLOG(3) << "ReleaseCdmVideoBufferImpl()";
+
+  scoped_ptr<FFmpegCdmVideoFrame> cdm_video_frame(
+      reinterpret_cast<FFmpegCdmVideoFrame*>(frame->opaque));
+
+  // The FFmpeg API expects us to zero the data pointers in this callback.
+  memset(frame->data, 0, sizeof(frame->data));
+  frame->opaque = NULL;
+}
+
+FFmpegCdmVideoDecoder::FFmpegCdmVideoDecoder(cdm::Allocator* allocator)
+    : codec_context_(NULL),
+      av_frame_(NULL),
+      is_initialized_(false),
+      allocator_(allocator) {
+}
+
+FFmpegCdmVideoDecoder::~FFmpegCdmVideoDecoder() {
+  ReleaseFFmpegResources();
+}
+
+bool FFmpegCdmVideoDecoder::Initialize(const cdm::VideoDecoderConfig& config) {
+  DVLOG(1) << "Initialize()";
+
+  if (is_initialized_) {
+    DLOG(ERROR) << "Already initialized.";
+    return false;
+  }
+
+  if (!FFmpegCdmVideoFrame::IsValidConfig(config.format, config.coded_size)) {
+    DLOG(ERROR) << "Invalid VideoDecoderConfig.";
+    return false;
+  }
+
+  av_register_all();
+
+  // Release existing resources if necessary.
+  ReleaseFFmpegResources();
+
+  // Initialize AVCodecContext structure.
+  codec_context_ = avcodec_alloc_context3(NULL);
+  CdmVideoDecoderConfigToAVCodecContext(config, codec_context_);
+
+  // Enable motion vector search (potentially slow), strong deblocking filter
+  // for damaged macroblocks, and set our error detection sensitivity.
+  codec_context_->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
+  codec_context_->err_recognition = AV_EF_CAREFUL;
+  codec_context_->thread_count = kDecodeThreads;
+  codec_context_->opaque = this;
+  codec_context_->flags |= CODEC_FLAG_EMU_EDGE;
+  codec_context_->get_buffer = GetCdmVideoBufferImpl;
+  codec_context_->release_buffer = ReleaseCdmVideoBufferImpl;
+  DCHECK_EQ(CODEC_ID_VP8, codec_context_->codec_id);
+
+  AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
+  if (!codec) {
+    LOG(ERROR) << "avcodec_find_decoder failed.";
+    return false;
+  }
+
+  int status;
+  if ((status = avcodec_open2(codec_context_, codec, NULL)) < 0) {
+    LOG(ERROR) << "avcodec_open2 failed: " << status;
+    return false;
+  }
+
+  av_frame_ = avcodec_alloc_frame();
+  config_ = config;
+
+  // TODO(tomfinegan): Do we need to copy the extra data? Zeroing the members
+  // because we don't own the memory.
+  config_.extra_data = NULL;
+  config_.extra_data_size = 0;
+
+  is_initialized_ = true;
+
+  return true;
+}
+
+void FFmpegCdmVideoDecoder::Deinitialize() {
+  DVLOG(1) << "Deinitialize()";
+  ReleaseFFmpegResources();
+}
+
+void FFmpegCdmVideoDecoder::Reset() {
+  DVLOG(1) << "Reset()";
+  avcodec_flush_buffers(codec_context_);
+}
+
+cdm::Status FFmpegCdmVideoDecoder::DecodeFrame(
+    const uint8_t* compressed_frame,
+    int32_t compressed_frame_size,
+    int64_t timestamp,
+    cdm::VideoFrame* decoded_frame) {
+  DVLOG(1) << "DecodeFrame()";
+  DCHECK(decoded_frame);
+
+  // Create a packet for input data.
+  AVPacket packet;
+  av_init_packet(&packet);
+
+  // The FFmpeg API changes does not allow us to have const read-only pointers.
+  packet.data = const_cast<uint8_t*>(compressed_frame);
+  packet.size = compressed_frame_size;
+
+  // Let FFmpeg handle presentation timestamp reordering.
+  codec_context_->reordered_opaque = timestamp;
+
+  // Reset frame to default values.
+  avcodec_get_frame_defaults(av_frame_);
+
+  // This is for codecs not using get_buffer to initialize
+  // |av_frame_->reordered_opaque|
+  av_frame_->reordered_opaque = codec_context_->reordered_opaque;
+
+  int frame_decoded = 0;
+  int result = avcodec_decode_video2(codec_context_,
+                                     av_frame_,
+                                     &frame_decoded,
+                                     &packet);
+  // Log the problem when we can't decode a video frame and exit early.
+  if (result < 0) {
+    LOG(ERROR) << "DecodeFrame: Error decoding a video frame with timestamp: "
+               << timestamp << " us, packet size: " << packet.size  << " bytes";
+    return cdm::kDecodeError;
+  }
+
+  // If no frame was produced then signal that more data is required to
+  // produce more frames. This can happen under two circumstances:
+  //   1) Decoder was recently initialized/flushed
+  //   2) End of stream was reached and all internal frames have been output

[xhwang, 2012/10/17 18:43:00]

As you mentioned offline, we can handle NeedMoreData upstream in CdmWrapper, or
in DVD. Maybe we can remove NeedMoreData all together later. But for now we are
relying on the CDM to return:
- For 1): NeedMoreData with NULL output frame
- For 2) Success for with NULL output frame

Could you please make this change for now. I'll figure out how we can best do
this later.

[Tom Finegan, 2012/10/17 19:55:44]

I think I did what your comment meant:

1) DecodeFrame() returns kNeedMoreData when there is non-null input, and no
output is produced.
2) DecodeFrame() returns kSuccess when there is null input, and no output is
produced.

PTAL at the comments.

+  if (frame_decoded == 0)
+    return cdm::kNeedMoreData;
+
+  // The decoder is in a bad state and not decoding correctly.
+  // Checking for NULL avoids a crash.
+  if (!av_frame_->data[cdm::VideoFrame::kYPlane] ||
+      !av_frame_->data[cdm::VideoFrame::kUPlane] ||
+      !av_frame_->data[cdm::VideoFrame::kVPlane]) {
+    LOG(ERROR) << "Video frame was produced yet has invalid frame data.";
+    return cdm::kDecodeError;
+  }
+
+  if (!av_frame_->opaque) {
+    LOG(ERROR) << "FFmpegCdmVideoFrame object associated with frame missing.";
+    return cdm::kDecodeError;
+  }
+
+  scoped_ptr<FFmpegCdmVideoFrame> video_frame(
+      static_cast<FFmpegCdmVideoFrame*>(av_frame_->opaque));
+  DCHECK(video_frame->frame_buffer());
+  video_frame->TransferVideoFrame(decoded_frame);
+  return cdm::kSuccess;
+}
+
+int FFmpegCdmVideoDecoder::GetVideoBuffer(AVCodecContext* codec_context,
+                                          AVFrame* av_frame) {
+  DVLOG(3) << "GetVideoBuffer()";
+
+  // Don't use |codec_context_| here! With threaded decoding,
+  // it will contain unsynchronized width/height/pix_fmt values,
+  // whereas |codec_context| contains the current threads's
+  // updated width/height/pix_fmt, which can change for adaptive
+  // content.
+  cdm::VideoFormat format =
+      PixelFormatToCdmVideoFormat(codec_context->pix_fmt);
+  if (format == cdm::kUnknownVideoFormat)
+    return AVERROR(EINVAL);
+  DCHECK(format == cdm::kYv12 || format == cdm::kI420);
+
+  cdm::Size size(codec_context->width, codec_context->height);
+  int ret;
+  if ((ret = av_image_check_size(size.width, size.height, 0, NULL)) < 0)
+    return ret;
+
+  if (!FFmpegCdmVideoFrame::IsValidConfig(format, size))
+    return AVERROR(EINVAL);
+
+  FFmpegCdmVideoFrame* video_frame = FFmpegCdmVideoFrame::Create(allocator_,
+                                                                 format,
+                                                                 size);
+  if (!video_frame) {
+    LOG(ERROR) << "GetVideoBuffer: VideoFrame Create failed";
+    return AVERROR(ENOMEM);
+  }
+
+  for (int i = 0; i < cdm::VideoFrame::kMaxPlanes; ++i) {
+    av_frame->base[i] = PlanePointer(video_frame, i);
+    av_frame->data[i] = PlanePointer(video_frame, i);
+    av_frame->linesize[i] = video_frame->stride(VideoPlane(i));
+  }
+
+  av_frame->opaque = reinterpret_cast<void*>(video_frame);
+  av_frame->type = FF_BUFFER_TYPE_USER;
+  av_frame->pkt_pts = codec_context->pkt ? codec_context->pkt->pts :
+                                           AV_NOPTS_VALUE;
+  av_frame->width = codec_context->width;
+  av_frame->height = codec_context->height;
+  av_frame->format = codec_context->pix_fmt;
+
+  return 0;
+}
+
+void FFmpegCdmVideoDecoder::ReleaseFFmpegResources() {
+  DVLOG(1) << "ReleaseFFmpegResources()";
+
+  if (codec_context_) {
+    av_free(codec_context_->extradata);
+    avcodec_close(codec_context_);
+    av_free(codec_context_);
+    codec_context_ = NULL;
+  }
+  if (av_frame_) {
+    av_free(av_frame_);
+    av_frame_ = NULL;
+  }
+
+  is_initialized_ = false;

[xhwang, 2012/10/17 18:43:00]

Move this to Deinitialize()?

[Tom Finegan, 2012/10/17 19:55:44]

Done.

+}
+
+}  // namespace webkit_media