FOR TESTING ONLY: Enable ffvp9 inside of Chrome.

media/filters/ffmpeg_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 "media/filters/ffmpeg_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 
+#include "third_party/ffmpeg/libavutil/intreadwrite.h"
+
 namespace media {
 
 // Always try to use three threads for video decoding.  There is little reason
 // not to since current day CPUs tend to be multi-core and we measured
 // performance benefits on older machines such as P4s with hyperthreading.
 //
 // Handling decoding on separate threads also frees up the pipeline thread to
 // continue processing. Although it'd be nice to have the option of a single
 // decoding thread, FFmpeg treats having one thread the same as having zero
 // threads (i.e., avcodec_decode_video() will execute on the calling thread).
 // Yet another reason for having two threads :)
 static const int kDecodeThreads = 2;
 static const int kMaxDecodeThreads = 16;
 
+// TODO(dalecurtis): This needs to be rewritten in Chrome style if we're going
+// to use it.  Right now, pulled directly from ffvp9 parser.
+int FFmpegVideoDecoder::ParseVP9Packet(uint8_t** out_data,
+                                       int* out_size,
+                                       uint8_t* data,
+                                       int size) {
+  VP9ParseContext* s = &parse_context_;
+  int marker = 0;
+
+  if (size <= 0) {
+    *out_size = 0;
+    *out_data = data;
+    return 0;
+  }
+
+  if (s->n_frames > 0) {
+    *out_data = data;
+    *out_size = s->size[--s->n_frames];
+    return s->n_frames > 0 ? *out_size : size /* i.e. include idx tail */;
+  }
+
+  marker = data[size - 1];
+  if ((marker & 0xe0) == 0xc0) {
+    int nbytes = 1 + ((marker >> 3) & 0x3);
+    int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
+
+    if (size >= idx_sz && data[size - idx_sz] == marker) {
+      const uint8_t* idx = data + size + 1 - idx_sz;
+      int first = 1;
+
+      switch (nbytes) {
+#define case_n(a, rd)                                         \
+  case a:                                                     \
+    while (n_frames--) {                                      \
+      unsigned sz = rd;                                       \
+      idx += a;                                               \
+      if (sz > static_cast<unsigned>(size)) {                 \
+        s->n_frames = 0;                                      \
+        LOG(ERROR) << "parsing failed, superframe too large"; \
+        return size;                                          \
+      }                                                       \
+      if (first) {                                            \
+        first = 0;                                            \
+        *out_data = data;                                     \
+        *out_size = sz;                                       \
+        s->n_frames = n_frames;                               \
+      } else {                                                \
+        s->size[n_frames] = sz;                               \
+      }                                                       \
+      data += sz;                                             \
+      size -= sz;                                             \
+    }                                                         \
+    return *out_size
+
+        case_n(1u, *idx);
+        case_n(2u, AV_RL16(idx));
+        case_n(3u, AV_RL24(idx));
+        case_n(4u, AV_RL32(idx));
+      }
+    }
+  }
+
+  *out_data = data;
+  *out_size = size;
+  return size;
+}
+
 // Returns the number of threads given the FFmpeg CodecID. Also inspects the
 // command line for a valid --video-threads flag.
 static int GetThreadCount(AVCodecID codec_id) {
   // Refer to http://crbug.com/93932 for tsan suppressions on decoding.
   int decode_threads = kDecodeThreads;
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
   if (threads.empty() || !base::StringToInt(threads, &decode_threads))
     return decode_threads;
@@ skipping 17 matching lines @@
 
 static size_t RoundUp(size_t value, size_t alignment) {
   // Check that |alignment| is a power of 2.
   DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1)));
   return ((value + (alignment - 1)) & ~(alignment - 1));
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner), state_(kUninitialized),
-      decode_nalus_(false) {}
+      decode_nalus_(false), parse_context_() {}
 
 int FFmpegVideoDecoder::GetVideoBuffer(struct AVCodecContext* codec_context,
                                        AVFrame* frame,
                                        int flags) {
   // 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.
   VideoFrame::Format format = PixelFormatToVideoFormat(codec_context->pix_fmt);
@@ skipping 161 matching lines @@
 
   if (state_ != kUninitialized)
     ReleaseFFmpegResources();
 }
 
 bool FFmpegVideoDecoder::FFmpegDecode(
     const scoped_refptr<DecoderBuffer>& buffer,
     bool* has_produced_frame) {
   DCHECK(!*has_produced_frame);
 
+  size_t remaining_size = buffer->end_of_stream() ? 0 : buffer->data_size();
+
   // Create a packet for input data.
   // Due to FFmpeg API changes we no longer have const read-only pointers.
   AVPacket packet;
-  av_init_packet(&packet);
-  if (buffer->end_of_stream()) {
-    packet.data = NULL;
-    packet.size = 0;
-  } else {
-    packet.data = const_cast<uint8*>(buffer->data());
-    packet.size = buffer->data_size();
+  while (remaining_size > 0) {
+    av_init_packet(&packet);
+    if (buffer->end_of_stream()) {
+      packet.data = NULL;
+      packet.size = 0;
+    } else {
+      // TODO(dalecurtis): ffvp9 can't handle superframes, which are multiple
+      // frames inside a single packet. Normally its demuxer handles this
+      // parsing, but when ChunkDemuxer is used, the packet isn't split right.
+      if (codec_context_->codec_id == AV_CODEC_ID_VP9) {
+        int len = ParseVP9Packet(
+            &packet.data, &packet.size,
+            buffer->writable_data() + (buffer->data_size() - remaining_size),
+            remaining_size);
+        remaining_size -= len;
+      } else {
+        packet.data = const_cast<uint8*>(buffer->data());
+        packet.size = buffer->data_size();
+        remaining_size = 0;
+      }
 
-    // Let FFmpeg handle presentation timestamp reordering.
-    codec_context_->reordered_opaque = buffer->timestamp().InMicroseconds();
+      // Let FFmpeg handle presentation timestamp reordering.
+      codec_context_->reordered_opaque = buffer->timestamp().InMicroseconds();
+      // buffer->set_timestamp(buffer->timestamp() + buffer->duration());
+    }
+
+    int frame_decoded = 0;
+    const int result = avcodec_decode_video2(
+        codec_context_.get(), av_frame_.get(), &frame_decoded, &packet);
+    // Log the problem if we can't decode a video frame and exit early.
+    if (result < 0) {
+      LOG(ERROR) << "Error decoding video: " << buffer->AsHumanReadableString();
+      return false;
+    }
+
+    // FFmpeg says some codecs might have multiple frames per packet.  Previous
+    // discussions with rbultje@ indicate this shouldn't be true for the codecs
+    // we use.
+    DCHECK_EQ(result, packet.size);
+
+    // 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
+    if (frame_decoded == 0)
+      continue;
+
+    // TODO(fbarchard): Work around for FFmpeg http://crbug.com/27675
+    // The decoder is in a bad state and not decoding correctly.
+    // Checking for NULL avoids a crash in CopyPlane().
+    if (!av_frame_->data[VideoFrame::kYPlane] ||
+        !av_frame_->data[VideoFrame::kUPlane] ||
+        !av_frame_->data[VideoFrame::kVPlane]) {
+      LOG(ERROR) << "Video frame was produced yet has invalid frame data.";
+      av_frame_unref(av_frame_.get());
+      return false;
+    }
+
+    scoped_refptr<VideoFrame> frame =
+        reinterpret_cast<VideoFrame*>(av_buffer_get_opaque(av_frame_->buf[0]));
+    frame->set_timestamp(
+        base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque));
+    *has_produced_frame = true;
+    output_cb_.Run(frame);
+
+    av_frame_unref(av_frame_.get());
   }
-
-  int frame_decoded = 0;
-  int result = avcodec_decode_video2(codec_context_.get(),
-                                     av_frame_.get(),
-                                     &frame_decoded,
-                                     &packet);
-  // Log the problem if we can't decode a video frame and exit early.
-  if (result < 0) {
-    LOG(ERROR) << "Error decoding video: " << buffer->AsHumanReadableString();
-    return false;
-  }
-
-  // FFmpeg says some codecs might have multiple frames per packet.  Previous
-  // discussions with rbultje@ indicate this shouldn't be true for the codecs
-  // we use.
-  DCHECK_EQ(result, packet.size);
-
-  // 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
-  if (frame_decoded == 0) {
-    return true;
-  }
-
-  // TODO(fbarchard): Work around for FFmpeg http://crbug.com/27675
-  // The decoder is in a bad state and not decoding correctly.
-  // Checking for NULL avoids a crash in CopyPlane().
-  if (!av_frame_->data[VideoFrame::kYPlane] ||
-      !av_frame_->data[VideoFrame::kUPlane] ||
-      !av_frame_->data[VideoFrame::kVPlane]) {
-    LOG(ERROR) << "Video frame was produced yet has invalid frame data.";
-    av_frame_unref(av_frame_.get());
-    return false;
-  }
-
-  scoped_refptr<VideoFrame> frame =
-      reinterpret_cast<VideoFrame*>(av_buffer_get_opaque(av_frame_->buf[0]));
-  frame->set_timestamp(
-      base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque));
-  *has_produced_frame = true;
-  output_cb_.Run(frame);
-
-  av_frame_unref(av_frame_.get());
   return true;
 }
 
 void FFmpegVideoDecoder::ReleaseFFmpegResources() {
   codec_context_.reset();
   av_frame_.reset();
 }
 
 bool FFmpegVideoDecoder::ConfigureDecoder(bool low_delay) {
   // Release existing decoder resources if necessary.
@@ skipping 17 matching lines @@
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_.reset(av_frame_alloc());
   return true;
 }
 
 }  // namespace media