[cast] Force 4:2:0 pixel formats in H264VideoToolboxEncoder.

media/cast/sender/h264_vt_encoder.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 "media/cast/sender/h264_vt_encoder.h"
 
 #include <string>
+#include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
 #include "media/cast/sender/video_frame_factory.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // Container for the associated data of a video frame being processed.
@@ skipping 12 matching lines @@
 
 base::ScopedCFTypeRef<CFDictionaryRef> DictionaryWithKeyValue(CFTypeRef key,
                                                               CFTypeRef value) {
   CFTypeRef keys[1] = {key};
   CFTypeRef values[1] = {value};
   return base::ScopedCFTypeRef<CFDictionaryRef>(CFDictionaryCreate(
       kCFAllocatorDefault, keys, values, 1, &kCFTypeDictionaryKeyCallBacks,
       &kCFTypeDictionaryValueCallBacks));
 }
 
+base::ScopedCFTypeRef<CFArrayRef> ArrayWithIntegers(const std::vector<int>& v) {
+  std::vector<CFNumberRef> numbers;
+  numbers.reserve(v.size());
+  for (const int i : v) {
+    numbers.push_back(CFNumberCreate(nullptr, kCFNumberSInt32Type, &i));
+  }
+  base::ScopedCFTypeRef<CFArrayRef> array(CFArrayCreate(
+      kCFAllocatorDefault, reinterpret_cast<const void**>(&numbers[0]),
+      numbers.size(), &kCFTypeArrayCallBacks));
+  for (CFNumberRef number : numbers) {
+    CFRelease(number);
+  }
+  return array;
+}
+
 template <typename NalSizeType>
 void CopyNalsToAnnexB(char* avcc_buffer,
                       const size_t avcc_size,
                       std::string* annexb_buffer) {
   static_assert(sizeof(NalSizeType) == 1 || sizeof(NalSizeType) == 2 ||
                     sizeof(NalSizeType) == 4,
                 "NAL size type has unsupported size");
   static const char startcode_3[3] = {0, 0, 1};
   DCHECK(avcc_buffer);
   DCHECK(annexb_buffer);
@@ skipping 194 matching lines @@
   // On OS X, allow the hardware encoder. Don't require it, it does not support
   // all configurations (some of which are used for testing).
   base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec;
 #if !defined(OS_IOS)
   encoder_spec = DictionaryWithKeyValue(
       videotoolbox_glue_
           ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder(),
       kCFBooleanTrue);
 #endif
 
+  // Certain encoders prefer kCVPixelFormatType_422YpCbCr8, which is not
+  // supported through VideoFrame. We can force 420 formats to be used instead.
+  const int formats[] = {
+      kCVPixelFormatType_420YpCbCr8Planar,
+      CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
+  base::ScopedCFTypeRef<CFArrayRef> formats_array = ArrayWithIntegers(
+      std::vector<int>(formats, formats + arraysize(formats)));
+  base::ScopedCFTypeRef<CFDictionaryRef> buffer_attributes =
+      DictionaryWithKeyValue(kCVPixelBufferPixelFormatTypeKey, formats_array);
+
   VTCompressionSessionRef session;
   OSStatus status = videotoolbox_glue_->VTCompressionSessionCreate(
       kCFAllocatorDefault, video_config.width, video_config.height,
-      CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec,
-      nullptr /* sourceImageBufferAttributes */,
+      CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec, buffer_attributes,
       nullptr /* compressedDataAllocator */,
       &H264VideoToolboxEncoder::CompressionCallback,
       reinterpret_cast<void*>(this), &session);
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCreate failed: " << status;
     return false;
   }
   compression_session_.reset(session);
 
   ConfigureSession(video_config);
@@ skipping 204 matching lines @@
   CopySampleBufferToAnnexBBuffer(sbuf, &encoded_frame->data, keyframe);
 
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media