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