1 /*
2 * Copyright (c) 2013 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 "test/fake_decoder.h"
12
13 #include <string.h>
14
15 #include <memory>
16
17 #include "api/scoped_refptr.h"
18 #include "api/video/i420_buffer.h"
19 #include "api/video/video_frame.h"
20 #include "api/video/video_frame_buffer.h"
21 #include "api/video/video_rotation.h"
22 #include "modules/video_coding/include/video_error_codes.h"
23 #include "rtc_base/checks.h"
24 #include "rtc_base/task_queue.h"
25 #include "rtc_base/time_utils.h"
26
27 namespace webrtc {
28 namespace test {
29
FakeDecoder()30 FakeDecoder::FakeDecoder() : FakeDecoder(nullptr) {}
31
FakeDecoder(TaskQueueFactory * task_queue_factory)32 FakeDecoder::FakeDecoder(TaskQueueFactory* task_queue_factory)
33 : callback_(nullptr),
34 width_(kDefaultWidth),
35 height_(kDefaultHeight),
36 task_queue_factory_(task_queue_factory),
37 decode_delay_ms_(0) {}
38
Configure(const Settings & settings)39 bool FakeDecoder::Configure(const Settings& settings) {
40 return true;
41 }
42
Decode(const EncodedImage & input,bool missing_frames,int64_t render_time_ms)43 int32_t FakeDecoder::Decode(const EncodedImage& input,
44 bool missing_frames,
45 int64_t render_time_ms) {
46 if (input._encodedWidth > 0 && input._encodedHeight > 0) {
47 width_ = input._encodedWidth;
48 height_ = input._encodedHeight;
49 }
50
51 rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(width_, height_);
52 I420Buffer::SetBlack(buffer.get());
53 VideoFrame frame = VideoFrame::Builder()
54 .set_video_frame_buffer(buffer)
55 .set_rotation(webrtc::kVideoRotation_0)
56 .set_timestamp_ms(render_time_ms)
57 .build();
58 frame.set_timestamp(input.Timestamp());
59 frame.set_ntp_time_ms(input.ntp_time_ms_);
60
61 if (decode_delay_ms_ == 0 || !task_queue_) {
62 callback_->Decoded(frame);
63 } else {
64 task_queue_->PostDelayedHighPrecisionTask(
65 [frame, this]() {
66 VideoFrame copy = frame;
67 callback_->Decoded(copy);
68 },
69 TimeDelta::Millis(decode_delay_ms_));
70 }
71
72 return WEBRTC_VIDEO_CODEC_OK;
73 }
74
SetDelayedDecoding(int decode_delay_ms)75 void FakeDecoder::SetDelayedDecoding(int decode_delay_ms) {
76 RTC_CHECK(task_queue_factory_);
77 if (!task_queue_) {
78 task_queue_ = task_queue_factory_->CreateTaskQueue(
79 "fake_decoder", TaskQueueFactory::Priority::NORMAL);
80 }
81 decode_delay_ms_ = decode_delay_ms;
82 }
83
RegisterDecodeCompleteCallback(DecodedImageCallback * callback)84 int32_t FakeDecoder::RegisterDecodeCompleteCallback(
85 DecodedImageCallback* callback) {
86 callback_ = callback;
87 return WEBRTC_VIDEO_CODEC_OK;
88 }
89
Release()90 int32_t FakeDecoder::Release() {
91 return WEBRTC_VIDEO_CODEC_OK;
92 }
93
94 const char* FakeDecoder::kImplementationName = "fake_decoder";
GetDecoderInfo() const95 VideoDecoder::DecoderInfo FakeDecoder::GetDecoderInfo() const {
96 DecoderInfo info;
97 info.implementation_name = kImplementationName;
98 info.is_hardware_accelerated = true;
99 return info;
100 }
ImplementationName() const101 const char* FakeDecoder::ImplementationName() const {
102 return kImplementationName;
103 }
104
Decode(const EncodedImage & input,bool missing_frames,int64_t render_time_ms)105 int32_t FakeH264Decoder::Decode(const EncodedImage& input,
106 bool missing_frames,
107 int64_t render_time_ms) {
108 uint8_t value = 0;
109 for (size_t i = 0; i < input.size(); ++i) {
110 uint8_t kStartCode[] = {0, 0, 0, 1};
111 if (i < input.size() - sizeof(kStartCode) &&
112 !memcmp(&input.data()[i], kStartCode, sizeof(kStartCode))) {
113 i += sizeof(kStartCode) + 1; // Skip start code and NAL header.
114 }
115 if (input.data()[i] != value) {
116 RTC_CHECK_EQ(value, input.data()[i])
117 << "Bitstream mismatch between sender and receiver.";
118 return -1;
119 }
120 ++value;
121 }
122 return FakeDecoder::Decode(input, missing_frames, render_time_ms);
123 }
124
125 } // namespace test
126 } // namespace webrtc
127