Motown: Various fixes related to video playback support

services/media/framework_ffmpeg/ffmpeg_video_decoder.cc

 // Copyright 2016 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 <algorithm>
 
 #include "base/logging.h"
+#include "mojo/services/media/common/cpp/timeline.h"
+#include "mojo/services/media/common/cpp/timeline_rate.h"
 #include "services/media/framework_ffmpeg/ffmpeg_formatting.h"
 #include "services/media/framework_ffmpeg/ffmpeg_video_decoder.h"
 extern "C" {
 #include "third_party/ffmpeg/libavutil/imgutils.h"
 }
 
 namespace mojo {
 namespace media {
 
 FfmpegVideoDecoder::FfmpegVideoDecoder(AvCodecContextPtr av_codec_context)
     : FfmpegDecoderBase(std::move(av_codec_context)) {
   DCHECK(context());
 
   context()->opaque = this;
   context()->get_buffer2 = AllocateBufferForAvFrame;
   context()->refcounted_frames = 1;
+
+  // Turn on multi-proc decoding by allowing the decoder to use three threads
+  // (the calling thread and the two specified here). FF_THREAD_FRAME means
+  // that threads are assigned an entire frame.
+  // TODO(dalesat): Consider using FF_THREAD_SLICE.
+  context()->thread_count = 2;
+  context()->thread_type = FF_THREAD_FRAME;
+
+  // Determine the frame rate in frames per nanosecond so we can translate pts
+  // values from frame index to nanoseconds.
+  frame_rate_in_frames_per_ns_ =
+      TimelineRate(context()->time_base.den,
+                   Timeline::ns_from_seconds(context()->time_base.num));
 }
 
 FfmpegVideoDecoder::~FfmpegVideoDecoder() {}
 
 int FfmpegVideoDecoder::Decode(const AVPacket& av_packet,
                                const ffmpeg::AvFramePtr& av_frame_ptr,
                                PayloadAllocator* allocator,
                                bool* frame_decoded_out) {
   DCHECK(allocator);
   DCHECK(frame_decoded_out);
@@ skipping 22 matching lines @@
 
 void FfmpegVideoDecoder::Flush() {
   FfmpegDecoderBase::Flush();
   next_pts_ = Packet::kUnknownPts;
 }
 
 PacketPtr FfmpegVideoDecoder::CreateOutputPacket(const AVFrame& av_frame,
                                                  PayloadAllocator* allocator) {
   DCHECK(allocator);
 
-  // Recover the pts deposited in Decode.
-  next_pts_ = av_frame.reordered_opaque;
+  // Recover the pts deposited in Decode and divide it by frames per nanosecond
+  // to get the pts in nanoseconds.
+  next_pts_ = av_frame.reordered_opaque / frame_rate_in_frames_per_ns_;
 
-  AvBufferContext* av_buffer_context =
-      reinterpret_cast<AvBufferContext*>(av_buffer_get_opaque(av_frame.buf[0]));
-
-  return Packet::Create(
-      next_pts_,
-      false,  // The base class is responsible for end-of-stream.
-      av_buffer_context->size(), av_buffer_context->Release(), allocator);
+  return DecoderPacket::Create(next_pts_, av_buffer_ref(av_frame.buf[0]));
 }
 
 PacketPtr FfmpegVideoDecoder::CreateOutputEndOfStreamPacket() {
   return Packet::CreateEndOfStream(next_pts_);
 }
 
 int FfmpegVideoDecoder::AllocateBufferForAvFrame(
     AVCodecContext* av_codec_context,
     AVFrame* av_frame,
     int flags) {
@@ skipping 28 matching lines @@
                static_cast<size_t>(av_codec_context->coded_width)),
       std::max(visible_size.height(),
                static_cast<size_t>(av_codec_context->coded_height)));
 
   VideoStreamType::FrameLayout frame_layout;
 
   VideoStreamType::InfoForPixelFormat(
       PixelFormatFromAVPixelFormat(av_codec_context->pix_fmt))
       .BuildFrameLayout(coded_size, &frame_layout);
 
-  AvBufferContext* av_buffer_context =
-      new AvBufferContext(frame_layout.size, self->allocator_);
-  uint8_t* buffer = av_buffer_context->buffer();
+  uint8_t* buffer = static_cast<uint8_t*>(
+      self->allocator_->AllocatePayloadBuffer(frame_layout.size));
 
   // TODO(dalesat): For investigation purposes only...remove one day.
   if (self->first_frame_) {
     self->first_frame_ = false;
     self->colorspace_ = av_codec_context->colorspace;
     self->coded_size_ = coded_size;
   } else {
     if (av_codec_context->colorspace != self->colorspace_) {
       LOG(WARNING) << " colorspace changed to " << av_codec_context->colorspace
                    << std::endl;
@@ skipping 24 matching lines @@
   }
 
   // TODO(dalesat): Do we need to attach colorspace info to the packet?
 
   av_frame->width = coded_size.width();
   av_frame->height = coded_size.height();
   av_frame->format = av_codec_context->pix_fmt;
   av_frame->reordered_opaque = av_codec_context->reordered_opaque;
 
   DCHECK(av_frame->data[0] == buffer);
-  av_frame->buf[0] =
-      av_buffer_create(buffer, av_buffer_context->size(),
-                       ReleaseBufferForAvFrame, av_buffer_context,
-                       0);  // flags
+  av_frame->buf[0] = av_buffer_create(buffer, frame_layout.size,
+                                      ReleaseBufferForAvFrame, self->allocator_,
+                                      0);  // flags
 
   return 0;
 }
 
 void FfmpegVideoDecoder::ReleaseBufferForAvFrame(void* opaque,
                                                  uint8_t* buffer) {
-  AvBufferContext* av_buffer_context =
-      reinterpret_cast<AvBufferContext*>(opaque);
-  DCHECK(av_buffer_context);
-  // Either this buffer has already been released to someone else's ownership,
-  // or it's the same as the buffer parameter.
-  DCHECK(av_buffer_context->buffer() == nullptr ||
-         av_buffer_context->buffer() == buffer);
-  delete av_buffer_context;
+  DCHECK(opaque);
+  DCHECK(buffer);
+  PayloadAllocator* allocator = reinterpret_cast<PayloadAllocator*>(opaque);
+  allocator->ReleasePayloadBuffer(buffer);
 }
 
 }  // namespace media
 }  // namespace mojo