1 /*
2 * Copyright (c) 2018 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/decoder_database.h"
12
13 #include <memory>
14 #include <utility>
15
16 #include "rtc_base/checks.h"
17 #include "rtc_base/logging.h"
18
19 namespace webrtc {
20
VCMDecoderDatabase()21 VCMDecoderDatabase::VCMDecoderDatabase() {
22 decoder_sequence_checker_.Detach();
23 }
24
DeregisterExternalDecoder(uint8_t payload_type)25 void VCMDecoderDatabase::DeregisterExternalDecoder(uint8_t payload_type) {
26 RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
27 auto it = decoders_.find(payload_type);
28 if (it == decoders_.end()) {
29 return;
30 }
31
32 // We can't use payload_type to check if the decoder is currently in use,
33 // because payload type may be out of date (e.g. before we decode the first
34 // frame after RegisterReceiveCodec).
35 if (current_decoder_ && current_decoder_->IsSameDecoder(it->second.get())) {
36 // Release it if it was registered and in use.
37 current_decoder_ = absl::nullopt;
38 }
39 decoders_.erase(it);
40 }
41
42 // Add the external decoder object to the list of external decoders.
43 // Won't be registered as a receive codec until RegisterReceiveCodec is called.
RegisterExternalDecoder(uint8_t payload_type,std::unique_ptr<VideoDecoder> external_decoder)44 void VCMDecoderDatabase::RegisterExternalDecoder(
45 uint8_t payload_type,
46 std::unique_ptr<VideoDecoder> external_decoder) {
47 RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
48 // If payload value already exists, erase old and insert new.
49 DeregisterExternalDecoder(payload_type);
50 if (external_decoder) {
51 decoders_.emplace(
52 std::make_pair(payload_type, std::move(external_decoder)));
53 }
54 }
55
IsExternalDecoderRegistered(uint8_t payload_type) const56 bool VCMDecoderDatabase::IsExternalDecoderRegistered(
57 uint8_t payload_type) const {
58 RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
59 return decoders_.find(payload_type) != decoders_.end();
60 }
61
RegisterReceiveCodec(uint8_t payload_type,const VideoDecoder::Settings & settings)62 void VCMDecoderDatabase::RegisterReceiveCodec(
63 uint8_t payload_type,
64 const VideoDecoder::Settings& settings) {
65 // If payload value already exists, erase old and insert new.
66 if (payload_type == current_payload_type_) {
67 current_payload_type_ = absl::nullopt;
68 }
69 decoder_settings_[payload_type] = settings;
70 }
71
DeregisterReceiveCodec(uint8_t payload_type)72 bool VCMDecoderDatabase::DeregisterReceiveCodec(uint8_t payload_type) {
73 if (decoder_settings_.erase(payload_type) == 0) {
74 return false;
75 }
76 if (payload_type == current_payload_type_) {
77 // This codec is currently in use.
78 current_payload_type_ = absl::nullopt;
79 }
80 return true;
81 }
82
DeregisterReceiveCodecs()83 void VCMDecoderDatabase::DeregisterReceiveCodecs() {
84 current_payload_type_ = absl::nullopt;
85 decoder_settings_.clear();
86 }
87
GetDecoder(const VCMEncodedFrame & frame,VCMDecodedFrameCallback * decoded_frame_callback)88 VCMGenericDecoder* VCMDecoderDatabase::GetDecoder(
89 const VCMEncodedFrame& frame,
90 VCMDecodedFrameCallback* decoded_frame_callback) {
91 RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
92 RTC_DCHECK(decoded_frame_callback->UserReceiveCallback());
93 uint8_t payload_type = frame.PayloadType();
94 if (payload_type == current_payload_type_ || payload_type == 0) {
95 return current_decoder_.has_value() ? &*current_decoder_ : nullptr;
96 }
97 // If decoder exists - delete.
98 if (current_decoder_.has_value()) {
99 current_decoder_ = absl::nullopt;
100 current_payload_type_ = absl::nullopt;
101 }
102
103 CreateAndInitDecoder(frame);
104 if (current_decoder_ == absl::nullopt) {
105 return nullptr;
106 }
107
108 VCMReceiveCallback* callback = decoded_frame_callback->UserReceiveCallback();
109 callback->OnIncomingPayloadType(payload_type);
110 if (current_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback) <
111 0) {
112 current_decoder_ = absl::nullopt;
113 return nullptr;
114 }
115
116 current_payload_type_ = payload_type;
117 return &*current_decoder_;
118 }
119
CreateAndInitDecoder(const VCMEncodedFrame & frame)120 void VCMDecoderDatabase::CreateAndInitDecoder(const VCMEncodedFrame& frame) {
121 uint8_t payload_type = frame.PayloadType();
122 RTC_DLOG(LS_INFO) << "Initializing decoder with payload type '"
123 << int{payload_type} << "'.";
124 auto decoder_item = decoder_settings_.find(payload_type);
125 if (decoder_item == decoder_settings_.end()) {
126 RTC_LOG(LS_ERROR) << "Can't find a decoder associated with payload type: "
127 << int{payload_type};
128 return;
129 }
130 auto external_dec_item = decoders_.find(payload_type);
131 if (external_dec_item == decoders_.end()) {
132 RTC_LOG(LS_ERROR) << "No decoder of this type exists.";
133 return;
134 }
135 current_decoder_.emplace(external_dec_item->second.get());
136
137 // Copy over input resolutions to prevent codec reinitialization due to
138 // the first frame being of a different resolution than the database values.
139 // This is best effort, since there's no guarantee that width/height have been
140 // parsed yet (and may be zero).
141 RenderResolution frame_resolution(frame.EncodedImage()._encodedWidth,
142 frame.EncodedImage()._encodedHeight);
143 if (frame_resolution.Valid()) {
144 decoder_item->second.set_max_render_resolution(frame_resolution);
145 }
146 if (!current_decoder_->Configure(decoder_item->second)) {
147 current_decoder_ = absl::nullopt;
148 RTC_LOG(LS_ERROR) << "Failed to initialize decoder.";
149 }
150 }
151
152 } // namespace webrtc
153