AndroidVideoCapturer: Return frames that have been dropped

talk/app/webrtc/androidvideocapturer.cc

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 53 matching lines @@
     captured_frame_.data_size = cricket::CapturedFrame::kUnknownDataSize;
     captured_frame_.fourcc = static_cast<uint32>(cricket::FOURCC_ANY);
   }
 
   void UpdateCapturedFrame(void* frame_data,
                            int length,
                            int width,
                            int height,
                            int rotation,
                            int64 time_stamp_in_ns) {
+    // Make sure we don't overwrite the previous frame.
+    CHECK(captured_frame_.data == nullptr);
     captured_frame_.fourcc = static_cast<uint32>(cricket::FOURCC_YV12);
     captured_frame_.data = frame_data;
     captured_frame_.width = width;
     captured_frame_.height = height;
     captured_frame_.elapsed_time = rtc::TimeNanos() - start_time_;
     captured_frame_.time_stamp = time_stamp_in_ns;
     captured_frame_.rotation = rotation;
     captured_frame_.data_size = length;
   }
 
+  void ClearCapturedFrame() const {
+    captured_frame_.data = nullptr;
+    captured_frame_.width = 0;
+    captured_frame_.height = 0;
+    captured_frame_.elapsed_time = 0;
+    captured_frame_.time_stamp = 0;
+    captured_frame_.data_size = 0;
+  }
+
   const cricket::CapturedFrame* GetCapturedFrame() const {
     return &captured_frame_;
   }
 
   cricket::VideoFrame* CreateAliasedFrame(
       const cricket::CapturedFrame* captured_frame,
       int dst_width,
       int dst_height) const override {
     // This override of CreateAliasedFrame creates a copy of the frame since
     // |captured_frame_.data| is only guaranteed to be valid during the scope
     // of |AndroidVideoCapturer::OnIncomingFrame_w|.
     // Check that captured_frame is actually our frame.
     CHECK(captured_frame == &captured_frame_);
+    CHECK(captured_frame->data != nullptr);
 
     if (!apply_rotation_ || captured_frame->rotation == kVideoRotation_0) {
       CHECK(captured_frame->fourcc == cricket::FOURCC_YV12);
       const uint8_t* y_plane = static_cast<uint8_t*>(captured_frame_.data);
 
       // Android guarantees that the stride is a multiple of 16.
       // http://developer.android.com/reference/android/hardware/Camera.Parameters.html#setPreviewFormat%28int%29
       int y_stride;
       int uv_stride;
       webrtc::Calc16ByteAlignedStride(captured_frame->width, &y_stride,
                                       &uv_stride);
       const uint8_t* v_plane = y_plane + y_stride * captured_frame->height;
       const uint8_t* u_plane =
           v_plane + uv_stride * webrtc::AlignInt(captured_frame->height, 2) / 2;
 
       // Create a WrappedI420Buffer and bind the |no_longer_used| callback
       // to the static method ReturnFrame. The |delegate_| is bound as an
       // argument which means that the callback will hold a reference to
       // |delegate_|.
       rtc::scoped_refptr<WrappedI420Buffer> buffer(
           new rtc::RefCountedObject<webrtc::WrappedI420Buffer>(
               dst_width, dst_height, captured_frame->width,
               captured_frame->height, y_plane, y_stride, u_plane, uv_stride,
               v_plane, uv_stride,
               rtc::Bind(&AndroidVideoCapturer::FrameFactory::ReturnFrame,
                         delegate_,
                         captured_frame->time_stamp)));
-      return new WebRtcVideoFrame(
+      cricket::VideoFrame* cricket_frame = new WebRtcVideoFrame(
          buffer, captured_frame->elapsed_time,
          captured_frame->time_stamp, captured_frame->GetRotation());
+      // |cricket_frame| is now responsible for returning the frame. Clear
+      // |captured_frame_| so the frame isn't returned twice.
+      ClearCapturedFrame();
+      return cricket_frame;
     }
 
     scoped_ptr<WebRtcVideoFrame> frame(new WebRtcVideoFrame());
     frame->Init(captured_frame, dst_width, dst_height, apply_rotation_);
-    // frame->Init copies the data in |captured_frame| so it is safe to return
-    // the buffer immediately.
-    delegate_->ReturnBuffer(captured_frame->time_stamp);
     return frame.release();
   }
 
   static void ReturnFrame(scoped_refptr<AndroidVideoCapturerDelegate> delegate,
                           int64 time_stamp) {
     delegate->ReturnBuffer(time_stamp);
   }
 
  private:
   uint64 start_time_;
-  cricket::CapturedFrame captured_frame_;
+  // |captured_frame_| is mutable as a hacky way to modify it inside
+  // CreateAliasedframe().
+  mutable cricket::CapturedFrame captured_frame_;
   scoped_refptr<AndroidVideoCapturerDelegate> delegate_;
 };
 
 AndroidVideoCapturer::AndroidVideoCapturer(
     const rtc::scoped_refptr<AndroidVideoCapturerDelegate>& delegate)
     : running_(false),
       delegate_(delegate),
       frame_factory_(NULL),
       current_state_(cricket::CS_STOPPED) {
   thread_checker_.DetachFromThread();
@@ skipping 85 matching lines @@
 void AndroidVideoCapturer::OnIncomingFrame(void* frame_data,
                                            int length,
                                            int width,
                                            int height,
                                            int rotation,
                                            int64 time_stamp) {
   CHECK(thread_checker_.CalledOnValidThread());
   frame_factory_->UpdateCapturedFrame(frame_data, length, width, height,
                                       rotation, time_stamp);
   SignalFrameCaptured(this, frame_factory_->GetCapturedFrame());
+  if (frame_factory_->GetCapturedFrame()->data == nullptr) {
+    // Ownership has been passed to a WrappedI420Buffer. Do nothing.
+  } else {
+    // |captured_frame_| has either been copied or dropped, return it
+    // immediately.
+    delegate_->ReturnBuffer(time_stamp);
+    frame_factory_->ClearCapturedFrame();
+  }
 }
 
 void AndroidVideoCapturer::OnOutputFormatRequest(
     int width, int height, int fps) {
   CHECK(thread_checker_.CalledOnValidThread());
   const cricket::VideoFormat& current = video_adapter()->output_format();
   cricket::VideoFormat format(
       width, height, cricket::VideoFormat::FpsToInterval(fps), current.fourcc);
   video_adapter()->OnOutputFormatRequest(format);
 }
 
 }  // namespace webrtc