1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "avcodec_video_decoder_impl.h"
16 #include "avcodec_video_encoder_impl.h"
17 #include "media_description.h"
18 #include "native_avcodec_base.h"
19 #include "native_avcodec_videodecoder.h"
20 #include "native_avcodec_videoencoder.h"
21
22 #include <cstddef>
23 #include <cstdint>
24 #include <fuzzer/FuzzedDataProvider.h>
25 #include "native_avcapability.h"
26
27 using namespace std;
28 using namespace OHOS;
29 using namespace OHOS::MediaAVCodec;
30 #define FUZZ_PROJECT_NAME "sync_fuzzer"
31
VideoEncoderCapiFuzzTest(const uint8_t * data,size_t size)32 bool VideoEncoderCapiFuzzTest(const uint8_t *data, size_t size)
33 {
34 if (size < sizeof(int64_t)) {
35 return false;
36 }
37 FuzzedDataProvider fdp(data, size);
38 uint32_t index = fdp.ConsumeIntegral<uint32_t>();
39 bool flag = fdp.ConsumeBool();
40 int64_t timeout = flag ? 1 : 0;
41 OH_AVCodec *codec = nullptr;
42 OH_VideoEncoder_QueryInputBuffer(codec, &index, timeout);
43 OH_VideoEncoder_QueryOutputBuffer(codec, &index, timeout);
44 OH_VideoEncoder_GetInputBuffer(codec, index);
45 OH_VideoEncoder_GetOutputBuffer(codec, index);
46
47 OH_AVCodec *videoEnc = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
48 if (videoEnc == nullptr) {
49 return false;
50 }
51 OH_VideoEncoder_QueryInputBuffer(videoEnc, &index, timeout);
52 OH_VideoEncoder_QueryOutputBuffer(videoEnc, &index, timeout);
53 OH_VideoEncoder_GetInputBuffer(videoEnc, index);
54 OH_VideoEncoder_GetOutputBuffer(videoEnc, index);
55
56 int32_t intData = fdp.ConsumeIntegral<int32_t>();
57 OH_AVFormat *format = OH_AVFormat_Create();
58 OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, intData);
59 OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, intData);
60 OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, intData);
61 OH_AVFormat_SetIntValue(format, OH_MD_KEY_ENABLE_SYNC_MODE, intData);
62 OH_VideoEncoder_Configure(videoEnc, format);
63 OH_AVFormat_Destroy(format);
64 OH_VideoEncoder_Destroy(videoEnc);
65 format = nullptr;
66 videoEnc = nullptr;
67 return true;
68 }
69
VideoDecoderCapiFuzzTest(const uint8_t * data,size_t size)70 bool VideoDecoderCapiFuzzTest(const uint8_t *data, size_t size)
71 {
72 if (size < sizeof(int64_t)) {
73 return false;
74 }
75 FuzzedDataProvider fdp(data, size);
76 uint32_t index = fdp.ConsumeIntegral<uint32_t>();
77 bool flag = fdp.ConsumeBool();
78 int64_t timeout = flag ? 1 : 0;
79 OH_AVCodec *codec = nullptr;
80 OH_VideoDecoder_QueryInputBuffer(codec, &index, timeout);
81 OH_VideoDecoder_QueryOutputBuffer(codec, &index, timeout);
82 OH_VideoDecoder_GetInputBuffer(codec, index);
83 OH_VideoDecoder_GetOutputBuffer(codec, index);
84
85 OH_AVCodec *videoDec = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
86 if (videoDec == nullptr) {
87 return false;
88 }
89 OH_VideoDecoder_QueryInputBuffer(videoDec, &index, timeout);
90 OH_VideoDecoder_QueryOutputBuffer(videoDec, &index, timeout);
91 OH_VideoDecoder_GetInputBuffer(videoDec, index);
92 OH_VideoDecoder_GetOutputBuffer(videoDec, index);
93
94 int32_t intData = fdp.ConsumeIntegral<int32_t>();
95 OH_AVFormat *format = OH_AVFormat_Create();
96 OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, intData);
97 OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, intData);
98 OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, intData);
99 OH_AVFormat_SetIntValue(format, OH_MD_KEY_ENABLE_SYNC_MODE, intData);
100 OH_VideoEncoder_Configure(videoDec, format);
101 OH_AVFormat_Destroy(format);
102 OH_VideoEncoder_Destroy(videoDec);
103 format = nullptr;
104 videoDec = nullptr;
105 return true;
106 }
107
VideoEncoderInnerFuzzTest(const uint8_t * data,size_t size)108 bool VideoEncoderInnerFuzzTest(const uint8_t *data, size_t size)
109 {
110 if (size < sizeof(int64_t)) {
111 return false;
112 }
113 FuzzedDataProvider fdp(data, size);
114 uint32_t index = fdp.ConsumeIntegral<uint32_t>();
115 bool flag = fdp.ConsumeBool();
116 int64_t timeout = flag ? 1 : 0;
117 AVCodecVideoEncoderImpl encoderImpl;
118 encoderImpl.QueryInputBuffer(index, timeout);
119 encoderImpl.QueryOutputBuffer(index, timeout);
120 encoderImpl.GetOutputBuffer(index);
121 encoderImpl.GetInputBuffer(index);
122
123 std::shared_ptr<AVCodecVideoEncoder> videoEnc =
124 VideoEncoderFactory::CreateByMime((CodecMimeType::VIDEO_AVC).data());
125 if (videoEnc == nullptr) {
126 return false;
127 }
128 int32_t intData = fdp.ConsumeIntegral<int32_t>();
129 Format format;
130 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, intData);
131 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, intData);
132 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
133 format.PutDoubleValue(OH_MD_KEY_ENABLE_SYNC_MODE, intData);
134 videoEnc->Configure(format);
135 return true;
136 }
137
VideoDecoderInnerFuzzTest(const uint8_t * data,size_t size)138 bool VideoDecoderInnerFuzzTest(const uint8_t *data, size_t size)
139 {
140 if (size < sizeof(int64_t)) {
141 return false;
142 }
143 FuzzedDataProvider fdp(data, size);
144 uint32_t index = fdp.ConsumeIntegral<uint32_t>();
145 bool flag = fdp.ConsumeBool();
146 int64_t timeout = flag ? 1 : 0;
147 AVCodecVideoDecoderImpl decoderImpl;
148
149 decoderImpl.QueryInputBuffer(index, timeout);
150 decoderImpl.QueryOutputBuffer(index, timeout);
151 decoderImpl.GetOutputBuffer(index);
152 decoderImpl.GetInputBuffer(index);
153
154 std::shared_ptr<AVCodecVideoDecoder> videoDec =
155 VideoDecoderFactory::CreateByMime((CodecMimeType::VIDEO_AVC).data());
156 if (videoDec == nullptr) {
157 return false;
158 }
159 int32_t intData = fdp.ConsumeIntegral<int32_t>();
160 Format format;
161 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, intData);
162 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, intData);
163 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
164 format.PutDoubleValue(OH_MD_KEY_ENABLE_SYNC_MODE, intData);
165 videoDec->Configure(format);
166 return true;
167 }
168
169 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)170 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
171 {
172 /* Run your code on data */
173 VideoEncoderCapiFuzzTest(data, size);
174 VideoDecoderCapiFuzzTest(data, size);
175 VideoEncoderInnerFuzzTest(data, size);
176 VideoDecoderInnerFuzzTest(data, size);
177 return 0;
178 }
179