AVFoundation Video Capturer: Remove thread jump when delivering frames

webrtc/sdk/objc/Framework/Classes/avfoundationvideocapturer.mm

 /*
  *  Copyright 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 578 matching lines @@
 }
 
 @end
 
 namespace webrtc {
 
 enum AVFoundationVideoCapturerMessageType : uint32_t {
   kMessageTypeFrame,
 };
 
-struct AVFoundationFrame {
-  AVFoundationFrame(CVImageBufferRef buffer,
-                    webrtc::VideoRotation rotation,
-                    int64_t time)
-      : image_buffer(buffer), rotation(rotation), capture_time(time) {}
-  CVImageBufferRef image_buffer;
-  webrtc::VideoRotation rotation;
-  int64_t capture_time;
-};
-
-AVFoundationVideoCapturer::AVFoundationVideoCapturer()
-    : _capturer(nil), _startThread(nullptr) {
+AVFoundationVideoCapturer::AVFoundationVideoCapturer() : _capturer(nil) {
   // Set our supported formats. This matches kAvailablePresets.
   _capturer =
       [[RTCAVFoundationVideoCapturerInternal alloc] initWithCapturer:this];
 
   std::vector<cricket::VideoFormat> supported_formats;
   int framerate = 30;
 
 #if TARGET_OS_IPHONE
   if ([UIDevice deviceType] == RTCDeviceTypeIPhone4S) {
     set_enable_video_adapter(false);
@@ skipping 35 matching lines @@
 
   [_capturer.captureSession beginConfiguration];
   if (![_capturer.captureSession canSetSessionPreset:desiredPreset]) {
     LOG(LS_ERROR) << "Unsupported video format.";
     [_capturer.captureSession commitConfiguration];
     return cricket::CaptureState::CS_FAILED;
   }
   _capturer.captureSession.sessionPreset = desiredPreset;
   [_capturer.captureSession commitConfiguration];
 
-  // Keep track of which thread capture started on. This is the thread that
-  // frames need to be sent to.
-  RTC_DCHECK(!_startThread);
-  _startThread = rtc::Thread::Current();
-
   SetCaptureFormat(&format);
   // This isn't super accurate because it takes a while for the AVCaptureSession
   // to spin up, and this call returns async.
   // TODO(tkchin): make this better.
   [_capturer start];
   SetCaptureState(cricket::CaptureState::CS_RUNNING);
 
   // Adjust the framerate for all capture devices.
   const auto fps = cricket::VideoFormat::IntervalToFps(format.interval);
   AVCaptureDevice *activeDevice = [_capturer getActiveCaptureDevice];
   [_capturer setMinFrameDuration:CMTimeMake(1, fps)forDevice:activeDevice];
 
   return cricket::CaptureState::CS_STARTING;
 }
 
 void AVFoundationVideoCapturer::Stop() {
   [_capturer stop];
   SetCaptureFormat(NULL);
-  _startThread = nullptr;
 }
 
 bool AVFoundationVideoCapturer::IsRunning() {
   return _capturer.isRunning;
 }
 
 AVCaptureSession* AVFoundationVideoCapturer::GetCaptureSession() {
   return _capturer.captureSession;
 }
 
@@ skipping 15 matching lines @@
       !CMSampleBufferIsValid(sample_buffer) ||
       !CMSampleBufferDataIsReady(sample_buffer)) {
     return;
   }
 
   CVImageBufferRef image_buffer = CMSampleBufferGetImageBuffer(sample_buffer);
   if (image_buffer == NULL) {
     return;
   }
 
-  // Retain the buffer and post it to the webrtc thread. It will be released
-  // after it has successfully been signaled.
-  CVBufferRetain(image_buffer);
-  AVFoundationFrame frame(image_buffer, rotation, rtc::TimeNanos());
-  _startThread->Post(RTC_FROM_HERE, this, kMessageTypeFrame,
-                     new rtc::TypedMessageData<AVFoundationFrame>(frame));
-}
-
-void AVFoundationVideoCapturer::OnMessage(rtc::Message *msg) {
-  switch (msg->message_id) {
-    case kMessageTypeFrame: {
-      rtc::TypedMessageData<AVFoundationFrame>* data =
-        static_cast<rtc::TypedMessageData<AVFoundationFrame>*>(msg->pdata);
-      const AVFoundationFrame& frame = data->data();
-      OnFrameMessage(frame.image_buffer, frame.rotation, frame.capture_time);
-      delete data;
-      break;
-    }
-  }
-}
-
-void AVFoundationVideoCapturer::OnFrameMessage(CVImageBufferRef image_buffer,
-                                               webrtc::VideoRotation rotation,
-                                               int64_t capture_time_ns) {
-  RTC_DCHECK(_startThread->IsCurrent());
-
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
       new rtc::RefCountedObject<webrtc::CoreVideoFrameBuffer>(image_buffer);
 
   const int captured_width = buffer->width();
   const int captured_height = buffer->height();
 
   int adapted_width;
   int adapted_height;
   int crop_width;
   int crop_height;
   int crop_x;
   int crop_y;
   int64_t translated_camera_time_us;
 
   if (!AdaptFrame(captured_width, captured_height,
-                  capture_time_ns / rtc::kNumNanosecsPerMicrosec,
+                  rtc::TimeNanos() / rtc::kNumNanosecsPerMicrosec,
                   rtc::TimeMicros(), &adapted_width, &adapted_height,
                   &crop_width, &crop_height, &crop_x, &crop_y,
                   &translated_camera_time_us)) {
-    CVBufferRelease(image_buffer);
     return;
   }
 
   if (adapted_width != captured_width || crop_width != captured_width ||
       adapted_height != captured_height || crop_height != captured_height ||
       (apply_rotation() && rotation != webrtc::kVideoRotation_0)) {
     // TODO(magjed): Avoid converting to I420.
     rtc::scoped_refptr<webrtc::I420Buffer> scaled_buffer(
         _buffer_pool.CreateBuffer(adapted_width, adapted_height));
     scaled_buffer->CropAndScaleFrom(buffer->NativeToI420Buffer(), crop_x,
@@ skipping 13 matching lines @@
                          buffer->MutableDataU(), buffer->StrideU(),
                          buffer->MutableDataV(), buffer->StrideV(),
                          crop_width, crop_height,
                          static_cast<libyuv::RotationMode>(rotation));
     }
   }
 
   OnFrame(cricket::WebRtcVideoFrame(buffer, rotation,
                                     translated_camera_time_us, 0),
           captured_width, captured_height);
-
-  CVBufferRelease(image_buffer);
 }
 
 }  // namespace webrtc