1 /*
2 * Copyright (c) 2013, Texas Instruments Incorporated
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32 #include <stdlib.h>
33 #include <string.h>
34 #include <stdio.h>
35 #include <unistd.h>
36 #include <stdint.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <sys/time.h>
40 #include <fcntl.h>
41 #include <errno.h>
42 #include <time.h>
43 #include <sys/mman.h>
44 #include <signal.h>
47 #include <omap_drm.h>
48 #include <omap_drmif.h>
49 #include "libdce.h"
51 #include <ti/sdo/ce/Engine.h>
52 #include <ti/sdo/ce/video2/videnc2.h>
53 #include <ti/sdo/codecs/h264enc/ih264enc.h>
54 #include <ti/sdo/codecs/mpeg4enc/impeg4enc.h>
55 #include <ti/sdo/codecs/jpegvenc/ijpegenc.h>
58 //#define PRINT_DEBUG
60 #define ERROR(FMT, ...) printf("%s:%d:\t%s\terror: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
61 // enable below to print debug information
62 #ifdef PRINT_DEBUG
63 #define MSG(FMT, ...) printf("%s:%d:\t%s\tdebug: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
64 #else
65 #define MSG(FMT, ...)
66 #endif
67 #define INFO(FMT, ...) printf("%s:%d:\t%s\tinfo: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
68 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
70 /* align x to next highest multiple of 2^n */
71 #define ALIGN2(x, n) (((x) + ((1 << (n)) - 1)) & ~((1 << (n)) - 1))
73 // Profile the init and encode calls
74 //#define PROFILE_TIME
76 // Getting codec version through XDM_GETVERSION
77 #define GETVERSION
79 enum {
80 IVAHD_H264_ENCODE,
81 IVAHD_MPEG4_ENCODE,
82 IVAHD_H263_ENCODE,
83 IVAHD_JPEG_ENCODE
84 };
86 enum {
87 DCE_ENC_TEST_H264 = 1,
88 DCE_ENC_TEST_MPEG4 = 2,
89 DCE_ENC_TEST_H263 = 3,
90 DCE_ENC_TEST_JPEG = 4
91 };
93 enum {
94 MEMTYPE_INVALID = -1,
95 MEMTYPE_OMAPDRM = 0,
96 };
98 typedef struct _bufferDesc{
99 void *y_bo; //buffer object for y pointer
100 void *uv_bo; //buffer object for uv pointer
101 int fdy; // y dma buf
102 int fduv; // uv dma buf
103 int sizey; // size of y
104 int sizeuv; // size of uv
105 void *ybuff; // Virtual addresses of y
106 void *uvbuff; // virtual address of uv
107 }bufferdesc;
109 typedef struct encoderObj{
110 int drmfd; //DRM device fd
111 void *dev; // Device handle
112 char *in_pattern; //Input filename with full path
113 char *out_pattern; //Output filename with full path
114 FILE *fin; // Input stream
115 FILE *fout; // output stream
116 int width; //Frame width
117 int height; // Frame height
118 int codectype; // H264 or MPEG4 or H263
119 int profile;
120 int level;
121 int nframes; // Number of frames to write
122 int memtype; // Memory allocation scheme (OMAPDRM)
123 int fps; //Frame rate
124 int bps; //bitrate
125 bufferdesc buf; // Holds input buffer address
126 struct omap_bo *output_bo;
127 unsigned char *cdata;
128 struct omap_bo *mv_bo;
130 int padded_width;
131 int padded_height;
132 int num_buffers;
133 Engine_Handle engine;
134 VIDENC2_Handle codec;
135 VIDENC2_Params *params;
136 VIDENC2_DynamicParams *dynParams;
137 VIDENC2_Status *status;
138 VIDENC2_DynamicParams *dynParams1;
139 VIDENC2_Status *status1;
140 IVIDEO2_BufDesc *inBufs;
141 XDM2_BufDesc *outBufs;
142 VIDENC2_InArgs *inArgs;
143 VIDENC2_OutArgs *outArgs;
145 // H.264 specific
146 IH264ENC_InArgs *h264enc_inArgs;
147 IH264ENC_OutArgs *h264enc_outArgs;
148 IH264ENC_Params *h264enc_params;
149 IH264ENC_DynamicParams *h264enc_dynParams;
150 IH264ENC_Status *h264enc_status;
152 // MPEG4/H.263 specific
153 IMPEG4ENC_InArgs *mpeg4enc_inArgs;
154 IMPEG4ENC_OutArgs *mpeg4enc_outArgs;
155 IMPEG4ENC_Params *mpeg4enc_params;
156 IMPEG4ENC_DynamicParams *mpeg4enc_dynParams;
157 IMPEG4ENC_Status *mpeg4enc_status;
159 // JPEG specific
160 IJPEGVENC_InArgs *jpegenc_inArgs;
161 IJPEGVENC_OutArgs *jpegenc_outArgs;
162 IJPEGVENC_Params *jpegenc_params;
163 IJPEGVENC_DynamicParams *jpegenc_dynParams;
164 IJPEGVENC_Status *jpegenc_status;
166 }encoder;
167 /*
168 * A very simple VIDENC2 client which will encode raw (unstrided) NV12 YUV frames
169 * and write out to either h264, MPEG4, or H.263 format.
170 */
172 static int encoder_init(encoder *enc);
173 static int encoder_deinit(encoder *enc);
174 static void usage(char **argv);
177 static int read_NV12frame(encoder *enc)
178 {
179 int numbytes = 0;
180 if(!enc->fin){
181 enc->fin = fopen(enc->in_pattern, "r+");
182 if(!enc->fin){
183 ERROR("Could not open input file %s\n", enc->in_pattern);
184 goto bail;
185 }
186 }
187 numbytes = fread(enc->buf.ybuff, 1, enc->width * enc->height, enc->fin);
188 numbytes += fread(enc->buf.uvbuff, 1, (enc->width * enc->height) / 2, enc->fin);
190 return numbytes;
191 bail:
192 return -1;
193 }
196 /* helper to write one frame of output */
197 int write_output(encoder *enc, int bytesToWrite)
198 {
199 int nbytes = -1;
200 if(!enc->fout){
201 enc->fout = fopen(enc->out_pattern, "wb+");
202 if(!enc->fout){
203 ERROR("Could not open file for output %s", enc->out_pattern);
204 goto fail;
205 }
206 }
207 nbytes = fwrite(enc->cdata, 1, bytesToWrite, enc->fout);
208 return nbytes;
209 fail:
210 return -1;
211 }
214 static int parse_codecinfo(char *argv[], encoder *enc)
215 {
216 /*
217 * Configuration based on the input parameters
218 */
219 const char *argcodec = argv[8];
220 const char *profile = argv[9];
221 const char *level = argv[10];
223 enc->level = atoi(level);
224 if( (!(strcmp(argcodec, "h264"))) ) {
225 enc->codectype = DCE_ENC_TEST_H264;
226 if( (!(strcmp(profile, "baseline"))) ) {
227 enc->profile = IH264_BASELINE_PROFILE;
228 } else if( (!(strcmp(profile, "high"))) ) {
229 enc->profile = IH264_HIGH_PROFILE;
230 } else {
231 ERROR("Wrong profile value. Please use: baseline or high.\n");
232 usage(argv);
233 return -1;
234 }
236 switch(enc->level) {
237 case IH264_LEVEL_10 :
238 case IH264_LEVEL_1b :
239 case IH264_LEVEL_11 :
240 case IH264_LEVEL_12 :
241 case IH264_LEVEL_13 :
242 case IH264_LEVEL_20 :
243 case IH264_LEVEL_21 :
244 case IH264_LEVEL_22 :
245 case IH264_LEVEL_30 :
246 case IH264_LEVEL_31 :
247 case IH264_LEVEL_32 :
248 case IH264_LEVEL_40 :
249 case IH264_LEVEL_41 :
250 case IH264_LEVEL_42 :
251 case IH264_LEVEL_50 :
252 case IH264_LEVEL_51 :
253 MSG("Acceptable H.264 level value = %d\n", enc->level);
254 break;
255 default :
256 ERROR("Wrong level value. Please use the correct level value for H.264\n");
257 usage(argv);
258 return -1;
259 }
260 } else if( !(strcmp(argcodec, "mpeg4"))) {
262 enc->codectype = DCE_ENC_TEST_MPEG4;
264 if( (!(strcmp(profile, "simple"))) ) {
265 enc->profile = 3;
266 } else {
267 ERROR("Wrong profile value. Please use: simple\n");
268 usage(argv);
269 return -1;
270 }
272 switch(enc->level) {
273 case IMPEG4ENC_SP_LEVEL_0 :
274 case IMPEG4ENC_SP_LEVEL_0B :
275 case IMPEG4ENC_SP_LEVEL_1 :
276 case IMPEG4ENC_SP_LEVEL_2 :
277 case IMPEG4ENC_SP_LEVEL_3 :
278 case IMPEG4ENC_SP_LEVEL_4A :
279 case IMPEG4ENC_SP_LEVEL_5 :
280 case IMPEG4ENC_SP_LEVEL_6 :
281 MSG("Acceptable MPEG4 level value = %d\n", enc->level);
282 break;
283 default :
284 ERROR("Wrong level value. Please use the correct level value for MPEG4\n");
285 usage(argv);
286 return -1;
287 }
288 } else if( !(strcmp(argcodec, "h263"))) {
290 enc->codectype = DCE_ENC_TEST_H263;
292 if( (!(strcmp(profile, "simple"))) ) {
293 enc->profile = 3;
294 } else {
295 ERROR("Wrong profile value. Please use: simple\n");
296 usage(argv);
297 return -1;
298 }
300 switch(enc->level) {
301 case IMPEG4ENC_H263_LEVEL_10 :
302 case IMPEG4ENC_H263_LEVEL_20 :
303 case IMPEG4ENC_H263_LEVEL_30 :
304 case IMPEG4ENC_H263_LEVEL_40 :
305 case IMPEG4ENC_H263_LEVEL_45 :
306 case IMPEG4ENC_H263_LEVEL_50 :
307 case IMPEG4ENC_H263_LEVEL_60 :
308 case IMPEG4ENC_H263_LEVEL_70 :
309 MSG("Acceptable H263 level value = %d\n", enc->level);
310 break;
311 default :
312 ERROR("Wrong level value. Please use the correct level value for H263\n");
313 usage(argv);
314 return -1;
315 }
316 } else if( !(strcmp(argcodec, "jpeg"))) {
317 enc->codectype = DCE_ENC_TEST_JPEG;
318 } else {
319 ERROR("No valid codec entry. Please use: h264 or mpeg4 or h263\n");
320 usage(argv);
321 return -1;
322 }
323 MSG("Selected codec: %d\n", enc->codectype);
324 return 0;
325 }
328 static void usage(char **argv)
329 {
330 printf("usage: %s width height frames_to_write inpattern outpattern fps bitrate(kbps) codec baseline/high level buffertype\n", argv[0]);
331 printf("example: %s 1920 1088 300 in.yuv out.h264 15 128 h264 baseline 10 OMAPDRM\n", argv[0]);
332 printf("example: %s 176 144 300 in.yuv out.m4v 30 64 mpeg4 simple/baseline 0 OMAPDRM\n", argv[0]);
333 printf("example: %s 176 144 300 in.yuv out.m4v 15 150 h263 simple/baseline 0 OMAPDRM\n", argv[0]);
334 printf("example: %s 176 144 5 in.yuv out.mjpeg 30 5000 jpeg null 0 OMAPDRM\n", argv[0]);
335 printf("Currently supported codecs: h264 or mpeg4 or h263 or jpeg\n");
336 printf("Currently supported Buffertypes: OMAPDRM\n");
337 printf("Run this command for help on the use case:%s\n", argv[0]);
338 return;
339 }
340 static int parse_command(int argc, char *argv[], encoder *enc)
341 {
343 if( argc != 12 ) {
344 usage(argv);
345 return -1;
346 }
347 enc->width = atoi(argv[1]);
348 enc->height = atoi(argv[2]);
349 enc->nframes = atoi(argv[3]);
350 enc->in_pattern = argv[4];
351 enc->out_pattern = argv[5];
352 enc->fps = atoi(argv[6]);
353 enc->bps = atoi(argv[7]) * 1000;
354 if(parse_codecinfo(argv, enc))
355 return -1;
357 if(!strcmp(argv[11], "OMAPDRM")){
358 MSG("Only DRM buffer type supported.. Rolling back to OMAPDRM\n");
359 }
361 enc->memtype = MEMTYPE_OMAPDRM;
362 MSG("Selected buffer: %d\n", enc->memtype);
364 return 0;
365 }
368 static void init_common_static_params(encoder *enc)
369 {
370 VIDENC2_Params *params = enc->params;
371 params->encodingPreset = XDM_USER_DEFINED; //XDM_USER_DEFINED; //XDM_EncodingPreset
372 params->rateControlPreset = IVIDEO_USER_DEFINED;
373 params->maxHeight = enc->height;
374 params->maxWidth = enc->width;
375 params->dataEndianness = XDM_BYTE; //XDM_DataFormat
376 params->maxBitRate = -1; //IGNORED
377 params->minBitRate = 0;
378 params->inputChromaFormat = XDM_YUV_420SP; //XDM_ChromaFormat
379 params->inputContentType = IVIDEO_PROGRESSIVE; //IVIDEO_ContentType
380 params->operatingMode = IVIDEO_ENCODE_ONLY; //IVIDEO_OperatingMode
381 params->profile = enc->profile;
382 params->level = enc->level;
383 params->inputDataMode = IVIDEO_ENTIREFRAME; //IVIDEO_DataMode
384 params->outputDataMode = IVIDEO_ENTIREFRAME; //IVIDEO_DataMode
385 params->numInputDataUnits = 1;
386 params->numOutputDataUnits = 1;
387 params->metadataType[0] = IVIDEO_METADATAPLANE_NONE;
388 params->metadataType[1] = IVIDEO_METADATAPLANE_NONE;
389 params->metadataType[2] = IVIDEO_METADATAPLANE_NONE;
390 return;
391 }
393 static int init_h264_static_params(encoder *enc)
394 {
395 IH264ENC_Params *h264enc_params = NULL;
396 enc->inArgs = dce_alloc(sizeof(IH264ENC_InArgs));
397 if(!enc->inArgs) goto bail;
398 enc->inArgs->size = sizeof(IH264ENC_InArgs);
399 enc->outArgs = dce_alloc(sizeof(IH264ENC_OutArgs));
400 if(!enc->outArgs) goto bail;
401 enc->outArgs->size = sizeof(IH264ENC_OutArgs);
402 enc->h264enc_outArgs = (IH264ENC_OutArgs *) enc->outArgs;
403 enc->params = dce_alloc(sizeof(IH264ENC_Params));
404 if(!enc->params) goto bail;
405 enc->params->size = sizeof(IH264ENC_Params);
407 init_common_static_params(enc);
408 MSG("H.264 Encoding with profile_value %d level %d", enc->profile, enc->level);
409 enc->params->maxInterFrameInterval = 1; //1,31 if IVIDEO_ContentType is IVIDEO_PROGRESSIVE
410 //Miscellaneous
411 h264enc_params = enc->h264enc_params = (IH264ENC_Params *) enc->params;
412 h264enc_params->interlaceCodingType = IH264_INTERLACE_DEFAULT;
413 h264enc_params->bottomFieldIntra = 0;
414 h264enc_params->gopStructure = IH264ENC_GOPSTRUCTURE_DEFAULT; // IH264ENC_GOPSTRUCTURE_NONUNIFORM
415 h264enc_params->entropyCodingMode = IH264_ENTROPYCODING_DEFAULT; // IH264_ENTROPYCODING_CAVLC - BASE PROFILE
416 h264enc_params->transformBlockSize = IH264_TRANSFORM_4x4; // BASE PROFILE
417 h264enc_params->log2MaxFNumMinus4 = 10;
418 h264enc_params->picOrderCountType = IH264_POC_TYPE_DEFAULT; // IH264_POC_TYPE_0
419 h264enc_params->enableWatermark = 0;
420 h264enc_params->IDRFrameInterval = 1;
421 h264enc_params->pConstantMemory = NULL;
422 h264enc_params->maxIntraFrameInterval = 0x7FFFFFFF;
423 h264enc_params->debugTraceLevel = 0;
424 h264enc_params->lastNFramesToLog = 0;
425 h264enc_params->enableAnalyticinfo = 0;
426 h264enc_params->enableGMVSei = 0;
427 h264enc_params->constraintSetFlags = 20;
428 h264enc_params->enableRCDO = 0;
429 h264enc_params->enableLongTermRefFrame = IH264ENC_LTRP_NONE;
430 h264enc_params->LTRPPeriod = 0;
432 //H-P Coding Control Params
433 h264enc_params->numTemporalLayer = IH264_TEMPORAL_LAYERS_1;
434 h264enc_params->referencePicMarking = IH264_LONG_TERM_PICTURE;
435 h264enc_params->reservedParams[0] = 0;
436 h264enc_params->reservedParams[1] = 0;
437 h264enc_params->reservedParams[2] = 0;
439 //rate control params
440 h264enc_params->rateControlParams.rateControlParamsPreset = IH264_RATECONTROLPARAMS_USERDEFINED;
441 h264enc_params->rateControlParams.scalingMatrixPreset = IH264_SCALINGMATRIX_NONE;
442 h264enc_params->rateControlParams.rcAlgo = IH264_RATECONTROL_DEFAULT; // 0
443 h264enc_params->rateControlParams.qpI = 28;
444 h264enc_params->rateControlParams.qpMaxI = 36;
445 h264enc_params->rateControlParams.qpMinI = 10;
446 h264enc_params->rateControlParams.qpP = 28;
447 h264enc_params->rateControlParams.qpMaxP = 40;
448 h264enc_params->rateControlParams.qpMinP = 10;
449 h264enc_params->rateControlParams.qpOffsetB = 4;
450 h264enc_params->rateControlParams.qpMaxB = 44;
451 h264enc_params->rateControlParams.qpMinB = 10;
452 h264enc_params->rateControlParams.allowFrameSkip = 0;
453 h264enc_params->rateControlParams.removeExpensiveCoeff = 0;
454 h264enc_params->rateControlParams.chromaQPIndexOffset = 0;
455 h264enc_params->rateControlParams.IPQualityFactor = IH264_QUALITY_FACTOR_DEFAULT; // 0
456 h264enc_params->rateControlParams.initialBufferLevel = 64000;
457 h264enc_params->rateControlParams.HRDBufferSize = 64000;
458 h264enc_params->rateControlParams.minPicSizeRatioI = 0;
459 h264enc_params->rateControlParams.maxPicSizeRatioI = 20;
460 h264enc_params->rateControlParams.minPicSizeRatioP = 0;
461 h264enc_params->rateControlParams.maxPicSizeRatioP = 0;
462 h264enc_params->rateControlParams.minPicSizeRatioB = 0;
463 h264enc_params->rateControlParams.maxPicSizeRatioB = 0;
464 h264enc_params->rateControlParams.enablePRC = 1;
465 h264enc_params->rateControlParams.enablePartialFrameSkip = 0;
466 h264enc_params->rateControlParams.discardSavedBits = 0;
467 h264enc_params->rateControlParams.reserved = 0;
468 h264enc_params->rateControlParams.VBRDuration = 8;
469 h264enc_params->rateControlParams.VBRsensitivity = 0;
470 h264enc_params->rateControlParams.skipDistributionWindowLength = 5;
471 h264enc_params->rateControlParams.numSkipInDistributionWindow =1;
472 h264enc_params->rateControlParams.enableHRDComplianceMode = 1;
473 h264enc_params->rateControlParams.frameSkipThMulQ5 = 0;
474 h264enc_params->rateControlParams.vbvUseLevelThQ5 = 0;
475 h264enc_params->rateControlParams.reservedRC[0] = 0;
476 h264enc_params->rateControlParams.reservedRC[1] = 0;
477 h264enc_params->rateControlParams.reservedRC[2] = 0;
479 //intercoding coding params
480 h264enc_params->interCodingParams.interCodingPreset = IH264_INTERCODING_USERDEFINED;
481 h264enc_params->interCodingParams.searchRangeHorP = 144;
482 h264enc_params->interCodingParams.searchRangeVerP = 32;
483 h264enc_params->interCodingParams.searchRangeHorB = 144;
484 h264enc_params->interCodingParams.searchRangeVerB = 16;
485 h264enc_params->interCodingParams.interCodingBias = IH264_BIASFACTOR_DEFAULT;
486 h264enc_params->interCodingParams.skipMVCodingBias = IH264_BIASFACTOR_MILD;
487 h264enc_params->interCodingParams.minBlockSizeP = IH264_BLOCKSIZE_8x8;
488 h264enc_params->interCodingParams.minBlockSizeB = IH264_BLOCKSIZE_8x8;
489 h264enc_params->interCodingParams.meAlgoMode = IH264ENC_MOTIONESTMODE_DEFAULT;
491 //intra coding params.
492 h264enc_params->intraCodingParams.intraCodingPreset = IH264_INTRACODING_DEFAULT;
493 h264enc_params->intraCodingParams.lumaIntra4x4Enable = 0;
494 h264enc_params->intraCodingParams.lumaIntra8x8Enable = 0x0FF;
495 h264enc_params->intraCodingParams.lumaIntra16x16Enable = 0; // BASE PROFILE
496 h264enc_params->intraCodingParams.chromaIntra8x8Enable = 0; // BASE PROFILE
497 h264enc_params->intraCodingParams.chromaComponentEnable = IH264_CHROMA_COMPONENT_CB_CR_BOTH; // BASE PROFILE
498 h264enc_params->intraCodingParams.intraRefreshMethod = IH264_INTRAREFRESH_DEFAULT;
499 h264enc_params->intraCodingParams.intraRefreshRate = 0;
500 h264enc_params->intraCodingParams.gdrOverlapRowsBtwFrames = 0;
501 h264enc_params->intraCodingParams.constrainedIntraPredEnable = 0;
502 h264enc_params->intraCodingParams.intraCodingBias = IH264ENC_INTRACODINGBIAS_DEFAULT;
504 //NALU Control Params.
505 h264enc_params->nalUnitControlParams.naluControlPreset = IH264_NALU_CONTROL_USERDEFINED;
506 h264enc_params->nalUnitControlParams.naluPresentMaskStartOfSequence = 0x01A0; // 416
507 h264enc_params->nalUnitControlParams.naluPresentMaskIDRPicture = 0x0020; //32
508 h264enc_params->nalUnitControlParams.naluPresentMaskIntraPicture = 2;
509 h264enc_params->nalUnitControlParams.naluPresentMaskNonIntraPicture = 2;
510 h264enc_params->nalUnitControlParams.naluPresentMaskEndOfSequence = 0x0C00; // 3072
512 //Slice coding params
513 h264enc_params->sliceCodingParams.sliceCodingPreset = IH264_SLICECODING_DEFAULT;
514 h264enc_params->sliceCodingParams.sliceMode = IH264_SLICEMODE_DEFAULT;
515 h264enc_params->sliceCodingParams.sliceUnitSize = 0;
516 h264enc_params->sliceCodingParams.sliceStartOffset[0] = 0;
517 h264enc_params->sliceCodingParams.sliceStartOffset[1] = 0;
518 h264enc_params->sliceCodingParams.sliceStartOffset[2] = 0;
519 h264enc_params->sliceCodingParams.streamFormat = IH264_STREAM_FORMAT_DEFAULT;
521 //Loop Filter Params
522 h264enc_params->loopFilterParams.loopfilterPreset = IH264_LOOPFILTER_DEFAULT;
523 h264enc_params->loopFilterParams.loopfilterDisableIDC = IH264_DISABLE_FILTER_DEFAULT;
524 h264enc_params->loopFilterParams.filterOffsetA = 0;
525 h264enc_params->loopFilterParams.filterOffsetB = 0;
527 //fmo coding params
528 h264enc_params->fmoCodingParams.fmoCodingPreset = IH264_FMOCODING_DEFAULT;
529 h264enc_params->fmoCodingParams.numSliceGroups = 1;
530 h264enc_params->fmoCodingParams.sliceGroupMapType = IH264_SLICE_GRP_MAP_DEFAULT; // 4
531 h264enc_params->fmoCodingParams.sliceGroupChangeDirectionFlag = IH264ENC_SLICEGROUP_CHANGE_DIRECTION_DEFAULT;
532 h264enc_params->fmoCodingParams.sliceGroupChangeRate = 0;
533 h264enc_params->fmoCodingParams.sliceGroupChangeCycle = 0;
534 h264enc_params->fmoCodingParams.sliceGroupParams[0] = 0;
535 h264enc_params->fmoCodingParams.sliceGroupParams[1] = 0;
537 //VUI Control Params
538 h264enc_params->vuiCodingParams.vuiCodingPreset = IH264_VUICODING_DEFAULT;
539 h264enc_params->vuiCodingParams.aspectRatioInfoPresentFlag = 0;
540 h264enc_params->vuiCodingParams.aspectRatioIdc = 0;
541 h264enc_params->vuiCodingParams.videoSignalTypePresentFlag = 0;
542 h264enc_params->vuiCodingParams.videoFormat = IH264ENC_VIDEOFORMAT_NTSC;
543 h264enc_params->vuiCodingParams.videoFullRangeFlag = 0;
544 h264enc_params->vuiCodingParams.timingInfoPresentFlag = 0;
545 h264enc_params->vuiCodingParams.hrdParamsPresentFlag = 0;
546 h264enc_params->vuiCodingParams.numUnitsInTicks= 1000;
548 //Stereo Info Control Params
549 h264enc_params->stereoInfoParams.stereoInfoPreset = IH264_STEREOINFO_DISABLE;
550 h264enc_params->stereoInfoParams.topFieldIsLeftViewFlag = 1;
551 h264enc_params->stereoInfoParams.viewSelfContainedFlag = 0;
553 //Frame Packing SEI Params
554 h264enc_params->framePackingSEIParams.framePackingPreset = IH264_FRAMEPACK_SEI_DISABLE;
555 h264enc_params->framePackingSEIParams.framePackingType = IH264_FRAMEPACK_TYPE_DEFAULT;
556 h264enc_params->framePackingSEIParams.frame0PositionX = 0;
557 h264enc_params->framePackingSEIParams.frame0PositionY = 0;
558 h264enc_params->framePackingSEIParams.frame1PositionX = 0;
559 h264enc_params->framePackingSEIParams.frame1PositionY = 0;
560 h264enc_params->framePackingSEIParams.reservedByte = 0;
562 //SVC coding params
563 h264enc_params->svcCodingParams.svcExtensionFlag = IH264_SVC_EXTENSION_FLAG_DISABLE;
564 h264enc_params->svcCodingParams.dependencyID = 0;
565 h264enc_params->svcCodingParams.qualityID = 0;
566 h264enc_params->svcCodingParams.enhancementProfileID = 0;
567 h264enc_params->svcCodingParams.layerIndex = 0;
568 h264enc_params->svcCodingParams.refLayerDQId = 0;
570 MSG("dce_alloc VIDENC2_Params successful h264enc_params=%p", h264enc_params);
571 enc->codec = VIDENC2_create(enc->engine, (char*) "ivahd_h264enc", (VIDENC2_Params *)h264enc_params);
572 if(!enc->codec){
573 ERROR("Codec could not be created %p\n", enc->codec);
574 goto bail;
575 }
576 return 0;
577 bail:
578 encoder_deinit(enc);
579 return -1;
580 }
582 static int init_mpeg4_static_params(encoder *enc)
583 {
584 IMPEG4ENC_Params *mpeg4enc_params = NULL;
585 enc->inArgs = dce_alloc(sizeof(IMPEG4ENC_InArgs));
586 if(!enc->inArgs) goto bail;
587 enc->inArgs->size = sizeof(IMPEG4ENC_InArgs);
589 enc->outArgs = dce_alloc(sizeof(IMPEG4ENC_OutArgs));
590 if(!enc->outArgs) goto bail;
591 enc->outArgs->size = sizeof (IMPEG4ENC_OutArgs);
592 enc->mpeg4enc_outArgs = (IMPEG4ENC_OutArgs *) enc->outArgs;
594 enc->params = dce_alloc(sizeof(IMPEG4ENC_Params));
595 if(!enc->params) goto bail;
596 enc->params->size = sizeof(IMPEG4ENC_Params);
598 init_common_static_params(enc);
600 enc->params->maxInterFrameInterval = 0;
601 mpeg4enc_params = enc->mpeg4enc_params = (IMPEG4ENC_Params *) enc->params;
603 mpeg4enc_params->useDataPartitioning = 0;
604 mpeg4enc_params->useRvlc = 0;
605 if( enc->codectype == DCE_ENC_TEST_H263 ) {
606 mpeg4enc_params->useShortVideoHeader = 1;
607 } else {
608 mpeg4enc_params->useShortVideoHeader = 0;
609 }
610 mpeg4enc_params->vopTimeIncrementResolution = 30;
611 mpeg4enc_params->nonMultiple16RefPadMethod = IMPEG4_PAD_METHOD_MPEG4;
612 mpeg4enc_params->pixelRange = IMPEG4ENC_PR_0_255;
613 mpeg4enc_params->enableSceneChangeAlgo = IMPEG4ENC_SCDA_DISABLE;
614 mpeg4enc_params->useVOS = 0;
615 mpeg4enc_params->enableMONA = 0;
616 mpeg4enc_params->enableAnalyticinfo = -1;
617 mpeg4enc_params->debugTraceLevel = 0;
618 mpeg4enc_params->lastNFramesToLog = 0;
620 // IMPEG4ENC_RateControlParams
621 mpeg4enc_params->rateControlParams.rateControlParamsPreset = IMPEG4_RATECONTROLPARAMS_DEFAULT;
622 mpeg4enc_params->rateControlParams.rcAlgo = IMPEG4_RATECONTROLALGO_VBR;
623 mpeg4enc_params->rateControlParams.qpI = 5;
624 mpeg4enc_params->rateControlParams.qpP = 5;
625 mpeg4enc_params->rateControlParams.seIntialQP = 5;
626 mpeg4enc_params->rateControlParams.qpMax = 31;
627 mpeg4enc_params->rateControlParams.qpMin = 1;
628 mpeg4enc_params->rateControlParams.enablePerceptualQuantMode = 0;
629 mpeg4enc_params->rateControlParams.allowFrameSkip = 0;
630 mpeg4enc_params->rateControlParams.initialBufferLevel = 0;
631 mpeg4enc_params->rateControlParams.vbvBufferSize = 0;
632 mpeg4enc_params->rateControlParams.qpMinIntra = 0;
634 // IMPEG4ENC_InterCodingParams
635 mpeg4enc_params->interCodingParams.interCodingPreset = IMPEG4_INTERCODING_DEFAULT;
636 mpeg4enc_params->interCodingParams.searchRangeHorP = 144;
637 mpeg4enc_params->interCodingParams.searchRangeVerP = 32;
638 mpeg4enc_params->interCodingParams.globalOffsetME = 1;
639 mpeg4enc_params->interCodingParams.earlySkipThreshold = 200;
640 mpeg4enc_params->interCodingParams.enableThresholdingMethod = 1;
641 mpeg4enc_params->interCodingParams.minBlockSizeP = IMPEG4_BLOCKSIZE_8x8;
642 mpeg4enc_params->interCodingParams.enableRoundingControl = 1;
644 // IMPEG4ENC_IntraCodingParams
645 mpeg4enc_params->intraCodingParams.intraCodingPreset = IMPEG4_INTRACODING_DEFAULT;
646 mpeg4enc_params->intraCodingParams.intraRefreshMethod = 0;
647 mpeg4enc_params->intraCodingParams.intraRefreshRate = 0;
648 mpeg4enc_params->intraCodingParams.acpredEnable = 1;
649 mpeg4enc_params->intraCodingParams.insertGOVHdrBeforeIframe = 0;
650 mpeg4enc_params->intraCodingParams.enableDriftControl = 1;
652 // IMPEG4ENC_sliceCodingParams
653 mpeg4enc_params->sliceCodingParams.sliceCodingPreset = IMPEG4_SLICECODING_DEFAULT;
654 mpeg4enc_params->sliceCodingParams.sliceMode = IMPEG4_SLICEMODE_NONE;
655 mpeg4enc_params->sliceCodingParams.sliceUnitSize = 0;
656 mpeg4enc_params->sliceCodingParams.gobInterval = 0;
657 mpeg4enc_params->sliceCodingParams.useHec = 0;
659 MSG("dce_alloc VIDENC2_Params successful mpeg4enc_params=%p", mpeg4enc_params);
660 enc->codec = VIDENC2_create(enc->engine, (String)"ivahd_mpeg4enc", (VIDENC2_Params *)mpeg4enc_params);
661 if(!enc->codec){
662 ERROR("Codec could not be created %p\n", enc->codec);
663 goto bail;
664 }
665 return 0;
666 bail:
667 encoder_deinit(enc);
668 return -1;
669 }
671 static int init_jpeg_static_params(encoder *enc)
672 {
673 IJPEGVENC_Params *jpegenc_params = NULL;
674 VIDENC2_Params *params;
675 enc->inArgs = dce_alloc(sizeof(IJPEGVENC_InArgs));
676 if(!enc->inArgs) goto bail;
677 enc->inArgs->size = sizeof(IJPEGVENC_InArgs);
679 enc->outArgs = dce_alloc(sizeof(IJPEGVENC_OutArgs));
680 if(!enc->outArgs) goto bail;
681 enc->outArgs->size = sizeof (IJPEGVENC_OutArgs);
682 enc->jpegenc_outArgs = (IJPEGVENC_OutArgs *) enc->outArgs;
684 enc->params = dce_alloc(sizeof(IJPEGVENC_Params));
685 if(!enc->params) goto bail;
686 params = enc->params;
688 init_common_static_params(enc);
690 params->size = sizeof(IJPEGVENC_Params);
692 jpegenc_params = enc->jpegenc_params = (IJPEGVENC_Params *) enc->params;
695 /*--------------------------------------------------------------------------*/
696 /* Set Extended Parameters in IJpegVENC parameters */
697 /*--------------------------------------------------------------------------*/
698 jpegenc_params->maxThumbnailHSizeApp0 = 4096;
699 jpegenc_params->maxThumbnailHSizeApp1 = 4096;
700 jpegenc_params->maxThumbnailVSizeApp0 = 4096;
701 jpegenc_params->maxThumbnailVSizeApp1 = 4096;
702 jpegenc_params->debugTraceLevel = 0;
704 jpegenc_params->lastNFramesToLog = 0;
705 jpegenc_params->Markerposition = 0;
707 jpegenc_params->rateControlParams.VBRDuration = 8;
708 jpegenc_params->rateControlParams.VBRsensitivity = 0;
709 jpegenc_params->rateControlParams.vbvUseLevelThQ5 = 0;
711 params->rateControlPreset = 4;
712 params->maxBitRate = 7500000;
713 params->minBitRate = 4500000;
715 jpegenc_params->rateControlParams.rateControlParamsPreset = 1;
716 jpegenc_params->rateControlParams.rcAlgo = 0;
717 jpegenc_params->rateControlParams.qpMaxI = 51;
718 jpegenc_params->rateControlParams.qpMinI = 1;
719 jpegenc_params->rateControlParams.qpI = -1;
720 jpegenc_params->rateControlParams.initialBufferLevel = 10000000;
721 jpegenc_params->rateControlParams.HRDBufferSize = 10000000;
722 jpegenc_params->rateControlParams.discardSavedBits = 0;
724 MSG("dce_alloc VIDENC2_Params successful jpegenc_params=%p", jpegenc_params);
725 enc->codec = VIDENC2_create(enc->engine, (String)"ivahd_jpegvenc", (VIDENC2_Params *)jpegenc_params);
726 if(!enc->codec){
727 ERROR("Codec could not be created %p\n", enc->codec);
728 goto bail;
729 }
730 return 0;
731 bail:
732 encoder_deinit(enc);
733 return -1;
734 }
736 static void set_common_dyn_params(encoder *enc)
737 {
738 VIDENC2_DynamicParams *dynParams = enc->dynParams;
739 dynParams->inputHeight = enc->height;
740 dynParams->inputWidth = enc->width;
741 dynParams->refFrameRate = enc->fps * 1000; // refFrameRate in fps * 1000
742 dynParams->targetFrameRate= enc->fps * 1000; // Target frame rate in fps * 1000
743 dynParams->targetBitRate = enc->bps;
744 MSG("targetFramerate = %d, targetbitrate = %d\n", dynParams->targetFrameRate, dynParams->targetBitRate);
745 dynParams->intraFrameInterval = 30; //Only 1st frame to be intra frame (I-frame)
746 dynParams->generateHeader = XDM_ENCODE_AU;
747 dynParams->captureWidth = enc->width;
748 dynParams->forceFrame = IVIDEO_NA_FRAME;
749 dynParams->sampleAspectRatioHeight = 1;
750 dynParams->sampleAspectRatioWidth = 1;
751 dynParams->ignoreOutbufSizeFlag = XDAS_FALSE; // If this is XDAS_TRUE then getBufferFxn and getBufferHandle needs to be set.
752 dynParams->putDataFxn = NULL;
753 dynParams->putDataHandle = NULL;
754 dynParams->getDataFxn = NULL;
755 dynParams->getDataHandle = NULL;
756 dynParams->getBufferFxn = NULL;
757 dynParams->getBufferHandle = NULL;
758 dynParams->lateAcquireArg = -1;
759 return;
760 }
762 static inline int init_mpeg4_dyn_params(encoder *enc)
763 {
764 VIDENC2_DynamicParams *dynParams = NULL;
765 XDAS_Int32 err;
766 IMPEG4ENC_DynamicParams *mpeg4enc_dynParams;
768 dynParams = enc->dynParams = dce_alloc(sizeof(IMPEG4ENC_DynamicParams));
769 if(!enc->dynParams) goto bail;
770 enc->dynParams->size = sizeof(IMPEG4ENC_DynamicParams);
771 MSG("dce_alloc dynParams successful dynParams=%p size=%d", enc->dynParams, enc->dynParams->size);
772 set_common_dyn_params(enc);
773 dynParams->interFrameInterval = 0;
774 dynParams->mvAccuracy = IVIDENC2_MOTIONVECTOR_HALFPEL; //IVIDENC2_MotionVectorAccuracy
776 MSG("dce_alloc IMPEG4ENC_DynamicParams successful size %d dynParams=%p", dynParams->size, dynParams);
777 mpeg4enc_dynParams = (IMPEG4ENC_DynamicParams *) dynParams;
779 mpeg4enc_dynParams->aspectRatioIdc = IMPEG4ENC_ASPECTRATIO_SQUARE;
781 // IMPEG4ENC_RateControlParams
782 memcpy(&mpeg4enc_dynParams->rateControlParams, &(enc->mpeg4enc_params->rateControlParams), sizeof(IMPEG4ENC_RateControlParams));
783 // IMPEG4ENC_InterCodingParams
784 memcpy(&mpeg4enc_dynParams->interCodingParams, &(enc->mpeg4enc_params->interCodingParams), sizeof(IMPEG4ENC_InterCodingParams));
785 // IMPEG4ENC_sliceCodingParams
786 memcpy(&mpeg4enc_dynParams->sliceCodingParams, &(enc->mpeg4enc_params->sliceCodingParams), sizeof(IMPEG4ENC_sliceCodingParams));
788 enc->mpeg4enc_status = dce_alloc(sizeof(IMPEG4ENC_Status));
789 if(!enc->mpeg4enc_status) goto bail;
790 ((VIDENC2_Status *)(enc->mpeg4enc_status))->size = sizeof(IMPEG4ENC_Status);
791 MSG("dce_alloc IMPEG4ENC_Status successful status=%p", enc->mpeg4enc_status);
793 err = VIDENC2_control(enc->codec, XDM_SETPARAMS, (VIDENC2_DynamicParams *) mpeg4enc_dynParams, (VIDENC2_Status *) (enc->mpeg4enc_status));
794 if(err){
795 ERROR("Codec_control returned err=%d, extendedError=%08x", err, enc->mpeg4enc_status->videnc2Status.extendedError);
796 goto bail;
797 }
798 return 0;
799 bail:
800 encoder_deinit(enc);
801 return -1;
802 }
804 static inline int init_h264_dyn_params(encoder *enc)
805 {
806 VIDENC2_DynamicParams *dynParams = NULL;
807 IH264ENC_DynamicParams *h264enc_dynParams;
808 XDAS_Int32 err;
810 dynParams = enc->dynParams = dce_alloc(sizeof(IH264ENC_DynamicParams));
811 if(!enc->dynParams) goto bail;
812 enc->dynParams->size = sizeof(IH264ENC_DynamicParams);
813 MSG("dce_alloc dynParams successful dynParams=%p size=%d", enc->dynParams, enc->dynParams->size);
814 set_common_dyn_params(enc);
815 dynParams->interFrameInterval = 1; // 2 B frames
816 dynParams->mvAccuracy = IVIDENC2_MOTIONVECTOR_QUARTERPEL; //IVIDENC2_MotionVectorAccuracy
818 MSG("dce_alloc IH264ENC_DynamicParams successful size %d dynParams=%p", dynParams->size, dynParams);
819 h264enc_dynParams = (IH264ENC_DynamicParams *) dynParams;
821 h264enc_dynParams->sliceGroupChangeCycle = 0;
822 h264enc_dynParams->searchCenter.x = 0x7FFF; // or 32767
823 h264enc_dynParams->searchCenter.y = 0x7FFF; // or 32767
824 h264enc_dynParams->enableStaticMBCount = 0;
825 h264enc_dynParams->enableROI = 0;
826 h264enc_dynParams->reservedDynParams[0] = 0;
827 h264enc_dynParams->reservedDynParams[1] = 0;
828 h264enc_dynParams->reservedDynParams[2] = 0;
830 //Rate Control Params
831 h264enc_dynParams->rateControlParams.rateControlParamsPreset = IH264_RATECONTROLPARAMS_EXISTING;
832 h264enc_dynParams->rateControlParams.scalingMatrixPreset = IH264_SCALINGMATRIX_NONE;
833 h264enc_dynParams->rateControlParams.rcAlgo = IH264_RATECONTROL_DEFAULT;
834 h264enc_dynParams->rateControlParams.qpI = 28;
835 h264enc_dynParams->rateControlParams.qpMaxI = 36;
836 h264enc_dynParams->rateControlParams.qpMinI = 10;
837 h264enc_dynParams->rateControlParams.qpP = 28;
838 h264enc_dynParams->rateControlParams.qpMaxP = 40;
839 h264enc_dynParams->rateControlParams.qpMinP = 10;
840 h264enc_dynParams->rateControlParams.qpOffsetB = 4;
841 h264enc_dynParams->rateControlParams.qpMaxB = 44;
842 h264enc_dynParams->rateControlParams.qpMinB = 10;
843 h264enc_dynParams->rateControlParams.allowFrameSkip = 0;
844 h264enc_dynParams->rateControlParams.removeExpensiveCoeff = 0;
845 h264enc_dynParams->rateControlParams.IPQualityFactor = IH264_QUALITY_FACTOR_DEFAULT;
846 h264enc_dynParams->rateControlParams.chromaQPIndexOffset = 0;
847 h264enc_dynParams->rateControlParams.initialBufferLevel = 64000;
848 h264enc_dynParams->rateControlParams.HRDBufferSize = 64000;
849 h264enc_dynParams->rateControlParams.enablePartialFrameSkip = 0;
850 h264enc_dynParams->rateControlParams.minPicSizeRatioI = 0;
851 h264enc_dynParams->rateControlParams.maxPicSizeRatioI = 20;
852 h264enc_dynParams->rateControlParams.minPicSizeRatioP = 0;
853 h264enc_dynParams->rateControlParams.maxPicSizeRatioP = 0;
854 h264enc_dynParams->rateControlParams.minPicSizeRatioB = 0;
855 h264enc_dynParams->rateControlParams.maxPicSizeRatioB = 0;
856 h264enc_dynParams->rateControlParams.enablePRC = 1;
857 h264enc_dynParams->rateControlParams.enableHRDComplianceMode = 0;
858 h264enc_dynParams->rateControlParams.reserved = 0;
859 h264enc_dynParams->rateControlParams.VBRDuration = 8;
860 h264enc_dynParams->rateControlParams.VBRsensitivity = 0;
861 h264enc_dynParams->rateControlParams.skipDistributionWindowLength = 5;
862 h264enc_dynParams->rateControlParams.numSkipInDistributionWindow = 1;
863 h264enc_dynParams->rateControlParams.enableHRDComplianceMode = 1;
864 h264enc_dynParams->rateControlParams.frameSkipThMulQ5 = 0;
865 h264enc_dynParams->rateControlParams.vbvUseLevelThQ5 = 0;
866 h264enc_dynParams->rateControlParams.reservedRC[0] = 0;
867 h264enc_dynParams->rateControlParams.reservedRC[1] = 0;
868 h264enc_dynParams->rateControlParams.reservedRC[2] = 0;
870 //Inter Coding Params
871 h264enc_dynParams->interCodingParams.interCodingPreset = IH264_INTERCODING_EXISTING;
872 h264enc_dynParams->interCodingParams.searchRangeHorP = 144;
873 h264enc_dynParams->interCodingParams.searchRangeVerP = 32;
874 h264enc_dynParams->interCodingParams.searchRangeHorB = 144;
875 h264enc_dynParams->interCodingParams.searchRangeVerB = 16;
876 h264enc_dynParams->interCodingParams.interCodingBias= IH264_BIASFACTOR_DEFAULT;
877 h264enc_dynParams->interCodingParams.skipMVCodingBias = IH264_BIASFACTOR_MILD;
878 h264enc_dynParams->interCodingParams.minBlockSizeP = IH264_BLOCKSIZE_8x8;
879 h264enc_dynParams->interCodingParams.minBlockSizeB = IH264_BLOCKSIZE_8x8;
880 h264enc_dynParams->interCodingParams.meAlgoMode = IH264ENC_MOTIONESTMODE_DEFAULT;
882 //Intra Coding Params
883 h264enc_dynParams->intraCodingParams.intraCodingPreset = IH264_INTRACODING_EXISTING;
884 h264enc_dynParams->intraCodingParams.lumaIntra4x4Enable = 0xFF; // or 255 BASE PROFILE
885 h264enc_dynParams->intraCodingParams.lumaIntra8x8Enable = 0; // BASE PROFILE
886 h264enc_dynParams->intraCodingParams.lumaIntra16x16Enable = 0;
887 h264enc_dynParams->intraCodingParams.chromaIntra8x8Enable = 0;
888 h264enc_dynParams->intraCodingParams.chromaComponentEnable = IH264_CHROMA_COMPONENT_CB_CR_BOTH;
889 h264enc_dynParams->intraCodingParams.intraRefreshMethod = IH264_INTRAREFRESH_DEFAULT;
890 h264enc_dynParams->intraCodingParams.intraRefreshRate = 0;
891 h264enc_dynParams->intraCodingParams.gdrOverlapRowsBtwFrames = 0;
892 h264enc_dynParams->intraCodingParams.constrainedIntraPredEnable = 0;
893 h264enc_dynParams->intraCodingParams.intraCodingBias = IH264ENC_INTRACODINGBIAS_DEFAULT;
895 //Slice Coding Params
896 h264enc_dynParams->sliceCodingParams.sliceCodingPreset = IH264_SLICECODING_EXISTING;
897 h264enc_dynParams->sliceCodingParams.sliceMode = IH264_SLICEMODE_DEFAULT;
898 h264enc_dynParams->sliceCodingParams.sliceUnitSize = 0;
899 h264enc_dynParams->sliceCodingParams.sliceStartOffset[0] = 0;
900 h264enc_dynParams->sliceCodingParams.sliceStartOffset[1] = 0;
901 h264enc_dynParams->sliceCodingParams.sliceStartOffset[2] = 0;
902 h264enc_dynParams->sliceCodingParams.streamFormat = IH264_STREAM_FORMAT_DEFAULT;
904 enc->h264enc_status = dce_alloc(sizeof(IH264ENC_Status));
905 if(!enc->h264enc_status) goto bail;
906 ((VIDENC2_Status*)(enc->h264enc_status))->size = sizeof(IH264ENC_Status);
907 MSG("dce_alloc IH264ENC_Status successful status=%p", enc->h264enc_status);
909 err = VIDENC2_control(enc->codec, XDM_SETPARAMS, (VIDENC2_DynamicParams *) h264enc_dynParams, (VIDENC2_Status *) (enc->h264enc_status));
910 if( err ) {
911 ERROR("Codec_control returned err=%d, extendedError=%08x", err, enc->h264enc_status->videnc2Status.extendedError);
912 goto bail;
913 }
914 MSG("dce_alloc IH264ENC_Status successful h264enc_status=%p", enc->h264enc_status);
917 return 0;
918 bail:
919 encoder_deinit(enc);
920 return -1;
921 }
923 static inline int init_jpeg_dyn_params(encoder *enc)
924 {
925 VIDENC2_DynamicParams *dynParams = NULL;
926 XDAS_Int32 err;
927 IJPEGVENC_DynamicParams *jpegenc_dynParams;
929 dynParams = enc->dynParams = dce_alloc(sizeof(IJPEGVENC_DynamicParams));
930 if(!enc->dynParams) goto bail;
931 enc->dynParams->size = sizeof(IJPEGVENC_DynamicParams);
932 MSG("dce_alloc dynParams successful dynParams=%p size=%d", enc->dynParams, enc->dynParams->size);
933 set_common_dyn_params(enc);
935 MSG("dce_alloc IJPEGVENC_DynamicParams successful size %d dynParams=%p", dynParams->size, dynParams);
936 jpegenc_dynParams = (IJPEGVENC_DynamicParams *) dynParams;
938 jpegenc_dynParams->restartInterval = 0;
939 jpegenc_dynParams->qualityFactor = 50;
940 jpegenc_dynParams->quantTable = NULL;
942 jpegenc_dynParams->enablePrivacyMasking = 0;
944 enc->jpegenc_status = dce_alloc(sizeof(IJPEGVENC_Status));
945 if(!enc->jpegenc_status) goto bail;
946 ((VIDENC2_Status *)(enc->jpegenc_status))->size = sizeof(IJPEGVENC_Status);
947 MSG("dce_alloc IJPEGVENC_Status successful status=%p", enc->jpegenc_status);
949 err = VIDENC2_control(enc->codec, XDM_SETPARAMS, (VIDENC2_DynamicParams *) jpegenc_dynParams, (VIDENC2_Status *) (enc->jpegenc_status));
950 if(err){
951 ERROR("Codec_control returned err=%d, extendedError=%08x", err, enc->jpegenc_status->videnc2Status.extendedError);
952 goto bail;
953 }
954 return 0;
955 bail:
956 encoder_deinit(enc);
957 return -1;
958 }
960 static int encoder_init(encoder *enc)
961 {
962 Engine_Error ec;
963 XDAS_Int32 err;
964 int output_size = 0;
965 int mvbufinfo_size = 0;
968 /*Initialze and Open DRM device*/
969 enc->drmfd = drmOpen("omapdrm", "platform:omapdrm:00");
970 if(!enc->drmfd)
971 {
972 ERROR("Unable to open drm device");
973 return -1;
974 }
975 dce_set_fd(enc->drmfd);
976 enc->dev = dce_init();
978 enc->engine = Engine_open((String)"ivahd_vidsvr", NULL, &ec);
979 if( !enc->engine ) {
980 ERROR("Engine open failed");
981 goto bail;
982 }
983 MSG("Engine_open successful engine=%p", enc->engine);
984 /* input buffer parameters in terms of MBs, Needs alignment to multiple of 16 */
985 enc->width = ALIGN2(enc->width, 4); /* round up to MB */
986 enc->height = ALIGN2(enc->height, 1); /* round up to MB */
988 switch( enc->codectype ) {
989 case DCE_ENC_TEST_H264 :
990 case DCE_ENC_TEST_MPEG4 :
991 case DCE_ENC_TEST_H263 :
992 case DCE_ENC_TEST_JPEG :
993 enc->num_buffers = 1;
994 break;
995 default :
996 ERROR("Unrecognized codec to encode");
997 }
998 /*Allocate the input buffers */
999 enc->buf.y_bo = omap_bo_new(enc->dev, enc->width * enc->height, OMAP_BO_WC);
1000 if(!enc->buf.y_bo) goto bail;
1001 enc->buf.ybuff = omap_bo_map(enc->buf.y_bo);
1002 enc->buf.fdy = omap_bo_dmabuf(enc->buf.y_bo);
1003 dce_buf_lock(1, (size_t*) &enc->buf.fdy);
1004 enc->buf.sizey = enc->width * enc->height;
1005 enc->buf.uv_bo = omap_bo_new(enc->dev,
1006 (enc->width * enc->height) / 2, OMAP_BO_WC);
1007 if(!enc->buf.uv_bo) goto bail;
1008 enc->buf.uvbuff = omap_bo_map(enc->buf.uv_bo);
1009 enc->buf.fduv = omap_bo_dmabuf(enc->buf.uv_bo);
1010 dce_buf_lock(1, (size_t*) &enc->buf.fduv);
1011 enc->buf.sizeuv = (enc->width * enc->height) / 2;
1013 /*Initialize the static ivariant input buffer parameters*/
1014 MSG("input buffer configuration width %d height %d", enc->width, enc->height);
1015 enc->inBufs = dce_alloc(sizeof(IVIDEO2_BufDesc));
1016 if(!enc->inBufs) goto bail;
1017 enc->inBufs->numPlanes = 2;
1018 enc->inBufs->imageRegion.topLeft.x = 0;
1019 enc->inBufs->imageRegion.topLeft.y = 0;
1020 enc->inBufs->imageRegion.bottomRight.x = enc->width;
1022 enc->inBufs->topFieldFirstFlag = 0; //Only valid for interlace content.
1023 enc->inBufs->contentType = IVIDEO_PROGRESSIVE;
1025 enc->inBufs->activeFrameRegion.topLeft.x = 0;
1026 enc->inBufs->activeFrameRegion.topLeft.y = 0;
1027 enc->inBufs->activeFrameRegion.bottomRight.x = enc->width;
1028 enc->inBufs->activeFrameRegion.bottomRight.y = enc->height;
1030 enc->inBufs->imageRegion.bottomRight.y = enc->height;
1031 enc->inBufs->chromaFormat = XDM_YUV_420SP;
1033 enc->inBufs->secondFieldOffsetWidth[0] = 0;
1034 enc->inBufs->secondFieldOffsetHeight[0] = 0;
1037 MSG("Allocating input buffers from omapdrm");
1039 enc->inBufs->imagePitch[0] = enc->width;
1040 enc->inBufs->planeDesc[0].memType = XDM_MEMTYPE_RAW;
1041 enc->inBufs->planeDesc[0].bufSize.bytes = enc->width * enc->height;
1042 enc->inBufs->secondFieldOffsetWidth[1] = 1;
1043 enc->inBufs->secondFieldOffsetHeight[1] = 0;
1045 enc->inBufs->imagePitch[1] = enc->width;
1046 enc->inBufs->planeDesc[1].memType = XDM_MEMTYPE_RAW;
1047 enc->inBufs->planeDesc[1].bufSize.bytes = enc->width * enc->height / 2;
1051 /*Initiaze static parameters of the codec*/
1052 switch(enc->codectype){
1053 case DCE_ENC_TEST_H264:
1054 if(init_h264_static_params(enc)){
1055 ERROR("H264 encoder static parameter error");
1056 goto bail;
1057 }
1059 if(init_h264_dyn_params(enc)){
1060 ERROR("H264 encoder static parameter error");
1061 goto bail;
1062 }
1063 enc->status = (VIDENC2_Status*) (enc->h264enc_status);
1064 break;
1065 case DCE_ENC_TEST_MPEG4:
1066 case DCE_ENC_TEST_H263:
1067 if(init_mpeg4_static_params(enc)){
1068 ERROR("MPEG4 encoder static parameter error");
1069 goto bail;
1070 }
1071 if(init_mpeg4_dyn_params(enc)){
1072 ERROR("H264 encoder static parameter error");
1073 goto bail;
1074 }
1075 enc->status = (VIDENC2_Status*) (enc->mpeg4enc_status);
1076 break;
1077 case DCE_ENC_TEST_JPEG:
1078 if(init_jpeg_static_params(enc)){
1079 ERROR("JPEG encoder static parameter error");
1080 goto bail;
1081 }
1083 if(init_jpeg_dyn_params(enc)){
1084 ERROR("JPEG encoder static parameter error");
1085 goto bail;
1086 }
1087 enc->status = (VIDENC2_Status*) (enc->jpegenc_status);
1088 break;
1089 default:
1090 ERROR("Unknown codec type");
1091 goto bail;
1092 }
1093 // XDM_GETBUFINFO
1094 // Send Control cmd XDM_GETBUFINFO to get min output and output size
1095 err = VIDENC2_control(enc->codec, XDM_GETBUFINFO, enc->dynParams, (VIDENC2_Status*) enc->status);
1096 MSG("VIDENC2_control - XDM_GETBUFINFO err %d status numOutBuf %d OutBufSize %d MVBufInfo %d",
1097 err, ((VIDENC2_Status *)(enc->status))->bufInfo.minNumOutBufs,
1098 ((VIDENC2_Status *)(enc->status))->bufInfo.minOutBufSize[0].bytes, ((VIDENC2_Status *)(enc->status))->bufInfo.minOutBufSize[1].bytes);
1099 /*
1100 * outBufs handling
1101 */
1102 enc->outBufs = dce_alloc(sizeof(XDM2_BufDesc));
1103 if(!enc->outBufs) goto bail;
1104 output_size = ((VIDENC2_Status *)(enc->status))->bufInfo.minOutBufSize[0].bytes;
1105 mvbufinfo_size = ((VIDENC2_Status *)(enc->status))->bufInfo.minOutBufSize[1].bytes;
1107 enc->outBufs->numBufs = (enc->codectype == DCE_ENC_TEST_H264) ? ((VIDENC2_Status *)(enc->h264enc_status))->bufInfo.minNumOutBufs : 1;
1109 /*allocate the output buffer*/
1110 enc->output_bo = omap_bo_new(enc->dev, output_size, OMAP_BO_WC);
1111 enc->cdata = omap_bo_map(enc->output_bo);
1112 enc->outBufs->descs[0].buf = (void *)omap_bo_dmabuf(enc->output_bo);
1113 dce_buf_lock(1, (size_t*) &(enc->outBufs->descs[0].buf));
1114 enc->outBufs->descs[0].memType = XDM_MEMTYPE_RAW;
1115 enc->outBufs->descs[0].bufSize.bytes = output_size;
1116 MSG("buf %p fd %p ", enc->output_bo, enc->outBufs->descs[0].buf);
1118 if( mvbufinfo_size > 0 ) {
1119 /*Allocate the output mv buffer*/
1120 enc->mv_bo = omap_bo_new(enc->dev, mvbufinfo_size, OMAP_BO_WC);
1121 enc->outBufs->descs[1].buf = (void *)omap_bo_dmabuf(enc->mv_bo);
1122 dce_buf_lock(1, (size_t*) &(enc->outBufs->descs[1].buf));
1123 enc->outBufs->descs[1].memType = XDM_MEMTYPE_RAW;
1124 enc->outBufs->descs[1].bufSize.bytes = mvbufinfo_size;
1125 MSG("mv buf %p fd %p ", enc->mv_bo, enc->outBufs->descs[1].buf);
1126 }
1128 return 0;
1129 bail:
1130 err = encoder_deinit(enc);
1131 return -1;
1132 }
1134 static int encoder_deinit(encoder *enc)
1135 {
1137 if(enc->buf.y_bo) {
1138 dce_buf_unlock(1, (size_t*) &enc->buf.fdy);
1139 close(enc->buf.fdy);
1140 omap_bo_del(enc->buf.y_bo);
1141 }
1142 if(enc->buf.uv_bo) {
1143 dce_buf_unlock(1, (size_t*) &enc->buf.fduv);
1144 close(enc->buf.fduv);
1145 omap_bo_del(enc->buf.uv_bo);
1146 }
1148 if(enc->codec) {
1149 MSG("\nDeleting encoder codec...\n");
1150 VIDENC2_delete(enc->codec);
1151 }
1153 if( enc->output_bo ) {
1154 MSG("\nFreeing output %p \n", enc->output_bo);
1155 dce_buf_unlock(1, (size_t*) &(enc->outBufs->descs[0].buf));
1156 close((int)(enc->outBufs->descs[0].buf));
1157 omap_bo_del(enc->output_bo);
1158 }
1159 if( enc->mv_bo ){
1160 MSG("\nFreeing output_mvbuf %p...\n", enc->mv_bo);
1161 dce_buf_unlock(1, (size_t*) &(enc->outBufs->descs[1].buf));
1162 close((int)(enc->outBufs->descs[1].buf));
1163 omap_bo_del(enc->mv_bo);
1164 }
1166 if( enc->params ) {
1167 dce_free(enc->params);
1168 }
1169 if( enc->dynParams ) {
1170 dce_free(enc->dynParams);
1171 }
1172 if( enc->h264enc_status ) {
1173 dce_free(enc->h264enc_status);
1174 }
1175 if( enc->mpeg4enc_status ) {
1176 dce_free(enc->mpeg4enc_status);
1177 }
1178 if( enc->inBufs ) {
1179 dce_free(enc->inBufs);
1180 }
1181 if( enc->outBufs ) {
1182 dce_free(enc->outBufs);
1183 }
1184 if( enc->inArgs ) {
1185 dce_free(enc->inArgs);
1186 }
1187 if( enc->outArgs ) {
1188 dce_free(enc->outArgs);
1189 }
1190 if( enc->engine ) {
1191 Engine_close(enc->engine);
1192 }
1194 if(enc->fin) fclose(enc->fin);
1195 if(enc->fout) fclose(enc->fout);
1196 if(enc->dev) dce_deinit(enc->dev);
1197 if(enc->drmfd) drmClose(enc->drmfd);
1198 memset(enc, 0, sizeof(encoder));
1199 return 0;
1200 }
1202 encoder encObj;
1204 static void sig_handler(int signo, siginfo_t *siginfo, void *context)
1205 {
1206 if (signo == SIGINT) {
1207 encoder_deinit(&encObj);
1208 sleep(1);
1209 exit(0);
1210 }
1211 }
1213 /* encoder body */
1214 int main(int argc, char * *argv)
1215 {
1216 struct sigaction sa;
1217 sa.sa_handler = sig_handler;
1218 sigemptyset(&sa.sa_mask);
1219 sa.sa_flags = SA_SIGINFO;
1220 if (sigaction(SIGINT, &sa, NULL) == -1) {
1221 ERROR ("\nDid not catch SIGINT\n");
1222 }
1224 XDAS_Int32 err;
1225 IH264ENC_InArgs *h264enc_inArgs;
1226 IMPEG4ENC_InArgs *mpeg4enc_inArgs;
1227 IJPEGVENC_InArgs *jpegenc_inArgs;
1228 IH264ENC_OutArgs *h264enc_outArgs;
1229 IMPEG4ENC_OutArgs *mpeg4enc_outArgs;
1230 IJPEGVENC_OutArgs *jpegenc_outArgs;
1232 int in_cnt = 0, out_cnt = 0, iters = 0;
1233 int eof = 0;
1234 int bytesGenerated = 0;
1237 memset(&encObj, 0, sizeof(encoder));
1239 if(parse_command(argc, argv, &encObj)){
1240 goto shutdown;
1241 }
1244 if(encoder_init(&encObj))
1245 {
1246 MSG("Error during encoder initialization");
1247 goto shutdown;
1248 }
1250 /*
1251 * codec process
1252 */
1253 while( encObj.inBufs->numPlanes && encObj.outBufs->numBufs ) {
1254 int n;
1255 MSG("Looping on reading input inBufs->numPlanes %d outBufs->numBufs %d",
1256 encObj.inBufs->numPlanes, encObj.outBufs->numBufs);
1258 //Read the NV12 frame to input buffer to be encoded.
1259 n = read_NV12frame(&encObj);
1261 if( n > 0) {
1262 eof = 0;
1263 /*Pass the FDs for subplanes*/
1264 encObj.inBufs->planeDesc[0].buf = (XDAS_Int8 *)(encObj.buf.fdy);
1265 encObj.inBufs->planeDesc[1].buf = (XDAS_Int8 *)(encObj.buf.fduv);
1266 MSG("inBufs->planeDesc[0].buf %p inBufs->planeDesc[1].buf %p",
1267 encObj.inBufs->planeDesc[0].buf, encObj.inBufs->planeDesc[1].buf);
1268 MSG("push: %d (plane[0]= %d + plane[1]= %d = %d bytes) (%p)",
1269 in_cnt, encObj.inBufs->planeDesc[0].bufSize.bytes, encObj.inBufs->planeDesc[1].bufSize.bytes, n, &encObj.buf);
1270 in_cnt++;
1272 encObj.inArgs->inputID = in_cnt; // Send frame count as the input ID
1273 /*
1274 * Input buffer has data to be encoded.
1275 */
1276 } else if( n == -1 ) {
1278 // Set EOF as 1 to ensure flush completes
1279 eof = 1;
1280 in_cnt++;
1282 MSG("n == -1 - go to shutdown");
1283 printf("Encoding completed successfully\n");
1285 goto shutdown;
1286 } else {
1287 /* end of input.. (n == 0) */
1288 encObj.inBufs->numPlanes = 0;
1289 eof = 1;
1290 MSG("n == 0 - go to shutdown");
1291 printf("Encoding completed successfully\n");
1293 goto shutdown;
1295 }
1298 do {
1300 if( encObj.codectype == DCE_ENC_TEST_H264 ) {
1301 h264enc_inArgs = (IH264ENC_InArgs *) encObj.inArgs;
1302 h264enc_outArgs = (IH264ENC_OutArgs *) encObj.outArgs;
1303 MSG("TEST inArgs->inputID %d h264enc_inArgs->videnc2InArgs.inputID %d",
1304 encObj.inArgs->inputID, h264enc_inArgs->videnc2InArgs.inputID);
1305 err = VIDENC2_process(encObj.codec, encObj.inBufs, encObj.outBufs, (VIDENC2_InArgs *) h264enc_inArgs, (VIDENC2_OutArgs *) h264enc_outArgs);
1306 MSG("[DCE_ENC_TEST] VIDENC2_process - err %d", err);
1308 if( err < 0 ) {
1309 int i = 0;
1311 for( i=0; i < IH264ENC_EXTERROR_NUM_MAXWORDS; i++ ) {
1312 MSG("DETAIL EXTENDED ERROR h264enc_outArgs->extErrorCode[%d]=%08x", i, (uint)h264enc_outArgs->extErrorCode[i]);
1313 }
1315 err = VIDENC2_control(encObj.codec, XDM_GETSTATUS, (VIDENC2_DynamicParams *) encObj.dynParams, (VIDENC2_Status *) encObj.h264enc_status);
1316 MSG("[DCE_ENC_TEST] VIDENC2_control - XDM_GETSTATUS err %d", err);
1318 for( i=0; i < IH264ENC_EXTERROR_NUM_MAXWORDS; i++ ) {
1319 MSG("DETAIL EXTENDED ERROR h264enc_status->extErrorCode[%d]=%08x", i, (uint)encObj.h264enc_status->extErrorCode[i]);
1320 }
1322 if( XDM_ISFATALERROR(h264enc_outArgs->videnc2OutArgs.extendedError) ) {
1323 ERROR("process returned error: %d\n", err);
1324 ERROR("extendedError: %08x", h264enc_outArgs->videnc2OutArgs.extendedError);
1325 printf("Encoding Error\n");
1326 goto shutdown;
1327 } else if( eof ) {
1328 ERROR("Codec_process returned err=%d, extendedError=%08x", err, h264enc_outArgs->videnc2OutArgs.extendedError);
1329 err = XDM_EFAIL;
1331 if( err == XDM_EFAIL ) {
1332 MSG("-------------------- Flush completed------------------------");
1333 }
1334 } else {
1335 ERROR("Non-fatal err=%d, h264enc_outArgs->videnc2OutArgs.extendedError=%08x ", err, h264enc_outArgs->videnc2OutArgs.extendedError);
1336 err = XDM_EOK;
1337 }
1338 }
1340 MSG("bytesGenerated %d", h264enc_outArgs->videnc2OutArgs.bytesGenerated);
1341 bytesGenerated = h264enc_outArgs->videnc2OutArgs.bytesGenerated;
1342 } else if( encObj.codectype == DCE_ENC_TEST_MPEG4 || encObj.codectype == DCE_ENC_TEST_H263 ) {
1343 mpeg4enc_inArgs = (IMPEG4ENC_InArgs *) encObj.inArgs;
1344 mpeg4enc_outArgs = (IMPEG4ENC_OutArgs *) encObj.outArgs;
1345 MSG("TEST inArgs->inputID %d mpeg4enc_inArgs->videnc2InArgs.inputID %d", encObj.inArgs->inputID, mpeg4enc_inArgs->videnc2InArgs.inputID);
1346 MSG("[DCE_ENC_TEST] codec %p inBufs %p outBufs %p mpeg4enc_inArgs %p mpeg4enc_outArgs %p", encObj.codec, encObj.inBufs, encObj.outBufs, mpeg4enc_inArgs, mpeg4enc_outArgs);
1347 err = VIDENC2_process(encObj.codec, encObj.inBufs, encObj.outBufs, (VIDENC2_InArgs *) mpeg4enc_inArgs, (VIDENC2_OutArgs *) mpeg4enc_outArgs);
1348 MSG("[DCE_ENC_TEST] VIDENC2_process - err %d", err);
1349 if( err < 0 ) {
1350 //TODO error handling on MPEG4/H.263
1351 ERROR("Codec_process returned err=%d, extendedError=%08x", err, mpeg4enc_outArgs->videnc2OutArgs.extendedError);
1352 printf("Encoding Error\n");
1353 goto shutdown;
1354 }
1355 MSG("\n bytesGenerated %d", mpeg4enc_outArgs->videnc2OutArgs.bytesGenerated);
1356 bytesGenerated = mpeg4enc_outArgs->videnc2OutArgs.bytesGenerated;
1357 } else if (encObj.codectype == DCE_ENC_TEST_JPEG) {
1358 jpegenc_inArgs = (IJPEGVENC_InArgs *) encObj.inArgs;
1359 jpegenc_outArgs = (IJPEGVENC_OutArgs *) encObj.outArgs;
1360 MSG("TEST inArgs->inputID %d jpegenc_inArgs->videnc2InArgs.inputID %d", encObj.inArgs->inputID, jpegenc_inArgs->videnc2InArgs.inputID);
1361 MSG("[DCE_ENC_TEST] codec %p inBufs %p outBufs %p jpegenc_inArgs %p jpegenc_outArgs %p", encObj.codec, encObj.inBufs, encObj.outBufs, jpegenc_inArgs, jpegenc_outArgs);
1362 err = VIDENC2_process(encObj.codec, encObj.inBufs, encObj.outBufs, (VIDENC2_InArgs *) jpegenc_inArgs, (VIDENC2_OutArgs *) jpegenc_outArgs);
1363 MSG("[DCE_ENC_TEST] VIDENC2_process - err %d", err);
1364 if( err < 0 ) {
1365 //TODO error handling on JPEG
1366 ERROR("Codec_process returned err=%d, extendedError=%08x", err, jpegenc_outArgs->videnc2OutArgs.extendedError);
1367 printf("Encoding Error\n");
1368 goto shutdown;
1369 }
1370 MSG("\n bytesGenerated %d", jpegenc_outArgs->videnc2OutArgs.bytesGenerated);
1371 bytesGenerated = jpegenc_outArgs->videnc2OutArgs.bytesGenerated;
1372 }
1375 /*
1376 * Handling of output data from codec
1377 */
1379 /* get the output buffer and write it to file */
1380 if( bytesGenerated ) {
1381 // write the frames to output file based on the value of frames_to_write on how many frames to write.
1382 if( out_cnt > encObj.nframes ){
1383 printf("Encoding completed successfully\n");
1384 goto shutdown;
1385 }
1386 INFO("Dumping frame %d", out_cnt);
1387 write_output(&encObj, bytesGenerated);
1388 }
1389 out_cnt++;
1390 ++iters; // Guard for infinite VIDENC2_PROCESS loop when codec never return XDM_EFAIL
1391 } while( eof && (err != XDM_EFAIL) && (iters < 1000)); // Multiple VIDENC2_process when eof until err == XDM_EFAIL
1392 }
1393 shutdown:
1394 encoder_deinit(&encObj);
1395 return 0;
1396 }