1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "ih264_defs.h"
18 #include "ih264_typedefs.h"
19 #include "ih264e.h"
20 #include "ih264e_error.h"
21
22 #include "TestArgs.h"
23
24 #define MAX_FRAME_HEIGHT 1080
25 #define MAX_FRAME_WIDTH 1920
26 #define MAX_OUTPUT_BUFFER_SIZE (MAX_FRAME_HEIGHT * MAX_FRAME_WIDTH)
27
28 #define ive_api_function ih264e_api_function
29
30 constexpr int16_t kCompressionRatio = 1;
31 constexpr size_t kMinQP = 4;
32 constexpr uint32_t kHeaderLength = 0x800;
33
34 static TestArgs* gArgs = nullptr;
35
36 class AvcEncTest
37 : public ::testing::TestWithParam<tuple<string, int32_t, int32_t, float, int32_t>> {
38 private:
39 void setRawBuf(iv_raw_buf_t* psInpRawBuf, const uint8_t* data);
40 void setFrameType(IV_PICTURE_CODING_TYPE_T eFrameType);
41 void setQp();
42 void setEncMode(IVE_ENC_MODE_T eEncMode);
43 void setDimensions();
44 void setNumCores();
45 void setFrameRate();
46 void setIpeParams();
47 void setBitRate();
48 void setAirParams();
49 void setMeParams();
50 void setGopParams();
51 void setProfileParams();
52 void setDeblockParams();
53 void setVbvParams();
54 void setDefault();
55 void setVuiParams();
56 void getBufInfo();
57 void setSeiMdcvParams();
58 void setSeiCllParams();
59 void setSeiAveParams();
60 void setSeiCcvParams();
61 void logVersion();
62 bool mHalfPelEnable = true;
63 bool mQPelEnable = true;
64 bool mIntra4x4 = true;
65 bool mEnableFastSad = false;
66 bool mEnableAltRef = false;
67 bool mConstrainedIntraFlag = false;
68 bool mSeiCllFlag = true;
69 bool mSeiAveFlag = true;
70 bool mSeiCcvFlag = true;
71 bool mSeiMdcvFlag = true;
72 bool mAspectRatioFlag = false;
73 bool mNalHrdFlag = false;
74 bool mVclHrdFlag = false;
75 bool mIsForceIdrEnabled = false;
76 bool mIsDynamicBitRateChangeEnabled = true;
77 bool mIsDynamicFrameRateChangeEnabled = true;
78 uint32_t mAvcEncLevel = 41;
79 uint32_t mNumMemRecords = 0;
80 uint32_t mNumCores = 4;
81 uint32_t mBframes = 0;
82 uint32_t mSliceParam = 256;
83 uint32_t mMeSpeedPreset = 100;
84 uint32_t mIInterval = 1000;
85 uint32_t mIDRInterval = 60;
86 uint32_t mDisableDeblockLevel = 0;
87 uint32_t mIQp = 24;
88 uint32_t mPQp = 27;
89 uint32_t mBQp = 29;
90 uint32_t mIntraRefresh = 30;
91 uint32_t mSearchRangeX = 16;
92 uint32_t mSearchRangeY = 16;
93 uint32_t mForceIdrInterval = 0; // in number of frames
94 uint32_t mDynamicBitRateInterval = 0; // in number of frames
95 uint32_t mDynamicFrameRateInterval = 0; // in number of frame
96 float mFrameRate = 30;
97 iv_obj_t* mCodecCtx = nullptr;
98 iv_mem_rec_t* mMemRecords = nullptr;
99 IVE_AIR_MODE_T mAirMode = IVE_AIR_MODE_NONE;
100 IVE_SPEED_CONFIG mEncSpeed = IVE_NORMAL;
101 IVE_RC_MODE_T mRCMode = IVE_RC_STORAGE;
102 IV_ARCH_T mArch = ARCH_NA;
103 IVE_SLICE_MODE_T mSliceMode = IVE_SLICE_MODE_NONE;
104 IV_COLOR_FORMAT_T mIvVideoColorFormat = IV_YUV_420P;
105 IV_COLOR_FORMAT_T mReconFormat = IV_YUV_420P;
106 IV_PROFILE_T mProfile = IV_PROFILE_BASE;
107
108 public:
AvcEncTest()109 AvcEncTest()
110 : mInputBuffer(nullptr), mOutputBuffer(nullptr), mFpInput(nullptr), mFpOutput(nullptr) {}
111
~AvcEncTest()112 ~AvcEncTest() {
113 iv_mem_rec_t* ps_mem_rec = mMemRecords;
114 for (size_t i = 0; i < mNumMemRecords; ++i) {
115 if (ps_mem_rec) {
116 free(ps_mem_rec->pv_base);
117 }
118 ++ps_mem_rec;
119 }
120 if (mMemRecords) {
121 free(mMemRecords);
122 }
123 mCodecCtx = nullptr;
124 }
125
SetUp()126 void SetUp() override {
127 tuple<string /* fileName */, int32_t /* frameWidth */, int32_t /* frameHeight */,
128 float /* frameRate */, int32_t /* bitRate */>
129 params = GetParam();
130 mFileName = gArgs->getRes() + get<0>(params);
131 mFrameWidth = get<1>(params);
132 mFrameHeight = get<2>(params);
133 mFrameRate = get<3>(params);
134 mBitRate = get<4>(params);
135 mOutFileName = gArgs->getRes() + "out.bin";
136
137 ASSERT_LE(mFrameWidth, 1080) << "Frame Width <= 1080";
138
139 ASSERT_LE(mFrameHeight, 1920) << "Frame Height <= 1920";
140
141 mOutputBufferSize = (mFrameWidth * mFrameHeight * 3 / 2) / kCompressionRatio;
142 mBitRate = mBitRate * 1024; // Conversion to bytes per sec
143
144 mInputBuffer = (uint8_t*)malloc((mFrameWidth * mFrameHeight * 3) / 2);
145 ASSERT_NE(mInputBuffer, nullptr) << "Failed to allocate the input buffer!";
146
147 mOutputBuffer = (uint8_t*)malloc(mOutputBufferSize);
148 ASSERT_NE(mOutputBuffer, nullptr) << "Failed to allocate the output buffer!";
149
150 mFpInput = fopen(mFileName.c_str(), "rb");
151 ASSERT_NE(mFpInput, nullptr) << "Failed to open the input file: " << mFileName;
152
153 mFpOutput = fopen(mOutFileName.c_str(), "wb");
154 ASSERT_NE(mFpOutput, nullptr) << "Failed to open the output file:" << mOutFileName;
155
156 /* Getting Number of MemRecords */
157 iv_num_mem_rec_ip_t sNumMemRecIp = {};
158 iv_num_mem_rec_op_t sNumMemRecOp = {};
159
160 sNumMemRecIp.u4_size = sizeof(iv_num_mem_rec_ip_t);
161 sNumMemRecOp.u4_size = sizeof(iv_num_mem_rec_op_t);
162 sNumMemRecIp.e_cmd = IV_CMD_GET_NUM_MEM_REC;
163
164 status = ive_api_function(nullptr, &sNumMemRecIp, &sNumMemRecOp);
165 ASSERT_EQ(status, IV_SUCCESS) << "Error in IV_CMD_GET_NUM_MEM_REC!";
166
167 mNumMemRecords = sNumMemRecOp.u4_num_mem_rec;
168 mMemRecords = (iv_mem_rec_t*)malloc(mNumMemRecords * sizeof(iv_mem_rec_t));
169 ASSERT_NE(mMemRecords, nullptr) << "Failed to allocate memory to nMemRecords!";
170
171 iv_mem_rec_t* psMemRec;
172 psMemRec = mMemRecords;
173 for (size_t i = 0; i < mNumMemRecords; ++i) {
174 psMemRec->u4_size = sizeof(iv_mem_rec_t);
175 psMemRec->pv_base = nullptr;
176 psMemRec->u4_mem_size = 0;
177 psMemRec->u4_mem_alignment = 0;
178 psMemRec->e_mem_type = IV_NA_MEM_TYPE;
179 ++psMemRec;
180 }
181
182 /* Getting MemRecords Attributes */
183 iv_fill_mem_rec_ip_t sFillMemRecIp = {};
184 iv_fill_mem_rec_op_t sFillMemRecOp = {};
185
186 sFillMemRecIp.u4_size = sizeof(iv_fill_mem_rec_ip_t);
187 sFillMemRecOp.u4_size = sizeof(iv_fill_mem_rec_op_t);
188
189 sFillMemRecIp.e_cmd = IV_CMD_FILL_NUM_MEM_REC;
190 sFillMemRecIp.ps_mem_rec = mMemRecords;
191 sFillMemRecIp.u4_num_mem_rec = mNumMemRecords;
192 sFillMemRecIp.u4_max_wd = mFrameWidth;
193 sFillMemRecIp.u4_max_ht = mFrameHeight;
194 sFillMemRecIp.u4_max_level = mAvcEncLevel;
195 sFillMemRecIp.e_color_format = IV_YUV_420SP_UV;
196 sFillMemRecIp.u4_max_ref_cnt = 2;
197 sFillMemRecIp.u4_max_reorder_cnt = 0;
198 sFillMemRecIp.u4_max_srch_rng_x = 256;
199 sFillMemRecIp.u4_max_srch_rng_y = 256;
200
201 status = ive_api_function(nullptr, &sFillMemRecIp, &sFillMemRecOp);
202 ASSERT_EQ(status, IV_SUCCESS) << "Failed to fill memory records!";
203
204 /* Allocating Memory for Mem Records */
205 psMemRec = mMemRecords;
206 for (size_t i = 0; i < mNumMemRecords; ++i) {
207 posix_memalign(&psMemRec->pv_base, psMemRec->u4_mem_alignment, psMemRec->u4_mem_size);
208 ASSERT_NE(psMemRec->pv_base, nullptr)
209 << "Failed to allocate for size " << psMemRec->u4_mem_size;
210
211 ++psMemRec;
212 }
213
214 /* Codec Instance Creation */
215 ive_init_ip_t sInitIp = {};
216 ive_init_op_t sInitOp = {};
217
218 mCodecCtx = (iv_obj_t*)mMemRecords[0].pv_base;
219 mCodecCtx->u4_size = sizeof(iv_obj_t);
220 mCodecCtx->pv_fxns = (void*)ive_api_function;
221
222 sInitIp.u4_size = sizeof(ive_init_ip_t);
223 sInitOp.u4_size = sizeof(ive_init_op_t);
224
225 sInitIp.e_cmd = IV_CMD_INIT;
226 sInitIp.u4_num_mem_rec = mNumMemRecords;
227 sInitIp.ps_mem_rec = mMemRecords;
228 sInitIp.u4_max_wd = mFrameWidth;
229 sInitIp.u4_max_ht = mFrameHeight;
230 sInitIp.u4_max_ref_cnt = 2;
231 sInitIp.u4_max_reorder_cnt = 0;
232 sInitIp.u4_max_level = mAvcEncLevel;
233 sInitIp.e_inp_color_fmt = mIvVideoColorFormat;
234 sInitIp.u4_enable_recon = 0;
235 sInitIp.e_recon_color_fmt = mReconFormat;
236 sInitIp.e_rc_mode = mRCMode;
237 sInitIp.u4_max_framerate = 120000;
238 sInitIp.u4_max_bitrate = 240000000;
239 sInitIp.u4_num_bframes = mBframes;
240 sInitIp.e_content_type = IV_PROGRESSIVE;
241 sInitIp.u4_max_srch_rng_x = 256;
242 sInitIp.u4_max_srch_rng_y = 256;
243 sInitIp.e_slice_mode = mSliceMode;
244 sInitIp.u4_slice_param = mSliceParam;
245 sInitIp.e_arch = mArch;
246 sInitIp.e_soc = SOC_GENERIC;
247
248 status = ive_api_function(mCodecCtx, &sInitIp, &sInitOp);
249 ASSERT_EQ(status, IV_SUCCESS) << "Failed to create Codec Instance!";
250
251 mFrameSize = (mIvVideoColorFormat == IV_YUV_422ILE)
252 ? (mFrameWidth * mFrameHeight * 2)
253 : ((mFrameWidth * mFrameHeight * 3) / 2);
254
255 mTotalFrames = getTotalFrames();
256
257 ASSERT_NO_FATAL_FAILURE(logVersion());
258
259 ASSERT_NO_FATAL_FAILURE(setDefault());
260
261 ASSERT_NO_FATAL_FAILURE(getBufInfo());
262
263 ASSERT_NO_FATAL_FAILURE(setNumCores());
264
265 ASSERT_NO_FATAL_FAILURE(setDimensions());
266
267 ASSERT_NO_FATAL_FAILURE(setFrameRate());
268
269 ASSERT_NO_FATAL_FAILURE(setIpeParams());
270
271 ASSERT_NO_FATAL_FAILURE(setBitRate());
272
273 ASSERT_NO_FATAL_FAILURE(setQp());
274
275 ASSERT_NO_FATAL_FAILURE(setAirParams());
276
277 ASSERT_NO_FATAL_FAILURE(setVbvParams());
278
279 ASSERT_NO_FATAL_FAILURE(setMeParams());
280
281 ASSERT_NO_FATAL_FAILURE(setGopParams());
282
283 ASSERT_NO_FATAL_FAILURE(setDeblockParams());
284
285 ASSERT_NO_FATAL_FAILURE(setVuiParams());
286
287 ASSERT_NO_FATAL_FAILURE(setSeiMdcvParams());
288
289 ASSERT_NO_FATAL_FAILURE(setSeiCllParams());
290
291 ASSERT_NO_FATAL_FAILURE(setSeiAveParams());
292
293 ASSERT_NO_FATAL_FAILURE(setSeiCcvParams());
294
295 ASSERT_NO_FATAL_FAILURE(setProfileParams());
296
297 ASSERT_NO_FATAL_FAILURE(setEncMode(IVE_ENC_MODE_PICTURE));
298 }
299
TearDown()300 void TearDown() override {
301 if (mInputBuffer) free(mInputBuffer);
302 if (mOutputBuffer) free(mOutputBuffer);
303 if (mFpInput) fclose(mFpInput);
304 if (mFpOutput) fclose(mFpOutput);
305 }
306
307 void encodeFrames(int64_t);
308 int64_t getTotalFrames();
309 int32_t mFrameWidth = MAX_FRAME_WIDTH;
310 int32_t mFrameHeight = MAX_FRAME_HEIGHT;
311 int32_t mFrameSize = (mFrameWidth * mFrameHeight * 3) / 2;
312 int64_t mTotalFrames = 0;
313 int32_t mBitRate = 256000;
314 int64_t mOutputBufferSize = MAX_OUTPUT_BUFFER_SIZE;
315 string mFileName;
316 string mOutFileName;
317 uint8_t* mInputBuffer = nullptr;
318 uint8_t* mOutputBuffer = nullptr;
319 FILE* mFpInput = nullptr;
320 FILE* mFpOutput = nullptr;
321 IV_STATUS_T status;
322 };
323
setDimensions()324 void AvcEncTest::setDimensions() {
325 ive_ctl_set_dimensions_ip_t sDimensionsIp = {};
326 ive_ctl_set_dimensions_op_t sDimensionsOp = {};
327
328 sDimensionsIp.e_cmd = IVE_CMD_VIDEO_CTL;
329 sDimensionsIp.e_sub_cmd = IVE_CMD_CTL_SET_DIMENSIONS;
330 sDimensionsIp.u4_ht = mFrameHeight;
331 sDimensionsIp.u4_wd = mFrameWidth;
332
333 sDimensionsIp.u4_timestamp_high = -1;
334 sDimensionsIp.u4_timestamp_low = -1;
335
336 sDimensionsIp.u4_size = sizeof(ive_ctl_set_dimensions_ip_t);
337 sDimensionsOp.u4_size = sizeof(ive_ctl_set_dimensions_op_t);
338
339 IV_STATUS_T status = ive_api_function(mCodecCtx, &sDimensionsIp, &sDimensionsOp);
340 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set dimensions!\n";
341
342 return;
343 }
344
setNumCores()345 void AvcEncTest::setNumCores() {
346 ive_ctl_set_num_cores_ip_t sNumCoresIp = {};
347 ive_ctl_set_num_cores_op_t sNumCoresOp = {};
348
349 sNumCoresIp.e_cmd = IVE_CMD_VIDEO_CTL;
350 sNumCoresIp.e_sub_cmd = IVE_CMD_CTL_SET_NUM_CORES;
351 sNumCoresIp.u4_num_cores = mNumCores;
352
353 sNumCoresIp.u4_timestamp_high = -1;
354 sNumCoresIp.u4_timestamp_low = -1;
355
356 sNumCoresIp.u4_size = sizeof(ive_ctl_set_num_cores_ip_t);
357 sNumCoresOp.u4_size = sizeof(ive_ctl_set_num_cores_op_t);
358
359 IV_STATUS_T status = ive_api_function(mCodecCtx, (void*)&sNumCoresIp, (void*)&sNumCoresOp);
360 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set number of cores!\n";
361
362 return;
363 }
364
setDefault()365 void AvcEncTest::setDefault() {
366 ive_ctl_setdefault_ip_t sDefaultIp = {};
367 ive_ctl_setdefault_op_t sDefaultOp = {};
368
369 sDefaultIp.e_cmd = IVE_CMD_VIDEO_CTL;
370 sDefaultIp.e_sub_cmd = IVE_CMD_CTL_SETDEFAULT;
371
372 sDefaultIp.u4_timestamp_high = -1;
373 sDefaultIp.u4_timestamp_low = -1;
374
375 sDefaultIp.u4_size = sizeof(ive_ctl_setdefault_ip_t);
376 sDefaultOp.u4_size = sizeof(ive_ctl_setdefault_op_t);
377
378 IV_STATUS_T status = ive_api_function(mCodecCtx, &sDefaultIp, &sDefaultOp);
379 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set default encoder parameters!\n";
380
381 return;
382 }
383
getBufInfo()384 void AvcEncTest::getBufInfo() {
385 ih264e_ctl_getbufinfo_ip_t sGetBufInfoIp = {};
386 ih264e_ctl_getbufinfo_op_t sGetBufInfoOp = {};
387
388 sGetBufInfoIp.s_ive_ip.u4_size = sizeof(ih264e_ctl_getbufinfo_ip_t);
389 sGetBufInfoOp.s_ive_op.u4_size = sizeof(ih264e_ctl_getbufinfo_op_t);
390
391 sGetBufInfoIp.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
392 sGetBufInfoIp.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_GETBUFINFO;
393 sGetBufInfoIp.s_ive_ip.u4_max_ht = mFrameHeight;
394 sGetBufInfoIp.s_ive_ip.u4_max_wd = mFrameWidth;
395 sGetBufInfoIp.s_ive_ip.e_inp_color_fmt = mIvVideoColorFormat;
396
397 IV_STATUS_T status = ih264e_api_function(mCodecCtx, &sGetBufInfoIp, &sGetBufInfoOp);
398 ASSERT_EQ(status, IV_SUCCESS) << "Failed to get buffer info!\n";
399
400 return;
401 }
402
setFrameRate()403 void AvcEncTest::setFrameRate() {
404 ive_ctl_set_frame_rate_ip_t sFrameRateIp = {};
405 ive_ctl_set_frame_rate_op_t sFrameRateOp = {};
406
407 sFrameRateIp.e_cmd = IVE_CMD_VIDEO_CTL;
408 sFrameRateIp.e_sub_cmd = IVE_CMD_CTL_SET_FRAMERATE;
409 sFrameRateIp.u4_src_frame_rate = mFrameRate;
410 sFrameRateIp.u4_tgt_frame_rate = mFrameRate;
411
412 sFrameRateIp.u4_timestamp_high = -1;
413 sFrameRateIp.u4_timestamp_low = -1;
414
415 sFrameRateIp.u4_size = sizeof(ive_ctl_set_frame_rate_ip_t);
416 sFrameRateOp.u4_size = sizeof(ive_ctl_set_frame_rate_op_t);
417
418 IV_STATUS_T status = ive_api_function(mCodecCtx, &sFrameRateIp, &sFrameRateOp);
419 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set frame rate!\n";
420
421 return;
422 }
423
setIpeParams()424 void AvcEncTest::setIpeParams() {
425 ive_ctl_set_ipe_params_ip_t sIpeParamsIp = {};
426 ive_ctl_set_ipe_params_op_t sIpeParamsOp = {};
427
428 sIpeParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
429 sIpeParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_IPE_PARAMS;
430 sIpeParamsIp.u4_enable_intra_4x4 = mIntra4x4;
431 sIpeParamsIp.u4_enc_speed_preset = mEncSpeed;
432 sIpeParamsIp.u4_constrained_intra_pred = mConstrainedIntraFlag;
433
434 sIpeParamsIp.u4_timestamp_high = -1;
435 sIpeParamsIp.u4_timestamp_low = -1;
436
437 sIpeParamsIp.u4_size = sizeof(ive_ctl_set_ipe_params_ip_t);
438 sIpeParamsOp.u4_size = sizeof(ive_ctl_set_ipe_params_op_t);
439
440 IV_STATUS_T status = ive_api_function(mCodecCtx, &sIpeParamsIp, &sIpeParamsOp);
441 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set IPE params!\n";
442
443 return;
444 }
445
setBitRate()446 void AvcEncTest::setBitRate() {
447 ive_ctl_set_bitrate_ip_t sBitrateIp = {};
448 ive_ctl_set_bitrate_op_t sBitrateOp = {};
449
450 sBitrateIp.e_cmd = IVE_CMD_VIDEO_CTL;
451 sBitrateIp.e_sub_cmd = IVE_CMD_CTL_SET_BITRATE;
452 sBitrateIp.u4_target_bitrate = mBitRate;
453
454 sBitrateIp.u4_timestamp_high = -1;
455 sBitrateIp.u4_timestamp_low = -1;
456
457 sBitrateIp.u4_size = sizeof(ive_ctl_set_bitrate_ip_t);
458 sBitrateOp.u4_size = sizeof(ive_ctl_set_bitrate_op_t);
459
460 IV_STATUS_T status = ive_api_function(mCodecCtx, &sBitrateIp, &sBitrateOp);
461 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set bit rate!\n";
462
463 return;
464 }
465
setFrameType(IV_PICTURE_CODING_TYPE_T eFrameType)466 void AvcEncTest::setFrameType(IV_PICTURE_CODING_TYPE_T eFrameType) {
467 ive_ctl_set_frame_type_ip_t sFrameTypeIp = {};
468 ive_ctl_set_frame_type_op_t sFrameTypeOp = {};
469
470 sFrameTypeIp.e_cmd = IVE_CMD_VIDEO_CTL;
471 sFrameTypeIp.e_sub_cmd = IVE_CMD_CTL_SET_FRAMETYPE;
472 sFrameTypeIp.e_frame_type = eFrameType;
473
474 sFrameTypeIp.u4_timestamp_high = -1;
475 sFrameTypeIp.u4_timestamp_low = -1;
476
477 sFrameTypeIp.u4_size = sizeof(ive_ctl_set_frame_type_ip_t);
478 sFrameTypeOp.u4_size = sizeof(ive_ctl_set_frame_type_op_t);
479
480 IV_STATUS_T status = ive_api_function(mCodecCtx, &sFrameTypeIp, &sFrameTypeOp);
481 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set Frame Type!\n";
482 return;
483 }
484
setQp()485 void AvcEncTest::setQp() {
486 ive_ctl_set_qp_ip_t s_QpIp = {};
487 ive_ctl_set_qp_op_t s_QpOp = {};
488
489 s_QpIp.e_cmd = IVE_CMD_VIDEO_CTL;
490 s_QpIp.e_sub_cmd = IVE_CMD_CTL_SET_QP;
491
492 s_QpIp.u4_i_qp = mIQp;
493 s_QpIp.u4_i_qp_max = MAX_H264_QP;
494 s_QpIp.u4_i_qp_min = kMinQP;
495
496 s_QpIp.u4_p_qp = mPQp;
497 s_QpIp.u4_p_qp_max = MAX_H264_QP;
498 s_QpIp.u4_p_qp_min = kMinQP;
499
500 s_QpIp.u4_b_qp = mBQp;
501 s_QpIp.u4_b_qp_max = MAX_H264_QP;
502 s_QpIp.u4_b_qp_min = kMinQP;
503
504 s_QpIp.u4_timestamp_high = -1;
505 s_QpIp.u4_timestamp_low = -1;
506
507 s_QpIp.u4_size = sizeof(ive_ctl_set_qp_ip_t);
508 s_QpOp.u4_size = sizeof(ive_ctl_set_qp_op_t);
509
510 IV_STATUS_T status = ive_api_function(mCodecCtx, &s_QpIp, &s_QpOp);
511 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set QP!\n";
512
513 return;
514 }
515
setEncMode(IVE_ENC_MODE_T eEncMode)516 void AvcEncTest::setEncMode(IVE_ENC_MODE_T eEncMode) {
517 ive_ctl_set_enc_mode_ip_t sEncModeIp = {};
518 ive_ctl_set_enc_mode_op_t sEncModeOp = {};
519
520 sEncModeIp.e_cmd = IVE_CMD_VIDEO_CTL;
521 sEncModeIp.e_sub_cmd = IVE_CMD_CTL_SET_ENC_MODE;
522 sEncModeIp.e_enc_mode = eEncMode;
523
524 sEncModeIp.u4_timestamp_high = -1;
525 sEncModeIp.u4_timestamp_low = -1;
526
527 sEncModeIp.u4_size = sizeof(ive_ctl_set_enc_mode_ip_t);
528 sEncModeOp.u4_size = sizeof(ive_ctl_set_enc_mode_op_t);
529
530 IV_STATUS_T status = ive_api_function(mCodecCtx, &sEncModeIp, &sEncModeOp);
531 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set encode mode!\n";
532
533 return;
534 }
535
setVbvParams()536 void AvcEncTest::setVbvParams() {
537 ive_ctl_set_vbv_params_ip_t sVbvIp = {};
538 ive_ctl_set_vbv_params_op_t sVbvOp = {};
539
540 sVbvIp.e_cmd = IVE_CMD_VIDEO_CTL;
541 sVbvIp.e_sub_cmd = IVE_CMD_CTL_SET_VBV_PARAMS;
542 sVbvIp.u4_vbv_buf_size = 0;
543 sVbvIp.u4_vbv_buffer_delay = 1000;
544
545 sVbvIp.u4_timestamp_high = -1;
546 sVbvIp.u4_timestamp_low = -1;
547
548 sVbvIp.u4_size = sizeof(ive_ctl_set_vbv_params_ip_t);
549 sVbvOp.u4_size = sizeof(ive_ctl_set_vbv_params_op_t);
550
551 IV_STATUS_T status = ive_api_function(mCodecCtx, &sVbvIp, &sVbvOp);
552 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set VBV params!\n";
553
554 return;
555 }
556
setAirParams()557 void AvcEncTest::setAirParams() {
558 ive_ctl_set_air_params_ip_t sAirIp = {};
559 ive_ctl_set_air_params_op_t sAirOp = {};
560
561 sAirIp.e_cmd = IVE_CMD_VIDEO_CTL;
562 sAirIp.e_sub_cmd = IVE_CMD_CTL_SET_AIR_PARAMS;
563 sAirIp.e_air_mode = mAirMode;
564 sAirIp.u4_air_refresh_period = mIntraRefresh;
565
566 sAirIp.u4_timestamp_high = -1;
567 sAirIp.u4_timestamp_low = -1;
568
569 sAirIp.u4_size = sizeof(ive_ctl_set_air_params_ip_t);
570 sAirOp.u4_size = sizeof(ive_ctl_set_air_params_op_t);
571
572 IV_STATUS_T status = ive_api_function(mCodecCtx, &sAirIp, &sAirOp);
573 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set AIR params!\n";
574
575 return;
576 }
577
setMeParams()578 void AvcEncTest::setMeParams() {
579 ive_ctl_set_me_params_ip_t sMeParamsIp = {};
580 ive_ctl_set_me_params_op_t sMeParamsOp = {};
581
582 sMeParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
583 sMeParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_ME_PARAMS;
584 sMeParamsIp.u4_enable_fast_sad = mEnableFastSad;
585 sMeParamsIp.u4_enable_alt_ref = mEnableAltRef;
586
587 sMeParamsIp.u4_enable_hpel = mHalfPelEnable;
588 sMeParamsIp.u4_enable_qpel = mQPelEnable;
589 sMeParamsIp.u4_me_speed_preset = mMeSpeedPreset;
590 sMeParamsIp.u4_srch_rng_x = mSearchRangeX;
591 sMeParamsIp.u4_srch_rng_y = mSearchRangeY;
592
593 sMeParamsIp.u4_timestamp_high = -1;
594 sMeParamsIp.u4_timestamp_low = -1;
595
596 sMeParamsIp.u4_size = sizeof(ive_ctl_set_me_params_ip_t);
597 sMeParamsOp.u4_size = sizeof(ive_ctl_set_me_params_op_t);
598
599 IV_STATUS_T status = ive_api_function(mCodecCtx, &sMeParamsIp, &sMeParamsOp);
600 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set ME params!\n";
601
602 return;
603 }
604
setGopParams()605 void AvcEncTest::setGopParams() {
606 ive_ctl_set_gop_params_ip_t sGopParamsIp = {};
607 ive_ctl_set_gop_params_op_t sGopParamsOp = {};
608
609 sGopParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
610 sGopParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_GOP_PARAMS;
611
612 sGopParamsIp.u4_i_frm_interval = mIInterval;
613 sGopParamsIp.u4_idr_frm_interval = mIDRInterval;
614
615 sGopParamsIp.u4_timestamp_high = -1;
616 sGopParamsIp.u4_timestamp_low = -1;
617
618 sGopParamsIp.u4_size = sizeof(ive_ctl_set_gop_params_ip_t);
619 sGopParamsOp.u4_size = sizeof(ive_ctl_set_gop_params_op_t);
620
621 IV_STATUS_T status = ive_api_function(mCodecCtx, &sGopParamsIp, &sGopParamsOp);
622 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set GOP params!\n";
623
624 return;
625 }
626
setProfileParams()627 void AvcEncTest::setProfileParams() {
628 ive_ctl_set_profile_params_ip_t sProfileParamsIp = {};
629 ive_ctl_set_profile_params_op_t sProfileParamsOp = {};
630
631 sProfileParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
632 sProfileParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_PROFILE_PARAMS;
633
634 sProfileParamsIp.e_profile = mProfile;
635 if (sProfileParamsIp.e_profile == IV_PROFILE_BASE) {
636 sProfileParamsIp.u4_entropy_coding_mode = 0;
637 } else {
638 sProfileParamsIp.u4_entropy_coding_mode = 1;
639 }
640 sProfileParamsIp.u4_timestamp_high = -1;
641 sProfileParamsIp.u4_timestamp_low = -1;
642
643 sProfileParamsIp.u4_size = sizeof(ive_ctl_set_profile_params_ip_t);
644 sProfileParamsOp.u4_size = sizeof(ive_ctl_set_profile_params_op_t);
645
646 IV_STATUS_T status = ive_api_function(mCodecCtx, &sProfileParamsIp, &sProfileParamsOp);
647 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set profile params!\n";
648
649 return;
650 }
651
setDeblockParams()652 void AvcEncTest::setDeblockParams() {
653 ive_ctl_set_deblock_params_ip_t sDeblockParamsIp = {};
654 ive_ctl_set_deblock_params_op_t sDeblockParamsOp = {};
655
656 sDeblockParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
657 sDeblockParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_DEBLOCK_PARAMS;
658
659 sDeblockParamsIp.u4_disable_deblock_level = mDisableDeblockLevel;
660
661 sDeblockParamsIp.u4_timestamp_high = -1;
662 sDeblockParamsIp.u4_timestamp_low = -1;
663
664 sDeblockParamsIp.u4_size = sizeof(ive_ctl_set_deblock_params_ip_t);
665 sDeblockParamsOp.u4_size = sizeof(ive_ctl_set_deblock_params_op_t);
666
667 IV_STATUS_T status = ive_api_function(mCodecCtx, &sDeblockParamsIp, &sDeblockParamsOp);
668 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set deblock params!\n";
669
670 return;
671 }
672
setVuiParams()673 void AvcEncTest::setVuiParams() {
674 ih264e_vui_ip_t sVuiParamsIp = {};
675 ih264e_vui_op_t sVuiParamsOp = {};
676
677 sVuiParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
678 sVuiParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_VUI_PARAMS;
679
680 sVuiParamsIp.u1_aspect_ratio_info_present_flag = mAspectRatioFlag;
681 sVuiParamsIp.u1_video_signal_type_present_flag = 1;
682 sVuiParamsIp.u1_colour_description_present_flag = 1;
683 sVuiParamsIp.u1_nal_hrd_parameters_present_flag = mNalHrdFlag;
684 sVuiParamsIp.u1_vcl_hrd_parameters_present_flag = mVclHrdFlag;
685
686 sVuiParamsIp.u4_size = sizeof(ih264e_vui_ip_t);
687 sVuiParamsOp.u4_size = sizeof(ih264e_vui_op_t);
688
689 IV_STATUS_T status = ive_api_function(mCodecCtx, &sVuiParamsIp, &sVuiParamsOp);
690 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set VUI params!\n";
691
692 return;
693 }
694
setSeiMdcvParams()695 void AvcEncTest::setSeiMdcvParams() {
696 ih264e_ctl_set_sei_mdcv_params_ip_t sSeiMdcvParamsIp = {};
697 ih264e_ctl_set_sei_mdcv_params_op_t sSeiMdcvParamsOp = {};
698
699 sSeiMdcvParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
700 sSeiMdcvParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_SEI_MDCV_PARAMS;
701 sSeiMdcvParamsIp.u1_sei_mdcv_params_present_flag = mSeiMdcvFlag;
702 if (mSeiMdcvFlag) {
703 for (int i4_count = 0; i4_count < NUM_SEI_MDCV_PRIMARIES; ++i4_count) {
704 sSeiMdcvParamsIp.au2_display_primaries_x[i4_count] = 30000;
705 sSeiMdcvParamsIp.au2_display_primaries_y[i4_count] = 35000;
706 }
707 sSeiMdcvParamsIp.u2_white_point_x = 30000;
708 sSeiMdcvParamsIp.u2_white_point_y = 35000;
709 sSeiMdcvParamsIp.u4_max_display_mastering_luminance = 100000000;
710 sSeiMdcvParamsIp.u4_min_display_mastering_luminance = 50000;
711 }
712
713 sSeiMdcvParamsIp.u4_timestamp_high = -1;
714 sSeiMdcvParamsIp.u4_timestamp_low = -1;
715
716 sSeiMdcvParamsIp.u4_size = sizeof(ih264e_ctl_set_sei_mdcv_params_ip_t);
717 sSeiMdcvParamsOp.u4_size = sizeof(ih264e_ctl_set_sei_mdcv_params_op_t);
718 IV_STATUS_T status = ih264e_api_function(mCodecCtx, &sSeiMdcvParamsIp, &sSeiMdcvParamsOp);
719 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set SEI MDCV params!\n";
720
721 return;
722 }
723
setSeiCllParams()724 void AvcEncTest::setSeiCllParams() {
725 ih264e_ctl_set_sei_cll_params_ip_t sSeiCllParamsIp = {};
726 ih264e_ctl_set_sei_cll_params_op_t sSeiCllParamsOp = {};
727
728 sSeiCllParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
729 sSeiCllParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_SEI_CLL_PARAMS;
730 sSeiCllParamsIp.u1_sei_cll_params_present_flag = mSeiCllFlag;
731 if (mSeiCllFlag) {
732 sSeiCllParamsIp.u2_max_content_light_level = 0;
733 sSeiCllParamsIp.u2_max_pic_average_light_level = 0;
734 }
735
736 sSeiCllParamsIp.u4_timestamp_high = -1;
737 sSeiCllParamsIp.u4_timestamp_low = -1;
738
739 sSeiCllParamsIp.u4_size = sizeof(ih264e_ctl_set_sei_cll_params_ip_t);
740 sSeiCllParamsOp.u4_size = sizeof(ih264e_ctl_set_sei_cll_params_op_t);
741
742 IV_STATUS_T status = ih264e_api_function(mCodecCtx, &sSeiCllParamsIp, &sSeiCllParamsOp);
743 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set SEI CLL params!\n";
744
745 return;
746 }
747
setSeiAveParams()748 void AvcEncTest::setSeiAveParams() {
749 ih264e_ctl_set_sei_ave_params_ip_t sSeiAveParamsIp = {};
750 ih264e_ctl_set_sei_ave_params_op_t sSeiAveParamsOp = {};
751
752 sSeiAveParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
753 sSeiAveParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_SEI_AVE_PARAMS;
754 sSeiAveParamsIp.u1_sei_ave_params_present_flag = mSeiAveFlag;
755 if (mSeiAveFlag) {
756 sSeiAveParamsIp.u4_ambient_illuminance = 1;
757 sSeiAveParamsIp.u2_ambient_light_x = 0;
758 sSeiAveParamsIp.u2_ambient_light_y = 0;
759 }
760
761 sSeiAveParamsIp.u4_timestamp_high = -1;
762 sSeiAveParamsIp.u4_timestamp_low = -1;
763
764 sSeiAveParamsIp.u4_size = sizeof(ih264e_ctl_set_sei_ave_params_ip_t);
765 sSeiAveParamsOp.u4_size = sizeof(ih264e_ctl_set_sei_ave_params_op_t);
766
767 IV_STATUS_T status = ih264e_api_function(mCodecCtx, &sSeiAveParamsIp, &sSeiAveParamsOp);
768 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set SEI AVE params!\n";
769
770 return;
771 }
772
setSeiCcvParams()773 void AvcEncTest::setSeiCcvParams() {
774 ih264e_ctl_set_sei_ccv_params_ip_t sSeiCcvParamsIp = {};
775 ih264e_ctl_set_sei_ccv_params_op_t sSeiCcvParamsOp = {};
776
777 sSeiCcvParamsIp.e_cmd = IVE_CMD_VIDEO_CTL;
778 sSeiCcvParamsIp.e_sub_cmd = IVE_CMD_CTL_SET_SEI_CCV_PARAMS;
779 sSeiCcvParamsIp.u1_sei_ccv_params_present_flag = mSeiCcvFlag;
780 if (mSeiCcvFlag) {
781 sSeiCcvParamsIp.u1_ccv_cancel_flag = 0;
782 sSeiCcvParamsIp.u1_ccv_persistence_flag = 1;
783 sSeiCcvParamsIp.u1_ccv_primaries_present_flag = 1;
784 sSeiCcvParamsIp.u1_ccv_min_luminance_value_present_flag = 1;
785 sSeiCcvParamsIp.u1_ccv_max_luminance_value_present_flag = 1;
786 sSeiCcvParamsIp.u1_ccv_avg_luminance_value_present_flag = 1;
787 sSeiCcvParamsIp.u1_ccv_reserved_zero_2bits = 0;
788 for (int i4_count = 0; i4_count < NUM_SEI_CCV_PRIMARIES; ++i4_count) {
789 sSeiCcvParamsIp.ai4_ccv_primaries_x[i4_count] = 1;
790 sSeiCcvParamsIp.ai4_ccv_primaries_y[i4_count] = 1;
791 }
792 sSeiCcvParamsIp.u4_ccv_min_luminance_value = 1;
793 sSeiCcvParamsIp.u4_ccv_max_luminance_value = 1;
794 sSeiCcvParamsIp.u4_ccv_avg_luminance_value = 1;
795 }
796
797 sSeiCcvParamsIp.u4_timestamp_high = -1;
798 sSeiCcvParamsIp.u4_timestamp_low = -1;
799
800 sSeiCcvParamsIp.u4_size = sizeof(ih264e_ctl_set_sei_ccv_params_ip_t);
801 sSeiCcvParamsOp.u4_size = sizeof(ih264e_ctl_set_sei_ccv_params_op_t);
802
803 IV_STATUS_T status = ih264e_api_function(mCodecCtx, &sSeiCcvParamsIp, &sSeiCcvParamsOp);
804 ASSERT_EQ(status, IV_SUCCESS) << "Failed to set SEI CCV params!\n";
805
806 return;
807 }
808
logVersion()809 void AvcEncTest::logVersion() {
810 ive_ctl_getversioninfo_ip_t sCtlIp = {};
811 ive_ctl_getversioninfo_op_t sCtlOp = {};
812 UWORD8 au1Buf[512];
813
814 sCtlIp.e_cmd = IVE_CMD_VIDEO_CTL;
815 sCtlIp.e_sub_cmd = IVE_CMD_CTL_GETVERSION;
816
817 sCtlIp.u4_size = sizeof(ive_ctl_getversioninfo_ip_t);
818 sCtlOp.u4_size = sizeof(ive_ctl_getversioninfo_op_t);
819 sCtlIp.pu1_version = au1Buf;
820 sCtlIp.u4_version_bufsize = sizeof(au1Buf);
821
822 IV_STATUS_T status = ive_api_function(mCodecCtx, (void*)&sCtlIp, (void*)&sCtlOp);
823 ASSERT_EQ(status, IV_SUCCESS) << "Failed to get encoder version!\n";
824
825 return;
826 }
827
encodeFrames(int64_t numFramesToEncode)828 void AvcEncTest::encodeFrames(int64_t numFramesToEncode) {
829 ih264e_video_encode_ip_t ih264e_video_encode_ip = {};
830 ih264e_video_encode_op_t ih264e_video_encode_op = {};
831
832 ive_video_encode_ip_t* sEncodeIp = &ih264e_video_encode_ip.s_ive_ip;
833 ive_video_encode_op_t* sEncodeOp = &ih264e_video_encode_op.s_ive_op;
834
835 uint8_t header[kHeaderLength];
836 iv_raw_buf_t* psInpRawBuf = &sEncodeIp->s_inp_buf;
837
838 sEncodeIp->s_out_buf.pv_buf = header;
839 sEncodeIp->s_out_buf.u4_bytes = 0;
840 sEncodeIp->s_out_buf.u4_bufsize = kHeaderLength;
841 sEncodeIp->u4_size = sizeof(ih264e_video_encode_ip_t);
842 sEncodeOp->u4_size = sizeof(ih264e_video_encode_op_t);
843
844 sEncodeIp->e_cmd = IVE_CMD_VIDEO_ENCODE;
845 sEncodeIp->pv_bufs = nullptr;
846 sEncodeIp->pv_mb_info = nullptr;
847 sEncodeIp->pv_pic_info = nullptr;
848 sEncodeIp->u4_mb_info_type = 0;
849 sEncodeIp->u4_pic_info_type = 0;
850 sEncodeIp->u4_is_last = 0;
851 sEncodeOp->s_out_buf.pv_buf = nullptr;
852
853 /* Initialize color formats */
854 memset(psInpRawBuf, 0, sizeof(iv_raw_buf_t));
855 psInpRawBuf->u4_size = sizeof(iv_raw_buf_t);
856 psInpRawBuf->e_color_fmt = mIvVideoColorFormat;
857
858 IV_STATUS_T status = ive_api_function(mCodecCtx, sEncodeIp, sEncodeOp);
859 ASSERT_EQ(status, IV_SUCCESS) << "Failed to Initialize Color Formats!\n";
860
861 uint32_t numFrame = 0;
862
863 while (numFramesToEncode > 0) {
864 int32_t bytesRead;
865 bytesRead = fread(mInputBuffer, 1, mFrameSize, mFpInput);
866
867 if (bytesRead != mFrameSize) {
868 break;
869 }
870
871 setRawBuf(psInpRawBuf, mInputBuffer);
872
873 sEncodeIp->s_out_buf.pv_buf = mOutputBuffer;
874 sEncodeIp->s_out_buf.u4_bufsize = mFrameSize;
875 if (mIsForceIdrEnabled) {
876 if (numFrame == mForceIdrInterval) {
877 ASSERT_NO_FATAL_FAILURE(setFrameType(IV_IDR_FRAME));
878 }
879 }
880 if (mIsDynamicBitRateChangeEnabled) {
881 if (numFrame == mDynamicBitRateInterval) {
882 mBitRate *= 2;
883 }
884 ASSERT_NO_FATAL_FAILURE(setBitRate());
885 }
886 if (mIsDynamicFrameRateChangeEnabled) {
887 if (numFrame == mDynamicFrameRateInterval) {
888 mFrameRate *= 2;
889 }
890 ASSERT_NO_FATAL_FAILURE(setFrameRate());
891 }
892
893 status = ive_api_function(mCodecCtx, &ih264e_video_encode_ip, &ih264e_video_encode_op);
894 ASSERT_EQ(status, IV_SUCCESS) << "Failed to encode frame!\n";
895
896 int32_t numOutputBytes = fwrite((UWORD8*)sEncodeOp->s_out_buf.pv_buf, sizeof(UWORD8),
897 sEncodeOp->s_out_buf.u4_bytes, mFpOutput);
898 ASSERT_NE(numOutputBytes, 0) << "Failed to write the output!" << mOutFileName;
899
900 numFramesToEncode--;
901 numFrame++;
902 }
903
904 sEncodeIp->u4_is_last = 1;
905 psInpRawBuf->apv_bufs[0] = nullptr;
906 psInpRawBuf->apv_bufs[1] = nullptr;
907 psInpRawBuf->apv_bufs[2] = nullptr;
908
909 status = ive_api_function(mCodecCtx, &ih264e_video_encode_ip, &ih264e_video_encode_op);
910 ASSERT_EQ(status, IV_SUCCESS) << "Failure after encoding last frame!\n";
911
912 if (sEncodeOp->output_present) {
913 int32_t numOutputBytes = fwrite((UWORD8*)sEncodeOp->s_out_buf.pv_buf, sizeof(UWORD8),
914 sEncodeOp->s_out_buf.u4_bytes, mFpOutput);
915 ASSERT_NE(numOutputBytes, 0) << "Failed to write the output!" << mOutFileName;
916 }
917 }
918
setRawBuf(iv_raw_buf_t * psInpRawBuf,const uint8_t * data)919 void AvcEncTest::setRawBuf(iv_raw_buf_t* psInpRawBuf, const uint8_t* data) {
920 switch (mIvVideoColorFormat) {
921 case IV_YUV_420SP_UV:
922 [[fallthrough]];
923 case IV_YUV_420SP_VU: {
924 uint8_t* yPlane = const_cast<uint8_t*>(data);
925 uint8_t* uPlane = const_cast<uint8_t*>(data + (mFrameWidth * mFrameHeight));
926 int32_t yStride = mFrameWidth;
927 int32_t uStride = mFrameWidth / 2;
928 psInpRawBuf->apv_bufs[0] = yPlane;
929 psInpRawBuf->apv_bufs[1] = uPlane;
930
931 psInpRawBuf->au4_wd[0] = mFrameWidth;
932 psInpRawBuf->au4_wd[1] = mFrameWidth;
933
934 psInpRawBuf->au4_ht[0] = mFrameHeight;
935 psInpRawBuf->au4_ht[1] = mFrameHeight / 2;
936
937 psInpRawBuf->au4_strd[0] = yStride;
938 psInpRawBuf->au4_strd[1] = uStride;
939 break;
940 }
941 case IV_YUV_422ILE: {
942 uint8_t* yPlane = const_cast<uint8_t*>(data);
943 psInpRawBuf->apv_bufs[0] = yPlane;
944
945 psInpRawBuf->au4_wd[0] = mFrameWidth * 2;
946
947 psInpRawBuf->au4_ht[0] = mFrameHeight;
948
949 psInpRawBuf->au4_strd[0] = mFrameWidth * 2;
950 break;
951 }
952 case IV_YUV_420P:
953 [[fallthrough]];
954 default: {
955 uint8_t* yPlane = const_cast<uint8_t*>(data);
956 uint8_t* uPlane = const_cast<uint8_t*>(data + (mFrameWidth * mFrameHeight));
957 uint8_t* vPlane = const_cast<uint8_t*>(data + ((mFrameWidth * mFrameHeight) * 5) / 4);
958 int32_t yStride = mFrameWidth;
959 int32_t uStride = mFrameWidth / 2;
960 int32_t vStride = mFrameWidth / 2;
961
962 psInpRawBuf->apv_bufs[0] = yPlane;
963 psInpRawBuf->apv_bufs[1] = uPlane;
964 psInpRawBuf->apv_bufs[2] = vPlane;
965
966 psInpRawBuf->au4_wd[0] = mFrameWidth;
967 psInpRawBuf->au4_wd[1] = mFrameWidth / 2;
968 psInpRawBuf->au4_wd[2] = mFrameWidth / 2;
969
970 psInpRawBuf->au4_ht[0] = mFrameHeight;
971 psInpRawBuf->au4_ht[1] = mFrameHeight / 2;
972 psInpRawBuf->au4_ht[2] = mFrameHeight / 2;
973
974 psInpRawBuf->au4_strd[0] = yStride;
975 psInpRawBuf->au4_strd[1] = uStride;
976 psInpRawBuf->au4_strd[2] = vStride;
977 break;
978 }
979 }
980 return;
981 }
982
getTotalFrames()983 int64_t AvcEncTest::getTotalFrames() {
984 struct stat buf;
985 stat(mFileName.c_str(), &buf);
986 size_t fileSize = buf.st_size;
987 int64_t totalFrames = (int64_t)(fileSize / mFrameSize);
988 return totalFrames;
989 }
990
TEST_P(AvcEncTest,EncodeTest)991 TEST_P(AvcEncTest, EncodeTest) {
992 ASSERT_NO_FATAL_FAILURE(encodeFrames(mTotalFrames)) << "Failed to Encode: " << mFileName;
993 }
994
995 INSTANTIATE_TEST_SUITE_P(EncodeTest, AvcEncTest,
996 ::testing::Values(make_tuple("bbb_352x288_420p_30fps_32frames.yuv", 352,
997 288, 30, 2048),
998 make_tuple("football_qvga.yuv", 320, 240, 30, 1024)));
999
main(int argc,char ** argv)1000 int32_t main(int argc, char** argv) {
1001 gArgs = new TestArgs();
1002 ::testing::AddGlobalTestEnvironment(gArgs);
1003 ::testing::InitGoogleTest(&argc, argv);
1004 uint8_t status = gArgs->initFromOptions(argc, argv);
1005 if (status == 0) {
1006 status = RUN_ALL_TESTS();
1007 }
1008 return status;
1009 }
1010