Revert of Mac: Decode hardware to 420 instead of 422

content/common/gpu/media/vt_video_decode_accelerator_mac.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 <stddef.h>
@@ skipping 56 matching lines @@
 // Maximum number of frames to queue for reordering before we stop asking for
 // more. (NotifyEndOfBitstreamBuffer() is called when frames are moved into the
 // reorder queue.)
 static const int kMaxReorderQueueSize = 16;
 
 // Build an |image_config| dictionary for VideoToolbox initialization.
 static base::ScopedCFTypeRef<CFMutableDictionaryRef>
 BuildImageConfig(CMVideoDimensions coded_dimensions) {
   base::ScopedCFTypeRef<CFMutableDictionaryRef> image_config;
 
-  // Note that 4:2:0 textures cannot be used directly as RGBA in OpenGL, but are
-  // lower power than 4:2:2 when composited directly by CoreAnimation.
-  int32_t pixel_format = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
+  // 4:2:2 is used over the native 4:2:0 because only 4:2:2 can be directly
+  // bound to a texture by CGLTexImageIOSurface2D().
+  int32_t pixel_format = kCVPixelFormatType_422YpCbCr8;
 #define CFINT(i) CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i)
   base::ScopedCFTypeRef<CFNumberRef> cf_pixel_format(CFINT(pixel_format));
   base::ScopedCFTypeRef<CFNumberRef> cf_width(CFINT(coded_dimensions.width));
   base::ScopedCFTypeRef<CFNumberRef> cf_height(CFINT(coded_dimensions.height));
 #undef CFINT
   if (!cf_pixel_format.get() || !cf_width.get() || !cf_height.get())
     return image_config;
 
-  image_config.reset(CFDictionaryCreateMutable(
-      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
-      &kCFTypeDictionaryValueCallBacks));
+  image_config.reset(
+      CFDictionaryCreateMutable(
+          kCFAllocatorDefault,
+          4,  // capacity
+          &kCFTypeDictionaryKeyCallBacks,
+          &kCFTypeDictionaryValueCallBacks));
   if (!image_config.get())
     return image_config;
 
   CFDictionarySetValue(image_config, kCVPixelBufferPixelFormatTypeKey,
                        cf_pixel_format);
   CFDictionarySetValue(image_config, kCVPixelBufferWidthKey, cf_width);
   CFDictionarySetValue(image_config, kCVPixelBufferHeightKey, cf_height);
+  CFDictionarySetValue(image_config, kCVPixelBufferOpenGLCompatibilityKey,
+                       kCFBooleanTrue);
 
   return image_config;
 }
 
 // Create a VTDecompressionSession using the provided |pps| and |sps|. If
 // |require_hardware| is true, the session must uses real hardware decoding
 // (as opposed to software decoding inside of VideoToolbox) to be considered
 // successful.
 //
 // TODO(sandersd): Merge with ConfigureDecoder(), as the code is very similar.
@@ skipping 168 matching lines @@
   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 MakeContextCurrentCallback& make_context_current,
-    const BindImageCallback& bind_image)
+    const base::Callback<bool(void)>& make_context_current,
+    const base::Callback<void(uint32_t, uint32_t, scoped_refptr<gl::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),
       config_changed_(false),
       missing_idr_logged_(false),
@@ skipping 723 matching lines @@
   PictureInfo* picture_info = picture_info_map_.find(picture_id)->second.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 io_surface = CVPixelBufferGetIOSurface(frame.image.get());
-
-  scoped_refptr<gl::GLImageIOSurface> gl_image(
-      new gl::GLImageIOSurface(frame.coded_size, GL_BGRA_EXT));
-  if (!gl_image->Initialize(io_surface, gfx::GenericSharedMemoryId(),
-                            gfx::BufferFormat::YUV_420_BIPLANAR)) {
-    NOTIFY_STATUS("Failed to initialize GLImageIOSurface", PLATFORM_FAILURE,
-                  SFT_PLATFORM_ERROR);
+  IOSurfaceRef surface = CVPixelBufferGetIOSurface(frame.image.get());
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGLCoreProfile)
+    glEnable(GL_TEXTURE_RECTANGLE_ARB);
+  gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_RECTANGLE_ARB,
+                                          picture_info->service_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
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGLCoreProfile)
+    glDisable(GL_TEXTURE_RECTANGLE_ARB);
+  if (status != kCGLNoError) {
+    NOTIFY_STATUS("CGLTexImageIOSurface2D()", status, SFT_PLATFORM_ERROR);
     return false;
   }
 
-  // Mark that the image is not bound for sampling. 4:2:0 images need to
-  // undergo a separate copy to be displayed.
+  bool allow_overlay = false;
+  scoped_refptr<gl::GLImageIOSurface> gl_image(
+      new gl::GLImageIOSurface(frame.coded_size, GL_BGRA_EXT));
+  if (gl_image->Initialize(surface, gfx::GenericSharedMemoryId(),
+                           gfx::BufferFormat::BGRA_8888)) {
+    allow_overlay = true;
+  } else {
+    gl_image = nullptr;
+  }
   bind_image_.Run(picture_info->client_texture_id, GL_TEXTURE_RECTANGLE_ARB,
-                  gl_image, false);
+                  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();
 
   // 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), true));
+                                       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