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 "modules/video_coding/video_coding_impl.h"
12
13 #include <algorithm>
14 #include <memory>
15
16 #include "api/video/encoded_image.h"
17 #include "modules/video_coding/include/video_codec_interface.h"
18 #include "modules/video_coding/timing.h"
19 #include "rtc_base/critical_section.h"
20 #include "rtc_base/thread_checker.h"
21 #include "system_wrappers/include/clock.h"
22
23 namespace webrtc {
24 namespace vcm {
25
Period() const26 int64_t VCMProcessTimer::Period() const {
27 return _periodMs;
28 }
29
TimeUntilProcess() const30 int64_t VCMProcessTimer::TimeUntilProcess() const {
31 const int64_t time_since_process = _clock->TimeInMilliseconds() - _latestMs;
32 const int64_t time_until_process = _periodMs - time_since_process;
33 return std::max<int64_t>(time_until_process, 0);
34 }
35
Processed()36 void VCMProcessTimer::Processed() {
37 _latestMs = _clock->TimeInMilliseconds();
38 }
39 } // namespace vcm
40
41 namespace {
42
43 class VideoCodingModuleImpl : public VideoCodingModule {
44 public:
VideoCodingModuleImpl(Clock * clock)45 explicit VideoCodingModuleImpl(Clock* clock)
46 : VideoCodingModule(),
47 timing_(new VCMTiming(clock)),
48 receiver_(clock, timing_.get()) {}
49
~VideoCodingModuleImpl()50 ~VideoCodingModuleImpl() override {}
51
TimeUntilNextProcess()52 int64_t TimeUntilNextProcess() override {
53 int64_t receiver_time = receiver_.TimeUntilNextProcess();
54 RTC_DCHECK_GE(receiver_time, 0);
55 return receiver_time;
56 }
57
Process()58 void Process() override { receiver_.Process(); }
59
RegisterReceiveCodec(const VideoCodec * receiveCodec,int32_t numberOfCores,bool requireKeyFrame)60 int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
61 int32_t numberOfCores,
62 bool requireKeyFrame) override {
63 return receiver_.RegisterReceiveCodec(receiveCodec, numberOfCores,
64 requireKeyFrame);
65 }
66
RegisterExternalDecoder(VideoDecoder * externalDecoder,uint8_t payloadType)67 void RegisterExternalDecoder(VideoDecoder* externalDecoder,
68 uint8_t payloadType) override {
69 receiver_.RegisterExternalDecoder(externalDecoder, payloadType);
70 }
71
RegisterReceiveCallback(VCMReceiveCallback * receiveCallback)72 int32_t RegisterReceiveCallback(
73 VCMReceiveCallback* receiveCallback) override {
74 RTC_DCHECK(construction_thread_.IsCurrent());
75 return receiver_.RegisterReceiveCallback(receiveCallback);
76 }
77
RegisterFrameTypeCallback(VCMFrameTypeCallback * frameTypeCallback)78 int32_t RegisterFrameTypeCallback(
79 VCMFrameTypeCallback* frameTypeCallback) override {
80 return receiver_.RegisterFrameTypeCallback(frameTypeCallback);
81 }
82
RegisterPacketRequestCallback(VCMPacketRequestCallback * callback)83 int32_t RegisterPacketRequestCallback(
84 VCMPacketRequestCallback* callback) override {
85 RTC_DCHECK(construction_thread_.IsCurrent());
86 return receiver_.RegisterPacketRequestCallback(callback);
87 }
88
Decode(uint16_t maxWaitTimeMs)89 int32_t Decode(uint16_t maxWaitTimeMs) override {
90 return receiver_.Decode(maxWaitTimeMs);
91 }
92
IncomingPacket(const uint8_t * incomingPayload,size_t payloadLength,const RTPHeader & rtp_header,const RTPVideoHeader & video_header)93 int32_t IncomingPacket(const uint8_t* incomingPayload,
94 size_t payloadLength,
95 const RTPHeader& rtp_header,
96 const RTPVideoHeader& video_header) override {
97 return receiver_.IncomingPacket(incomingPayload, payloadLength, rtp_header,
98 video_header);
99 }
100
SetNackSettings(size_t max_nack_list_size,int max_packet_age_to_nack,int max_incomplete_time_ms)101 void SetNackSettings(size_t max_nack_list_size,
102 int max_packet_age_to_nack,
103 int max_incomplete_time_ms) override {
104 return receiver_.SetNackSettings(max_nack_list_size, max_packet_age_to_nack,
105 max_incomplete_time_ms);
106 }
107
108 private:
109 rtc::ThreadChecker construction_thread_;
110 const std::unique_ptr<VCMTiming> timing_;
111 vcm::VideoReceiver receiver_;
112 };
113 } // namespace
114
115 // DEPRECATED. Create method for current interface, will be removed when the
116 // new jitter buffer is in place.
Create(Clock * clock)117 VideoCodingModule* VideoCodingModule::Create(Clock* clock) {
118 RTC_DCHECK(clock);
119 return new VideoCodingModuleImpl(clock);
120 }
121
122 } // namespace webrtc
123