1 /******************************************************************************
2 *
3 * Copyright (C) 2015 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
21 /*****************************************************************************/
22 /* File Includes */
23 /*****************************************************************************/
24
25 /* System include files */
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stddef.h>
29 #include <assert.h>
30 #include <string.h>
31
32 #ifndef IOS
33 #include <malloc.h>
34 #endif
35
36 #ifdef WINDOWS_TIMER
37 #include "windows.h"
38 #else
39 #include <sys/time.h>
40 #endif
41 /* User include files */
42 #include "ih264_typedefs.h"
43 #include "iv2.h"
44 #include "ive2.h"
45 #include "ih264e.h"
46 #include "app.h"
47 #include "psnr.h"
48
49 /* Function declarations */
50 #ifndef MD5_DISABLE
51 void calc_md5_cksum(UWORD8 *pu1_inbuf,UWORD32 u4_stride,UWORD32 u4_width,UWORD32 u4_height,UWORD8 *pu1_cksum_p );
52 #else
53 #define calc_md5_cksum(a, b, c, d, e)
54 #endif
55
56 /*****************************************************************************/
57 /* Enums */
58 /*****************************************************************************/
59 typedef enum
60 {
61 INVALID,
62 HELP,
63 INPUT_FILE,
64 OUTPUT_FILE,
65 RECON_FILE,
66 RECON_ENABLE,
67 CHKSUM_ENABLE,
68 CHKSUM_FILE,
69 INPUT_CHROMA_FORMAT,
70 RECON_CHROMA_FORMAT,
71 MAX_WD,
72 MAX_HT,
73 WD,
74 HT,
75 MAX_LEVEL,
76 ENC_SPEED,
77 ME_SPEED,
78 START_FRM,
79 NUM_FRMS,
80 MAX_FRAMERATE,
81 SRC_FRAMERATE,
82 TGT_FRAMERATE,
83 RC,
84 MAX_BITRATE,
85 BITRATE,
86 I_QP,
87 P_QP,
88 B_QP,
89 I_QP_MAX,
90 P_QP_MAX,
91 B_QP_MAX,
92 I_QP_MIN,
93 P_QP_MIN,
94 B_QP_MIN,
95 ENTROPY,
96 AIR,
97 AIR_REFRESH_PERIOD,
98 ARCH,
99 SOC,
100 NUMCORES,
101 PRE_ENC_ME,
102 PRE_ENC_IPE,
103 HPEL,
104 QPEL,
105 SRCH_RNG_X,
106 SRCH_RNG_Y,
107 I_INTERVAL,
108 IDR_INTERVAL,
109 CONSTRAINED_INTRA_PRED,
110 B_FRMS,
111 NUM_B_FRMS,
112 DISABLE_DBLK,
113 PROFILE,
114 FAST_SAD,
115 ALT_REF,
116 DISABLE_DEBLOCK_LEVEL,
117 PSNR,
118 SLICE_MODE,
119 SLICE_PARAM,
120 CONFIG,
121 LOOPBACK,
122 VBV_DELAY,
123 VBV_SIZE,
124 INTRA_4x4_ENABLE,
125 MB_INFO_FILE,
126 MB_INFO_TYPE,
127 PIC_INFO_FILE,
128 PIC_INFO_TYPE,
129 } ARGUMENT_T;
130
131 typedef struct
132 {
133 CHAR argument_shortname[8];
134 CHAR argument_name[128];
135 ARGUMENT_T argument;
136 CHAR description[512];
137 } argument_t;
138
139 static const argument_t argument_mapping[] =
140 {
141 { "--", "--help", HELP, "Print this help\n" },
142 { "-i", "--input", INPUT_FILE, "Input file\n" },
143 { "-o", "--output", OUTPUT_FILE, "Output file\n" },
144 { "--", "--recon_enable", RECON_ENABLE, "Recon enable flag\n" },
145 { "-r", "--recon", RECON_FILE, "Recon file \n" },
146 { "--", "--input_chroma_format", INPUT_CHROMA_FORMAT,
147 "Input Chroma format Supported values YUV_420P, YUV_420SP_UV, YUV_420SP_VU\n" },
148 { "--", "--recon_chroma_format", RECON_CHROMA_FORMAT,
149 "Recon Chroma format Supported values YUV_420P, YUV_420SP_UV, YUV_420SP_VU\n" },
150 { "-w", "--width", WD, "Width of input file\n" },
151 { "-h", "--height", HT, "Height file\n" },
152 { "--", "--start_frame", START_FRM, "Starting frame number\n" },
153 { "-f", "--num_frames", NUM_FRMS, "Number of frames to be encoded\n" },
154 { "--", "--rc", RC, "Rate control mode 0: Constant Qp, 1: Storage, 2: CBR non low delay, 3: CBR low delay \n" },
155 { "--", "--max_framerate", MAX_FRAMERATE, "Maximum frame rate \n" },
156 { "--", "--tgt_framerate", TGT_FRAMERATE, "Target frame rate \n" },
157 { "--", "--src_framerate", SRC_FRAMERATE, "Source frame rate \n" },
158 { "--", "--i_interval", I_INTERVAL, "Intra frame interval \n" },
159 { "--", "--idr_interval", IDR_INTERVAL, "IDR frame interval \n" },
160 { "--", "--constrained_intrapred", CONSTRAINED_INTRA_PRED, "Constrained IntraPrediction Flag \n" },
161 { "--", "--bframes", NUM_B_FRMS, "Maximum number of consecutive B frames \n" },
162 { "--", "--speed", ENC_SPEED, "Encoder speed preset 0 (slowest) and 100 (fastest)\n" },
163 { "--", "--me_speed", ME_SPEED, "Encoder speed preset 0 (slowest) and 100 (fastest)\n" },
164 { "--", "--fast_sad", FAST_SAD, " Flag for faster sad execution\n" },
165 { "--", "--alt_ref", ALT_REF , "Flag to enable alternate refernce frames"},
166 { "--", "--hpel", HPEL, "Flag to enable/disable Quarter pel estimation \n" },
167 { "--", "--qpel", QPEL, "Flag to enable/disable Quarter pel estimation \n" },
168 { "--", "--disable_deblock_level", DISABLE_DEBLOCK_LEVEL,
169 "Disable deblock level - 0 : Enables deblock completely, 1: enables for I and 8th frame , 2: Enables for I only, 3 : disables completely\n" },
170 { "--", "--search_range_x", SRCH_RNG_X, "Search range for X \n" },
171 { "--", "--search_range_y", SRCH_RNG_Y, "Search range for Y \n" },
172 { "--", "--psnr", PSNR, "Enable PSNR computation (Disable while benchmarking performance) \n" },
173 { "--", "--pre_enc_me", PRE_ENC_ME, "Flag to enable/disable Pre Enc Motion Estimation\n" },
174 { "--", "--pre_enc_ipe", PRE_ENC_IPE, "Flag to enable/disable Pre Enc Intra prediction Estimation\n" },
175 { "-n", "--num_cores", NUMCORES, "Number of cores to be used\n" },
176 { "--", "--adaptive_intra_refresh", AIR ,"Adaptive Intra Refresh enable/disable\n"},
177 { "--", "--air_refresh_period", AIR_REFRESH_PERIOD,"adaptive intra refresh period\n"},
178 { "--", "--slice", SLICE_MODE, "Slice mode- 0 :No slice, 1: Bytes per slice, 2: MB/CTB per slice \n" },
179 { "--", "--slice_param", SLICE_PARAM, "Slice param value based on slice mode. Slice mode of 1 implies number of bytes per slice, 2 implies number of MBs/CTBs, for 0 value is neglected \n" },
180 { "--", "--max_wd", MAX_WD, "Maximum width (Default: 1920) \n" },
181 { "--", "--max_ht", MAX_HT, "Maximum height (Default: 1088)\n" },
182 { "--", "--max_level", MAX_LEVEL, "Maximum Level (Default: 50)\n" },
183 { "--", "--arch", ARCH, "Set Architecture. Supported values ARM_NONEON, ARM_A9Q, ARM_A7, ARM_A5, ARM_NEONINTR, X86_GENERIC, X86_SSSE3, X86_SSE4 \n" },
184 { "--", "--soc", SOC, "Set SOC. Supported values GENERIC, HISI_37X \n" },
185 { "--", "--chksum", CHKSUM_FILE, "Save Check sum file for recon data\n" },
186 { "--", "--chksum_enable", CHKSUM_ENABLE, "Recon MD5 Checksum file\n"},
187 { "-c", "--config", CONFIG, "config file (Default: enc.cfg)\n" },
188 { "--", "--loopback", LOOPBACK, "Enable encoding in a loop\n" },
189 { "--", "--profile", PROFILE, "Profile mode: Supported values BASE, MAIN, HIGH\n" },
190 { "--", "--max_bitrate", MAX_BITRATE, "Max bitrate\n"},
191 { "--", "--bitrate", BITRATE, "Target bitrate\n"},
192 { "--", "--qp_i", I_QP, "QP for I frames\n"},
193 { "--", "--qp_p", P_QP, "QP for P frames\n"},
194 { "--", "--qp_b", B_QP, "QP for B frames\n"},
195 { "--", "--qp_i_max", I_QP_MAX, "Max QP for I frames\n"},
196 { "--", "--qp_p_max", P_QP_MAX, "Max QP for P frames\n"},
197 { "--", "--qp_b_max", B_QP_MAX, "Max QP for B frames\n"},
198 { "--", "--qp_i_min", I_QP_MIN, "Min QP for I frames\n"},
199 { "--", "--qp_p_min", P_QP_MIN, "Min QP for P frames\n"},
200 { "--", "--qp_b_min", B_QP_MIN, "Min QP for B frames\n"},
201 { "--", "--entropy", ENTROPY, "Entropy coding mode(0: CAVLC or 1: CABAC)\n"},
202 { "--", "--vbv_delay", VBV_DELAY, "VBV buffer delay\n"},
203 { "--", "--vbv_size", VBV_SIZE, "VBV buffer size\n"},
204 { "-i4", "--intra_4x4_enable", INTRA_4x4_ENABLE, "Intra 4x4 enable \n" },
205 { "--", "--mb_info_file", MB_INFO_FILE, "MB info file\n"},
206 { "--", "--mb_info_type", MB_INFO_TYPE, "MB info type\n"},
207 { "--", "--pic_info_file", PIC_INFO_FILE, "Pic info file\n"},
208 { "--", "--pic_info_type", PIC_INFO_TYPE, "Pic info type\n"},
209 };
210
211
212
213 /*****************************************************************************/
214 /* Function Declarations */
215 /*****************************************************************************/
216
217
218
219 /*****************************************************************************/
220 /* Function Definitions */
221 /*****************************************************************************/
222
223
224 #if(defined X86) && (defined X86_MINGW)
225 /*****************************************************************************/
226 /* Function to print library calls */
227 /*****************************************************************************/
228 /*****************************************************************************/
229 /* */
230 /* Function Name : memalign */
231 /* */
232 /* Description : Returns malloc data. Ideally should return aligned memory*/
233 /* support alignment will be added later */
234 /* */
235 /* Inputs : alignment */
236 /* size */
237 /* Globals : */
238 /* Processing : */
239 /* */
240 /* Outputs : */
241 /* Returns : */
242 /* */
243 /* Issues : */
244 /* */
245 /* Revision History: */
246 /* */
247 /* DD MM YYYY Author(s) Changes */
248 /* 07 09 2012 100189 Initial Version */
249 /* */
250 /*****************************************************************************/
251
ih264a_aligned_malloc(WORD32 alignment,WORD32 size)252 void * ih264a_aligned_malloc(WORD32 alignment, WORD32 size)
253 {
254 return _aligned_malloc(size, alignment);
255 }
256
ih264a_aligned_free(void * pv_buf)257 void ih264a_aligned_free(void *pv_buf)
258 {
259 _aligned_free(pv_buf);
260 return;
261 }
262
263 #elif IOS
264
ih264a_aligned_malloc(WORD32 alignment,WORD32 size)265 void * ih264a_aligned_malloc(WORD32 alignment, WORD32 size)
266 {
267 return malloc(size);
268 }
269
ih264a_aligned_free(void * pv_buf)270 void ih264a_aligned_free(void *pv_buf)
271 {
272 free(pv_buf);
273 return;
274 }
275
276 #else
277
ih264a_aligned_malloc(WORD32 alignment,WORD32 size)278 void * ih264a_aligned_malloc(WORD32 alignment, WORD32 size)
279 {
280 return memalign(alignment, size);
281 }
282
ih264a_aligned_free(void * pv_buf)283 void ih264a_aligned_free(void *pv_buf)
284 {
285 free(pv_buf);
286 return;
287 }
288
289 #endif
290
291 /*****************************************************************************/
292 /* */
293 /* Function Name : codec_exit */
294 /* */
295 /* Description : handles unrecoverable errors */
296 /* Inputs : Error message */
297 /* Globals : None */
298 /* Processing : Prints error message to console and exits. */
299 /* Outputs : Error message to the console */
300 /* Returns : None */
301 /* */
302 /* Issues : */
303 /* */
304 /* Revision History: */
305 /* */
306 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
307 /* 07 06 2006 Sankar Creation */
308 /* */
309 /*****************************************************************************/
codec_exit(CHAR * pc_err_message)310 void codec_exit(CHAR *pc_err_message)
311 {
312 printf("%s\n", pc_err_message);
313 exit(-1);
314 }
315
316 /*****************************************************************************/
317 /* */
318 /* Function Name : codec_exit */
319 /* */
320 /* Description : handles unrecoverable errors */
321 /* Inputs : Error message */
322 /* Globals : None */
323 /* Processing : Prints error message to console and exits. */
324 /* Outputs : Error mesage to the console */
325 /* Returns : None */
326 /* */
327 /* Issues : */
328 /* */
329 /* Revision History: */
330 /* */
331 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
332 /* 07 06 2006 Sankar Creation */
333 /* */
334 /*****************************************************************************/
get_chroma_fmt(CHAR * value)335 IV_COLOR_FORMAT_T get_chroma_fmt(CHAR *value)
336 {
337 IV_COLOR_FORMAT_T e_chroma_format;
338 if((strcmp(value, "YUV_420P")) == 0)
339 e_chroma_format = IV_YUV_420P;
340 else if((strcmp(value, "YUV_422ILE")) == 0)
341 e_chroma_format = IV_YUV_422ILE;
342 else if((strcmp(value, "RGB_565")) == 0)
343 e_chroma_format = IV_RGB_565;
344 else if((strcmp(value, "RGBA_8888")) == 0)
345 e_chroma_format = IV_RGBA_8888;
346 else if((strcmp(value, "YUV_420SP_UV")) == 0)
347 e_chroma_format = IV_YUV_420SP_UV;
348 else if((strcmp(value, "YUV_420SP_VU")) == 0)
349 e_chroma_format = IV_YUV_420SP_VU;
350 else
351 {
352 printf("\nInvalid colour format setting it to IV_YUV_420P\n");
353 e_chroma_format = IV_YUV_420P;
354 }
355 return e_chroma_format;
356 }
357
358 /*****************************************************************************/
359 /* */
360 /* Function Name : codec_exit */
361 /* */
362 /* Description : handles unrecoverable errors */
363 /* Inputs : Error message */
364 /* Globals : None */
365 /* Processing : Prints error message to console and exits. */
366 /* Outputs : Error mesage to the console */
367 /* Returns : None */
368 /* */
369 /* Issues : */
370 /* */
371 /* Revision History: */
372 /* */
373 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
374 /* 07 06 2006 Sankar Creation */
375 /* */
376 /*****************************************************************************/
get_speed_preset(CHAR * value)377 IVE_SPEED_CONFIG get_speed_preset(CHAR *value)
378 {
379 IVE_SPEED_CONFIG e_enc_speed_preset;
380 if((strcmp(value, "CONFIG")) == 0)
381 e_enc_speed_preset = IVE_CONFIG;
382 else if((strcmp(value, "SLOWEST")) == 0)
383 e_enc_speed_preset = IVE_SLOWEST;
384 else if((strcmp(value, "NORMAL")) == 0)
385 e_enc_speed_preset = IVE_NORMAL;
386 else if((strcmp(value, "FAST")) == 0)
387 e_enc_speed_preset = IVE_FAST;
388 else if((strcmp(value, "HIGH_SPEED")) == 0)
389 e_enc_speed_preset = IVE_HIGH_SPEED;
390 else if((strcmp(value, "FASTEST")) == 0)
391 e_enc_speed_preset = IVE_FASTEST;
392 else
393 {
394 printf("\nInvalid speed preset, setting it to IVE_FASTEST\n");
395 e_enc_speed_preset = IVE_FASTEST;
396 }
397 return e_enc_speed_preset;
398 }
399
400 /*****************************************************************************/
401 /* */
402 /* Function Name : print_usage */
403 /* */
404 /* Description : Prints argument format */
405 /* */
406 /* */
407 /* Inputs : */
408 /* Globals : */
409 /* Processing : Prints argument format */
410 /* */
411 /* Outputs : */
412 /* Returns : */
413 /* */
414 /* Issues : */
415 /* */
416 /* Revision History: */
417 /* */
418 /* DD MM YYYY Author(s) Changes */
419 /* 07 09 2012 100189 Initial Version */
420 /* */
421 /*****************************************************************************/
422
print_usage(void)423 void print_usage(void)
424 {
425 WORD32 i = 0;
426 WORD32 num_entries = sizeof(argument_mapping) / sizeof(argument_t);
427 printf("\nUsage:\n");
428 while(i < num_entries)
429 {
430 printf("%-32s\t %s", argument_mapping[i].argument_name,
431 argument_mapping[i].description);
432 i++;
433 }
434 }
435
436 /*****************************************************************************/
437 /* */
438 /* Function Name : get_argument */
439 /* */
440 /* Description : Gets argument for a given string */
441 /* */
442 /* */
443 /* Inputs : name */
444 /* Globals : */
445 /* Processing : Searches the given string in the array and returns */
446 /* appropriate argument ID */
447 /* */
448 /* Outputs : Argument ID */
449 /* Returns : Argument ID */
450 /* */
451 /* Issues : */
452 /* */
453 /* Revision History: */
454 /* */
455 /* DD MM YYYY Author(s) Changes */
456 /* 07 09 2012 100189 Initial Version */
457 /* */
458 /*****************************************************************************/
get_argument(CHAR * name)459 ARGUMENT_T get_argument(CHAR *name)
460 {
461 WORD32 i = 0;
462 WORD32 num_entries = sizeof(argument_mapping) / sizeof(argument_t);
463 while(i < num_entries)
464 {
465 if((0 == strcmp(argument_mapping[i].argument_name, name)) ||
466 ((0 == strcmp(argument_mapping[i].argument_shortname, name)) &&
467 (0 != strcmp(argument_mapping[i].argument_shortname, "--"))))
468 {
469 return argument_mapping[i].argument;
470 }
471 i++;
472 }
473 return INVALID;
474 }
475
476 /*****************************************************************************/
477 /* */
478 /* Function Name : get_argument */
479 /* */
480 /* Description : Gets argument for a given string */
481 /* */
482 /* */
483 /* Inputs : name */
484 /* Globals : */
485 /* Processing : Searches the given string in the array and returns */
486 /* appropriate argument ID */
487 /* */
488 /* Outputs : Argument ID */
489 /* Returns : Argument ID */
490 /* */
491 /* Issues : */
492 /* */
493 /* Revision History: */
494 /* */
495 /* DD MM YYYY Author(s) Changes */
496 /* 07 09 2012 100189 Initial Version */
497 /* */
498 /*****************************************************************************/
parse_argument(app_ctxt_t * ps_app_ctxt,CHAR * argument,CHAR * value)499 void parse_argument(app_ctxt_t *ps_app_ctxt, CHAR *argument, CHAR *value)
500 {
501 ARGUMENT_T arg;
502
503 arg = get_argument(argument);
504 switch(arg)
505 {
506 case HELP:
507 print_usage();
508 exit(-1);
509 break;
510 case SLICE_MODE:
511 sscanf(value, "%d", &ps_app_ctxt->u4_slice_mode);
512 break;
513 case SLICE_PARAM:
514 sscanf(value, "%d", &ps_app_ctxt->u4_slice_param);
515 break;
516 case INPUT_FILE:
517 sscanf(value, "%s", ps_app_ctxt->ac_ip_fname);
518 break;
519
520 case OUTPUT_FILE:
521 sscanf(value, "%s", ps_app_ctxt->ac_op_fname);
522 break;
523
524 case RECON_FILE:
525 sscanf(value, "%s", ps_app_ctxt->ac_recon_fname);
526 break;
527
528 case RECON_ENABLE:
529 sscanf(value, "%d", &ps_app_ctxt->u4_recon_enable);
530 break;
531
532 case CHKSUM_FILE:
533 sscanf(value, "%s", ps_app_ctxt->ac_chksum_fname);
534 break;
535
536 case CHKSUM_ENABLE:
537 sscanf(value, "%d", &ps_app_ctxt->u4_chksum_enable);
538 break;
539
540 case MB_INFO_FILE:
541 sscanf(value, "%s", ps_app_ctxt->ac_mb_info_fname);
542 break;
543
544 case MB_INFO_TYPE:
545 sscanf(value, "%d", &ps_app_ctxt->u4_mb_info_type);
546 break;
547
548 case PIC_INFO_FILE:
549 sscanf(value, "%s", ps_app_ctxt->ac_pic_info_fname);
550 break;
551
552 case PIC_INFO_TYPE:
553 sscanf(value, "%d", &ps_app_ctxt->u4_pic_info_type);
554 break;
555
556 case INPUT_CHROMA_FORMAT:
557 ps_app_ctxt->e_inp_color_fmt = get_chroma_fmt(value);
558 break;
559
560 case RECON_CHROMA_FORMAT:
561 ps_app_ctxt->e_recon_color_fmt = get_chroma_fmt(value);
562 break;
563
564 case MAX_WD:
565 sscanf(value, "%d", &ps_app_ctxt->u4_max_wd);
566 break;
567
568 case MAX_HT:
569 sscanf(value, "%d", &ps_app_ctxt->u4_max_ht);
570 break;
571
572 case WD:
573 sscanf(value, "%d", &ps_app_ctxt->u4_wd);
574 break;
575
576 case HT:
577 sscanf(value, "%d", &ps_app_ctxt->u4_ht);
578 break;
579
580 case MAX_LEVEL:
581 sscanf(value, "%d", &ps_app_ctxt->u4_max_level);
582 break;
583
584 case ENC_SPEED:
585 ps_app_ctxt->u4_enc_speed = get_speed_preset(value);
586 break;
587
588 case ME_SPEED:
589 sscanf(value, "%d", &ps_app_ctxt->u4_me_speed);
590 break;
591
592 case START_FRM:
593 sscanf(value, "%d", &ps_app_ctxt->u4_start_frm);
594 break;
595
596 case NUM_FRMS:
597 sscanf(value, "%d", &ps_app_ctxt->u4_max_num_frms);
598 break;
599
600 case MAX_FRAMERATE:
601 sscanf(value, "%d", &ps_app_ctxt->u4_max_frame_rate);
602 if(ps_app_ctxt->u4_max_frame_rate <= 0)
603 ps_app_ctxt->u4_max_frame_rate = DEFAULT_MAX_FRAMERATE;
604 break;
605
606 case SRC_FRAMERATE:
607 sscanf(value, "%d", &ps_app_ctxt->u4_src_frame_rate);
608 if(ps_app_ctxt->u4_src_frame_rate <= 0)
609 ps_app_ctxt->u4_src_frame_rate = DEFAULT_SRC_FRAME_RATE;
610 break;
611
612 case TGT_FRAMERATE:
613 sscanf(value, "%d", &ps_app_ctxt->u4_tgt_frame_rate);
614 if(ps_app_ctxt->u4_tgt_frame_rate <= 0)
615 ps_app_ctxt->u4_tgt_frame_rate = DEFAULT_TGT_FRAME_RATE;
616 break;
617
618 case RC:
619 sscanf(value, "%d", &ps_app_ctxt->u4_rc);
620 break;
621
622 case MAX_BITRATE:
623 sscanf(value, "%d", &ps_app_ctxt->u4_max_bitrate);
624 break;
625
626 case BITRATE:
627 sscanf(value, "%d", &ps_app_ctxt->u4_bitrate);
628 break;
629
630 case I_QP:
631 sscanf(value, "%d", &ps_app_ctxt->u4_i_qp);
632 break;
633
634 case I_QP_MAX:
635 sscanf(value, "%d", &ps_app_ctxt->u4_i_qp_max);
636 break;
637
638 case I_QP_MIN:
639 sscanf(value, "%d", &ps_app_ctxt->u4_i_qp_min);
640 break;
641
642 case P_QP:
643 sscanf(value, "%d", &ps_app_ctxt->u4_p_qp);
644 break;
645
646 case P_QP_MAX:
647 sscanf(value, "%d", &ps_app_ctxt->u4_p_qp_max);
648 break;
649
650 case P_QP_MIN:
651 sscanf(value, "%d", &ps_app_ctxt->u4_p_qp_min);
652 break;
653
654 case B_QP:
655 sscanf(value, "%d", &ps_app_ctxt->u4_b_qp);
656 break;
657
658 case B_QP_MAX:
659 sscanf(value, "%d", &ps_app_ctxt->u4_b_qp_max);
660 break;
661
662 case B_QP_MIN:
663 sscanf(value, "%d", &ps_app_ctxt->u4_b_qp_min);
664 break;
665
666 case ENTROPY:
667 sscanf(value, "%d", &ps_app_ctxt->u4_entropy_coding_mode);
668 break;
669
670 case AIR:
671 sscanf(value, "%d", &ps_app_ctxt->u4_air);
672 break;
673
674 case ARCH:
675 if((strcmp(value, "ARM_NONEON")) == 0)
676 ps_app_ctxt->e_arch = ARCH_ARM_NONEON;
677 else if((strcmp(value, "ARM_A9Q")) == 0)
678 ps_app_ctxt->e_arch = ARCH_ARM_A9Q;
679 else if((strcmp(value, "ARM_A7")) == 0)
680 ps_app_ctxt->e_arch = ARCH_ARM_A7;
681 else if((strcmp(value, "ARM_A5")) == 0)
682 ps_app_ctxt->e_arch = ARCH_ARM_A5;
683 else if((strcmp(value, "ARM_NEONINTR")) == 0)
684 ps_app_ctxt->e_arch = ARCH_ARM_NEONINTR;
685 else if((strcmp(value, "X86_GENERIC")) == 0)
686 ps_app_ctxt->e_arch = ARCH_X86_GENERIC;
687 else if((strcmp(value, "X86_SSSE3")) == 0)
688 ps_app_ctxt->e_arch = ARCH_X86_SSSE3;
689 else if((strcmp(value, "X86_SSE42")) == 0)
690 ps_app_ctxt->e_arch = ARCH_X86_SSE42;
691 else if((strcmp(value, "ARM_A53")) == 0)
692 ps_app_ctxt->e_arch = ARCH_ARM_A53;
693 else if((strcmp(value, "ARM_A57")) == 0)
694 ps_app_ctxt->e_arch = ARCH_ARM_A57;
695 else if((strcmp(value, "ARM_V8_NEON")) == 0)
696 ps_app_ctxt->e_arch = ARCH_ARM_V8_NEON;
697 else
698 {
699 printf("\nInvalid Arch. Setting it to ARM_A9Q\n");
700 ps_app_ctxt->e_arch = ARCH_ARM_A9Q;
701 }
702
703 break;
704 case SOC:
705 if((strcmp(value, "GENERIC")) == 0)
706 ps_app_ctxt->e_soc = SOC_GENERIC;
707 else if((strcmp(value, "HISI_37X")) == 0)
708 ps_app_ctxt->e_soc = SOC_HISI_37X;
709 else
710 {
711 ps_app_ctxt->e_soc = SOC_GENERIC;
712 }
713 break;
714
715 case NUMCORES:
716 sscanf(value, "%d", &ps_app_ctxt->u4_num_cores);
717 break;
718
719 case LOOPBACK:
720 sscanf(value, "%d", &ps_app_ctxt->u4_loopback);
721 break;
722
723 case PRE_ENC_ME:
724 sscanf(value, "%d", &ps_app_ctxt->u4_pre_enc_me);
725 break;
726
727 case PRE_ENC_IPE:
728 sscanf(value, "%d", &ps_app_ctxt->u4_pre_enc_ipe);
729 break;
730
731 case HPEL:
732 sscanf(value, "%d", &ps_app_ctxt->u4_hpel);
733 break;
734
735 case QPEL:
736 sscanf(value, "%d", &ps_app_ctxt->u4_qpel);
737 break;
738
739 case SRCH_RNG_X:
740 sscanf(value, "%d", &ps_app_ctxt->u4_srch_rng_x);
741 break;
742
743 case SRCH_RNG_Y:
744 sscanf(value, "%d", &ps_app_ctxt->u4_srch_rng_y);
745 break;
746
747 case I_INTERVAL:
748 sscanf(value, "%d", &ps_app_ctxt->u4_i_interval);
749 break;
750
751 case IDR_INTERVAL:
752 sscanf(value, "%d", &ps_app_ctxt->u4_idr_interval);
753 break;
754
755 case CONSTRAINED_INTRA_PRED:
756 sscanf(value, "%d", &ps_app_ctxt->u4_constrained_intra_pred);
757 break;
758
759 case NUM_B_FRMS:
760 sscanf(value, "%d", &ps_app_ctxt->u4_num_bframes);
761 break;
762
763 case DISABLE_DEBLOCK_LEVEL:
764 sscanf(value, "%d", &ps_app_ctxt->u4_disable_deblk_level);
765 break;
766
767 case VBV_DELAY:
768 sscanf(value, "%d", &ps_app_ctxt->u4_vbv_buffer_delay);
769 break;
770
771 case VBV_SIZE:
772 sscanf(value, "%d", &ps_app_ctxt->u4_vbv_buf_size);
773 break;
774
775 case FAST_SAD:
776 sscanf(value, "%d", &ps_app_ctxt->u4_enable_fast_sad);
777 break;
778
779 case ALT_REF:
780 sscanf(value, "%d", &ps_app_ctxt->u4_enable_alt_ref);
781 break;
782
783 case AIR_REFRESH_PERIOD:
784 sscanf(value, "%d", &ps_app_ctxt->u4_air_refresh_period);
785 break;
786
787 case PROFILE:
788 if((strcmp(value, "BASE")) == 0)
789 ps_app_ctxt->e_profile = IV_PROFILE_BASE;
790 else if((strcmp(value, "MAIN")) == 0)
791 ps_app_ctxt->e_profile = IV_PROFILE_MAIN;
792 else if((strcmp(value, "HIGH")) == 0)
793 ps_app_ctxt->e_profile = IV_PROFILE_HIGH;
794 else
795 {
796 printf("\nInvalid profile. Setting it to BASE\n");
797 ps_app_ctxt->e_profile = IV_PROFILE_BASE;
798 }
799 break;
800
801 case PSNR:
802 sscanf(value, "%d", &ps_app_ctxt->u4_psnr_enable);
803 break;
804
805 case INTRA_4x4_ENABLE:
806 sscanf(value, "%d", &ps_app_ctxt->u4_enable_intra_4x4);
807 break;
808
809
810 case INVALID:
811 default:
812 printf("Ignoring argument : %s\n", argument);
813 break;
814 }
815 }
816
817 /*****************************************************************************/
818 /* */
819 /* Function Name : read_cfg_file */
820 /* */
821 /* Description : Reads arguments from a configuration file */
822 /* */
823 /* */
824 /* Inputs : ps_app_ctxt : Application context */
825 /* fp_cfg_file : Configuration file handle */
826 /* Globals : */
827 /* Processing : Parses the arguments and fills in the application context*/
828 /* */
829 /* Outputs : Arguments parsed */
830 /* Returns : None */
831 /* */
832 /* Issues : */
833 /* */
834 /* Revision History: */
835 /* */
836 /* DD MM YYYY Author(s) Changes */
837 /* 07 09 2012 100189 Initial Version */
838 /* */
839 /*****************************************************************************/
read_cfg_file(app_ctxt_t * ps_app_ctxt,FILE * fp_cfg)840 void read_cfg_file(app_ctxt_t *ps_app_ctxt, FILE *fp_cfg)
841 {
842 CHAR line[STRLENGTH];
843 CHAR description[STRLENGTH];
844 CHAR value[STRLENGTH];
845 CHAR argument[STRLENGTH];
846
847 while(0 == (feof(fp_cfg)))
848 {
849 line[0] = '\0';
850 fgets(line, STRLENGTH, fp_cfg);
851 argument[0] = '\0';
852 /* Reading Input File Name */
853 sscanf(line, "%s %s %s", argument, value, description);
854 if(argument[0] == '\0')
855 continue;
856
857 parse_argument(ps_app_ctxt, argument, value);
858 }
859 }
860
invalid_argument_exit(CHAR * pc_err_message)861 void invalid_argument_exit(CHAR *pc_err_message)
862 {
863 print_usage();
864 codec_exit(pc_err_message);
865 }
866
validate_params(app_ctxt_t * ps_app_ctxt)867 void validate_params(app_ctxt_t *ps_app_ctxt)
868 {
869 CHAR ac_error[STRLENGTH];
870
871 if(ps_app_ctxt->ac_ip_fname[0] == '\0')
872 {
873 invalid_argument_exit("Specify input file");
874 }
875 if(ps_app_ctxt->ac_op_fname[0] == '\0')
876 {
877 invalid_argument_exit("Specify output file");
878 }
879 if((1 == ps_app_ctxt->u4_recon_enable) && (ps_app_ctxt->ac_recon_fname[0] == '\0'))
880 {
881 invalid_argument_exit("Specify recon file");
882 }
883 if((1 == ps_app_ctxt->u4_chksum_enable) && (ps_app_ctxt->ac_chksum_fname[0] == '\0'))
884 {
885 invalid_argument_exit("Specify checksum file");
886 }
887 if(0 >= (WORD32)ps_app_ctxt->u4_wd)
888 {
889 sprintf(ac_error, "Invalid width: %d", ps_app_ctxt->u4_wd);
890 invalid_argument_exit(ac_error);
891 }
892 if(0 >= (WORD32)ps_app_ctxt->u4_ht)
893 {
894 sprintf(ac_error, "Invalid height: %d", ps_app_ctxt->u4_ht);
895 invalid_argument_exit(ac_error);
896 }
897
898 if(0 == (WORD32)ps_app_ctxt->u4_max_num_frms)
899 {
900 sprintf(ac_error, "Invalid number of frames to be encoded: %d", ps_app_ctxt->u4_max_num_frms);
901 invalid_argument_exit(ac_error);
902 }
903 if ((0 != (WORD32)ps_app_ctxt->u4_entropy_coding_mode)
904 && (1 != (WORD32)ps_app_ctxt->u4_entropy_coding_mode))
905 {
906 sprintf(ac_error, "Invalid entropy codeing mode: %d",
907 ps_app_ctxt->u4_entropy_coding_mode);
908 invalid_argument_exit(ac_error);
909 }
910 return;
911 }
912
init_default_params(app_ctxt_t * ps_app_ctxt)913 void init_default_params(app_ctxt_t *ps_app_ctxt)
914 {
915
916 ps_app_ctxt->ps_enc = NULL;
917 ps_app_ctxt->ps_mem_rec = NULL;
918 ps_app_ctxt->u4_num_mem_rec = DEFAULT_MEM_REC_CNT;
919 ps_app_ctxt->u4_recon_enable = DEFAULT_RECON_ENABLE;
920 ps_app_ctxt->u4_chksum_enable = DEFAULT_CHKSUM_ENABLE;
921 ps_app_ctxt->u4_mb_info_type = 0;
922 ps_app_ctxt->u4_pic_info_type = 0;
923 ps_app_ctxt->u4_mb_info_size = 0;
924 ps_app_ctxt->u4_pic_info_size = 0;
925 ps_app_ctxt->u4_start_frm = DEFAULT_START_FRM;
926 ps_app_ctxt->u4_max_num_frms = DEFAULT_NUM_FRMS;
927 ps_app_ctxt->avg_time = 0;
928 ps_app_ctxt->u4_total_bytes = 0;
929 ps_app_ctxt->u4_pics_cnt = 0;
930 ps_app_ctxt->e_inp_color_fmt = DEFAULT_INP_COLOR_FMT;
931 ps_app_ctxt->e_recon_color_fmt = DEFAULT_RECON_COLOR_FMT;
932 ps_app_ctxt->e_arch = ARCH_ARM_A9Q;
933 ps_app_ctxt->e_soc = SOC_GENERIC;
934 ps_app_ctxt->header_generated = 0;
935 ps_app_ctxt->pv_codec_obj = NULL;
936 ps_app_ctxt->u4_num_cores = DEFAULT_NUM_CORES;
937 ps_app_ctxt->u4_pre_enc_me = 0;
938 ps_app_ctxt->u4_pre_enc_ipe = 0;
939 ps_app_ctxt->ac_ip_fname[0] = '\0';
940 ps_app_ctxt->ac_op_fname[0] = '\0';
941 ps_app_ctxt->ac_recon_fname[0] = '\0';
942 ps_app_ctxt->ac_chksum_fname[0] = '\0';
943 ps_app_ctxt->ac_mb_info_fname[0] = '\0';
944 ps_app_ctxt->fp_ip = NULL;
945 ps_app_ctxt->fp_op = NULL;
946 ps_app_ctxt->fp_recon = NULL;
947 ps_app_ctxt->fp_chksum = NULL;
948 ps_app_ctxt->fp_psnr_ip = NULL;
949 ps_app_ctxt->fp_mb_info = NULL;
950 ps_app_ctxt->fp_pic_info = NULL;
951 ps_app_ctxt->u4_loopback = DEFAULT_LOOPBACK;
952 ps_app_ctxt->u4_max_frame_rate = DEFAULT_MAX_FRAMERATE;
953 ps_app_ctxt->u4_src_frame_rate = DEFAULT_SRC_FRAME_RATE;
954 ps_app_ctxt->u4_tgt_frame_rate = DEFAULT_TGT_FRAME_RATE;
955 ps_app_ctxt->u4_max_wd = DEFAULT_MAX_WD;
956 ps_app_ctxt->u4_max_ht = DEFAULT_MAX_HT;
957 ps_app_ctxt->u4_max_level = DEFAULT_MAX_LEVEL;
958 ps_app_ctxt->u4_strd = DEFAULT_STRIDE;
959 ps_app_ctxt->u4_wd = DEFAULT_WD;
960 ps_app_ctxt->u4_ht = DEFAULT_HT;
961 ps_app_ctxt->u4_psnr_enable = DEFAULT_PSNR_ENABLE;
962 ps_app_ctxt->u4_enc_speed = IVE_FASTEST;
963 ps_app_ctxt->u4_me_speed = DEFAULT_ME_SPEED;
964 ps_app_ctxt->u4_enable_fast_sad = DEFAULT_ENABLE_FAST_SAD;
965 ps_app_ctxt->u4_enable_alt_ref = DEFAULT_ENABLE_ALT_REF;
966 ps_app_ctxt->u4_rc = DEFAULT_RC;
967 ps_app_ctxt->u4_max_bitrate = DEFAULT_MAX_BITRATE;
968 ps_app_ctxt->u4_num_bframes = DEFAULT_NUM_BFRAMES;
969 ps_app_ctxt->u4_bitrate = DEFAULT_BITRATE;
970 ps_app_ctxt->u4_i_qp = DEFAULT_I_QP;
971 ps_app_ctxt->u4_p_qp = DEFAULT_P_QP;
972 ps_app_ctxt->u4_b_qp = DEFAULT_B_QP;
973 ps_app_ctxt->u4_i_qp_min = DEFAULT_QP_MIN;
974 ps_app_ctxt->u4_i_qp_max = DEFAULT_QP_MAX;
975 ps_app_ctxt->u4_p_qp_min = DEFAULT_QP_MIN;
976 ps_app_ctxt->u4_p_qp_max = DEFAULT_QP_MAX;
977 ps_app_ctxt->u4_b_qp_min = DEFAULT_QP_MIN;
978 ps_app_ctxt->u4_b_qp_max = DEFAULT_QP_MAX;
979 ps_app_ctxt->u4_air = DEFAULT_AIR;
980 ps_app_ctxt->u4_air_refresh_period = DEFAULT_AIR_REFRESH_PERIOD;
981 ps_app_ctxt->u4_srch_rng_x = DEFAULT_SRCH_RNG_X;
982 ps_app_ctxt->u4_srch_rng_y = DEFAULT_SRCH_RNG_Y;
983 ps_app_ctxt->u4_i_interval = DEFAULT_I_INTERVAL;
984 ps_app_ctxt->u4_idr_interval = DEFAULT_IDR_INTERVAL;
985 ps_app_ctxt->u4_constrained_intra_pred = DEFAULT_CONSTRAINED_INTRAPRED;
986 ps_app_ctxt->u4_disable_deblk_level = DEFAULT_DISABLE_DEBLK_LEVEL;
987 ps_app_ctxt->u4_hpel = DEFAULT_HPEL;
988 ps_app_ctxt->u4_qpel = DEFAULT_QPEL;
989 ps_app_ctxt->u4_enable_intra_4x4 = DEFAULT_I4;
990 ps_app_ctxt->e_profile = DEFAULT_EPROFILE;
991 ps_app_ctxt->u4_slice_mode = DEFAULT_SLICE_MODE;
992 ps_app_ctxt->u4_slice_param = DEFAULT_SLICE_PARAM;
993 ps_app_ctxt->pv_input_thread_handle = NULL;
994 ps_app_ctxt->pv_output_thread_handle = NULL;
995 ps_app_ctxt->pv_recon_thread_handle = NULL;
996 ps_app_ctxt->u4_vbv_buf_size = 0;
997 ps_app_ctxt->u4_vbv_buffer_delay = 1000;
998 ps_app_ctxt->adbl_psnr[0] = 0.0;
999 ps_app_ctxt->adbl_psnr[1] = 0.0;
1000 ps_app_ctxt->adbl_psnr[2] = 0.0;
1001 ps_app_ctxt->u4_psnr_cnt = 0;
1002 ps_app_ctxt->pu1_psnr_buf = NULL;
1003 ps_app_ctxt->u4_psnr_buf_size = 0;
1004 ps_app_ctxt->u4_entropy_coding_mode = DEFAULT_ENTROPY_CODING_MODE;
1005
1006 return;
1007 }
1008
set_dimensions(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1009 void set_dimensions(app_ctxt_t *ps_app_ctxt,
1010 UWORD32 u4_timestamp_low,
1011 UWORD32 u4_timestamp_high)
1012 {
1013 ih264e_ctl_set_dimensions_ip_t s_frame_dimensions_ip;
1014 ih264e_ctl_set_dimensions_op_t s_frame_dimensions_op;
1015 IV_STATUS_T status;
1016
1017 s_frame_dimensions_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1018 s_frame_dimensions_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_DIMENSIONS;
1019
1020 s_frame_dimensions_ip.s_ive_ip.u4_ht = ps_app_ctxt->u4_ht;
1021 s_frame_dimensions_ip.s_ive_ip.u4_wd = ps_app_ctxt->u4_wd;
1022
1023 s_frame_dimensions_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1024 s_frame_dimensions_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1025
1026 s_frame_dimensions_ip.s_ive_ip.u4_size =
1027 sizeof(ih264e_ctl_set_dimensions_ip_t);
1028 s_frame_dimensions_op.s_ive_op.u4_size =
1029 sizeof(ih264e_ctl_set_dimensions_op_t);
1030
1031 status = ih264e_api_function(ps_app_ctxt->ps_enc,
1032 &s_frame_dimensions_ip,
1033 &s_frame_dimensions_op);
1034 if(status != IV_SUCCESS)
1035 {
1036 CHAR ac_error[STRLENGTH];
1037 sprintf(ac_error, "Unable to set frame dimensions = 0x%x\n",
1038 s_frame_dimensions_op.s_ive_op.u4_error_code);
1039 codec_exit(ac_error);
1040 }
1041 return;
1042 }
1043
set_frame_rate(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1044 void set_frame_rate(app_ctxt_t *ps_app_ctxt,
1045 UWORD32 u4_timestamp_low,
1046 UWORD32 u4_timestamp_high)
1047 {
1048 ih264e_ctl_set_frame_rate_ip_t s_frame_rate_ip;
1049 ih264e_ctl_set_frame_rate_op_t s_frame_rate_op;
1050 IV_STATUS_T status;
1051
1052 s_frame_rate_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1053 s_frame_rate_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_FRAMERATE;
1054
1055 s_frame_rate_ip.s_ive_ip.u4_src_frame_rate =
1056 ps_app_ctxt->u4_src_frame_rate;
1057 s_frame_rate_ip.s_ive_ip.u4_tgt_frame_rate =
1058 ps_app_ctxt->u4_tgt_frame_rate;
1059
1060 s_frame_rate_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1061 s_frame_rate_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1062
1063 s_frame_rate_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_frame_rate_ip_t);
1064 s_frame_rate_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_frame_rate_op_t);
1065
1066 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_frame_rate_ip,&s_frame_rate_op);
1067 if(status != IV_SUCCESS)
1068 {
1069 CHAR ac_error[STRLENGTH];
1070 sprintf(ac_error, "Unable to set frame rate = 0x%x\n",
1071 s_frame_rate_op.s_ive_op.u4_error_code);
1072 codec_exit(ac_error);
1073 }
1074 return;
1075 }
1076
1077
set_ipe_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1078 void set_ipe_params(app_ctxt_t *ps_app_ctxt,
1079 UWORD32 u4_timestamp_low,
1080 UWORD32 u4_timestamp_high)
1081 {
1082 ih264e_ctl_set_ipe_params_ip_t s_ipe_params_ip;
1083 ih264e_ctl_set_ipe_params_op_t s_ipe_params_op;
1084 IV_STATUS_T status;
1085
1086 s_ipe_params_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1087 s_ipe_params_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_IPE_PARAMS;
1088
1089 s_ipe_params_ip.s_ive_ip.u4_enable_intra_4x4 = ps_app_ctxt->u4_enable_intra_4x4;
1090 s_ipe_params_ip.s_ive_ip.u4_enc_speed_preset = ps_app_ctxt->u4_enc_speed;
1091
1092 s_ipe_params_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1093 s_ipe_params_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1094
1095 s_ipe_params_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_ipe_params_ip_t);
1096 s_ipe_params_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_ipe_params_op_t);
1097
1098 s_ipe_params_ip.s_ive_ip.u4_constrained_intra_pred =
1099 ps_app_ctxt->u4_constrained_intra_pred;
1100
1101 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_ipe_params_ip,&s_ipe_params_op);
1102 if(status != IV_SUCCESS)
1103 {
1104 CHAR ac_error[STRLENGTH];
1105 sprintf(ac_error, "Unable to set ipe params = 0x%x\n",
1106 s_ipe_params_op.s_ive_op.u4_error_code);
1107 codec_exit(ac_error);
1108 }
1109 return;
1110 }
1111
set_bit_rate(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1112 void set_bit_rate(app_ctxt_t *ps_app_ctxt,
1113 UWORD32 u4_timestamp_low, UWORD32 u4_timestamp_high)
1114 {
1115 ih264e_ctl_set_bitrate_ip_t s_bitrate_ip;
1116 ih264e_ctl_set_bitrate_op_t s_bitrate_op;
1117 IV_STATUS_T status;
1118
1119 s_bitrate_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1120 s_bitrate_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_BITRATE;
1121
1122 s_bitrate_ip.s_ive_ip.u4_target_bitrate = ps_app_ctxt->u4_bitrate;
1123
1124 s_bitrate_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1125 s_bitrate_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1126
1127 s_bitrate_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_bitrate_ip_t);
1128 s_bitrate_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_bitrate_op_t);
1129
1130 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_bitrate_ip,&s_bitrate_op);
1131 if(status != IV_SUCCESS)
1132 {
1133 CHAR ac_error[STRLENGTH];
1134 sprintf(ac_error, "Unable to set bit rate = 0x%x\n",
1135 s_bitrate_op.s_ive_op.u4_error_code);
1136 codec_exit(ac_error);
1137 }
1138 return;
1139 }
1140
1141
set_frame_type(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high,IV_PICTURE_CODING_TYPE_T e_frame_type)1142 void set_frame_type(app_ctxt_t *ps_app_ctxt,
1143 UWORD32 u4_timestamp_low,
1144 UWORD32 u4_timestamp_high,
1145 IV_PICTURE_CODING_TYPE_T e_frame_type)
1146 {
1147 ih264e_ctl_set_frame_type_ip_t s_frame_type_ip;
1148 ih264e_ctl_set_frame_type_op_t s_frame_type_op;
1149 IV_STATUS_T status;
1150
1151 s_frame_type_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1152 s_frame_type_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_FRAMETYPE;
1153
1154 s_frame_type_ip.s_ive_ip.e_frame_type = e_frame_type;
1155
1156 s_frame_type_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1157 s_frame_type_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1158
1159 s_frame_type_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_frame_type_ip_t);
1160 s_frame_type_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_frame_type_op_t);
1161
1162 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_frame_type_ip,&s_frame_type_op);
1163 if(status != IV_SUCCESS)
1164 {
1165 CHAR ac_error[STRLENGTH];
1166 sprintf(ac_error, "Unable to set frame type = 0x%x\n",
1167 s_frame_type_op.s_ive_op.u4_error_code);
1168 codec_exit(ac_error);
1169 }
1170 return;
1171 }
1172
set_qp(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1173 void set_qp(app_ctxt_t *ps_app_ctxt,
1174 UWORD32 u4_timestamp_low, UWORD32 u4_timestamp_high)
1175 {
1176 ih264e_ctl_set_qp_ip_t s_qp_ip;
1177 ih264e_ctl_set_qp_op_t s_qp_op;
1178 IV_STATUS_T status;
1179
1180 s_qp_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1181 s_qp_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_QP;
1182
1183 s_qp_ip.s_ive_ip.u4_i_qp = ps_app_ctxt->u4_i_qp;
1184 s_qp_ip.s_ive_ip.u4_i_qp_max = ps_app_ctxt->u4_i_qp_max;
1185 s_qp_ip.s_ive_ip.u4_i_qp_min = ps_app_ctxt->u4_i_qp_min;
1186
1187 s_qp_ip.s_ive_ip.u4_p_qp = ps_app_ctxt->u4_p_qp;
1188 s_qp_ip.s_ive_ip.u4_p_qp_max = ps_app_ctxt->u4_p_qp_max;
1189 s_qp_ip.s_ive_ip.u4_p_qp_min = ps_app_ctxt->u4_p_qp_min;
1190
1191 s_qp_ip.s_ive_ip.u4_b_qp = ps_app_ctxt->u4_b_qp;
1192 s_qp_ip.s_ive_ip.u4_b_qp_max = ps_app_ctxt->u4_b_qp_max;
1193 s_qp_ip.s_ive_ip.u4_b_qp_min = ps_app_ctxt->u4_b_qp_min;
1194
1195 s_qp_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1196 s_qp_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1197
1198 s_qp_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_qp_ip_t);
1199 s_qp_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_qp_op_t);
1200
1201 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_qp_ip,&s_qp_op);
1202 if(status != IV_SUCCESS)
1203 {
1204 CHAR ac_error[STRLENGTH];
1205 sprintf(ac_error, "Unable to set qp 0x%x\n",
1206 s_qp_op.s_ive_op.u4_error_code);
1207 codec_exit(ac_error);
1208 }
1209 return;
1210 }
1211
set_enc_mode(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high,IVE_ENC_MODE_T e_enc_mode)1212 void set_enc_mode(app_ctxt_t *ps_app_ctxt,
1213 UWORD32 u4_timestamp_low, UWORD32 u4_timestamp_high,
1214 IVE_ENC_MODE_T e_enc_mode)
1215 {
1216 IV_STATUS_T status;
1217
1218 ih264e_ctl_set_enc_mode_ip_t s_enc_mode_ip;
1219 ih264e_ctl_set_enc_mode_op_t s_enc_mode_op;
1220
1221 s_enc_mode_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1222 s_enc_mode_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_ENC_MODE;
1223
1224 s_enc_mode_ip.s_ive_ip.e_enc_mode = e_enc_mode;
1225
1226 s_enc_mode_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1227 s_enc_mode_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1228
1229 s_enc_mode_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_enc_mode_ip_t);
1230 s_enc_mode_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_enc_mode_op_t);
1231
1232 status = ih264e_api_function(ps_app_ctxt->ps_enc, &s_enc_mode_ip,
1233 &s_enc_mode_op);
1234 if(status != IV_SUCCESS)
1235 {
1236 CHAR ac_error[STRLENGTH];
1237 sprintf(ac_error, "Unable to set in header encode mode = 0x%x\n",
1238 s_enc_mode_op.s_ive_op.u4_error_code);
1239 codec_exit(ac_error);
1240 }
1241 return;
1242 }
1243
1244
set_vbv_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1245 void set_vbv_params(app_ctxt_t *ps_app_ctxt,
1246 UWORD32 u4_timestamp_low,
1247 UWORD32 u4_timestamp_high)
1248 {
1249 ih264e_ctl_set_vbv_params_ip_t s_vbv_ip;
1250 ih264e_ctl_set_vbv_params_op_t s_vbv_op;
1251 IV_STATUS_T status;
1252
1253 s_vbv_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1254 s_vbv_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_VBV_PARAMS;
1255
1256 s_vbv_ip.s_ive_ip.u4_vbv_buf_size = ps_app_ctxt->u4_vbv_buf_size;
1257 s_vbv_ip.s_ive_ip.u4_vbv_buffer_delay =
1258 ps_app_ctxt->u4_vbv_buffer_delay;
1259
1260 s_vbv_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1261 s_vbv_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1262
1263 s_vbv_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_vbv_params_ip_t);
1264 s_vbv_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_vbv_params_op_t);
1265
1266 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_vbv_ip,&s_vbv_op);
1267 if(status != IV_SUCCESS)
1268 {
1269 CHAR ac_error[STRLENGTH];
1270 sprintf(ac_error, "Unable to set VBC params = 0x%x\n",
1271 s_vbv_op.s_ive_op.u4_error_code);
1272 codec_exit(ac_error);
1273 }
1274 return;
1275 }
1276
set_air_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1277 void set_air_params(app_ctxt_t *ps_app_ctxt,
1278 UWORD32 u4_timestamp_low,
1279 UWORD32 u4_timestamp_high)
1280 {
1281 ih264e_ctl_set_air_params_ip_t s_air_ip;
1282 ih264e_ctl_set_air_params_op_t s_air_op;
1283 IV_STATUS_T status;
1284
1285 s_air_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1286 s_air_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_AIR_PARAMS;
1287
1288 s_air_ip.s_ive_ip.e_air_mode = ps_app_ctxt->u4_air;
1289 s_air_ip.s_ive_ip.u4_air_refresh_period = ps_app_ctxt->u4_air_refresh_period;
1290
1291 s_air_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1292 s_air_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1293
1294 s_air_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_air_params_ip_t);
1295 s_air_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_air_params_op_t);
1296
1297 status = ih264e_api_function(ps_app_ctxt->ps_enc,&s_air_ip,&s_air_op);
1298 if(status != IV_SUCCESS)
1299 {
1300 CHAR ac_error[STRLENGTH];
1301 sprintf(ac_error, "Unable to set air params = 0x%x\n",
1302 s_air_op.s_ive_op.u4_error_code);
1303 codec_exit(ac_error);
1304 }
1305 return;
1306 }
1307
set_me_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1308 void set_me_params(app_ctxt_t *ps_app_ctxt,
1309 UWORD32 u4_timestamp_low,
1310 UWORD32 u4_timestamp_high)
1311 {
1312 IV_STATUS_T status;
1313
1314 ih264e_ctl_set_me_params_ip_t s_me_params_ip;
1315 ih264e_ctl_set_me_params_op_t s_me_params_op;
1316
1317 s_me_params_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1318 s_me_params_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_ME_PARAMS;
1319
1320 s_me_params_ip.s_ive_ip.u4_enable_fast_sad = ps_app_ctxt->u4_enable_fast_sad;
1321 s_me_params_ip.s_ive_ip.u4_enable_alt_ref = ps_app_ctxt->u4_enable_alt_ref;
1322
1323 s_me_params_ip.s_ive_ip.u4_enable_hpel = ps_app_ctxt->u4_hpel;
1324 s_me_params_ip.s_ive_ip.u4_enable_qpel = ps_app_ctxt->u4_qpel;
1325 s_me_params_ip.s_ive_ip.u4_me_speed_preset = ps_app_ctxt->u4_me_speed;
1326 s_me_params_ip.s_ive_ip.u4_srch_rng_x = ps_app_ctxt->u4_srch_rng_x;
1327 s_me_params_ip.s_ive_ip.u4_srch_rng_y = ps_app_ctxt->u4_srch_rng_y;
1328
1329 s_me_params_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1330 s_me_params_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1331
1332 s_me_params_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_me_params_ip_t);
1333 s_me_params_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_me_params_op_t);
1334
1335 status = ih264e_api_function(ps_app_ctxt->ps_enc, &s_me_params_ip,
1336 &s_me_params_op);
1337 if(status != IV_SUCCESS)
1338 {
1339 CHAR ac_error[STRLENGTH];
1340 sprintf(ac_error, "Unable to set me params = 0x%x\n",
1341 s_me_params_op.s_ive_op.u4_error_code);
1342 codec_exit(ac_error);
1343 }
1344 return;
1345 }
1346
1347
set_gop_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1348 void set_gop_params(app_ctxt_t *ps_app_ctxt,
1349 UWORD32 u4_timestamp_low,
1350 UWORD32 u4_timestamp_high)
1351 {
1352 IV_STATUS_T status;
1353
1354 ih264e_ctl_set_gop_params_ip_t s_gop_params_ip;
1355 ih264e_ctl_set_gop_params_op_t s_gop_params_op;
1356
1357 s_gop_params_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1358 s_gop_params_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_GOP_PARAMS;
1359
1360 s_gop_params_ip.s_ive_ip.u4_i_frm_interval = ps_app_ctxt->u4_i_interval;
1361 s_gop_params_ip.s_ive_ip.u4_idr_frm_interval = ps_app_ctxt->u4_idr_interval;
1362
1363 s_gop_params_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1364 s_gop_params_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1365
1366 s_gop_params_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_gop_params_ip_t);
1367 s_gop_params_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_gop_params_op_t);
1368
1369 status = ih264e_api_function(ps_app_ctxt->ps_enc, &s_gop_params_ip,
1370 &s_gop_params_op);
1371 if(status != IV_SUCCESS)
1372 {
1373 CHAR ac_error[STRLENGTH];
1374 sprintf(ac_error, "Unable to set ME params = 0x%x\n",
1375 s_gop_params_op.s_ive_op.u4_error_code);
1376 codec_exit(ac_error);
1377 }
1378 return;
1379 }
1380
set_profile_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1381 void set_profile_params(app_ctxt_t *ps_app_ctxt,
1382 UWORD32 u4_timestamp_low,
1383 UWORD32 u4_timestamp_high)
1384 {
1385 IV_STATUS_T status;
1386
1387 ih264e_ctl_set_profile_params_ip_t s_profile_params_ip;
1388 ih264e_ctl_set_profile_params_op_t s_profile_params_op;
1389
1390 s_profile_params_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1391 s_profile_params_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_PROFILE_PARAMS;
1392
1393 s_profile_params_ip.s_ive_ip.e_profile = ps_app_ctxt->e_profile;
1394
1395 s_profile_params_ip.s_ive_ip.u4_entropy_coding_mode = ps_app_ctxt->u4_entropy_coding_mode;
1396
1397 s_profile_params_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1398 s_profile_params_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1399
1400 s_profile_params_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_profile_params_ip_t);
1401 s_profile_params_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_profile_params_op_t);
1402
1403 status = ih264e_api_function(ps_app_ctxt->ps_enc, &s_profile_params_ip,
1404 &s_profile_params_op);
1405 if(status != IV_SUCCESS)
1406 {
1407 CHAR ac_error[STRLENGTH];
1408 sprintf(ac_error, "Unable to set profile params = 0x%x\n",
1409 s_profile_params_op.s_ive_op.u4_error_code);
1410 codec_exit(ac_error);
1411 }
1412 return;
1413 }
1414
set_deblock_params(app_ctxt_t * ps_app_ctxt,UWORD32 u4_timestamp_low,UWORD32 u4_timestamp_high)1415 void set_deblock_params(app_ctxt_t *ps_app_ctxt,
1416 UWORD32 u4_timestamp_low,
1417 UWORD32 u4_timestamp_high)
1418 {
1419 IV_STATUS_T status;
1420
1421 ih264e_ctl_set_deblock_params_ip_t s_deblock_params_ip;
1422 ih264e_ctl_set_deblock_params_op_t s_deblock_params_op;
1423
1424 s_deblock_params_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1425 s_deblock_params_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_DEBLOCK_PARAMS;
1426
1427 s_deblock_params_ip.s_ive_ip.u4_disable_deblock_level =
1428 ps_app_ctxt->u4_disable_deblk_level;
1429
1430 s_deblock_params_ip.s_ive_ip.u4_timestamp_high = u4_timestamp_high;
1431 s_deblock_params_ip.s_ive_ip.u4_timestamp_low = u4_timestamp_low;
1432
1433 s_deblock_params_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_deblock_params_ip_t);
1434 s_deblock_params_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_deblock_params_op_t);
1435
1436 status = ih264e_api_function(ps_app_ctxt->ps_enc, &s_deblock_params_ip,
1437 &s_deblock_params_op);
1438 if(status != IV_SUCCESS)
1439 {
1440 CHAR ac_error[STRLENGTH];
1441 sprintf(ac_error, "Unable to enable/disable deblock params = 0x%x\n",
1442 s_deblock_params_op.s_ive_op.u4_error_code);
1443 codec_exit(ac_error);
1444 }
1445 return;
1446 }
1447
1448
set_vui_params(app_ctxt_t * ps_app_ctxt)1449 void set_vui_params(app_ctxt_t *ps_app_ctxt)
1450 {
1451 IV_STATUS_T status;
1452
1453 ih264e_vui_ip_t s_vui_params_ip;
1454 ih264e_vui_op_t s_vui_params_op;
1455
1456 s_vui_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1457 s_vui_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_VUI_PARAMS;
1458
1459 s_vui_params_ip.u1_aspect_ratio_info_present_flag = 0;
1460 s_vui_params_ip.u1_aspect_ratio_idc = 0;
1461 s_vui_params_ip.u2_sar_width = 0;
1462 s_vui_params_ip.u2_sar_height = 0;
1463 s_vui_params_ip.u1_overscan_info_present_flag = 0;
1464 s_vui_params_ip.u1_overscan_appropriate_flag = 0;
1465 s_vui_params_ip.u1_video_signal_type_present_flag = 0;
1466 s_vui_params_ip.u1_video_format = 0;
1467 s_vui_params_ip.u1_video_full_range_flag = 0;
1468 s_vui_params_ip.u1_colour_description_present_flag = 0;
1469 s_vui_params_ip.u1_colour_primaries = 0;
1470 s_vui_params_ip.u1_transfer_characteristics = 0;
1471 s_vui_params_ip.u1_matrix_coefficients = 0;
1472 s_vui_params_ip.u1_chroma_loc_info_present_flag = 0;
1473 s_vui_params_ip.u1_chroma_sample_loc_type_top_field = 0;
1474 s_vui_params_ip.u1_chroma_sample_loc_type_bottom_field = 0;
1475 s_vui_params_ip.u1_vui_timing_info_present_flag = 0;
1476 s_vui_params_ip.u4_vui_num_units_in_tick = 0;
1477 s_vui_params_ip.u4_vui_time_scale = 0;
1478 s_vui_params_ip.u1_fixed_frame_rate_flag = 0;
1479 s_vui_params_ip.u1_nal_hrd_parameters_present_flag = 0;
1480 s_vui_params_ip.u1_vcl_hrd_parameters_present_flag = 0;
1481 s_vui_params_ip.u1_low_delay_hrd_flag = 0;
1482 s_vui_params_ip.u1_pic_struct_present_flag = 0;
1483 s_vui_params_ip.u1_bitstream_restriction_flag = 0;
1484 s_vui_params_ip.u1_motion_vectors_over_pic_boundaries_flag = 0;
1485 s_vui_params_ip.u1_max_bytes_per_pic_denom = 0;
1486 s_vui_params_ip.u1_max_bits_per_mb_denom = 0;
1487 s_vui_params_ip.u1_log2_max_mv_length_horizontal = 0;
1488 s_vui_params_ip.u1_log2_max_mv_length_vertical = 0;
1489 s_vui_params_ip.u1_num_reorder_frames = 0;
1490 s_vui_params_ip.u1_max_dec_frame_buffering = 0;
1491
1492
1493 s_vui_params_ip.u4_size = sizeof(ih264e_vui_ip_t);
1494 s_vui_params_op.u4_size = sizeof(ih264e_vui_op_t);
1495
1496 status = ih264e_api_function(ps_app_ctxt->ps_enc, &s_vui_params_ip,
1497 &s_vui_params_op);
1498 if(status != IV_SUCCESS)
1499 {
1500 CHAR ac_error[STRLENGTH];
1501 sprintf(ac_error, "Unable to set vui params = 0x%x\n",
1502 s_vui_params_op.u4_error_code);
1503 codec_exit(ac_error);
1504 }
1505 return;
1506 }
1507 #define PEAK_WINDOW_SIZE 8
1508
synchronous_encode(iv_obj_t * ps_enc,app_ctxt_t * ps_app_ctxt)1509 void synchronous_encode(iv_obj_t *ps_enc, app_ctxt_t *ps_app_ctxt)
1510 {
1511 ih264e_video_encode_ip_t ih264e_video_encode_ip;
1512 ih264e_video_encode_op_t ih264e_video_encode_op;
1513
1514 ive_video_encode_ip_t *ps_video_encode_ip = &ih264e_video_encode_ip.s_ive_ip;
1515 ive_video_encode_op_t *ps_video_encode_op = &ih264e_video_encode_op.s_ive_op;
1516
1517 iv_raw_buf_t *ps_inp_raw_buf = &ps_video_encode_ip->s_inp_buf;
1518
1519 IV_STATUS_T status = IV_SUCCESS;
1520
1521 WORD32 i, is_last = 0, buff_size = 0, num_bytes = 0;
1522 UWORD32 u4_total_time = 0;
1523 UWORD8 *pu1_buf = NULL;
1524 UWORD32 u4_timestamp_low, u4_timestamp_high;
1525 void *pv_mb_info = NULL, *pv_pic_info = NULL;
1526
1527 TIMER curtime ;
1528 #ifdef WINDOWS_TIMER
1529 TIMER frequency;
1530 #endif
1531 WORD32 peak_window[PEAK_WINDOW_SIZE] = {0};
1532 WORD32 peak_window_idx = 0;
1533 WORD32 peak_avg_max = 0, timetaken = 0;
1534 iv_raw_buf_t s_inp_buf, s_recon_buf;
1535 CHAR ac_error[STRLENGTH];
1536 WORD32 end_of_frames=0;
1537 WORD32 i4_inp_done =0;
1538
1539 u4_timestamp_low = 0;
1540 u4_timestamp_high = 0;
1541
1542 /*************************************************************************/
1543 /* Allocate I/O Buffers */
1544 /*************************************************************************/
1545 allocate_input(ps_app_ctxt);
1546 allocate_output(ps_app_ctxt);
1547 allocate_recon(ps_app_ctxt);
1548
1549 /* init psnr */
1550 init_psnr(ps_app_ctxt);
1551
1552 /* open file pointers */
1553 ps_app_ctxt->fp_ip = fopen(ps_app_ctxt->ac_ip_fname, "rb");
1554 if(NULL == ps_app_ctxt->fp_ip)
1555 {
1556 sprintf(ac_error, "Unable to open input file for reading: %s", ps_app_ctxt->ac_ip_fname);
1557 invalid_argument_exit(ac_error);
1558 }
1559
1560 ps_app_ctxt->fp_op = fopen(ps_app_ctxt->ac_op_fname, "wb");
1561 if(NULL == ps_app_ctxt->fp_op)
1562 {
1563 sprintf(ac_error, "Unable to open output file for writing: %s", ps_app_ctxt->ac_op_fname);
1564 invalid_argument_exit(ac_error);
1565 }
1566
1567 if(1 == ps_app_ctxt->u4_recon_enable)
1568 {
1569 ps_app_ctxt->fp_recon = fopen(ps_app_ctxt->ac_recon_fname, "wb");
1570 if(NULL == ps_app_ctxt->fp_recon)
1571 {
1572 sprintf(ac_error, "Unable to open recon file for writing: %s", ps_app_ctxt->ac_recon_fname);
1573 invalid_argument_exit(ac_error);
1574 }
1575 }
1576
1577 if(1 == ps_app_ctxt->u4_chksum_enable)
1578 {
1579 ps_app_ctxt->fp_chksum = fopen(ps_app_ctxt->ac_chksum_fname, "wb");
1580 if(NULL == ps_app_ctxt->fp_chksum)
1581 {
1582 sprintf(ac_error, "Unable to open checksum file for writing: %s", ps_app_ctxt->ac_chksum_fname);
1583 invalid_argument_exit(ac_error);
1584 }
1585 }
1586
1587 /* If PSNR is enabled, open input file again and hold a different file pointer
1588 * This makes it easy to compute PSNR without adding dependency between input and recon threads
1589 */
1590 if(1 == ps_app_ctxt->u4_psnr_enable)
1591 {
1592 ps_app_ctxt->fp_psnr_ip = fopen(ps_app_ctxt->ac_ip_fname, "rb");
1593 if(NULL == ps_app_ctxt->fp_psnr_ip)
1594 {
1595 sprintf(ac_error, "Unable to open input file for reading: %s", ps_app_ctxt->ac_ip_fname);
1596 invalid_argument_exit(ac_error);
1597 }
1598 }
1599
1600 if(0 != ps_app_ctxt->u4_mb_info_type)
1601 {
1602 ps_app_ctxt->fp_mb_info = fopen(ps_app_ctxt->ac_mb_info_fname, "rb");
1603 if(NULL == ps_app_ctxt->fp_mb_info)
1604 {
1605 sprintf(ac_error, "Unable to open MB info file for reading: %s", ps_app_ctxt->ac_mb_info_fname);
1606 invalid_argument_exit(ac_error);
1607 }
1608 }
1609 if (ps_app_ctxt->u4_pic_info_type)
1610 {
1611 ps_app_ctxt->fp_pic_info = fopen(ps_app_ctxt->ac_pic_info_fname, "rb");
1612 if(NULL == ps_app_ctxt->fp_pic_info)
1613 {
1614 sprintf(ac_error, "Unable to open Pic info file for reading: %s", ps_app_ctxt->ac_pic_info_fname);
1615 invalid_argument_exit(ac_error);
1616 }
1617 }
1618
1619 GETTIME(&ps_app_ctxt->enc_start_time);
1620 ps_app_ctxt->enc_last_time = ps_app_ctxt->enc_start_time;
1621
1622 while(1)
1623 {
1624
1625 /******************************************************************************/
1626 /****************** Input Initialization **************************************/
1627 /******************************************************************************/
1628
1629 for(i = 0; i < DEFAULT_MAX_INPUT_BUFS; i++)
1630 {
1631 if(ps_app_ctxt->as_input_buf[i].u4_is_free)
1632 {
1633 pu1_buf = ps_app_ctxt->as_input_buf[i].pu1_buf;
1634 pv_mb_info = ps_app_ctxt->as_input_buf[i].pv_mb_info;
1635 pv_pic_info = ps_app_ctxt->as_input_buf[i].pv_pic_info;
1636 ps_app_ctxt->as_input_buf[i].u4_is_free = 0;
1637 break;
1638 }
1639 }
1640
1641 if (i == DEFAULT_MAX_INPUT_BUFS)
1642 {
1643 printf("\n Unable to find a free input buffer!!");
1644 exit(0);
1645 }
1646
1647 ps_video_encode_ip->u4_size = sizeof(ih264e_video_encode_ip_t);
1648 ps_video_encode_op->u4_size = sizeof(ih264e_video_encode_op_t);
1649
1650 ps_video_encode_ip->e_cmd = IVE_CMD_VIDEO_ENCODE;
1651 ps_video_encode_ip->pv_bufs = pu1_buf;
1652 ps_video_encode_ip->pv_mb_info = pv_mb_info;
1653 ps_video_encode_ip->pv_pic_info = pv_pic_info;
1654 ps_video_encode_ip->u4_pic_info_type = ps_app_ctxt->u4_pic_info_type;
1655 /*
1656 * Since the buffers are used for reading,
1657 * And after each row we have a stride we nned to calculate
1658 * the luma size according to the stride
1659 */
1660 ps_inp_raw_buf->e_color_fmt = ps_app_ctxt->e_inp_color_fmt;
1661
1662 /* Initialize for 420SP */
1663 if(IV_YUV_420SP_UV == ps_app_ctxt->e_inp_color_fmt||
1664 IV_YUV_420SP_VU == ps_app_ctxt->e_inp_color_fmt)
1665 {
1666 /*init luma buffer*/
1667 ps_inp_raw_buf->apv_bufs[0] = pu1_buf;
1668
1669 /*Init chroma buffer*/
1670 pu1_buf += ps_app_ctxt->u4_strd * ps_app_ctxt->u4_ht;
1671 ps_inp_raw_buf->apv_bufs[1] = pu1_buf;
1672
1673 ps_inp_raw_buf->au4_wd[0] = ps_app_ctxt->u4_wd;
1674 ps_inp_raw_buf->au4_wd[1] = ps_app_ctxt->u4_wd;
1675
1676 ps_inp_raw_buf->au4_ht[0] = ps_app_ctxt->u4_ht;
1677 ps_inp_raw_buf->au4_ht[1] = ps_app_ctxt->u4_ht / 2;
1678
1679 ps_inp_raw_buf->au4_strd[0] = ps_app_ctxt->u4_strd;
1680 ps_inp_raw_buf->au4_strd[1] = ps_app_ctxt->u4_strd;
1681 }
1682 else if(IV_YUV_420P == ps_app_ctxt->e_inp_color_fmt)
1683 {
1684 /* init buffers */
1685 ps_inp_raw_buf->apv_bufs[0] = pu1_buf;
1686 pu1_buf += (ps_app_ctxt->u4_wd) * ps_app_ctxt->u4_ht;
1687 ps_inp_raw_buf->apv_bufs[1] = pu1_buf;
1688 pu1_buf += (ps_app_ctxt->u4_wd >> 1) * (ps_app_ctxt->u4_ht >> 1);
1689 ps_inp_raw_buf->apv_bufs[2] = pu1_buf;
1690
1691 ps_inp_raw_buf->au4_wd[0] = ps_app_ctxt->u4_wd;
1692 ps_inp_raw_buf->au4_wd[1] = ps_app_ctxt->u4_wd / 2;
1693 ps_inp_raw_buf->au4_wd[2] = ps_app_ctxt->u4_wd / 2;
1694
1695 ps_inp_raw_buf->au4_ht[0] = ps_app_ctxt->u4_ht;
1696 ps_inp_raw_buf->au4_ht[1] = ps_app_ctxt->u4_ht / 2;
1697 ps_inp_raw_buf->au4_ht[2] = ps_app_ctxt->u4_ht / 2;
1698
1699 ps_inp_raw_buf->au4_strd[0] = ps_app_ctxt->u4_strd;
1700 ps_inp_raw_buf->au4_strd[1] = ps_app_ctxt->u4_strd / 2;
1701 ps_inp_raw_buf->au4_strd[2] = ps_app_ctxt->u4_strd / 2;
1702
1703 }
1704 else if(IV_YUV_422ILE == ps_app_ctxt->e_inp_color_fmt)
1705 {
1706 /*init luma buffer*/
1707 ps_inp_raw_buf->apv_bufs[0] = pu1_buf;
1708
1709 ps_inp_raw_buf->au4_wd[0] = ps_app_ctxt->u4_wd * 2;
1710
1711 ps_inp_raw_buf->au4_ht[0] = ps_app_ctxt->u4_ht;
1712
1713 ps_inp_raw_buf->au4_strd[0] = ps_app_ctxt->u4_strd *2;
1714 }
1715
1716 /*
1717 * Here we read input and other associated buffers. Regardless of success
1718 * we will proceed from here as we will need extra calls to flush out
1719 * input queue in encoder. Note that this is not necessary. You can just
1720 * send encode calls till with valid output and recon buffers till the
1721 * queue is flushed.
1722 */
1723 while(1)
1724 {
1725 IV_STATUS_T mb_info_status = IV_SUCCESS, pic_info_status = IV_SUCCESS;
1726
1727 status = read_input(ps_app_ctxt->fp_ip, ps_inp_raw_buf);
1728
1729 if (ps_app_ctxt->u4_mb_info_type != 0)
1730 {
1731 mb_info_status = read_mb_info(ps_app_ctxt, pv_mb_info);
1732 }
1733 if (ps_app_ctxt->u4_pic_info_type != 0)
1734 {
1735 pic_info_status = read_pic_info(ps_app_ctxt, pv_pic_info);
1736 }
1737 if((IV_SUCCESS != status) || (IV_SUCCESS != mb_info_status)
1738 || (IV_SUCCESS != pic_info_status))
1739 {
1740 if(0 == ps_app_ctxt->u4_loopback)
1741 {
1742 is_last = 1;
1743 break;
1744 }
1745 else
1746 fseek(ps_app_ctxt->fp_ip, 0, SEEK_SET);
1747 }
1748 break;
1749 }
1750
1751 /******************************************************************************/
1752 /****************** Output Initialization *************************************/
1753 /******************************************************************************/
1754
1755 for(i = 0; i < DEFAULT_MAX_OUTPUT_BUFS; i++)
1756 {
1757 if(ps_app_ctxt->as_output_buf[i].u4_is_free)
1758 {
1759 pu1_buf = ps_app_ctxt->as_output_buf[i].pu1_buf;
1760 buff_size = ps_app_ctxt->as_output_buf[i].u4_buf_size;
1761 ps_app_ctxt->as_output_buf[i].u4_is_free = 0;
1762 break;
1763 }
1764 }
1765 ps_video_encode_ip->s_out_buf.pv_buf = pu1_buf;
1766 ps_video_encode_ip->s_out_buf.u4_bytes = 0;
1767 ps_video_encode_ip->s_out_buf.u4_bufsize = buff_size;
1768
1769 /******************************************************************************/
1770 /****************** Recon Initialization **************************************/
1771 /******************************************************************************/
1772 init_raw_buf_descr(ps_app_ctxt, &s_recon_buf, ps_app_ctxt->as_recon_buf[0].pu1_buf, ps_app_ctxt->e_recon_color_fmt);
1773
1774 if(ps_app_ctxt->u4_psnr_enable)
1775 init_raw_buf_descr(ps_app_ctxt, &s_inp_buf, ps_app_ctxt->pu1_psnr_buf, ps_app_ctxt->e_inp_color_fmt);
1776
1777 ps_video_encode_ip->s_recon_buf = s_recon_buf;
1778
1779 /******************************************************************************/
1780 /************************* Un Initialized *************************************/
1781 /******************************************************************************/
1782 if(0 == ps_app_ctxt->u4_loopback)
1783 {
1784 /* If input file is read completely and loopback is not enabled,
1785 * then exit the loop */
1786 if(feof(ps_app_ctxt->fp_ip))
1787 {
1788 is_last = 1;
1789 }
1790 }
1791
1792
1793 /* If last frame, send input null to get back encoded frames */
1794 if ( is_last == 1 || ((ps_app_ctxt->u4_max_num_frms) <= u4_timestamp_low) )
1795 {
1796 is_last = 1;
1797 ps_inp_raw_buf->apv_bufs[0] = NULL;
1798 ps_inp_raw_buf->apv_bufs[1] = NULL;
1799 ps_inp_raw_buf->apv_bufs[2] = NULL;
1800 }
1801
1802 ps_video_encode_ip->u4_is_last = is_last;
1803 ps_video_encode_ip->u4_mb_info_type = ps_app_ctxt->u4_mb_info_type;
1804 ps_video_encode_ip->u4_pic_info_type = ps_app_ctxt->u4_pic_info_type;;
1805 ps_video_encode_op->s_out_buf.pv_buf= NULL;
1806 ps_video_encode_ip->u4_timestamp_high = u4_timestamp_high;
1807 ps_video_encode_ip->u4_timestamp_low = u4_timestamp_low;
1808
1809
1810 GETTIME(&ps_app_ctxt->enc_last_time);
1811
1812 status = ih264e_api_function(ps_enc, &ih264e_video_encode_ip, &ih264e_video_encode_op);
1813
1814 if (IV_SUCCESS != status)
1815 {
1816 printf("Encode Frame failed = 0x%x\n", ih264e_video_encode_op.s_ive_op.u4_error_code);
1817 break;
1818 }
1819
1820 #ifdef WINDOWS_TIMER
1821 QueryPerformanceFrequency ( &frequency);
1822 #endif
1823 GETTIME(&curtime);
1824 ELAPSEDTIME(ps_app_ctxt->enc_last_time, curtime, timetaken, frequency);
1825 ps_app_ctxt->enc_last_time = curtime;
1826
1827 #ifdef PROFILE_ENABLE
1828 {
1829 WORD32 peak_avg, id;
1830 u4_total_time += timetaken;
1831 peak_window[peak_window_idx++] = timetaken;
1832 if(peak_window_idx == PEAK_WINDOW_SIZE)
1833 peak_window_idx = 0;
1834 peak_avg = 0;
1835 for(id = 0; id < PEAK_WINDOW_SIZE; id++)
1836 {
1837 peak_avg += peak_window[id];
1838 }
1839 peak_avg /= PEAK_WINDOW_SIZE;
1840 if (peak_avg > peak_avg_max)
1841 peak_avg_max = peak_avg;
1842 }
1843 #endif
1844
1845 /******************************************************************************/
1846 /****************** Writing Output ********************************************/
1847 /******************************************************************************/
1848 num_bytes = 0;
1849
1850 if(1 == ps_video_encode_op->output_present)
1851 {
1852 num_bytes = ps_video_encode_op->s_out_buf.u4_bytes;
1853 buff_size = ps_video_encode_op->s_out_buf.u4_bufsize;
1854 pu1_buf = (UWORD8*)ps_video_encode_op->s_out_buf.pv_buf;
1855
1856 status = write_output(ps_app_ctxt->fp_op, pu1_buf, num_bytes);
1857 if(IV_SUCCESS != status)
1858 {
1859 printf("Error: Unable to write to output file\n");
1860 break;
1861 }
1862 }
1863
1864 /* free input bufer if codec returns a valid input buffer */
1865 if (ps_video_encode_op->s_inp_buf.apv_bufs[0])
1866 {
1867 /* Reuse of freed input buffer */
1868 for(i = 0; i < DEFAULT_MAX_INPUT_BUFS; i++)
1869 {
1870 if(ps_app_ctxt->as_input_buf[i].pu1_buf == ps_video_encode_op->s_inp_buf.apv_bufs[0])
1871 {
1872 ps_app_ctxt->as_input_buf[i].u4_is_free = 1;
1873 break;
1874 }
1875 }
1876 }
1877
1878 /* free output buffer if codec returns a valid output buffer */
1879 // if(ps_video_encode_op->s_out_buf.pv_buf)
1880 {
1881 for(i = 0; i < DEFAULT_MAX_OUTPUT_BUFS; i++)
1882 {
1883 if(ps_app_ctxt->as_output_buf[i].pu1_buf == ps_video_encode_op->s_out_buf.pv_buf)
1884 {
1885 ps_app_ctxt->as_output_buf[i].u4_is_free = 1;
1886 break;
1887 }
1888 }
1889 }
1890
1891 /**********************************************************************
1892 * Print stats
1893 **********************************************************************/
1894 {
1895 UWORD8 u1_pic_type[][5] =
1896 { "IDR", "I", "P", "B", "NA" };
1897 WORD32 lookup_idx = 0;
1898
1899 if (ih264e_video_encode_op.s_ive_op.u4_encoded_frame_type
1900 == IV_IDR_FRAME)
1901 {
1902 lookup_idx = 0;
1903 }
1904 else if(ih264e_video_encode_op.s_ive_op.u4_encoded_frame_type
1905 == IV_I_FRAME)
1906 {
1907 lookup_idx = 1;
1908 }
1909 else if(ih264e_video_encode_op.s_ive_op.u4_encoded_frame_type
1910 == IV_P_FRAME)
1911 {
1912 lookup_idx = 2;
1913 }
1914 else if(ih264e_video_encode_op.s_ive_op.u4_encoded_frame_type
1915 == IV_B_FRAME)
1916 {
1917 lookup_idx = 3;
1918 }
1919 else if(ih264e_video_encode_op.s_ive_op.u4_encoded_frame_type
1920 == IV_NA_FRAME)
1921 {
1922 lookup_idx = 4;
1923 }
1924
1925 if (ih264e_video_encode_op.s_ive_op.u4_encoded_frame_type
1926 != IV_NA_FRAME)
1927 {
1928 ps_app_ctxt->u4_pics_cnt++;
1929 ps_app_ctxt->avg_time = u4_total_time / ps_app_ctxt->u4_pics_cnt;
1930 ps_app_ctxt->u4_total_bytes += num_bytes;
1931 }
1932
1933 if (ps_app_ctxt->u4_psnr_enable == 0)
1934 {
1935 printf("[%s] PicNum %4d Bytes Generated %6d TimeTaken(microsec): %6d AvgTime: %6d PeakAvgTimeMax: %6d\n",
1936 u1_pic_type[lookup_idx], ps_app_ctxt->u4_pics_cnt,
1937 num_bytes, timetaken, ps_app_ctxt->avg_time,
1938 peak_avg_max);
1939 }
1940 }
1941
1942
1943 /* For psnr computation, we need to read the correct input frame and
1944 * compare with recon. The difficulty with doing it is that we only know
1945 * that the frame number of recon is monotonically increasing. There
1946 * may be gaps in the recon if any pre or post enc skip happens. There are
1947 * 3 senarios
1948 * 1) A frame is encoded -> returns the pic type
1949 * 2) A frame is not encoded -> Encoder is waiting, the frame may get
1950 * encoded later
1951 * 3) A frame is not encoded -> A post enc or pre enc skip happend. The
1952 * frame is not going to be encoded
1953 *
1954 * The 1st and 2nd scenarios are easy, since we just needs to increment
1955 * recon cnt whenever we get a valid recon. This cnt can we used to
1956 * sync the recon and input
1957 * 3rd scenario in conjuction with 2nd will pose problems. Even if
1958 * the returning frame is NA, we donot know we should increment the
1959 * recon cnt or not becasue it can be case 2 or case 3.
1960 *
1961 * Solutions:
1962 * -------------------------
1963 * One way to over come this will be to return more information as of
1964 * the frame type. We can send if a frame was skipped as a part of the
1965 * return frame type.
1966 * This will not work. Since the output and recon are not in sync, we
1967 * cannot use the current output frame type to determine if a recon
1968 * is present currently or not. We need some other way to acheive this.
1969 *
1970 * Other way to do this which is cleaner and maintains the seperation
1971 * between recon and the ouptut is to set the width [& height] of output recon
1972 * buffer to be zero. Hence we will in effect be saying :"look there
1973 * is a recon, but due to frame not being encoded it is having a width 0".
1974 * To be more clear we need to make height also to be zero.
1975 *
1976 * But are we using these variables for allocating and deallocating
1977 * the buffers some where ? No we are not. The buffer gets re-init
1978 * at every encode call
1979 *
1980 * Fixes
1981 * ------------------------
1982 * Currently the recon buff width and height are set in the encoder.
1983 * This will not work now because since recon and input are not
1984 * in sync. Hence a recon buff sent at time stamp x will get used to
1985 * fill recon of input at time stamp y (x > y). If we reduced the
1986 * frame dimensions in between, the recon buffer will not have enough
1987 * space. Hence we need to set the with and height appropriatley inside
1988 * lib itself.
1989 */
1990
1991 if (ps_app_ctxt->u4_recon_enable || ps_app_ctxt->u4_chksum_enable
1992 || ps_app_ctxt->u4_psnr_enable)
1993 {
1994 if (ps_video_encode_op->dump_recon)
1995 {
1996 s_recon_buf = ps_video_encode_op->s_recon_buf;
1997
1998 /* Read input for psnr computuation */
1999 if (ps_app_ctxt->u4_psnr_enable)
2000 read_input(ps_app_ctxt->fp_psnr_ip, &s_inp_buf);
2001
2002 /* if we have a valid recon buffer do the assocated tasks */
2003 if (s_recon_buf.au4_wd[0])
2004 {
2005 /* Dump recon when enabled, and output bytes != 0 */
2006 if (ps_app_ctxt->u4_recon_enable)
2007 {
2008 status = write_recon(ps_app_ctxt->fp_recon, &s_recon_buf);
2009 if (IV_SUCCESS != status)
2010 {
2011 printf("Error: Unable to write to recon file\n");
2012 break;
2013 }
2014 }
2015
2016 if (ps_app_ctxt->u4_psnr_enable)
2017 {
2018 compute_psnr(ps_app_ctxt, &s_recon_buf, &s_inp_buf);
2019 }
2020
2021
2022 if (ps_app_ctxt->u4_chksum_enable)
2023 {
2024 WORD32 comp, num_comp = 2;
2025
2026 if (IV_YUV_420P == s_recon_buf.e_color_fmt)
2027 num_comp = 3;
2028
2029 for (comp = 0; comp < num_comp; comp++)
2030 {
2031 UWORD8 au1_chksum[16];
2032 calc_md5_cksum((UWORD8 *)s_recon_buf.apv_bufs[comp],
2033 s_recon_buf.au4_strd[comp],
2034 s_recon_buf.au4_wd[comp],
2035 s_recon_buf.au4_ht[comp],
2036 au1_chksum);
2037 fwrite(au1_chksum, sizeof(UWORD8), 16, ps_app_ctxt->fp_chksum);
2038 }
2039 }
2040 }
2041 }
2042 }
2043
2044 u4_timestamp_low++;
2045
2046 /* Break if all the encoded frames are taken from encoder */
2047 if (1 == ps_video_encode_op->u4_is_last)
2048 {
2049 break;
2050 }
2051 }
2052
2053 /* Pic count is 1 more than actual num frames encoded, because last call is to just get the output */
2054 ps_app_ctxt->u4_pics_cnt--;
2055
2056 if(ps_app_ctxt->u4_psnr_enable)
2057 {
2058 print_average_psnr(ps_app_ctxt);
2059 }
2060
2061 /* house keeping operations */
2062 fclose(ps_app_ctxt->fp_ip);
2063 fclose(ps_app_ctxt->fp_op);
2064 if(1 == ps_app_ctxt->u4_recon_enable)
2065 {
2066 fclose(ps_app_ctxt->fp_recon);
2067 }
2068 if(1 == ps_app_ctxt->u4_chksum_enable)
2069 {
2070 fclose(ps_app_ctxt->fp_chksum);
2071 }
2072 if(1 == ps_app_ctxt->u4_psnr_enable)
2073 {
2074 fclose(ps_app_ctxt->fp_psnr_ip);
2075 }
2076
2077 if(0 != ps_app_ctxt->u4_mb_info_type)
2078 {
2079 fclose(ps_app_ctxt->fp_mb_info);
2080 }
2081 if (ps_app_ctxt->u4_pic_info_type)
2082 {
2083 fclose(ps_app_ctxt->fp_pic_info);
2084 }
2085
2086 free_input(ps_app_ctxt);
2087 free_output(ps_app_ctxt);
2088 free_recon(ps_app_ctxt);
2089 }
2090
2091 /*****************************************************************************/
2092 /* */
2093 /* Function Name : main */
2094 /* */
2095 /* Description : Application to demonstrate codec API */
2096 /* */
2097 /* */
2098 /* Inputs : argc - Number of arguments */
2099 /* argv[] - Arguments */
2100 /* Globals : */
2101 /* Processing : Shows how to use create, process, control and delete */
2102 /* */
2103 /* Outputs : Codec output in a file */
2104 /* Returns : */
2105 /* */
2106 /* Issues : Assumes both PROFILE_ENABLE to be */
2107 /* defined for multithread decode-display working */
2108 /* */
2109 /* Revision History: */
2110 /* */
2111 /* DD MM YYYY Author(s) Changes */
2112 /* 20 11 2013 100189 Initial Version */
2113 /*****************************************************************************/
2114 #ifdef IOS
h264enc_main(char * homedir,char * documentdir,int screen_wd,int screen_ht)2115 int h264enc_main(char * homedir,char *documentdir, int screen_wd, int screen_ht)
2116 #else
2117 int main(int argc, char *argv[])
2118 #endif
2119 {
2120 /* Config Parameters for Encoding */
2121 app_ctxt_t s_app_ctxt;
2122
2123 /* error string */
2124 CHAR ac_error[STRLENGTH];
2125
2126 /* config file name */
2127 CHAR ac_cfg_fname[STRLENGTH];
2128
2129 /* error status */
2130 IV_STATUS_T status = IV_SUCCESS;
2131 #ifdef IOS
2132 /* temp var */
2133 CHAR filename_with_path[STRLENGTH];
2134 #endif
2135 WORD32 num_mem_recs;
2136 iv_obj_t *ps_enc;
2137 WORD32 i;
2138 FILE *fp_cfg = NULL;
2139
2140 #ifdef X86_MINGW
2141
2142 /* For getting printfs without any delay in eclipse */
2143 setvbuf(stdout, NULL, _IONBF, 0);
2144 setvbuf(stderr, NULL, _IONBF, 0);
2145
2146 #endif
2147
2148 init_default_params(&s_app_ctxt);
2149
2150 #ifndef IOS
2151
2152 /* Usage */
2153 if(argc < 2)
2154 {
2155 printf("Using enc.cfg as configuration file \n");
2156 strcpy(ac_cfg_fname, "enc.cfg");
2157 }
2158 else if(argc == 2)
2159 {
2160 if (!strcmp(argv[1], "--help"))
2161 {
2162 print_usage();
2163 exit(-1);
2164 }
2165 strcpy(ac_cfg_fname, argv[1]);
2166 }
2167
2168 #else
2169 strcpy(ac_cfg_fname, "test.cfg");
2170
2171 #endif
2172
2173 /*************************************************************************/
2174 /* Parse arguments */
2175 /*************************************************************************/
2176
2177 #ifndef IOS
2178
2179 /* Read command line arguments */
2180 if(argc > 2)
2181 {
2182 for(i = 1; i + 1 < argc; i += 2)
2183 {
2184 if(CONFIG == get_argument(argv[i]))
2185 {
2186 strcpy(ac_cfg_fname, argv[i + 1]);
2187 if((fp_cfg = fopen(ac_cfg_fname, "r")) == NULL)
2188 {
2189 sprintf(ac_error,
2190 "Could not open Configuration file %s",
2191 ac_cfg_fname);
2192 codec_exit(ac_error);
2193 }
2194 read_cfg_file(&s_app_ctxt, fp_cfg);
2195 fclose(fp_cfg);
2196 }
2197 else
2198 {
2199 parse_argument(&s_app_ctxt, argv[i], argv[i + 1]);
2200 }
2201 }
2202 }
2203 else
2204 {
2205 if((fp_cfg = fopen(ac_cfg_fname, "r")) == NULL)
2206 {
2207 sprintf(ac_error, "Could not open Configuration file %s",
2208 ac_cfg_fname);
2209 codec_exit(ac_error);
2210 }
2211 read_cfg_file(&s_app_ctxt, fp_cfg);
2212 fclose(fp_cfg);
2213 }
2214
2215 #else
2216
2217 sprintf(filename_with_path, "%s/%s", homedir, "enc.cfg");
2218 if((fp_cfg = fopen(filename_with_path, "r")) == NULL)
2219 {
2220 sprintf(ac_error, "Could not open Configuration file %s",
2221 ac_cfg_fname);
2222 codec_exit(ac_error);
2223
2224 }
2225 read_cfg_file(&s_app_ctxt, fp_cfg);
2226 fclose(fp_cfg);
2227
2228 #endif
2229
2230
2231 validate_params(&s_app_ctxt);
2232
2233
2234 /*************************************************************************/
2235 /* Getting Number of MemRecords */
2236 /*************************************************************************/
2237 {
2238 ih264e_num_mem_rec_ip_t s_num_mem_rec_ip;
2239 ih264e_num_mem_rec_op_t s_num_mem_rec_op;
2240
2241 s_num_mem_rec_ip.s_ive_ip.u4_size = sizeof(ih264e_num_mem_rec_ip_t);
2242 s_num_mem_rec_op.s_ive_op.u4_size = sizeof(ih264e_num_mem_rec_op_t);
2243
2244 s_num_mem_rec_ip.s_ive_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC;
2245
2246 status = ih264e_api_function(0, &s_num_mem_rec_ip, &s_num_mem_rec_op);
2247
2248 if(status != IV_SUCCESS)
2249 {
2250 sprintf(ac_error, "Get number of memory records failed = 0x%x\n", s_num_mem_rec_op.s_ive_op.u4_error_code);
2251 codec_exit(ac_error);
2252 }
2253
2254 s_app_ctxt.u4_num_mem_rec = num_mem_recs = s_num_mem_rec_op.s_ive_op.u4_num_mem_rec;
2255 }
2256
2257 /* Allocate array to hold memory records */
2258 s_app_ctxt.ps_mem_rec = (iv_mem_rec_t *) malloc(num_mem_recs * sizeof(iv_mem_rec_t));
2259 if(NULL == s_app_ctxt.ps_mem_rec)
2260 {
2261
2262 sprintf(ac_error, "Unable to allocate memory for hold memory records: Size %d", (WORD32)(num_mem_recs * sizeof(iv_mem_rec_t)));
2263 codec_exit(ac_error);
2264 }
2265
2266 {
2267 iv_mem_rec_t *ps_mem_rec;
2268 ps_mem_rec = s_app_ctxt.ps_mem_rec;
2269 for(i = 0; i < num_mem_recs; i++)
2270 {
2271 ps_mem_rec->u4_size = sizeof(iv_mem_rec_t);
2272 ps_mem_rec->pv_base = NULL;
2273 ps_mem_rec->u4_mem_size = 0;
2274 ps_mem_rec->u4_mem_alignment = 0;
2275 ps_mem_rec->e_mem_type = IV_NA_MEM_TYPE;
2276
2277 ps_mem_rec++;
2278 }
2279 }
2280
2281 /*************************************************************************/
2282 /* Getting MemRecords Attributes */
2283 /*************************************************************************/
2284 {
2285 ih264e_fill_mem_rec_ip_t s_fill_mem_rec_ip;
2286 ih264e_fill_mem_rec_op_t s_fill_mem_rec_op;
2287
2288 s_fill_mem_rec_ip.s_ive_ip.u4_size = sizeof(ih264e_fill_mem_rec_ip_t);
2289 s_fill_mem_rec_op.s_ive_op.u4_size = sizeof(ih264e_fill_mem_rec_op_t);
2290
2291 s_fill_mem_rec_ip.s_ive_ip.e_cmd = IV_CMD_FILL_NUM_MEM_REC;
2292 s_fill_mem_rec_ip.s_ive_ip.ps_mem_rec = s_app_ctxt.ps_mem_rec;
2293 s_fill_mem_rec_ip.s_ive_ip.u4_num_mem_rec = s_app_ctxt.u4_num_mem_rec;
2294 s_fill_mem_rec_ip.s_ive_ip.u4_max_wd = s_app_ctxt.u4_max_wd;
2295 s_fill_mem_rec_ip.s_ive_ip.u4_max_ht = s_app_ctxt.u4_max_ht;
2296 s_fill_mem_rec_ip.s_ive_ip.u4_max_level = s_app_ctxt.u4_max_level;
2297 s_fill_mem_rec_ip.s_ive_ip.e_color_format = DEFAULT_INP_COLOR_FMT;
2298 s_fill_mem_rec_ip.s_ive_ip.u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;
2299 s_fill_mem_rec_ip.s_ive_ip.u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;
2300 s_fill_mem_rec_ip.s_ive_ip.u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;
2301 s_fill_mem_rec_ip.s_ive_ip.u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;
2302
2303 status = ih264e_api_function(0, &s_fill_mem_rec_ip, &s_fill_mem_rec_op);
2304
2305 if(status != IV_SUCCESS)
2306 {
2307 sprintf(ac_error, "Fill memory records failed = 0x%x\n",
2308 s_fill_mem_rec_op.s_ive_op.u4_error_code);
2309 codec_exit(ac_error);
2310 }
2311 }
2312
2313 /*************************************************************************/
2314 /* Allocating Memory for Mem Records */
2315 /*************************************************************************/
2316 {
2317 WORD32 total_size;
2318 iv_mem_rec_t *ps_mem_rec;
2319 total_size = 0;
2320
2321 ps_mem_rec = s_app_ctxt.ps_mem_rec;
2322 for(i = 0; i < num_mem_recs; i++)
2323 {
2324 ps_mem_rec->pv_base = ih264a_aligned_malloc(ps_mem_rec->u4_mem_alignment,
2325 ps_mem_rec->u4_mem_size);
2326 if(ps_mem_rec->pv_base == NULL)
2327 {
2328 sprintf(ac_error, "Allocation failure for mem record id %d size %d\n",
2329 i, ps_mem_rec->u4_mem_size);
2330 codec_exit(ac_error);
2331 }
2332 total_size += ps_mem_rec->u4_mem_size;
2333
2334 ps_mem_rec++;
2335 }
2336 printf("\nTotal memory for codec %d\n", total_size);
2337 }
2338
2339
2340 /*************************************************************************/
2341 /* Codec Instance Creation */
2342 /*************************************************************************/
2343 {
2344 ih264e_init_ip_t s_init_ip;
2345 ih264e_init_op_t s_init_op;
2346
2347 ps_enc = s_app_ctxt.ps_mem_rec[0].pv_base;
2348 ps_enc->u4_size = sizeof(iv_obj_t);
2349 ps_enc->pv_fxns = ih264e_api_function;
2350 s_app_ctxt.ps_enc = ps_enc;
2351
2352 s_init_ip.s_ive_ip.u4_size = sizeof(ih264e_init_ip_t);
2353 s_init_op.s_ive_op.u4_size = sizeof(ih264e_init_op_t);
2354
2355 s_init_ip.s_ive_ip.e_cmd = IV_CMD_INIT;
2356 s_init_ip.s_ive_ip.u4_num_mem_rec = s_app_ctxt.u4_num_mem_rec;
2357 s_init_ip.s_ive_ip.ps_mem_rec = s_app_ctxt.ps_mem_rec;
2358 s_init_ip.s_ive_ip.u4_max_wd = s_app_ctxt.u4_max_wd;
2359 s_init_ip.s_ive_ip.u4_max_ht = s_app_ctxt.u4_max_ht;
2360 s_init_ip.s_ive_ip.u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;
2361 s_init_ip.s_ive_ip.u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;
2362 s_init_ip.s_ive_ip.u4_max_level = s_app_ctxt.u4_max_level;
2363 s_init_ip.s_ive_ip.e_inp_color_fmt = s_app_ctxt.e_inp_color_fmt;
2364 if(s_app_ctxt.u4_recon_enable || s_app_ctxt.u4_psnr_enable || s_app_ctxt.u4_chksum_enable)
2365 {
2366 s_init_ip.s_ive_ip.u4_enable_recon = 1;
2367 }
2368 else
2369 {
2370 s_init_ip.s_ive_ip.u4_enable_recon = 0;
2371 }
2372 s_init_ip.s_ive_ip.e_recon_color_fmt = s_app_ctxt.e_recon_color_fmt;
2373 s_init_ip.s_ive_ip.e_rc_mode = s_app_ctxt.u4_rc;
2374 s_init_ip.s_ive_ip.u4_max_framerate = s_app_ctxt.u4_max_frame_rate;
2375 s_init_ip.s_ive_ip.u4_max_bitrate = s_app_ctxt.u4_max_bitrate;
2376 s_init_ip.s_ive_ip.u4_num_bframes = s_app_ctxt.u4_num_bframes;
2377 s_init_ip.s_ive_ip.e_content_type = IV_PROGRESSIVE;
2378 s_init_ip.s_ive_ip.u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;
2379 s_init_ip.s_ive_ip.u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;
2380 s_init_ip.s_ive_ip.e_slice_mode = s_app_ctxt.u4_slice_mode;
2381 s_init_ip.s_ive_ip.u4_slice_param = s_app_ctxt.u4_slice_param;
2382 s_init_ip.s_ive_ip.e_arch = s_app_ctxt.e_arch;
2383 s_init_ip.s_ive_ip.e_soc = s_app_ctxt.e_soc;
2384
2385 status = ih264e_api_function(ps_enc, &s_init_ip, &s_init_op);
2386
2387 if(status != IV_SUCCESS)
2388 {
2389 sprintf(ac_error, "Init memory records failed = 0x%x\n",
2390 s_init_op.s_ive_op.u4_error_code);
2391 codec_exit(ac_error);
2392 }
2393 }
2394
2395 /*************************************************************************/
2396 /* set processor details */
2397 /*************************************************************************/
2398 {
2399 ih264e_ctl_set_num_cores_ip_t s_ctl_set_num_cores_ip;
2400 ih264e_ctl_set_num_cores_op_t s_ctl_set_num_cores_op;
2401 s_ctl_set_num_cores_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
2402 s_ctl_set_num_cores_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_SET_NUM_CORES;
2403 s_ctl_set_num_cores_ip.s_ive_ip.u4_num_cores = s_app_ctxt.u4_num_cores;
2404 s_ctl_set_num_cores_ip.s_ive_ip.u4_timestamp_high = 0;
2405 s_ctl_set_num_cores_ip.s_ive_ip.u4_timestamp_low = 0;
2406 s_ctl_set_num_cores_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_set_num_cores_ip_t);
2407
2408 s_ctl_set_num_cores_op.s_ive_op.u4_size = sizeof(ih264e_ctl_set_num_cores_op_t);
2409
2410 status = ih264e_api_function(ps_enc, (void *) &s_ctl_set_num_cores_ip,
2411 (void *) &s_ctl_set_num_cores_op);
2412 if(status != IV_SUCCESS)
2413 {
2414 sprintf(ac_error, "Unable to set processor params = 0x%x\n",
2415 s_ctl_set_num_cores_op.s_ive_op.u4_error_code);
2416 codec_exit(ac_error);
2417 }
2418
2419 }
2420
2421 /*************************************************************************/
2422 /* Get Codec Version */
2423 /*************************************************************************/
2424 {
2425 ih264e_ctl_getversioninfo_ip_t s_ctl_set_getversioninfo_ip;
2426 ih264e_ctl_getversioninfo_op_t s_ctl_set_getversioninfo_op;
2427 CHAR ac_version_string[STRLENGTH];
2428 s_ctl_set_getversioninfo_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
2429 s_ctl_set_getversioninfo_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_GETVERSION;
2430 s_ctl_set_getversioninfo_ip.s_ive_ip.pu1_version = (UWORD8 *)ac_version_string;
2431 s_ctl_set_getversioninfo_ip.s_ive_ip.u4_version_bufsize = sizeof(ac_version_string);
2432 s_ctl_set_getversioninfo_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_getversioninfo_ip_t);
2433 s_ctl_set_getversioninfo_op.s_ive_op.u4_size = sizeof(ih264e_ctl_getversioninfo_op_t);
2434
2435 status = ih264e_api_function(ps_enc, (void *) &s_ctl_set_getversioninfo_ip,
2436 (void *) &s_ctl_set_getversioninfo_op);
2437 if(status != IV_SUCCESS)
2438 {
2439 sprintf(ac_error, "Unable to get codec version = 0x%x\n",
2440 s_ctl_set_getversioninfo_op.s_ive_op.u4_error_code);
2441 codec_exit(ac_error);
2442 }
2443 printf("CODEC VERSION %s\n", ac_version_string);
2444 }
2445
2446 /*************************************************************************/
2447 /* Get I/O Buffer Requirement */
2448 /*************************************************************************/
2449 {
2450 ih264e_ctl_getbufinfo_ip_t s_get_buf_info_ip;
2451 ih264e_ctl_getbufinfo_op_t s_get_buf_info_op;
2452
2453 s_get_buf_info_ip.s_ive_ip.u4_size = sizeof(ih264e_ctl_getbufinfo_ip_t);
2454 s_get_buf_info_op.s_ive_op.u4_size = sizeof(ih264e_ctl_getbufinfo_op_t);
2455
2456 s_get_buf_info_ip.s_ive_ip.e_cmd = IVE_CMD_VIDEO_CTL;
2457 s_get_buf_info_ip.s_ive_ip.e_sub_cmd = IVE_CMD_CTL_GETBUFINFO;
2458 s_get_buf_info_ip.s_ive_ip.u4_max_ht = s_app_ctxt.u4_max_ht;
2459 s_get_buf_info_ip.s_ive_ip.u4_max_wd = s_app_ctxt.u4_max_wd;
2460 s_get_buf_info_ip.s_ive_ip.e_inp_color_fmt = s_app_ctxt.e_inp_color_fmt;
2461
2462 status = ih264e_api_function(ps_enc, &s_get_buf_info_ip, &s_get_buf_info_op);
2463
2464 if (status != IV_SUCCESS)
2465 {
2466 sprintf(ac_error, "Unable to get I/O buffer requirements = 0x%x\n",
2467 s_get_buf_info_op.s_ive_op.u4_error_code);
2468 codec_exit(ac_error);
2469 }
2470 s_app_ctxt.s_get_buf_info_op = s_get_buf_info_op;
2471 }
2472
2473 /*****************************************************************************/
2474 /* Add the following initializations based on the parameters in context */
2475 /*****************************************************************************/
2476
2477
2478 /*****************************************************************************/
2479 /* Video control Set Frame dimensions */
2480 /*****************************************************************************/
2481 s_app_ctxt.u4_strd = s_app_ctxt.u4_wd;
2482 set_dimensions(&s_app_ctxt, 0, 0);
2483
2484 /*****************************************************************************/
2485 /* Video control Set Frame rates */
2486 /*****************************************************************************/
2487 set_frame_rate(&s_app_ctxt, 0, 0);
2488
2489 /*****************************************************************************/
2490 /* Video control Set IPE Params */
2491 /*****************************************************************************/
2492 set_ipe_params(&s_app_ctxt, 0, 0);
2493
2494 /*****************************************************************************/
2495 /* Video control Set Bitrate */
2496 /*****************************************************************************/
2497 set_bit_rate(&s_app_ctxt, 0, 0);
2498
2499 /*****************************************************************************/
2500 /* Video control Set QP */
2501 /*****************************************************************************/
2502 set_qp(&s_app_ctxt,0,0);
2503
2504 /*****************************************************************************/
2505 /* Video control Set AIR params */
2506 /*****************************************************************************/
2507 set_air_params(&s_app_ctxt,0,0);
2508
2509 /*****************************************************************************/
2510 /* Video control Set VBV params */
2511 /*****************************************************************************/
2512 set_vbv_params(&s_app_ctxt,0,0);
2513
2514 /*****************************************************************************/
2515 /* Video control Set Motion estimation params */
2516 /*****************************************************************************/
2517 set_me_params(&s_app_ctxt,0,0);
2518
2519 /*****************************************************************************/
2520 /* Video control Set GOP params */
2521 /*****************************************************************************/
2522 set_gop_params(&s_app_ctxt, 0, 0);
2523
2524 /*****************************************************************************/
2525 /* Video control Set Deblock params */
2526 /*****************************************************************************/
2527 set_deblock_params(&s_app_ctxt, 0, 0);
2528
2529 /*****************************************************************************/
2530 /* Video control Set Profile params */
2531 /*****************************************************************************/
2532 set_profile_params(&s_app_ctxt, 0, 0);
2533
2534 /*****************************************************************************/
2535 /* Video control Set in Encode header mode */
2536 /*****************************************************************************/
2537 set_enc_mode(&s_app_ctxt, 0, 0, IVE_ENC_MODE_PICTURE);
2538
2539 /*****************************************************************************/
2540 /* Video usability information */
2541 /*****************************************************************************/
2542 set_vui_params(&s_app_ctxt);
2543
2544 #ifdef IOS
2545 /* Correct file paths */
2546 sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctxt.ac_ip_fname);
2547 strcpy (s_app_ctxt.ac_ip_fname, filename_with_path);
2548
2549 sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctxt.ac_op_fname);
2550 strcpy (s_app_ctxt.ac_op_fname, filename_with_path);
2551
2552 sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctxt.ac_recon_fname);
2553 strcpy (s_app_ctxt.ac_recon_fname, filename_with_path);
2554
2555 sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctxt.ac_chksum_fname);
2556 strcpy (s_app_ctxt.ac_chksum_fname, filename_with_path);
2557
2558 sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctxt.ac_mb_info_fname);
2559 strcpy (s_app_ctxt.ac_mb_info_fname, filename_with_path);
2560
2561 sprintf(filename_with_path, "%s/%s", documentdir, s_app_ctxt.ac_pic_info_fname);
2562 strcpy (s_app_ctxt.ac_pic_info_fname, filename_with_path);
2563 #endif
2564
2565 /*************************************************************************/
2566 /* begin encoding */
2567 /*************************************************************************/
2568
2569 synchronous_encode(ps_enc, &s_app_ctxt);
2570
2571 {
2572 DOUBLE bytes_per_frame;
2573 DOUBLE bytes_per_second;
2574 WORD32 achieved_bitrate;
2575
2576 if(s_app_ctxt.u4_pics_cnt != 0)
2577 {
2578 bytes_per_frame = (s_app_ctxt.u4_total_bytes) / (s_app_ctxt.u4_pics_cnt);
2579 }
2580 else
2581 {
2582 bytes_per_frame = 0;
2583 }
2584 bytes_per_second = (bytes_per_frame * s_app_ctxt.u4_tgt_frame_rate);
2585
2586 achieved_bitrate = bytes_per_second * 8;
2587
2588 printf("\nEncoding Completed\n");
2589 printf("Summary\n");
2590 printf("Input filename : %s\n", s_app_ctxt.ac_ip_fname);
2591 printf("Output filename : %s\n", s_app_ctxt.ac_op_fname);
2592 printf("Output Width : %-4d\n", s_app_ctxt.u4_wd);
2593 printf("Output Height : %-4d\n", s_app_ctxt.u4_ht);
2594 printf("Target Bitrate (bps) : %-4d\n", s_app_ctxt.u4_bitrate);
2595 printf("Achieved Bitrate (bps) : %-4d\n", achieved_bitrate);
2596 printf("Average Time per Frame : %-4d\n", s_app_ctxt.avg_time);
2597 printf("Achieved FPS : %-4.2f\n", 1000000.0 / s_app_ctxt.avg_time);
2598 }
2599
2600
2601 /*************************************************************************/
2602 /* Close Codec Instance */
2603 /*************************************************************************/
2604 {
2605 ih264e_retrieve_mem_rec_ip_t s_retrieve_mem_ip;
2606 ih264e_retrieve_mem_rec_op_t s_retrieve_mem_op;
2607 iv_mem_rec_t *ps_mem_rec;
2608 s_retrieve_mem_ip.s_ive_ip.u4_size =
2609 sizeof(ih264e_retrieve_mem_rec_ip_t);
2610 s_retrieve_mem_op.s_ive_op.u4_size =
2611 sizeof(ih264e_retrieve_mem_rec_op_t);
2612
2613 s_retrieve_mem_ip.s_ive_ip.e_cmd = IV_CMD_RETRIEVE_MEMREC;
2614 s_retrieve_mem_ip.s_ive_ip.ps_mem_rec = s_app_ctxt.ps_mem_rec;
2615
2616 status = ih264e_api_function(ps_enc, &s_retrieve_mem_ip,
2617 &s_retrieve_mem_op);
2618
2619 if(status != IV_SUCCESS)
2620 {
2621 sprintf(ac_error, "Unable to retrieve memory records = 0x%x\n",
2622 s_retrieve_mem_op.s_ive_op.u4_error_code);
2623 codec_exit(ac_error);
2624 }
2625
2626 /* Free memory records */
2627 ps_mem_rec = s_app_ctxt.ps_mem_rec;
2628 for(i = 0; i < num_mem_recs; i++)
2629 {
2630 ih264a_aligned_free(ps_mem_rec->pv_base);
2631 ps_mem_rec++;
2632 }
2633
2634 free(s_app_ctxt.ps_mem_rec);
2635
2636 }
2637
2638 return 0;
2639 }
2640
2641
2642 #ifdef ANDROID_NDK
raise(int a)2643 int raise(int a)
2644 {
2645 printf("Divide by zero\n");
2646 return 0;
2647 }
__aeabi_assert(const char * assertion,const char * file,unsigned int line)2648 void __aeabi_assert(const char *assertion, const char *file, unsigned int line)
2649 {
2650 return;
2651 }
2652 #endif
2653