xref: /aosp_15_r20/external/libavc/tests/AvcEncTest.cpp (revision 495ae853bb871d1e5a258cb02c2cc13cde8ddb9a)
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