1 /*
2 * Copyright (c) 2022 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
16 #include "vcodecconfigure_fuzzer.h"
17 #include <iostream>
18 #include "string_ex.h"
19 #include "media_errors.h"
20 #include "directory_ex.h"
21 #include "ui/rs_surface_node.h"
22 #include "window_option.h"
23 #include "aw_common.h"
24
25 using namespace std;
26 using namespace OHOS;
27 using namespace OHOS::Media;
28 using namespace OHOS::Media::VCodecTestParam;
29
VCodecConfigureFuzzer()30 VCodecConfigureFuzzer::VCodecConfigureFuzzer()
31 {
32 }
33
~VCodecConfigureFuzzer()34 VCodecConfigureFuzzer::~VCodecConfigureFuzzer()
35 {
36 }
37
FuzzVideoConfigure(uint8_t * data,size_t size)38 bool VCodecConfigureFuzzer::FuzzVideoConfigure(uint8_t *data, size_t size)
39 {
40 constexpr int32_t WAITTING_TIME = 2;
41 std::shared_ptr<VDecSignal> vdecSignal = std::make_shared<VDecSignal>();
42 vdecCallback_ = std::make_shared<VDecCallbackTest>(vdecSignal);
43 CHECK_INSTANCE_AND_RETURN_RET(vdecCallback_, false);
44 videoDec_ = std::make_shared<VDecMock>(vdecSignal);
45 CHECK_INSTANCE_AND_RETURN_RET(videoDec_, false);
46 CHECK_BOOL_AND_RETURN_RET(videoDec_->CreateVideoDecMockByMime("video/avc"), false);
47 CHECK_STATE_AND_RETURN_RET(videoDec_->SetCallback(vdecCallback_), false);
48
49 std::shared_ptr<VEncSignal> vencSignal = std::make_shared<VEncSignal>();
50 vencCallback_ = std::make_shared<VEncCallbackTest>(vencSignal);
51 CHECK_INSTANCE_AND_RETURN_RET(vencCallback_, false);
52 videoEnc_ = std::make_shared<VEncMock>(vencSignal);
53 CHECK_INSTANCE_AND_RETURN_RET(videoEnc_, false);
54 CHECK_BOOL_AND_RETURN_RET(videoEnc_->CreateVideoEncMockByMime("video/avc"), false);
55 CHECK_STATE_AND_RETURN_RET(videoEnc_->SetCallback(vencCallback_), false);
56
57 videoEnc_->SetOutPath("/data/test/media/avc_configurefuzz_out.es");
58 std::shared_ptr<FormatMock> format = AVCodecMockFactory::CreateFormat();
59 CHECK_INSTANCE_AND_RETURN_RET(format, false);
60 int32_t data_ = *reinterpret_cast<int32_t *>(data);
61 (void)format->PutIntValue("width", DEFAULT_WIDTH);
62 (void)format->PutIntValue("height", DEFAULT_HEIGHT);
63 (void)format->PutIntValue("pixel_format", NV12);
64 (void)format->PutIntValue("frame_rate", data_);
65 videoDec_->SetSource(H264_SRC_PATH, ES_H264, ES_LENGTH_H264);
66 videoEnc_->Configure(format);
67 videoDec_->Configure(format);
68 std::shared_ptr<SurfaceMock> surface = videoEnc_->GetInputSurface();
69 videoDec_->SetOutputSurface(surface);
70 videoDec_->Prepare();
71 videoEnc_->Prepare();
72 videoDec_->Start();
73 videoEnc_->Start();
74 sleep(WAITTING_TIME);
75 videoDec_->Flush();
76 videoEnc_->Flush();
77 videoDec_->Stop();
78 videoEnc_->Stop();
79 if (videoDec_ != nullptr) {
80 videoDec_->Reset();
81 videoDec_->Release();
82 }
83 if (videoEnc_ != nullptr) {
84 videoEnc_->Reset();
85 videoEnc_->Release();
86 }
87 return true;
88 }
89
FuzzVCodecConfigure(uint8_t * data,size_t size)90 bool OHOS::Media::FuzzVCodecConfigure(uint8_t *data, size_t size)
91 {
92 auto codecfuzzer = std::make_unique<VCodecConfigureFuzzer>();
93 if (codecfuzzer == nullptr) {
94 cout << "codecfuzzer is null" << endl;
95 return 0;
96 }
97 if (size < sizeof(int32_t)) {
98 return 0;
99 }
100 return codecfuzzer->FuzzVideoConfigure(data, size);
101 }
102
103 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(uint8_t * data,size_t size)104 extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
105 {
106 /* Run your code on data */
107 OHOS::Media::FuzzVCodecConfigure(data, size);
108 return 0;
109 }