1 /******************************************************************************
2 *
3 * Copyright (C) 2020 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 #include <algorithm>
21 #include <memory>
22 #include <string.h>
23
24 #include "ihevc_typedefs.h"
25 #include "itt_video_api.h"
26 #include "ihevce_api.h"
27 #include "ihevce_plugin.h"
28 #include "ihevce_profile.h"
29
30 constexpr size_t kRcType[] = {2, 3, 5};
31 constexpr IHEVCE_QUALITY_CONFIG_T kQuality[] = {
32 IHEVCE_QUALITY_P0, IHEVCE_QUALITY_P2, IHEVCE_QUALITY_P3, IHEVCE_QUALITY_P4,
33 IHEVCE_QUALITY_P5, IHEVCE_QUALITY_P6, IHEVCE_QUALITY_P7};
34
35 constexpr size_t kRcTypeNum = std::size(kRcType);
36 constexpr size_t kQualityNum = std::size(kQuality);
37 constexpr size_t kMaxQP = 51;
38 constexpr size_t kMaxGopPeriod = 16;
39 constexpr size_t kMaxWidth = 10240;
40 constexpr size_t kMaxHeight = 10240;
41 constexpr size_t kMaxBitrate = 500000000;
42
43 enum {
44 IDX_WD_BYTE_1,
45 IDX_WD_BYTE_2,
46 IDX_HT_BYTE_1,
47 IDX_HT_BYTE_2,
48 IDX_MAX_INTRA_TX_DEPTH,
49 IDX_MAX_INTER_TX_DEPTH,
50 IDX_CU_RC,
51 IDX_RC_MODE,
52 IDX_FRAME_QP,
53 IDX_PRESET,
54 IDX_BITRATE_BYTE_1,
55 IDX_BITRATE_BYTE_2,
56 IDX_ENABLE_ENTROPY_SYNC,
57 IDX_DEBLOCKING_TYPE,
58 IDX_USE_SC_MTX,
59 IDX_MAX_TEMPORAL_LAYERS,
60 IDX_MAX_CLOSED_GOP,
61 IDX_MIN_CLOSED_GOP,
62 IDX_MAX_I_OPEN_GOP,
63 IDX_MAX_CRA_OPEN_GOP,
64 IDX_ENABLE_SPS_AT_CDR,
65 IDX_ENABLE_VUI,
66 IDX_ENABLE_SEI,
67 IDX_ARCH_TYPE,
68 IDX_ENABLE_FORCE_IDR,
69 IDX_ENABLE_DYNAMIC_BITRATE,
70 IDX_FORCE_IDR_INTERVAL,
71 IDX_DYNAMIC_BITRATE_INTERVAL,
72 IDX_LAST
73 };
74
75 class Codec {
76 public:
77 Codec() = default;
~Codec()78 ~Codec() { deInitEncoder(); }
79 bool initEncoder(const uint8_t *data);
80 void deInitEncoder();
81 void encodeFrames(const uint8_t *data, size_t size);
82
83 private:
84 bool mIsForceIdrEnabled = false;
85 bool mIsDynamicBitrateChangeEnabled = false;
86 size_t mWidth = 352;
87 size_t mHeight = 288;
88 size_t mForceIdrInterval = 0; // in number of frames
89 size_t mDynamicBitrateInterval = 0; // in number of frames
90 uint64_t mBitrate = 5000000;
91 void *mCodecCtx = nullptr;
92 ihevce_static_cfg_params_t mEncParams = {};
93 };
94
initEncoder(const uint8_t * data)95 bool Codec::initEncoder(const uint8_t *data) {
96 // default configuration
97 if (IHEVCE_EOK != ihevce_set_def_params(&mEncParams)) {
98 return false;
99 }
100 mWidth = ((data[IDX_WD_BYTE_1] << 8) | data[IDX_WD_BYTE_2]) % kMaxWidth;
101 mHeight = ((data[IDX_HT_BYTE_1] << 8) | data[IDX_HT_BYTE_2]) % kMaxHeight;
102
103 // update configuration
104 mEncParams.s_src_prms.i4_width = mWidth;
105 mEncParams.s_src_prms.i4_height = mHeight;
106
107 mEncParams.s_config_prms.i4_max_tr_tree_depth_I = (data[IDX_MAX_INTRA_TX_DEPTH] % 3) + 1;
108 mEncParams.s_config_prms.i4_max_tr_tree_depth_nI = (data[IDX_MAX_INTER_TX_DEPTH] & 0x03) + 1;
109 mEncParams.s_config_prms.i4_cu_level_rc = data[IDX_CU_RC] & 0x01;
110 mEncParams.s_config_prms.i4_rate_control_mode = kRcType[data[IDX_RC_MODE] % kRcTypeNum];
111
112 mEncParams.s_tgt_lyr_prms.as_tgt_params[0].ai4_frame_qp[0] = (data[IDX_FRAME_QP] % kMaxQP) + 1;
113 mEncParams.s_tgt_lyr_prms.as_tgt_params[0].i4_quality_preset =
114 kQuality[data[IDX_PRESET] % kQualityNum];
115 mEncParams.s_tgt_lyr_prms.as_tgt_params[0].ai4_tgt_bitrate[0] =
116 (((data[IDX_BITRATE_BYTE_1] << 8) | data[IDX_BITRATE_BYTE_2]) * 1000) % kMaxBitrate;
117 mEncParams.s_tgt_lyr_prms.as_tgt_params[0].ai4_peak_bitrate[0] =
118 ((((data[IDX_BITRATE_BYTE_1] << 8) | data[IDX_BITRATE_BYTE_2]) * 1000) % kMaxBitrate) << 1;
119 mEncParams.s_coding_tools_prms.i4_enable_entropy_sync = data[IDX_ENABLE_ENTROPY_SYNC] & 0x01;
120 mEncParams.s_coding_tools_prms.i4_deblocking_type = data[IDX_DEBLOCKING_TYPE] & 0x01;
121 mEncParams.s_coding_tools_prms.i4_use_default_sc_mtx = data[IDX_USE_SC_MTX] & 0x01;
122 mEncParams.s_coding_tools_prms.i4_max_temporal_layers = data[IDX_MAX_TEMPORAL_LAYERS] & 0x02;
123 mEncParams.s_coding_tools_prms.i4_max_closed_gop_period =
124 data[IDX_MAX_CLOSED_GOP] % kMaxGopPeriod;
125 mEncParams.s_coding_tools_prms.i4_min_closed_gop_period =
126 data[IDX_MIN_CLOSED_GOP] % kMaxGopPeriod;
127 mEncParams.s_coding_tools_prms.i4_max_i_open_gop_period =
128 data[IDX_MAX_I_OPEN_GOP] % kMaxGopPeriod;
129 mEncParams.s_coding_tools_prms.i4_max_cra_open_gop_period =
130 data[IDX_MAX_CRA_OPEN_GOP] % kMaxGopPeriod;
131
132 mEncParams.s_out_strm_prms.i4_sps_at_cdr_enable = data[IDX_ENABLE_SPS_AT_CDR] & 0x01;
133 mEncParams.s_out_strm_prms.i4_vui_enable = data[IDX_ENABLE_VUI] & 0x01;
134 mEncParams.s_out_strm_prms.i4_sei_enable_flag = data[IDX_ENABLE_SEI] & 0x01;
135
136 mEncParams.e_arch_type = ((data[IDX_ARCH_TYPE] & 0x03) == 0x00) ? ARCH_ARM_NONEON : ARCH_NA;
137 mIsForceIdrEnabled = data[IDX_ENABLE_FORCE_IDR] & 0x01;
138 mIsDynamicBitrateChangeEnabled = data[IDX_ENABLE_DYNAMIC_BITRATE] & 0x01;
139 mForceIdrInterval = data[IDX_FORCE_IDR_INTERVAL] & 0x07;
140 mDynamicBitrateInterval = data[IDX_DYNAMIC_BITRATE_INTERVAL] & 0x07;
141
142 if (IHEVCE_EOK != ihevce_init(&mEncParams, &mCodecCtx)) {
143 return false;
144 }
145 return true;
146 }
147
encodeFrames(const uint8_t * data,size_t size)148 void Codec::encodeFrames(const uint8_t *data, size_t size) {
149 size_t frameSize = (mWidth * mHeight * 3) / 2;
150
151 ihevce_out_buf_t sHeaderOp{};
152 ihevce_encode_header(mCodecCtx, &sHeaderOp);
153 size_t frameNumber = 0;
154 uint8_t *tmpData = new uint8_t[frameSize];
155 while (size > 0) {
156 ihevce_inp_buf_t sEncodeIp{};
157 ihevce_out_buf_t sEncodeOp{};
158 size_t bytesConsumed = std::min(size, frameSize);
159 if (bytesConsumed < frameSize) {
160 memset(&tmpData[bytesConsumed], data[0], frameSize - bytesConsumed);
161 }
162 memcpy(tmpData, data, bytesConsumed);
163 int32_t yStride = mWidth;
164 int32_t uStride = mWidth >> 1;
165 int32_t vStride = mWidth >> 1;
166
167 sEncodeIp.apv_inp_planes[0] = tmpData;
168 sEncodeIp.apv_inp_planes[1] = tmpData + (mWidth * mHeight);
169 sEncodeIp.apv_inp_planes[2] = tmpData + ((mWidth * mHeight) * 5) / 4;
170
171 sEncodeIp.ai4_inp_strd[0] = yStride;
172 sEncodeIp.ai4_inp_strd[1] = uStride;
173 sEncodeIp.ai4_inp_strd[2] = vStride;
174
175 sEncodeIp.ai4_inp_size[0] = yStride * mHeight;
176 sEncodeIp.ai4_inp_size[1] = uStride * mHeight >> 1;
177 sEncodeIp.ai4_inp_size[2] = vStride * mHeight >> 1;
178
179 sEncodeIp.i4_force_idr_flag = 0;
180 sEncodeIp.i4_curr_bitrate = mBitrate;
181 sEncodeIp.i4_curr_peak_bitrate = mBitrate << 1;
182 sEncodeIp.u8_pts = 0;
183 if (mIsForceIdrEnabled) {
184 if (frameNumber == mForceIdrInterval) {
185 sEncodeIp.i4_force_idr_flag = 1;
186 }
187 }
188 if (mIsDynamicBitrateChangeEnabled) {
189 if (frameNumber == mDynamicBitrateInterval) {
190 mBitrate = mBitrate << 1;
191 }
192 }
193 ihevce_encode(mCodecCtx, &sEncodeIp, &sEncodeOp);
194 ++frameNumber;
195 data += bytesConsumed;
196 size -= bytesConsumed;
197 }
198 delete[] tmpData;
199 }
200
deInitEncoder()201 void Codec::deInitEncoder() {
202 if (mCodecCtx) {
203 ihevce_close(mCodecCtx);
204 mCodecCtx = nullptr;
205 }
206 return;
207 }
208
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)209 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
210 if (size < IDX_LAST) {
211 return 0;
212 }
213 Codec *codec = new Codec();
214 if (codec->initEncoder(data)) {
215 data += IDX_LAST;
216 size -= IDX_LAST;
217 codec->encodeFrames(data, size);
218 }
219 delete codec;
220 return 0;
221 }
222