src/third_party/webrtc/modules/video_capture/video_capture_impl.h

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #ifndef WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_VIDEO_CAPTURE_IMPL_H_
  12 #define WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_VIDEO_CAPTURE_IMPL_H_
  13
  14 /*
  15  * video_capture_impl.h
  16  */
  17
  18 #include "webrtc/common_video/interface/i420_video_frame.h"
  19 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
  20 #include "webrtc/modules/video_capture/include/video_capture.h"
  21 #include "webrtc/modules/video_capture/video_capture_config.h"
  22 #include "webrtc/system_wrappers/interface/tick_util.h"
  23
  24 namespace webrtc
  25 {
  26 class CriticalSectionWrapper;
  27
  28 namespace videocapturemodule {
  29 // Class definitions
  30 class VideoCaptureImpl: public VideoCaptureModule, public VideoCaptureExternal
  31 {
  32 public:
  33
  34     /*
  35      *   Create a video capture module object
  36      *
  37      *   id              - unique identifier of this video capture module object
  38      *   deviceUniqueIdUTF8 -  name of the device. Available names can be found by using GetDeviceName
  39      */
  40     static VideoCaptureModule* Create(const int32_t id,
  41                                       const char* deviceUniqueIdUTF8);
  42
  43     /*
  44      *   Create a video capture module object used for external capture.
  45      *
  46      *   id              - unique identifier of this video capture module object
  47      *   externalCapture - [out] interface to call when a new frame is captured.
  48      */
  49     static VideoCaptureModule* Create(const int32_t id,
  50                                       VideoCaptureExternal*& externalCapture);
  51
  52     static DeviceInfo* CreateDeviceInfo(const int32_t id);
  53
  54     // Helpers for converting between (integral) degrees and
  55     // VideoCaptureRotation values.  Return 0 on success.
  56     static int32_t RotationFromDegrees(int degrees,
  57                                        VideoCaptureRotation* rotation);
  58     static int32_t RotationInDegrees(VideoCaptureRotation rotation,
  59                                      int* degrees);
  60
  61     // Implements Module declared functions.
  62     virtual int32_t ChangeUniqueId(const int32_t id);
  63
  64     //Call backs
  65     virtual void RegisterCaptureDataCallback(
  66         VideoCaptureDataCallback& dataCallback);
  67     virtual void DeRegisterCaptureDataCallback();
  68     virtual void RegisterCaptureCallback(VideoCaptureFeedBack& callBack);
  69     virtual void DeRegisterCaptureCallback();
  70
  71     virtual void SetCaptureDelay(int32_t delayMS);
  72     virtual int32_t CaptureDelay();
  73     virtual int32_t SetCaptureRotation(VideoCaptureRotation rotation);
  74
  75     virtual void EnableFrameRateCallback(const bool enable);
  76     virtual void EnableNoPictureAlarm(const bool enable);
  77
  78     virtual const char* CurrentDeviceName() const;
  79
  80     // Module handling
  81     virtual int32_t TimeUntilNextProcess();
  82     virtual int32_t Process();
  83
  84     // Implement VideoCaptureExternal
  85     // |capture_time| must be specified in the NTP time format in milliseconds.
  86     virtual int32_t IncomingFrame(uint8_t* videoFrame,
  87                                   int32_t videoFrameLength,
  88                                   const VideoCaptureCapability& frameInfo,
  89                                   int64_t captureTime = 0);
  90
  91     virtual int32_t IncomingI420VideoFrame(I420VideoFrame* video_frame,
  92                                            int64_t captureTime = 0);
  93
  94     // Platform dependent
  95     virtual int32_t StartCapture(const VideoCaptureCapability& capability)
  96     {
  97         _requestedCapability = capability;
  98         return -1;
  99     }
 100     virtual int32_t StopCapture()   { return -1; }
 101     virtual bool CaptureStarted() {return false; }
 102     virtual int32_t CaptureSettings(VideoCaptureCapability& /*settings*/)
 103     { return -1; }
 104     VideoCaptureEncodeInterface* GetEncodeInterface(const VideoCodec& /*codec*/)
 105     { return NULL; }
 106
 107 protected:
 108     VideoCaptureImpl(const int32_t id);
 109     virtual ~VideoCaptureImpl();
 110     int32_t DeliverCapturedFrame(I420VideoFrame& captureFrame,
 111                                  int64_t capture_time);
 112
 113     int32_t _id; // Module ID
 114     char* _deviceUniqueId; // current Device unique name;
 115     CriticalSectionWrapper& _apiCs;
 116     int32_t _captureDelay; // Current capture delay. May be changed of platform dependent parts.
 117     VideoCaptureCapability _requestedCapability; // Should be set by platform dependent code in StartCapture.
 118 private:
 119     void UpdateFrameCount();
 120     uint32_t CalculateFrameRate(const TickTime& now);
 121
 122     CriticalSectionWrapper& _callBackCs;
 123
 124     TickTime _lastProcessTime; // last time the module process function was called.
 125     TickTime _lastFrameRateCallbackTime; // last time the frame rate callback function was called.
 126     bool _frameRateCallBack; // true if EnableFrameRateCallback
 127     bool _noPictureAlarmCallBack; //true if EnableNoPictureAlarm
 128     VideoCaptureAlarm _captureAlarm; // current value of the noPictureAlarm
 129
 130     int32_t _setCaptureDelay; // The currently used capture delay
 131     VideoCaptureDataCallback* _dataCallBack;
 132     VideoCaptureFeedBack* _captureCallBack;
 133
 134     TickTime _lastProcessFrameCount;
 135     TickTime _incomingFrameTimes[kFrameRateCountHistorySize];// timestamp for local captured frames
 136     VideoRotationMode _rotateFrame; //Set if the frame should be rotated by the capture module.
 137
 138     I420VideoFrame _captureFrame;
 139     VideoFrame _capture_encoded_frame;
 140
 141     // Used to make sure incoming timestamp is increasing for every frame.
 142     int64_t last_capture_time_;
 143
 144     // Delta used for translating between NTP and internal timestamps.
 145     const int64_t delta_ntp_internal_ms_;
 146 };
 147 }  // namespace videocapturemodule
 148 }  // namespace webrtc
 149 #endif  // WEBRTC_MODULES_VIDEO_CAPTURE_MAIN_SOURCE_VIDEO_CAPTURE_IMPL_H_