change videotoolbox format from NV12 to I420

webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  *
  */
@@ skipping 30 matching lines @@
 };
 
 // On decode we receive a CVPixelBuffer, which we need to convert to a frame
 // buffer for use in the rest of WebRTC. Unfortunately this involves a frame
 // copy.
 // TODO(tkchin): Stuff CVPixelBuffer into a TextureBuffer and pass that along
 // instead once the pipeline supports it.
 rtc::scoped_refptr<webrtc::VideoFrameBuffer> VideoFrameBufferForPixelBuffer(
     CVPixelBufferRef pixel_buffer) {
   RTC_DCHECK(pixel_buffer);
-  RTC_DCHECK(CVPixelBufferGetPixelFormatType(pixel_buffer) ==
-             kCVPixelFormatType_420YpCbCr8BiPlanarFullRange);
   size_t width = CVPixelBufferGetWidthOfPlane(pixel_buffer, 0);
   size_t height = CVPixelBufferGetHeightOfPlane(pixel_buffer, 0);
   // TODO(tkchin): Use a frame buffer pool.
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
       new rtc::RefCountedObject<webrtc::I420Buffer>(width, height);
-  CVPixelBufferLockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly);
-  const uint8_t* src_y = reinterpret_cast<const uint8_t*>(
-      CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 0));
-  int src_y_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 0);
-  const uint8_t* src_uv = reinterpret_cast<const uint8_t*>(
-      CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 1));
-  int src_uv_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 1);
-  int ret = libyuv::NV12ToI420(
-      src_y, src_y_stride, src_uv, src_uv_stride,
-      buffer->MutableData(webrtc::kYPlane), buffer->stride(webrtc::kYPlane),
-      buffer->MutableData(webrtc::kUPlane), buffer->stride(webrtc::kUPlane),
-      buffer->MutableData(webrtc::kVPlane), buffer->stride(webrtc::kVPlane),
-      width, height);
-  CVPixelBufferUnlockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly);
-  if (ret) {
-    LOG(LS_ERROR) << "Error converting NV12 to I420: " << ret;
+
+  OSType format = CVPixelBufferGetPixelFormatType(pixel_buffer);
+  if (format == kCVPixelFormatType_420YpCbCr8Planar ||
+      format == kCVPixelFormatType_420YpCbCr8PlanarFullRange) {
+    int stride;
+    CVPixelBufferLockBaseAddress(pixel_buffer, 0);
+    size_t height = CVPixelBufferGetHeight(pixel_buffer);
+    const int half_height = (height + 1) / 2;
+    for (size_t planeIndex = 0;
+         planeIndex < CVPixelBufferGetPlaneCount(pixel_buffer); planeIndex++) {
+      void* baseAddress =
+          CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, planeIndex);
+      stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, planeIndex);
+      memcpy(buffer->MutableData((webrtc::PlaneType)planeIndex), baseAddress,
+             (planeIndex == webrtc::kYPlane) ? stride * height
+                                             : stride * half_height);
+    }
+    CVPixelBufferUnlockBaseAddress(pixel_buffer, 0);
+  } else if (format == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange ||
+             format == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange) {
+    CVPixelBufferLockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly);
+    const uint8_t* src_y = reinterpret_cast<const uint8_t*>(
+        CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 0));
+    int src_y_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 0);
+    const uint8_t* src_uv = reinterpret_cast<const uint8_t*>(
+        CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 1));
+    int src_uv_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 1);
+    int ret = libyuv::NV12ToI420(
+        src_y, src_y_stride, src_uv, src_uv_stride,
+        buffer->MutableData(webrtc::kYPlane), buffer->stride(webrtc::kYPlane),
+        buffer->MutableData(webrtc::kUPlane), buffer->stride(webrtc::kUPlane),
+        buffer->MutableData(webrtc::kVPlane), buffer->stride(webrtc::kVPlane),
+        width, height);
+    CVPixelBufferUnlockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly);
+    if (ret) {
+      LOG(LS_ERROR) << "Error converting NV12 to I420: " << ret;
+      return nullptr;
+    }
+  } else {
+    LOG(LS_ERROR) << "Unsupported pixel buffer format: " << format;
     return nullptr;
   }
+
   return buffer;
 }
 
 // This is the callback function that VideoToolbox calls when decode is
 // complete.
 void VTDecompressionOutputCallback(void* decoder,
                                    void* params,
                                    OSStatus status,
                                    VTDecodeInfoFlags info_flags,
                                    CVImageBufferRef image_buffer,
@@ skipping 110 matching lines @@
 #if defined(WEBRTC_IOS)
     kCVPixelBufferOpenGLESCompatibilityKey,
 #elif defined(WEBRTC_MAC)
     kCVPixelBufferOpenGLCompatibilityKey,
 #endif
     kCVPixelBufferIOSurfacePropertiesKey,
     kCVPixelBufferPixelFormatTypeKey
   };
   CFDictionaryRef io_surface_value =
       internal::CreateCFDictionary(nullptr, nullptr, 0);
-  int64_t nv12type = kCVPixelFormatType_420YpCbCr8BiPlanarFullRange;
+  OSType i420type = kCVPixelFormatType_420YpCbCr8Planar;
   CFNumberRef pixel_format =
-      CFNumberCreate(nullptr, kCFNumberLongType, &nv12type);
+      CFNumberCreate(nullptr, kCFNumberSInt32Type, &i420type);
   CFTypeRef values[attributes_size] = {
     kCFBooleanTrue,
     io_surface_value,
     pixel_format
   };
   CFDictionaryRef attributes =
       internal::CreateCFDictionary(keys, values, attributes_size);
   if (io_surface_value) {
     CFRelease(io_surface_value);
     io_surface_value = nullptr;
@@ skipping 43 matching lines @@
   }
   video_format_ = video_format;
   if (video_format_) {
     CFRetain(video_format_);
   }
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)