Revert of Delete VideoFrameFactory, CapturedFrame, and related code.

webrtc/media/base/videocapturer.h

 /*
  *  Copyright (c) 2010 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 10 matching lines @@
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/media/base/videosourceinterface.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timestampaligner.h"
 #include "webrtc/media/base/videoadapter.h"
 #include "webrtc/media/base/videobroadcaster.h"
 #include "webrtc/media/base/videocommon.h"
+#include "webrtc/media/base/videoframefactory.h"
 
 
 namespace cricket {
 
 // Current state of the capturer.
 enum CaptureState {
   CS_STOPPED,    // The capturer has been stopped or hasn't started yet.
   CS_STARTING,   // The capturer is in the process of starting. Note, it may
                  // still fail to start.
   CS_RUNNING,    // The capturer has been started successfully and is now
                  // capturing.
   CS_FAILED,     // The capturer failed to start.
 };
 
 class VideoFrame;
 
+struct CapturedFrame {
+  static const uint32_t kFrameHeaderSize = 40;  // Size from width to data_size.
+  static const uint32_t kUnknownDataSize = 0xFFFFFFFF;
+
+  CapturedFrame();
+
+  // Get the number of bytes of the frame data. If data_size is known, return
+  // it directly. Otherwise, calculate the size based on width, height, and
+  // fourcc. Return true if succeeded.
+  bool GetDataSize(uint32_t* size) const;
+
+  // The width and height of the captured frame could be different from those
+  // of VideoFormat. Once the first frame is captured, the width, height,
+  // fourcc, pixel_width, and pixel_height should keep the same over frames.
+  int width;              // in number of pixels
+  int height;             // in number of pixels
+  uint32_t fourcc;        // compression
+  uint32_t pixel_width;   // width of a pixel, default is 1
+  uint32_t pixel_height;  // height of a pixel, default is 1
+  int64_t time_stamp;  // timestamp of when the frame was captured, in unix
+                       // time with nanosecond units.
+  uint32_t data_size;  // number of bytes of the frame data
+
+  webrtc::VideoRotation rotation;  // rotation in degrees of the frame.
+
+  void*  data;          // pointer to the frame data. This object allocates the
+                        // memory or points to an existing memory.
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(CapturedFrame);
+};
+
 // VideoCapturer is an abstract class that defines the interfaces for video
 // capturing. The subclasses implement the video capturer for various types of
 // capturers and various platforms.
 //
 // The captured frames may need to be adapted (for example, cropping).
 // Video adaptation is built into and enabled by default. After a frame has
 // been captured from the device, it is sent to the video adapter, then out to
 // the sinks.
 //
 // Programming model:
@@ skipping 107 matching lines @@
   void set_enable_camera_list(bool enable_camera_list) {
     enable_camera_list_ = enable_camera_list;
   }
   bool enable_camera_list() {
     return enable_camera_list_;
   }
 
   // Signal all capture state changes that are not a direct result of calling
   // Start().
   sigslot::signal2<VideoCapturer*, CaptureState> SignalStateChange;
+  // Frame callbacks are multithreaded to allow disconnect and connect to be
+  // called concurrently. It also ensures that it is safe to call disconnect
+  // at any time which is needed since the signal may be called from an
+  // unmarshalled thread owned by the VideoCapturer.
+  // Signal the captured frame to downstream.
+  sigslot::signal2<VideoCapturer*, const CapturedFrame*,
+                   sigslot::multi_threaded_local> SignalFrameCaptured;
 
   // If true, run video adaptation. By default, video adaptation is enabled
   // and users must call video_adapter()->OnOutputFormatRequest()
   // to receive frames.
   bool enable_video_adapter() const { return enable_video_adapter_; }
   void set_enable_video_adapter(bool enable_video_adapter) {
     enable_video_adapter_ = enable_video_adapter;
   }
 
+  // Takes ownership.
+  void set_frame_factory(VideoFrameFactory* frame_factory);
+
   bool GetInputSize(int* width, int* height);
 
   // Implements VideoSourceInterface
   void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override;
   void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
  protected:
   // OnSinkWantsChanged can be overridden to change the default behavior
   // when a sink changes its VideoSinkWants by calling AddOrUpdateSink.
@@ skipping 20 matching lines @@
                   int64_t camera_time_us,
                   int64_t system_time_us,
                   int* out_width,
                   int* out_height,
                   int* crop_width,
                   int* crop_height,
                   int* crop_x,
                   int* crop_y,
                   int64_t* translated_camera_time_us);
 
+  // Callback attached to SignalFrameCaptured where SignalVideoFrames is called.
+  void OnFrameCaptured(VideoCapturer* video_capturer,
+                       const CapturedFrame* captured_frame);
+
   // Called when a frame has been captured and converted to a
   // VideoFrame. OnFrame can be called directly by an implementation
   // that does not use SignalFrameCaptured or OnFrameCaptured. The
   // orig_width and orig_height are used only to produce stats.
   void OnFrame(const VideoFrame& frame, int orig_width, int orig_height);
 
   VideoAdapter* video_adapter() { return &video_adapter_; }
 
   void SetCaptureState(CaptureState state);
 
   // subclasses override this virtual method to provide a vector of fourccs, in
   // order of preference, that are expected by the media engine.
   virtual bool GetPreferredFourccs(std::vector<uint32_t>* fourccs) = 0;
 
   // mutators to set private attributes
   void SetId(const std::string& id) {
     id_ = id;
   }
 
   void SetCaptureFormat(const VideoFormat* format) {
     capture_format_.reset(format ? new VideoFormat(*format) : NULL);
   }
 
   void SetSupportedFormats(const std::vector<VideoFormat>& formats);
+  VideoFrameFactory* frame_factory() { return frame_factory_.get(); }
 
  private:
   void Construct();
   // Get the distance between the desired format and the supported format.
   // Return the max distance if they mismatch. See the implementation for
   // details.
   int64_t GetFormatDistance(const VideoFormat& desired,
                             const VideoFormat& supported);
 
+  // Convert captured frame to readable string for LOG messages.
+  std::string ToString(const CapturedFrame* frame) const;
+
   // Updates filtered_supported_formats_ so that it contains the formats in
   // supported_formats_ that fulfill all applied restrictions.
   void UpdateFilteredSupportedFormats();
   // Returns true if format doesn't fulfill all applied restrictions.
   bool ShouldFilterFormat(const VideoFormat& format) const;
 
   void UpdateInputSize(int width, int height);
 
   rtc::ThreadChecker thread_checker_;
   std::string id_;
   CaptureState capture_state_;
+  std::unique_ptr<VideoFrameFactory> frame_factory_;
   std::unique_ptr<VideoFormat> capture_format_;
   std::vector<VideoFormat> supported_formats_;
   std::unique_ptr<VideoFormat> max_format_;
   std::vector<VideoFormat> filtered_supported_formats_;
 
   bool enable_camera_list_;
   int scaled_width_;  // Current output size from ComputeScale.
   int scaled_height_;
 
   rtc::VideoBroadcaster broadcaster_;
   bool enable_video_adapter_;
   VideoAdapter video_adapter_;
 
   rtc::CriticalSection frame_stats_crit_;
   // The captured frame size before potential adapation.
   bool input_size_valid_ GUARDED_BY(frame_stats_crit_) = false;
   int input_width_ GUARDED_BY(frame_stats_crit_);
   int input_height_ GUARDED_BY(frame_stats_crit_);
 
-  // Whether capturer should apply rotation to the frame before
-  // passing it on to the registered sinks.
+  // Whether capturer should apply rotation to the frame before signaling it.
   bool apply_rotation_;
 
   // State for the timestamp translation.
   rtc::TimestampAligner timestamp_aligner_;
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOCAPTURER_H_