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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
/*
* 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_VIDEO_ENGINE_VIE_ENCODER_H_
#define WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_
#include <list>
#include <map>
#include "webrtc/common_types.h"
#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
#include "webrtc/modules/video_processing/main/interface/video_processing.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/typedefs.h"
#include "webrtc/video_engine/vie_defines.h"
#include "webrtc/video_engine/vie_frame_provider_base.h"
namespace webrtc {
class CriticalSectionWrapper;
class Config;
class PacedSender;
class ProcessThread;
class QMVideoSettingsCallback;
class RtpRtcp;
class VideoCodingModule;
class ViEBitrateObserver;
class ViEEffectFilter;
class ViEEncoderObserver;
class ViEPacedSenderCallback;
class ViEEncoder
: public RtcpIntraFrameObserver,
public VCMPacketizationCallback,
public VCMProtectionCallback,
public VCMSendStatisticsCallback,
public ViEFrameCallback {
public:
friend class ViEBitrateObserver;
friend class ViEPacedSenderCallback;
ViEEncoder(int32_t engine_id,
int32_t channel_id,
uint32_t number_of_cores,
const Config& config,
ProcessThread& module_process_thread,
BitrateController* bitrate_controller);
~ViEEncoder();
bool Init();
void SetNetworkTransmissionState(bool is_transmitting);
// Returns the id of the owning channel.
int Owner() const;
// Drops incoming packets before they get to the encoder.
void Pause();
void Restart();
int32_t DropDeltaAfterKey(bool enable);
// Codec settings.
uint8_t NumberOfCodecs();
int32_t GetCodec(uint8_t list_index, VideoCodec* video_codec);
int32_t RegisterExternalEncoder(VideoEncoder* encoder,
uint8_t pl_type,
bool internal_source);
int32_t DeRegisterExternalEncoder(uint8_t pl_type);
int32_t SetEncoder(const VideoCodec& video_codec);
int32_t GetEncoder(VideoCodec* video_codec);
int32_t GetCodecConfigParameters(
unsigned char config_parameters[kConfigParameterSize],
unsigned char& config_parameters_size);
PacedSender* GetPacedSender();
// Scale or crop/pad image.
int32_t ScaleInputImage(bool enable);
// RTP settings.
RtpRtcp* SendRtpRtcpModule();
// Implementing ViEFrameCallback.
virtual void DeliverFrame(int id,
I420VideoFrame* video_frame,
int num_csrcs = 0,
const uint32_t CSRC[kRtpCsrcSize] = NULL);
virtual void DelayChanged(int id, int frame_delay);
virtual int GetPreferedFrameSettings(int* width,
int* height,
int* frame_rate);
virtual void ProviderDestroyed(int id) {
return;
}
int32_t SendKeyFrame();
int32_t SendCodecStatistics(uint32_t* num_key_frames,
uint32_t* num_delta_frames);
int32_t EstimatedSendBandwidth(
uint32_t* available_bandwidth) const;
int CodecTargetBitrate(uint32_t* bitrate) const;
// Loss protection.
int32_t UpdateProtectionMethod();
// Buffering mode.
void SetSenderBufferingMode(int target_delay_ms);
// Implements VCMPacketizationCallback.
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t time_stamp,
int64_t capture_time_ms,
const uint8_t* payload_data,
uint32_t payload_size,
const RTPFragmentationHeader& fragmentation_header,
const RTPVideoHeader* rtp_video_hdr);
// Implements VideoProtectionCallback.
virtual int ProtectionRequest(
const FecProtectionParams* delta_fec_params,
const FecProtectionParams* key_fec_params,
uint32_t* sent_video_rate_bps,
uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps);
// Implements VideoSendStatisticsCallback.
virtual int32_t SendStatistics(const uint32_t bit_rate,
const uint32_t frame_rate);
int32_t RegisterCodecObserver(ViEEncoderObserver* observer);
// Implements RtcpIntraFrameObserver.
virtual void OnReceivedIntraFrameRequest(uint32_t ssrc);
virtual void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id);
virtual void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id);
virtual void OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc);
// Sets SSRCs for all streams.
bool SetSsrcs(const std::list<unsigned int>& ssrcs);
// Effect filter.
int32_t RegisterEffectFilter(ViEEffectFilter* effect_filter);
// Enables recording of debugging information.
virtual int StartDebugRecording(const char* fileNameUTF8);
// Disables recording of debugging information.
virtual int StopDebugRecording();
int channel_id() const { return channel_id_; }
protected:
// Called by BitrateObserver.
void OnNetworkChanged(const uint32_t bitrate_bps,
const uint8_t fraction_lost,
const uint32_t round_trip_time_ms);
// Called by PacedSender.
bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number,
int64_t capture_time_ms);
int TimeToSendPadding(int bytes);
private:
bool EncoderPaused() const;
int32_t engine_id_;
const int channel_id_;
const uint32_t number_of_cores_;
VideoCodingModule& vcm_;
VideoProcessingModule& vpm_;
scoped_ptr<RtpRtcp> default_rtp_rtcp_;
scoped_ptr<CriticalSectionWrapper> callback_cs_;
scoped_ptr<CriticalSectionWrapper> data_cs_;
scoped_ptr<BitrateObserver> bitrate_observer_;
scoped_ptr<PacedSender> paced_sender_;
scoped_ptr<ViEPacedSenderCallback> pacing_callback_;
BitrateController* bitrate_controller_;
bool send_padding_;
int target_delay_ms_;
bool network_is_transmitting_;
bool encoder_paused_;
bool encoder_paused_and_dropped_frame_;
std::map<unsigned int, int64_t> time_last_intra_request_ms_;
int32_t channels_dropping_delta_frames_;
bool drop_next_frame_;
bool fec_enabled_;
bool nack_enabled_;
ViEEncoderObserver* codec_observer_;
ViEEffectFilter* effect_filter_;
ProcessThread& module_process_thread_;
bool has_received_sli_;
uint8_t picture_id_sli_;
bool has_received_rpsi_;
uint64_t picture_id_rpsi_;
std::map<unsigned int, int> ssrc_streams_;
// Quality modes callback
QMVideoSettingsCallback* qm_callback_;
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_
|
