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_VIDEO_ENGINE_VIE_ENCODER_H_ 12 #define WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ 13 14 #include <list> 15 #include <map> 16 17 #include "webrtc/common_types.h" 18 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" 19 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h" 20 #include "webrtc/modules/video_coding/main/interface/video_coding_defines.h" 21 #include "webrtc/modules/video_processing/main/interface/video_processing.h" 22 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 23 #include "webrtc/system_wrappers/interface/thread_annotations.h" 24 #include "webrtc/typedefs.h" 25 #include "webrtc/frame_callback.h" 26 #include "webrtc/video_engine/vie_defines.h" 27 #include "webrtc/video_engine/vie_frame_provider_base.h" 28 29 namespace webrtc { 30 31 class Config; 32 class CriticalSectionWrapper; 33 class EncodedImageCallback; 34 class PacedSender; 35 class ProcessThread; 36 class QMVideoSettingsCallback; 37 class RtpRtcp; 38 class ViEBitrateObserver; 39 class ViEEffectFilter; 40 class ViEEncoderObserver; 41 class VideoCodingModule; 42 class ViEPacedSenderCallback; 43 44 class ViEEncoder 45 : public RtcpIntraFrameObserver, 46 public VCMPacketizationCallback, 47 public VCMProtectionCallback, 48 public VCMSendStatisticsCallback, 49 public ViEFrameCallback { 50 public: 51 friend class ViEBitrateObserver; 52 friend class ViEPacedSenderCallback; 53 54 ViEEncoder(int32_t engine_id, 55 int32_t channel_id, 56 uint32_t number_of_cores, 57 const Config& config, 58 ProcessThread& module_process_thread, 59 BitrateController* bitrate_controller); 60 ~ViEEncoder(); 61 62 bool Init(); 63 64 void SetNetworkTransmissionState(bool is_transmitting); 65 66 // Returns the id of the owning channel. 67 int Owner() const; 68 69 // Drops incoming packets before they get to the encoder. 70 void Pause(); 71 void Restart(); 72 73 // Codec settings. 74 uint8_t NumberOfCodecs(); 75 int32_t GetCodec(uint8_t list_index, VideoCodec* video_codec); 76 int32_t RegisterExternalEncoder(VideoEncoder* encoder, 77 uint8_t pl_type, 78 bool internal_source); 79 int32_t DeRegisterExternalEncoder(uint8_t pl_type); 80 int32_t SetEncoder(const VideoCodec& video_codec); 81 int32_t GetEncoder(VideoCodec* video_codec); 82 83 int32_t GetCodecConfigParameters( 84 unsigned char config_parameters[kConfigParameterSize], 85 unsigned char& config_parameters_size); 86 87 PacedSender* GetPacedSender(); 88 89 // Scale or crop/pad image. 90 int32_t ScaleInputImage(bool enable); 91 92 // RTP settings. 93 RtpRtcp* SendRtpRtcpModule(); 94 95 // Implementing ViEFrameCallback. 96 virtual void DeliverFrame(int id, 97 I420VideoFrame* video_frame, 98 int num_csrcs = 0, 99 const uint32_t CSRC[kRtpCsrcSize] = NULL); 100 virtual void DelayChanged(int id, int frame_delay); 101 virtual int GetPreferedFrameSettings(int* width, 102 int* height, 103 int* frame_rate); 104 ProviderDestroyed(int id)105 virtual void ProviderDestroyed(int id) { 106 return; 107 } 108 109 int32_t SendKeyFrame(); 110 int32_t SendCodecStatistics(uint32_t* num_key_frames, 111 uint32_t* num_delta_frames); 112 113 int PacerQueuingDelayMs() const; 114 115 int CodecTargetBitrate(uint32_t* bitrate) const; 116 // Loss protection. 117 int32_t UpdateProtectionMethod(bool enable_nack); nack_enabled()118 bool nack_enabled() const { return nack_enabled_; } 119 120 // Buffering mode. 121 void SetSenderBufferingMode(int target_delay_ms); 122 123 // Implements VCMPacketizationCallback. 124 virtual int32_t SendData( 125 FrameType frame_type, 126 uint8_t payload_type, 127 uint32_t time_stamp, 128 int64_t capture_time_ms, 129 const uint8_t* payload_data, 130 uint32_t payload_size, 131 const RTPFragmentationHeader& fragmentation_header, 132 const RTPVideoHeader* rtp_video_hdr); 133 134 // Implements VideoProtectionCallback. 135 virtual int ProtectionRequest( 136 const FecProtectionParams* delta_fec_params, 137 const FecProtectionParams* key_fec_params, 138 uint32_t* sent_video_rate_bps, 139 uint32_t* sent_nack_rate_bps, 140 uint32_t* sent_fec_rate_bps); 141 142 // Implements VideoSendStatisticsCallback. 143 virtual int32_t SendStatistics(const uint32_t bit_rate, 144 const uint32_t frame_rate); 145 int32_t RegisterCodecObserver(ViEEncoderObserver* observer); 146 147 // Implements RtcpIntraFrameObserver. 148 virtual void OnReceivedIntraFrameRequest(uint32_t ssrc); 149 virtual void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id); 150 virtual void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id); 151 virtual void OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc); 152 153 // Sets SSRCs for all streams. 154 bool SetSsrcs(const std::list<unsigned int>& ssrcs); 155 156 void SetMinTransmitBitrate(int min_transmit_bitrate_kbps); 157 158 // Effect filter. 159 int32_t RegisterEffectFilter(ViEEffectFilter* effect_filter); 160 161 // Enables recording of debugging information. 162 virtual int StartDebugRecording(const char* fileNameUTF8); 163 164 // Disables recording of debugging information. 165 virtual int StopDebugRecording(); 166 167 // Lets the sender suspend video when the rate drops below 168 // |threshold_bps|, and turns back on when the rate goes back up above 169 // |threshold_bps| + |window_bps|. 170 virtual void SuspendBelowMinBitrate(); 171 172 // New-style callbacks, used by VideoSendStream. 173 void RegisterPreEncodeCallback(I420FrameCallback* pre_encode_callback); 174 void DeRegisterPreEncodeCallback(); 175 void RegisterPostEncodeImageCallback( 176 EncodedImageCallback* post_encode_callback); 177 void DeRegisterPostEncodeImageCallback(); 178 channel_id()179 int channel_id() const { return channel_id_; } 180 181 protected: 182 // Called by BitrateObserver. 183 void OnNetworkChanged(const uint32_t bitrate_bps, 184 const uint8_t fraction_lost, 185 const uint32_t round_trip_time_ms); 186 187 // Called by PacedSender. 188 bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, 189 int64_t capture_time_ms, bool retransmission); 190 int TimeToSendPadding(int bytes); 191 private: 192 bool EncoderPaused() const; 193 194 int32_t engine_id_; 195 const int channel_id_; 196 const uint32_t number_of_cores_; 197 198 VideoCodingModule& vcm_; 199 VideoProcessingModule& vpm_; 200 scoped_ptr<RtpRtcp> default_rtp_rtcp_; 201 scoped_ptr<CriticalSectionWrapper> callback_cs_; 202 scoped_ptr<CriticalSectionWrapper> data_cs_; 203 scoped_ptr<BitrateObserver> bitrate_observer_; 204 scoped_ptr<PacedSender> paced_sender_; 205 scoped_ptr<ViEPacedSenderCallback> pacing_callback_; 206 207 BitrateController* bitrate_controller_; 208 209 int64_t time_of_last_incoming_frame_ms_; 210 bool send_padding_; 211 int min_transmit_bitrate_kbps_ GUARDED_BY(data_cs_); 212 int target_delay_ms_; 213 bool network_is_transmitting_; 214 bool encoder_paused_; 215 bool encoder_paused_and_dropped_frame_; 216 std::map<unsigned int, int64_t> time_last_intra_request_ms_; 217 218 bool fec_enabled_; 219 bool nack_enabled_; 220 221 ViEEncoderObserver* codec_observer_ GUARDED_BY(callback_cs_); 222 ViEEffectFilter* effect_filter_; 223 ProcessThread& module_process_thread_; 224 225 bool has_received_sli_; 226 uint8_t picture_id_sli_; 227 bool has_received_rpsi_; 228 uint64_t picture_id_rpsi_; 229 std::map<unsigned int, int> ssrc_streams_; 230 231 // Quality modes callback 232 QMVideoSettingsCallback* qm_callback_; 233 bool video_suspended_; 234 I420FrameCallback* pre_encode_callback_; 235 }; 236 237 } // namespace webrtc 238 239 #endif // WEBRTC_VIDEO_ENGINE_VIE_ENCODER_H_ 240