New helper class AdaptedVideoSource.

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.
  */
 
 // Declaration of abstract class VideoCapturer
 
 #ifndef WEBRTC_MEDIA_BASE_VIDEOCAPTURER_H_
 #define WEBRTC_MEDIA_BASE_VIDEOCAPTURER_H_
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
 
 #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/adaptedvideosource.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
@@ skipping 156 matching lines @@
   // 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;
-  }
+  bool enable_video_adapter() const;
+  void set_enable_video_adapter(bool 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.
   virtual void OnSinkWantsChanged(const rtc::VideoSinkWants& wants);
 
-  // Reports the appropriate frame size after adaptation. Returns true
-  // if a frame is wanted. Returns false if there are no interested
-  // sinks, or if the VideoAdapter decides to drop the frame.
-
-  // This function also implements timestamp translation/filtering.
-  // |camera_time_ns| is the camera's timestamp for the captured
-  // frame; it is expected to have good accuracy, but it may use an
-  // arbitrary epoch and a small possibly free-running with a frequency
-  // slightly different from the system clock. |system_time_us| is the
-  // monotonic system time (in the same scale as rtc::TimeMicros) when
-  // the frame was captured; the application is expected to read the
-  // system time as soon as possible after frame capture, but it may
-  // suffer scheduling jitter or poor system clock resolution. The
-  // output |translated_camera_time_us| is a combined timestamp,
-  // taking advantage of the supposedly higher accuracy in the camera
-  // timestamp, but using the same epoch and frequency as system time.
-  bool AdaptFrame(int width,
-                  int height,
-                  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_; }
+  VideoAdapter* video_adapter() { return adapted_source_.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;
@@ skipping 31 matching lines @@
   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::AdaptedVideoSource adapted_source_;
 
   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 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_