Add CoreVideoFrameBuffer.

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.
  *
  */
 
 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.h"
 
 #if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
 
 #include <memory>
 
 #include "libyuv/convert.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #if defined(WEBRTC_IOS)
 #include "webrtc/base/objc/RTCUIApplication.h"
 #endif
-#include "webrtc/common_video/include/video_frame_buffer.h"
+#include "webrtc/common_video/include/corevideo_frame_buffer.h"
 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.h"
 #include "webrtc/video_frame.h"
 
 namespace internal {
 
+static const int64_t kMsPerSec = 1000;
+
 // Convenience function for creating a dictionary.
 inline CFDictionaryRef CreateCFDictionary(CFTypeRef* keys,
                                           CFTypeRef* values,
                                           size_t size) {
   return CFDictionaryCreate(nullptr, keys, values, size,
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 // Struct that we pass to the decoder per frame to decode. We receive it again
 // in the decoder callback.
 struct FrameDecodeParams {
   FrameDecodeParams(webrtc::DecodedImageCallback* cb, int64_t ts)
       : callback(cb), timestamp(ts) {}
   webrtc::DecodedImageCallback* callback;
   int64_t timestamp;
 };
 
-// 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;
-    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,
                                    CMTime timestamp,
                                    CMTime duration) {
   std::unique_ptr<FrameDecodeParams> decode_params(
       reinterpret_cast<FrameDecodeParams*>(params));
   if (status != noErr) {
     LOG(LS_ERROR) << "Failed to decode frame. Status: " << status;
     return;
   }
   // TODO(tkchin): Handle CVO properly.
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
-      VideoFrameBufferForPixelBuffer(image_buffer);
-  webrtc::VideoFrame decoded_frame(buffer, decode_params->timestamp, 0,
+      new rtc::RefCountedObject<webrtc::CoreVideoFrameBuffer>(image_buffer);
+  webrtc::VideoFrame decoded_frame(buffer, decode_params->timestamp,
+                                   CMTimeGetSeconds(timestamp) * kMsPerSec,
                                    webrtc::kVideoRotation_0);
   decode_params->callback->Decoded(decoded_frame);
 }
 
 }  // namespace internal
 
 namespace webrtc {
 
 H264VideoToolboxDecoder::H264VideoToolboxDecoder()
     : callback_(nullptr),
@@ skipping 192 matching lines @@
   }
 }
 
 const char* H264VideoToolboxDecoder::ImplementationName() const {
   return "VideoToolbox";
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)