Mac Overlays: Enable h264 overlays

content/common/gpu/media/vt_video_decode_accelerator.cc

 // Copyright 2014 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 <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/version.h"
 #include "content/common/gpu/media/vt_video_decode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/limits.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_image_io_surface.h"
 #include "ui/gl/scoped_binders.h"
 
 using content_common_gpu_media::kModuleVt;
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::IsVtInitialized;
 using content_common_gpu_media::StubPathMap;
 
 #define NOTIFY_STATUS(name, status, session_failure)   \
     do {                                               \
       OSSTATUS_DLOG(ERROR, status) << name;            \
@@ skipping 233 matching lines @@
 VTVideoDecodeAccelerator::Task::~Task() {
 }
 
 VTVideoDecodeAccelerator::Frame::Frame(int32_t bitstream_id)
     : bitstream_id(bitstream_id), pic_order_cnt(0), reorder_window(0) {
 }
 
 VTVideoDecodeAccelerator::Frame::~Frame() {
 }
 
+VTVideoDecodeAccelerator::PictureInfo::PictureInfo(
+    uint32_t client_texture_id, uint32_t service_texture_id)
+    : client_texture_id(client_texture_id),
+      service_texture_id(service_texture_id) {
+}
+
+VTVideoDecodeAccelerator::PictureInfo::~PictureInfo() {
+  if (gl_image)
+    gl_image->Destroy(false);
+}
+
 bool VTVideoDecodeAccelerator::FrameOrder::operator()(
     const linked_ptr<Frame>& lhs,
     const linked_ptr<Frame>& rhs) const {
   if (lhs->pic_order_cnt != rhs->pic_order_cnt)
     return lhs->pic_order_cnt > rhs->pic_order_cnt;
   // If |pic_order_cnt| is the same, fall back on using the bitstream order.
   // TODO(sandersd): Assign a sequence number in Decode() and use that instead.
   // TODO(sandersd): Using the sequence number, ensure that frames older than
   // |kMaxReorderQueueSize| are ordered first, regardless of |pic_order_cnt|.
   return lhs->bitstream_id > rhs->bitstream_id;
 }
 
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(
-    const base::Callback<bool(void)>& make_context_current)
+    const base::Callback<bool(void)>& make_context_current,
+    const base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)>&
+        bind_image)
     : make_context_current_(make_context_current),
+      bind_image_(bind_image),
       client_(nullptr),
       state_(STATE_DECODING),
       format_(nullptr),
       session_(nullptr),
       last_sps_id_(-1),
       last_pps_id_(-1),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("VTDecoderThread"),
       weak_this_factory_(this) {
   DCHECK(!make_context_current_.is_null());
   callback_.decompressionOutputCallback = OutputThunk;
   callback_.decompressionOutputRefCon = this;
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
+  DCHECK(gpu_thread_checker_.CalledOnValidThread());
 }
 
 bool VTVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
     Client* client) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   client_ = client;
 
   if (!InitializeVideoToolbox())
     return false;
@@ skipping 485 matching lines @@
   decoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&VTVideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream, frame));
 }
 
 void VTVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& pictures) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   for (const media::PictureBuffer& picture : pictures) {
-    DCHECK(!texture_ids_.count(picture.id()));
+    DCHECK(!picture_info_map_.count(picture.id()));
     assigned_picture_ids_.insert(picture.id());
     available_picture_ids_.push_back(picture.id());
-    texture_ids_[picture.id()] = picture.texture_id();
+    picture_info_map_[picture.id()].reset(new PictureInfo(
+        picture.texture_id(), picture.internal_texture_id()));

[piman, 2015/09/04 03:04:57]

drive-by nit: so, there's a double inversion which makes things super confusing.

in PictureBuffer, texture_id is the service id (the actual GL id), and
internal_texture_id is the client id (the command buffer id).

On l.1024 below, you definitely want to use the service id in the
ScopedTextureBinder (which operates at the GL level and doesn't know about
command buffers)

On l.1051, below, you definitely want to use the client id in BindImage, which
operates on command buffer structures.


The code you currently have works, but because the 2 ids are inverted here, the
code below that uses it looks really wrong...

[ccameron, 2015/09/04 08:53:50]

Ack! That's what I get for last-minute search-replace! Fixed.

   }
 
   // Pictures are not marked as uncleared until after this method returns, and
   // they will be broken if they are used before that happens. So, schedule
   // future work after that happens.
   gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VTVideoDecodeAccelerator::ProcessWorkQueues, weak_this_));
 }
 
 void VTVideoDecodeAccelerator::ReusePictureBuffer(int32_t picture_id) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(CFGetRetainCount(picture_bindings_[picture_id]), 1);
