src/third_party/webrtc/modules/video_coding/main/source/video_coding_impl.cc

   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 #include "webrtc/common_types.h"
  12 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
  13 #include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
  14 #include "webrtc/modules/video_coding/main/source/encoded_frame.h"
  15 #include "webrtc/modules/video_coding/main/source/jitter_buffer.h"
  16 #include "webrtc/modules/video_coding/main/source/packet.h"
  17 #include "webrtc/modules/video_coding/main/source/video_coding_impl.h"
  18 #include "webrtc/system_wrappers/interface/clock.h"
  19 #include "webrtc/system_wrappers/interface/trace.h"
  20 #include "webrtc/system_wrappers/interface/trace_event.h"
  21
  22 namespace webrtc {
  23 namespace vcm {
  24
  25 uint32_t
  26 VCMProcessTimer::Period() const {
  27     return _periodMs;
  28 }
  29
  30 uint32_t
  31 VCMProcessTimer::TimeUntilProcess() const {
  32     const int64_t time_since_process = _clock->TimeInMilliseconds() -
  33         static_cast<int64_t>(_latestMs);
  34     const int64_t time_until_process = static_cast<int64_t>(_periodMs) -
  35         time_since_process;
  36     if (time_until_process < 0)
  37       return 0;
  38     return time_until_process;
  39 }
  40
  41 void
  42 VCMProcessTimer::Processed() {
  43     _latestMs = _clock->TimeInMilliseconds();
  44 }
  45 }  // namespace vcm
  46
  47 namespace {
  48 // This wrapper provides a way to modify the callback without the need to expose
  49 // a register method all the way down to the function calling it.
  50 class EncodedImageCallbackWrapper : public EncodedImageCallback {
  51  public:
  52   EncodedImageCallbackWrapper()
  53       : cs_(CriticalSectionWrapper::CreateCriticalSection()), callback_(NULL) {}
  54
  55   virtual ~EncodedImageCallbackWrapper() {}
  56
  57   void Register(EncodedImageCallback* callback) {
  58     CriticalSectionScoped cs(cs_.get());
  59     callback_ = callback;
  60   }
  61
  62   // TODO(andresp): Change to void as return value is ignored.
  63   virtual int32_t Encoded(EncodedImage& encoded_image,
  64                           const CodecSpecificInfo* codec_specific_info,
  65                           const RTPFragmentationHeader* fragmentation) {
  66     CriticalSectionScoped cs(cs_.get());
  67     if (callback_)
  68       return callback_->Encoded(
  69           encoded_image, codec_specific_info, fragmentation);
  70     return 0;
  71   }
  72
  73  private:
  74   scoped_ptr<CriticalSectionWrapper> cs_;
  75   EncodedImageCallback* callback_ GUARDED_BY(cs_);
  76 };
  77
  78 class VideoCodingModuleImpl : public VideoCodingModule {
  79  public:
  80   VideoCodingModuleImpl(const int32_t id,
  81                         Clock* clock,
  82                         EventFactory* event_factory,
  83                         bool owns_event_factory)
  84       : VideoCodingModule(),
  85         sender_(new vcm::VideoSender(id, clock, &post_encode_callback_)),
  86         receiver_(new vcm::VideoReceiver(id, clock, event_factory)),
  87         own_event_factory_(owns_event_factory ? event_factory : NULL) {}
  88
  89   virtual ~VideoCodingModuleImpl() {
  90     sender_.reset();
  91     receiver_.reset();
  92     own_event_factory_.reset();
  93   }
  94
  95   virtual int32_t TimeUntilNextProcess() OVERRIDE {
  96     int32_t sender_time = sender_->TimeUntilNextProcess();
  97     int32_t receiver_time = receiver_->TimeUntilNextProcess();
  98     assert(sender_time >= 0);
  99     assert(receiver_time >= 0);
 100     return VCM_MIN(sender_time, receiver_time);
 101   }
 102
 103   virtual int32_t Process() OVERRIDE {
 104     int32_t sender_return = sender_->Process();
 105     int32_t receiver_return = receiver_->Process();
 106     if (sender_return != VCM_OK)
 107       return sender_return;
 108     return receiver_return;
 109   }
 110
 111   virtual int32_t InitializeSender() OVERRIDE {
 112     return sender_->InitializeSender();
 113   }
 114
 115   virtual int32_t RegisterSendCodec(const VideoCodec* sendCodec,
 116                                     uint32_t numberOfCores,
 117                                     uint32_t maxPayloadSize) OVERRIDE {
 118     return sender_->RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize);
 119   }
 120
 121   virtual int32_t SendCodec(VideoCodec* currentSendCodec) const OVERRIDE {
 122     return sender_->SendCodec(currentSendCodec);
 123   }
 124
 125   virtual VideoCodecType SendCodec() const OVERRIDE {
 126     return sender_->SendCodec();
 127   }
 128
 129   virtual int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder,
 130                                           uint8_t payloadType,
 131                                           bool internalSource) OVERRIDE {
 132     return sender_->RegisterExternalEncoder(
 133         externalEncoder, payloadType, internalSource);
 134   }
 135
 136   virtual int32_t CodecConfigParameters(uint8_t* buffer, int32_t size)
 137       OVERRIDE {
 138     return sender_->CodecConfigParameters(buffer, size);
 139   }
 140
 141   virtual int Bitrate(unsigned int* bitrate) const OVERRIDE {
 142     return sender_->Bitrate(bitrate);
 143   }
 144
 145   virtual int FrameRate(unsigned int* framerate) const OVERRIDE {
 146     return sender_->FrameRate(framerate);
 147   }
 148
 149   virtual int32_t SetChannelParameters(uint32_t target_bitrate,  // bits/s.
 150                                        uint8_t lossRate,
 151                                        uint32_t rtt) OVERRIDE {
 152     return sender_->SetChannelParameters(target_bitrate, lossRate, rtt);
 153   }
 154
 155   virtual int32_t RegisterTransportCallback(VCMPacketizationCallback* transport)
 156       OVERRIDE {
 157     return sender_->RegisterTransportCallback(transport);
 158   }
 159
 160   virtual int32_t RegisterSendStatisticsCallback(
 161       VCMSendStatisticsCallback* sendStats) OVERRIDE {
 162     return sender_->RegisterSendStatisticsCallback(sendStats);
 163   }
 164
 165   virtual int32_t RegisterVideoQMCallback(
 166       VCMQMSettingsCallback* videoQMSettings) OVERRIDE {
 167     return sender_->RegisterVideoQMCallback(videoQMSettings);
 168   }
 169
 170   virtual int32_t RegisterProtectionCallback(VCMProtectionCallback* protection)
 171       OVERRIDE {
 172     return sender_->RegisterProtectionCallback(protection);
 173   }
 174
 175   virtual int32_t SetVideoProtection(VCMVideoProtection videoProtection,
 176                                      bool enable) OVERRIDE {
 177     int32_t sender_return =
 178         sender_->SetVideoProtection(videoProtection, enable);
 179     int32_t receiver_return =
 180         receiver_->SetVideoProtection(videoProtection, enable);
 181     if (sender_return == VCM_OK)
 182       return receiver_return;
 183     return sender_return;
 184   }
 185
 186   virtual int32_t AddVideoFrame(const I420VideoFrame& videoFrame,
 187                                 const VideoContentMetrics* contentMetrics,
 188                                 const CodecSpecificInfo* codecSpecificInfo)
 189       OVERRIDE {
 190     return sender_->AddVideoFrame(
 191         videoFrame, contentMetrics, codecSpecificInfo);
 192   }
 193
 194   virtual int32_t IntraFrameRequest(int stream_index) OVERRIDE {
 195     return sender_->IntraFrameRequest(stream_index);
 196   }
 197
 198   virtual int32_t EnableFrameDropper(bool enable) OVERRIDE {
 199     return sender_->EnableFrameDropper(enable);
 200   }
 201
 202   virtual int32_t SentFrameCount(VCMFrameCount& frameCount) const OVERRIDE {
 203     return sender_->SentFrameCount(&frameCount);
 204   }
 205
 206   virtual int SetSenderNackMode(SenderNackMode mode) OVERRIDE {
 207     return sender_->SetSenderNackMode(mode);
 208   }
 209
 210   virtual int SetSenderReferenceSelection(bool enable) OVERRIDE {
 211     return sender_->SetSenderReferenceSelection(enable);
 212   }
 213
 214   virtual int SetSenderFEC(bool enable) OVERRIDE {
 215     return sender_->SetSenderFEC(enable);
 216   }
 217
 218   virtual int SetSenderKeyFramePeriod(int periodMs) OVERRIDE {
 219     return sender_->SetSenderKeyFramePeriod(periodMs);
 220   }
 221
 222   virtual int StartDebugRecording(const char* file_name_utf8) OVERRIDE {
 223     return sender_->StartDebugRecording(file_name_utf8);
 224   }
 225
 226   virtual int StopDebugRecording() OVERRIDE {
 227     sender_->StopDebugRecording();
 228     return VCM_OK;
 229   }
 230
 231   virtual void SuspendBelowMinBitrate() {
 232     return sender_->SuspendBelowMinBitrate();
 233   }
 234
 235   virtual bool VideoSuspended() const {
 236     return sender_->VideoSuspended();
 237   }
 238
 239   virtual int32_t InitializeReceiver() OVERRIDE {
 240     return receiver_->InitializeReceiver();
 241   }
 242
 243   virtual int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
 244                                        int32_t numberOfCores,
 245                                        bool requireKeyFrame) OVERRIDE {
 246     return receiver_->RegisterReceiveCodec(
 247         receiveCodec, numberOfCores, requireKeyFrame);
 248   }
 249
 250   virtual int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder,
 251                                           uint8_t payloadType,
 252                                           bool internalRenderTiming) OVERRIDE {
 253     return receiver_->RegisterExternalDecoder(
 254         externalDecoder, payloadType, internalRenderTiming);
 255   }
 256
 257   virtual int32_t RegisterReceiveCallback(VCMReceiveCallback* receiveCallback)
 258       OVERRIDE {
 259     return receiver_->RegisterReceiveCallback(receiveCallback);
 260   }
 261
 262   virtual int32_t RegisterReceiveStatisticsCallback(
 263       VCMReceiveStatisticsCallback* receiveStats) OVERRIDE {
 264     return receiver_->RegisterReceiveStatisticsCallback(receiveStats);
 265   }
 266
 267   virtual int32_t RegisterDecoderTimingCallback(
 268       VCMDecoderTimingCallback* decoderTiming) OVERRIDE {
 269     return receiver_->RegisterDecoderTimingCallback(decoderTiming);
 270   }
 271
 272   virtual int32_t RegisterFrameTypeCallback(
 273       VCMFrameTypeCallback* frameTypeCallback) OVERRIDE {
 274     return receiver_->RegisterFrameTypeCallback(frameTypeCallback);
 275   }
 276
 277   virtual int32_t RegisterPacketRequestCallback(
 278       VCMPacketRequestCallback* callback) OVERRIDE {
 279     return receiver_->RegisterPacketRequestCallback(callback);
 280   }
 281
 282   virtual int RegisterRenderBufferSizeCallback(
 283       VCMRenderBufferSizeCallback* callback) OVERRIDE {
 284     return receiver_->RegisterRenderBufferSizeCallback(callback);
 285   }
 286
 287   virtual int32_t Decode(uint16_t maxWaitTimeMs) OVERRIDE {
 288     return receiver_->Decode(maxWaitTimeMs);
 289   }
 290
 291   virtual int32_t DecodeDualFrame(uint16_t maxWaitTimeMs) OVERRIDE {
 292     return receiver_->DecodeDualFrame(maxWaitTimeMs);
 293   }
 294
 295   virtual int32_t ResetDecoder() OVERRIDE { return receiver_->ResetDecoder(); }
 296
 297   virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const {
 298     return receiver_->ReceiveCodec(currentReceiveCodec);
 299   }
 300
 301   virtual VideoCodecType ReceiveCodec() const OVERRIDE {
 302     return receiver_->ReceiveCodec();
 303   }
 304
 305   virtual int32_t IncomingPacket(const uint8_t* incomingPayload,
 306                                  uint32_t payloadLength,
 307                                  const WebRtcRTPHeader& rtpInfo) OVERRIDE {
 308     return receiver_->IncomingPacket(incomingPayload, payloadLength, rtpInfo);
 309   }
 310
 311   virtual int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) OVERRIDE {
 312     return receiver_->SetMinimumPlayoutDelay(minPlayoutDelayMs);
 313   }
 314
 315   virtual int32_t SetRenderDelay(uint32_t timeMS) OVERRIDE {
 316     return receiver_->SetRenderDelay(timeMS);
 317   }
 318
 319   virtual int32_t Delay() const OVERRIDE { return receiver_->Delay(); }
 320
 321   virtual int32_t ReceivedFrameCount(VCMFrameCount& frameCount) const OVERRIDE {
 322     return receiver_->ReceivedFrameCount(&frameCount);
 323   }
 324
 325   virtual uint32_t DiscardedPackets() const OVERRIDE {
 326     return receiver_->DiscardedPackets();
 327   }
 328
 329   virtual int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
 330                                         VCMDecodeErrorMode errorMode) OVERRIDE {
 331     return receiver_->SetReceiverRobustnessMode(robustnessMode, errorMode);
 332   }
 333
 334   virtual void SetNackSettings(size_t max_nack_list_size,
 335                                int max_packet_age_to_nack,
 336                                int max_incomplete_time_ms) OVERRIDE {
 337     return receiver_->SetNackSettings(
 338         max_nack_list_size, max_packet_age_to_nack, max_incomplete_time_ms);
 339   }
 340
 341   void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) OVERRIDE {
 342     return receiver_->SetDecodeErrorMode(decode_error_mode);
 343   }
 344
 345   virtual int SetMinReceiverDelay(int desired_delay_ms) OVERRIDE {
 346     return receiver_->SetMinReceiverDelay(desired_delay_ms);
 347   }
 348
 349   virtual int32_t SetReceiveChannelParameters(uint32_t rtt) OVERRIDE {
 350     return receiver_->SetReceiveChannelParameters(rtt);
 351   }
 352
 353   virtual void RegisterPreDecodeImageCallback(
 354       EncodedImageCallback* observer) OVERRIDE {
 355     receiver_->RegisterPreDecodeImageCallback(observer);
 356   }
 357
 358   virtual void RegisterPostEncodeImageCallback(
 359       EncodedImageCallback* observer) OVERRIDE {
 360     post_encode_callback_.Register(observer);
 361   }
 362
 363  private:
 364   EncodedImageCallbackWrapper post_encode_callback_;
 365   scoped_ptr<vcm::VideoSender> sender_;
 366   scoped_ptr<vcm::VideoReceiver> receiver_;
 367   scoped_ptr<EventFactory> own_event_factory_;
 368 };
 369 }  // namespace
 370
 371 uint8_t VideoCodingModule::NumberOfCodecs() {
 372   return VCMCodecDataBase::NumberOfCodecs();
 373 }
 374
 375 int32_t VideoCodingModule::Codec(uint8_t listId, VideoCodec* codec) {
 376   if (codec == NULL) {
 377     return VCM_PARAMETER_ERROR;
 378   }
 379   return VCMCodecDataBase::Codec(listId, codec) ? 0 : -1;
 380 }
 381
 382 int32_t VideoCodingModule::Codec(VideoCodecType codecType, VideoCodec* codec) {
 383   if (codec == NULL) {
 384     return VCM_PARAMETER_ERROR;
 385   }
 386   return VCMCodecDataBase::Codec(codecType, codec) ? 0 : -1;
 387 }
 388
 389 VideoCodingModule* VideoCodingModule::Create(const int32_t id) {
 390   return new VideoCodingModuleImpl(
 391       id, Clock::GetRealTimeClock(), new EventFactoryImpl, true);
 392 }
 393
 394 VideoCodingModule* VideoCodingModule::Create(const int32_t id,
 395                                              Clock* clock,
 396                                              EventFactory* event_factory) {
 397   assert(clock);
 398   assert(event_factory);
 399   return new VideoCodingModuleImpl(id, clock, event_factory, false);
 400 }
 401
 402 void VideoCodingModule::Destroy(VideoCodingModule* module) {
 403   if (module != NULL) {
 404     delete static_cast<VideoCodingModuleImpl*>(module);
 405   }
 406 }
 407 }  // namespace webrtc