-  picture_bindings_.erase(picture_id);
+  DCHECK(picture_info_map_.count(picture_id));
+  PictureInfo* picture_info = picture_info_map_[picture_id].get();
+  DCHECK_EQ(CFGetRetainCount(picture_info->cv_image), 1);
+  picture_info->cv_image.reset();
+  picture_info->gl_image->Destroy(false);
+  picture_info->gl_image = nullptr;
+
   if (assigned_picture_ids_.count(picture_id) != 0) {
     available_picture_ids_.push_back(picture_id);
     ProcessWorkQueues();
   } else {
     client_->DismissPictureBuffer(picture_id);
   }
 }
 
 void VTVideoDecodeAccelerator::ProcessWorkQueues() {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
@@ skipping 138 matching lines @@
 }
 
 bool VTVideoDecodeAccelerator::SendFrame(const Frame& frame) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_DECODING);
 
   if (available_picture_ids_.empty())
     return false;
 
   int32_t picture_id = available_picture_ids_.back();
-  IOSurfaceRef surface = CVPixelBufferGetIOSurface(frame.image.get());
+  DCHECK(picture_info_map_.count(picture_id));
+  PictureInfo* picture_info = picture_info_map_[picture_id].get();
+  DCHECK(!picture_info->cv_image);
+  DCHECK(!picture_info->gl_image);
 
   if (!make_context_current_.Run()) {
     DLOG(ERROR) << "Failed to make GL context current";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
+  IOSurfaceRef surface = CVPixelBufferGetIOSurface(frame.image.get());
   glEnable(GL_TEXTURE_RECTANGLE_ARB);
   gfx::ScopedTextureBinder
-      texture_binder(GL_TEXTURE_RECTANGLE_ARB, texture_ids_[picture_id]);
+      texture_binder(GL_TEXTURE_RECTANGLE_ARB, picture_info->client_texture_id);
   CGLContextObj cgl_context =
       static_cast<CGLContextObj>(gfx::GLContext::GetCurrent()->GetHandle());
   CGLError status = CGLTexImageIOSurface2D(
       cgl_context,                  // ctx
       GL_TEXTURE_RECTANGLE_ARB,     // target
       GL_RGB,                       // internal_format
       frame.coded_size.width(),     // width
       frame.coded_size.height(),    // height
       GL_YCBCR_422_APPLE,           // format
       GL_UNSIGNED_SHORT_8_8_APPLE,  // type
       surface,                      // io_surface
       0);                           // plane
   glDisable(GL_TEXTURE_RECTANGLE_ARB);
   if (status != kCGLNoError) {
     NOTIFY_STATUS("CGLTexImageIOSurface2D()", status, SFT_PLATFORM_ERROR);
     return false;
   }
 
+  bool allow_overlay = false;
+  scoped_refptr<gfx::GLImageIOSurface> gl_image(new gfx::GLImageIOSurface(
+      gfx::GenericSharedMemoryId(), frame.coded_size, GL_BGRA_EXT));
+  if (gl_image->Initialize(surface, gfx::BufferFormat::BGRA_8888)) {
+    allow_overlay = true;
+  } else {
+    gl_image = nullptr;
+  }
+  bind_image_.Run(picture_info->service_texture_id, GL_TEXTURE_RECTANGLE_ARB,
+                  gl_image);
+
+  // Assign the new image(s) to the the picture info.
+  picture_info->gl_image = gl_image;
+  picture_info->cv_image = frame.image;
   available_picture_ids_.pop_back();
-  picture_bindings_[picture_id] = frame.image;
+
   // TODO(sandersd): Currently, the size got from
   // CMVideoFormatDescriptionGetDimensions is visible size. We pass it to
   // GpuVideoDecoder so that GpuVideoDecoder can use correct visible size in
   // resolution changed. We should find the correct API to get the real
   // coded size and fix it.
   client_->PictureReady(media::Picture(picture_id, frame.bitstream_id,
-                                       gfx::Rect(frame.coded_size), false));
+                                       gfx::Rect(frame.coded_size),
+                                       allow_overlay));
   return true;
 }
 
 void VTVideoDecodeAccelerator::NotifyError(
     Error vda_error_type,
     VTVDASessionFailureType session_failure_type) {
   DCHECK_LT(session_failure_type, SFT_MAX + 1);
   if (!gpu_thread_checker_.CalledOnValidThread()) {
     gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VTVideoDecodeAccelerator::NotifyError, weak_this_, vda_error_type,
@@ skipping 61 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace content