1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #include "oscl_types.h"
19 #include "oscl_mem.h"
20 #include "avcenc_api.h"
21 #include "avcenc_lib.h"
22
23 /* ======================================================================== */
24 /* Function : PVAVCGetNALType() */
25 /* Date : 11/4/2003 */
26 /* Purpose : Sniff NAL type from the bitstream */
27 /* In/out : */
28 /* Return : AVCENC_SUCCESS if succeed, AVCENC_FAIL if fail. */
29 /* Modified : */
30 /* ======================================================================== */
PVAVCEncGetNALType(unsigned char * bitstream,int size,int * nal_type,int * nal_ref_idc)31 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetNALType(unsigned char *bitstream, int size,
32 int *nal_type, int *nal_ref_idc)
33 {
34 int forbidden_zero_bit;
35 if (size > 0)
36 {
37 forbidden_zero_bit = bitstream[0] >> 7;
38 if (forbidden_zero_bit != 0)
39 return AVCENC_FAIL;
40 *nal_ref_idc = (bitstream[0] & 0x60) >> 5;
41 *nal_type = bitstream[0] & 0x1F;
42 return AVCENC_SUCCESS;
43 }
44
45 return AVCENC_FAIL;
46 }
47
48
49 /* ======================================================================== */
50 /* Function : PVAVCEncInitialize() */
51 /* Date : 3/18/2004 */
52 /* Purpose : Initialize the encoder library, allocate memory and verify */
53 /* the profile/level support/settings. */
54 /* In/out : Encoding parameters. */
55 /* Return : AVCENC_SUCCESS for success. */
56 /* Modified : */
57 /* ======================================================================== */
PVAVCEncInitialize(AVCHandle * avcHandle,AVCEncParams * encParam,void * extSPS,void * extPPS)58 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncInitialize(AVCHandle *avcHandle, AVCEncParams *encParam,
59 void* extSPS, void* extPPS)
60 {
61 AVCEnc_Status status;
62 AVCEncObject *encvid;
63 AVCCommonObj *video;
64 uint32 *userData = (uint32*) avcHandle->userData;
65 int framesize;
66
67 if (avcHandle->AVCObject != NULL)
68 {
69 return AVCENC_ALREADY_INITIALIZED; /* It's already initialized, need to cleanup first */
70 }
71
72 /* not initialized */
73
74 /* allocate videoObject */
75 avcHandle->AVCObject = (void*)avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncObject), DEFAULT_ATTR);
76 if (avcHandle->AVCObject == NULL)
77 {
78 return AVCENC_MEMORY_FAIL;
79 }
80
81 encvid = (AVCEncObject*) avcHandle->AVCObject;
82 oscl_memset(encvid, 0, sizeof(AVCEncObject)); /* reset everything */
83
84 encvid->enc_state = AVCEnc_Initializing;
85
86 encvid->avcHandle = avcHandle;
87
88 encvid->common = (AVCCommonObj*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCCommonObj), DEFAULT_ATTR);
89 if (encvid->common == NULL)
90 {
91 return AVCENC_MEMORY_FAIL;
92 }
93
94 video = encvid->common;
95 oscl_memset(video, 0, sizeof(AVCCommonObj));
96
97 /* allocate bitstream structure */
98 encvid->bitstream = (AVCEncBitstream*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncBitstream), DEFAULT_ATTR);
99 if (encvid->bitstream == NULL)
100 {
101 return AVCENC_MEMORY_FAIL;
102 }
103 encvid->bitstream->encvid = encvid; /* to point back for reallocation */
104
105 /* allocate sequence parameter set structure */
106 video->currSeqParams = (AVCSeqParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSeqParamSet), DEFAULT_ATTR);
107 if (video->currSeqParams == NULL)
108 {
109 return AVCENC_MEMORY_FAIL;
110 }
111 oscl_memset(video->currSeqParams, 0, sizeof(AVCSeqParamSet));
112
113 /* allocate picture parameter set structure */
114 video->currPicParams = (AVCPicParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCPicParamSet), DEFAULT_ATTR);
115 if (video->currPicParams == NULL)
116 {
117 return AVCENC_MEMORY_FAIL;
118 }
119 oscl_memset(video->currPicParams, 0, sizeof(AVCPicParamSet));
120
121 /* allocate slice header structure */
122 video->sliceHdr = (AVCSliceHeader*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSliceHeader), DEFAULT_ATTR);
123 if (video->sliceHdr == NULL)
124 {
125 return AVCENC_MEMORY_FAIL;
126 }
127 oscl_memset(video->sliceHdr, 0, sizeof(AVCSliceHeader));
128
129 /* allocate encoded picture buffer structure*/
130 video->decPicBuf = (AVCDecPicBuffer*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCDecPicBuffer), DEFAULT_ATTR);
131 if (video->decPicBuf == NULL)
132 {
133 return AVCENC_MEMORY_FAIL;
134 }
135 oscl_memset(video->decPicBuf, 0, sizeof(AVCDecPicBuffer));
136
137 /* allocate rate control structure */
138 encvid->rateCtrl = (AVCRateControl*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCRateControl), DEFAULT_ATTR);
139 if (encvid->rateCtrl == NULL)
140 {
141 return AVCENC_MEMORY_FAIL;
142 }
143 oscl_memset(encvid->rateCtrl, 0, sizeof(AVCRateControl));
144
145 /* reset frame list, not really needed */
146 video->currPic = NULL;
147 video->currFS = NULL;
148 encvid->currInput = NULL;
149 video->prevRefPic = NULL;
150
151 /* now read encParams, and allocate dimension-dependent variables */
152 /* such as mblock */
153 status = SetEncodeParam(avcHandle, encParam, extSPS, extPPS); /* initialized variables to be used in SPS*/
154 if (status != AVCENC_SUCCESS)
155 {
156 return status;
157 }
158
159 if (encParam->use_overrun_buffer == AVC_ON)
160 {
161 /* allocate overrun buffer */
162 encvid->oBSize = encvid->rateCtrl->cpbSize;
163 if (encvid->oBSize > DEFAULT_OVERRUN_BUFFER_SIZE)
164 {
165 encvid->oBSize = DEFAULT_OVERRUN_BUFFER_SIZE;
166 }
167 encvid->overrunBuffer = (uint8*) avcHandle->CBAVC_Malloc(userData, encvid->oBSize, DEFAULT_ATTR);
168 if (encvid->overrunBuffer == NULL)
169 {
170 return AVCENC_MEMORY_FAIL;
171 }
172 }
173 else
174 {
175 encvid->oBSize = 0;
176 encvid->overrunBuffer = NULL;
177 }
178
179 /* allocate frame size dependent structures */
180 framesize = video->FrameHeightInMbs * video->PicWidthInMbs;
181
182 video->mblock = (AVCMacroblock*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMacroblock) * framesize, DEFAULT_ATTR);
183 if (video->mblock == NULL)
184 {
185 return AVCENC_MEMORY_FAIL;
186 }
187
188 video->MbToSliceGroupMap = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(uint) * video->PicSizeInMapUnits * 2, DEFAULT_ATTR);
189 if (video->MbToSliceGroupMap == NULL)
190 {
191 return AVCENC_MEMORY_FAIL;
192 }
193
194 encvid->mot16x16 = (AVCMV*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMV) * framesize, DEFAULT_ATTR);
195 if (encvid->mot16x16 == NULL)
196 {
197 return AVCENC_MEMORY_FAIL;
198 }
199 oscl_memset(encvid->mot16x16, 0, sizeof(AVCMV)*framesize);
200
201 encvid->intraSearch = (uint8*) avcHandle->CBAVC_Malloc(userData, sizeof(uint8) * framesize, DEFAULT_ATTR);
202 if (encvid->intraSearch == NULL)
203 {
204 return AVCENC_MEMORY_FAIL;
205 }
206
207 encvid->min_cost = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(int) * framesize, DEFAULT_ATTR);
208 if (encvid->min_cost == NULL)
209 {
210 return AVCENC_MEMORY_FAIL;
211 }
212
213 /* initialize motion search related memory */
214 if (AVCENC_SUCCESS != InitMotionSearchModule(avcHandle))
215 {
216 return AVCENC_MEMORY_FAIL;
217 }
218
219 if (AVCENC_SUCCESS != InitRateControlModule(avcHandle))
220 {
221 return AVCENC_MEMORY_FAIL;
222 }
223
224 /* intialize function pointers */
225 encvid->functionPointer = (AVCEncFuncPtr*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncFuncPtr), DEFAULT_ATTR);
226 if (encvid->functionPointer == NULL)
227 {
228 return AVCENC_MEMORY_FAIL;
229 }
230 encvid->functionPointer->SAD_Macroblock = &AVCSAD_Macroblock_C;
231 encvid->functionPointer->SAD_MB_HalfPel[0] = NULL;
232 encvid->functionPointer->SAD_MB_HalfPel[1] = &AVCSAD_MB_HalfPel_Cxh;
233 encvid->functionPointer->SAD_MB_HalfPel[2] = &AVCSAD_MB_HalfPel_Cyh;
234 encvid->functionPointer->SAD_MB_HalfPel[3] = &AVCSAD_MB_HalfPel_Cxhyh;
235
236 /* initialize timing control */
237 encvid->modTimeRef = 0; /* ALWAYS ASSUME THAT TIMESTAMP START FROM 0 !!!*/
238 video->prevFrameNum = 0;
239 encvid->prevCodedFrameNum = 0;
240 encvid->dispOrdPOCRef = 0;
241
242 if (encvid->outOfBandParamSet == TRUE)
243 {
244 encvid->enc_state = AVCEnc_Encoding_SPS;
245 }
246 else
247 {
248 encvid->enc_state = AVCEnc_Analyzing_Frame;
249 }
250
251 return AVCENC_SUCCESS;
252 }
253
254 /* ======================================================================== */
255 /* Function : PVAVCEncGetMaxOutputSize() */
256 /* Date : 11/29/2008 */
257 /* Purpose : Return max output buffer size that apps should allocate for */
258 /* output buffer. */
259 /* In/out : */
260 /* Return : AVCENC_SUCCESS for success. */
261 /* Modified : size */
262 /* ======================================================================== */
263
PVAVCEncGetMaxOutputBufferSize(AVCHandle * avcHandle,int * size)264 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetMaxOutputBufferSize(AVCHandle *avcHandle, int* size)
265 {
266 AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
267
268 if (encvid == NULL)
269 {
270 return AVCENC_UNINITIALIZED;
271 }
272
273 *size = encvid->rateCtrl->cpbSize;
274
275 return AVCENC_SUCCESS;
276 }
277
278 /* ======================================================================== */
279 /* Function : PVAVCEncSetInput() */
280 /* Date : 4/18/2004 */
281 /* Purpose : To feed an unencoded original frame to the encoder library. */
282 /* In/out : */
283 /* Return : AVCENC_SUCCESS for success. */
284 /* Modified : */
285 /* ======================================================================== */
PVAVCEncSetInput(AVCHandle * avcHandle,AVCFrameIO * input)286 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncSetInput(AVCHandle *avcHandle, AVCFrameIO *input)
287 {
288 AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
289 AVCCommonObj *video = encvid->common;
290 AVCRateControl *rateCtrl = encvid->rateCtrl;
291
292 AVCEnc_Status status;
293 uint frameNum;
294
295 if (encvid == NULL)
296 {
297 return AVCENC_UNINITIALIZED;
298 }
299
300 if (encvid->enc_state == AVCEnc_WaitingForBuffer)
301 {
302 goto RECALL_INITFRAME;
303 }
304 else if (encvid->enc_state != AVCEnc_Analyzing_Frame)
305 {
306 return AVCENC_FAIL;
307 }
308
309 if (input->pitch > 0xFFFF)
310 {
311 return AVCENC_NOT_SUPPORTED; // we use 2-bytes for pitch
312 }
313
314 /***********************************/
315
316 /* Let's rate control decide whether to encode this frame or not */
317 /* Also set video->nal_unit_type, sliceHdr->slice_type, video->slice_type */
318 if (AVCENC_SUCCESS != RCDetermineFrameNum(encvid, rateCtrl, input->coding_timestamp, &frameNum))
319 {
320 return AVCENC_SKIPPED_PICTURE; /* not time to encode, thus skipping */
321 }
322
323 /* we may not need this line */
324 //nextFrmModTime = (uint32)((((frameNum+1)*1000)/rateCtrl->frame_rate) + modTimeRef); /* rec. time */
325 //encvid->nextModTime = nextFrmModTime - (encvid->frameInterval>>1) - 1; /* between current and next frame */
326
327 encvid->currInput = input;
328 encvid->currInput->coding_order = frameNum;
329
330 RECALL_INITFRAME:
331 /* initialize and analyze the frame */
332 status = InitFrame(encvid);
333
334 if (status == AVCENC_SUCCESS)
335 {
336 encvid->enc_state = AVCEnc_Encoding_Frame;
337 }
338 else if (status == AVCENC_NEW_IDR)
339 {
340 if (encvid->outOfBandParamSet == TRUE)
341 {
342 encvid->enc_state = AVCEnc_Encoding_Frame;
343 }
344 else // assuming that in-band paramset keeps sending new SPS and PPS.
345 {
346 encvid->enc_state = AVCEnc_Encoding_SPS;
347 //video->currSeqParams->seq_parameter_set_id++;
348 //if(video->currSeqParams->seq_parameter_set_id > 31) // range check
349 {
350 video->currSeqParams->seq_parameter_set_id = 0; // reset
351 }
352 }
353
354 video->sliceHdr->idr_pic_id++;
355 if (video->sliceHdr->idr_pic_id > 65535) // range check
356 {
357 video->sliceHdr->idr_pic_id = 0; // reset
358 }
359 }
360 /* the following logics need to be revisited */
361 else if (status == AVCENC_PICTURE_READY) // no buffers returned back to the encoder
362 {
363 encvid->enc_state = AVCEnc_WaitingForBuffer; // Input accepted but can't continue
364 // need to free up some memory before proceeding with Encode
365 }
366
367 return status; // return status, including the AVCENC_FAIL case and all 3 above.
368 }
369
370 /* ======================================================================== */
371 /* Function : PVAVCEncodeNAL() */
372 /* Date : 4/29/2004 */
373 /* Purpose : To encode one NAL/slice. */
374 /* In/out : */
375 /* Return : AVCENC_SUCCESS for success. */
376 /* Modified : */
377 /* ======================================================================== */
PVAVCEncodeNAL(AVCHandle * avcHandle,unsigned char * buffer,unsigned int * buf_nal_size,int * nal_type)378 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncodeNAL(AVCHandle *avcHandle, unsigned char *buffer, unsigned int *buf_nal_size, int *nal_type)
379 {
380 AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
381 AVCCommonObj *video = encvid->common;
382 AVCEncBitstream *bitstream = encvid->bitstream;
383 AVCEnc_Status status;
384
385 if (encvid == NULL)
386 {
387 return AVCENC_UNINITIALIZED;
388 }
389
390 switch (encvid->enc_state)
391 {
392 case AVCEnc_Initializing:
393 return AVCENC_UNINITIALIZED;
394 case AVCEnc_Encoding_SPS:
395 /* initialized the structure */
396 BitstreamEncInit(bitstream, buffer, *buf_nal_size, NULL, 0);
397 BitstreamWriteBits(bitstream, 8, (1 << 5) | AVC_NALTYPE_SPS);
398
399 /* encode SPS */
400 status = EncodeSPS(encvid, bitstream);
401 if (status != AVCENC_SUCCESS)
402 {
403 return status;
404 }
405
406 /* closing the NAL with trailing bits */
407 status = BitstreamTrailingBits(bitstream, buf_nal_size);
408 if (status == AVCENC_SUCCESS)
409 {
410 encvid->enc_state = AVCEnc_Encoding_PPS;
411 video->currPicParams->seq_parameter_set_id = video->currSeqParams->seq_parameter_set_id;
412 video->currPicParams->pic_parameter_set_id++;
413 *nal_type = AVC_NALTYPE_SPS;
414 *buf_nal_size = bitstream->write_pos;
415 }
416 break;
417 case AVCEnc_Encoding_PPS:
418 /* initialized the structure */
419 BitstreamEncInit(bitstream, buffer, *buf_nal_size, NULL, 0);
420 BitstreamWriteBits(bitstream, 8, (1 << 5) | AVC_NALTYPE_PPS);
421
422 /* encode PPS */
423 status = EncodePPS(encvid, bitstream);
424 if (status != AVCENC_SUCCESS)
425 {
426 return status;
427 }
428
429 /* closing the NAL with trailing bits */
430 status = BitstreamTrailingBits(bitstream, buf_nal_size);
431 if (status == AVCENC_SUCCESS)
432 {
433 if (encvid->outOfBandParamSet == TRUE) // already extract PPS, SPS
434 {
435 encvid->enc_state = AVCEnc_Analyzing_Frame;
436 }
437 else // SetInput has been called before SPS and PPS.
438 {
439 encvid->enc_state = AVCEnc_Encoding_Frame;
440 }
441
442 *nal_type = AVC_NALTYPE_PPS;
443 *buf_nal_size = bitstream->write_pos;
444 }
445 break;
446
447 case AVCEnc_Encoding_Frame:
448 /* initialized the structure */
449 BitstreamEncInit(bitstream, buffer, *buf_nal_size, encvid->overrunBuffer, encvid->oBSize);
450 BitstreamWriteBits(bitstream, 8, (video->nal_ref_idc << 5) | (video->nal_unit_type));
451
452 /* Re-order the reference list according to the ref_pic_list_reordering() */
453 /* We don't have to reorder the list for the encoder here. This can only be done
454 after we encode this slice. We can run thru a second-pass to see if new ordering
455 would save more bits. Too much delay !! */
456 /* status = ReOrderList(video);*/
457 status = InitSlice(encvid);
458 if (status != AVCENC_SUCCESS)
459 {
460 return status;
461 }
462
463 /* when we have everything, we encode the slice header */
464 status = EncodeSliceHeader(encvid, bitstream);
465 if (status != AVCENC_SUCCESS)
466 {
467 return status;
468 }
469
470 status = AVCEncodeSlice(encvid);
471
472 video->slice_id++;
473
474 /* closing the NAL with trailing bits */
475 BitstreamTrailingBits(bitstream, buf_nal_size);
476
477 *buf_nal_size = bitstream->write_pos;
478
479 encvid->rateCtrl->numFrameBits += ((*buf_nal_size) << 3);
480
481 *nal_type = video->nal_unit_type;
482
483 if (status == AVCENC_PICTURE_READY)
484 {
485 status = RCUpdateFrame(encvid);
486 if (status == AVCENC_SKIPPED_PICTURE) /* skip current frame */
487 {
488 DPBReleaseCurrentFrame(avcHandle, video);
489 encvid->enc_state = AVCEnc_Analyzing_Frame;
490
491 return status;
492 }
493
494 /* perform loop-filtering on the entire frame */
495 DeblockPicture(video);
496
497 /* update the original frame array */
498 encvid->prevCodedFrameNum = encvid->currInput->coding_order;
499
500 /* store the encoded picture in the DPB buffer */
501 StorePictureInDPB(avcHandle, video);
502
503 if (video->currPic->isReference)
504 {
505 video->PrevRefFrameNum = video->sliceHdr->frame_num;
506 }
507
508 /* update POC related variables */
509 PostPOC(video);
510
511 encvid->enc_state = AVCEnc_Analyzing_Frame;
512 status = AVCENC_PICTURE_READY;
513
514 }
515 break;
516 default:
517 status = AVCENC_WRONG_STATE;
518 }
519
520 return status;
521 }
522
523 /* ======================================================================== */
524 /* Function : PVAVCEncGetOverrunBuffer() */
525 /* Purpose : To retrieve the overrun buffer. Check whether overrun buffer */
526 /* is used or not before returning */
527 /* In/out : */
528 /* Return : Pointer to the internal overrun buffer. */
529 /* Modified : */
530 /* ======================================================================== */
PVAVCEncGetOverrunBuffer(AVCHandle * avcHandle)531 OSCL_EXPORT_REF uint8* PVAVCEncGetOverrunBuffer(AVCHandle* avcHandle)
532 {
533 AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
534 AVCEncBitstream *bitstream = encvid->bitstream;
535
536 if (bitstream->overrunBuffer == bitstream->bitstreamBuffer) /* OB is used */
537 {
538 return encvid->overrunBuffer;
539 }
540 else
541 {
542 return NULL;
543 }
544 }
545
546
547 /* ======================================================================== */
548 /* Function : PVAVCEncGetRecon() */
549 /* Date : 4/29/2004 */
550 /* Purpose : To retrieve the most recently encoded frame. */
551 /* assume that user will make a copy if they want to hold on */
552 /* to it. Otherwise, it is not guaranteed to be reserved. */
553 /* Most applications prefer to see original frame rather than */
554 /* reconstructed frame. So, we are staying aware from complex */
555 /* buffering mechanism. If needed, can be added later. */
556 /* In/out : */
557 /* Return : AVCENC_SUCCESS for success. */
558 /* Modified : */
559 /* ======================================================================== */
PVAVCEncGetRecon(AVCHandle * avcHandle,AVCFrameIO * recon)560 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetRecon(AVCHandle *avcHandle, AVCFrameIO *recon)
561 {
562 AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
563 AVCCommonObj *video = encvid->common;
564 AVCFrameStore *currFS = video->currFS;
565
566 if (encvid == NULL)
567 {
568 return AVCENC_UNINITIALIZED;
569 }
570
571 recon->YCbCr[0] = currFS->frame.Sl;
572 recon->YCbCr[1] = currFS->frame.Scb;
573 recon->YCbCr[2] = currFS->frame.Scr;
574 recon->height = currFS->frame.height;
575 recon->pitch = currFS->frame.pitch;
576 recon->disp_order = currFS->PicOrderCnt;
577 recon->coding_order = currFS->FrameNum;
578 recon->id = (uint32) currFS->base_dpb; /* use the pointer as the id */
579
580 currFS->IsOutputted |= 1;
581
582 return AVCENC_SUCCESS;
583 }
584
PVAVCEncReleaseRecon(AVCHandle * avcHandle,AVCFrameIO * recon)585 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncReleaseRecon(AVCHandle *avcHandle, AVCFrameIO *recon)
586 {
587 OSCL_UNUSED_ARG(avcHandle);
588 OSCL_UNUSED_ARG(recon);
589
590 return AVCENC_SUCCESS; //for now
591 }
592
593 /* ======================================================================== */
594 /* Function : PVAVCCleanUpEncoder() */
595 /* Date : 4/18/2004 */
596 /* Purpose : To clean up memories allocated by PVAVCEncInitialize() */
597 /* In/out : */
598 /* Return : AVCENC_SUCCESS for success. */
599 /* Modified : */
600 /* ======================================================================== */
PVAVCCleanUpEncoder(AVCHandle * avcHandle)601 OSCL_EXPORT_REF void PVAVCCleanUpEncoder(AVCHandle *avcHandle)
602 {
603 AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
604 AVCCommonObj *video;
605 uint32 *userData = (uint32*) avcHandle->userData;
606
607 if (encvid != NULL)
608 {
609 CleanMotionSearchModule(avcHandle);
610
611 CleanupRateControlModule(avcHandle);
612
613 if (encvid->functionPointer != NULL)
614 {
615 avcHandle->CBAVC_Free(userData, (int)encvid->functionPointer);
616 }
617
618 if (encvid->min_cost)
619 {
620 avcHandle->CBAVC_Free(userData, (int)encvid->min_cost);
621 }
622
623 if (encvid->intraSearch)
624 {
625 avcHandle->CBAVC_Free(userData, (int)encvid->intraSearch);
626 }
627
628 if (encvid->mot16x16)
629 {
630 avcHandle->CBAVC_Free(userData, (int)encvid->mot16x16);
631 }
632
633 if (encvid->rateCtrl)
634 {
635 avcHandle->CBAVC_Free(userData, (int)encvid->rateCtrl);
636 }
637
638 if (encvid->overrunBuffer)
639 {
640 avcHandle->CBAVC_Free(userData, (int)encvid->overrunBuffer);
641 }
642
643 video = encvid->common;
644 if (video != NULL)
645 {
646 if (video->MbToSliceGroupMap)
647 {
648 avcHandle->CBAVC_Free(userData, (int)video->MbToSliceGroupMap);
649 }
650 if (video->mblock != NULL)
651 {
652 avcHandle->CBAVC_Free(userData, (int)video->mblock);
653 }
654 if (video->decPicBuf != NULL)
655 {
656 CleanUpDPB(avcHandle, video);
657 avcHandle->CBAVC_Free(userData, (int)video->decPicBuf);
658 }
659 if (video->sliceHdr != NULL)
660 {
661 avcHandle->CBAVC_Free(userData, (int)video->sliceHdr);
662 }
663 if (video->currPicParams != NULL)
664 {
665 if (video->currPicParams->slice_group_id)
666 {
667 avcHandle->CBAVC_Free(userData, (int)video->currPicParams->slice_group_id);
668 }
669
670 avcHandle->CBAVC_Free(userData, (int)video->currPicParams);
671 }
672 if (video->currSeqParams != NULL)
673 {
674 avcHandle->CBAVC_Free(userData, (int)video->currSeqParams);
675 }
676 if (encvid->bitstream != NULL)
677 {
678 avcHandle->CBAVC_Free(userData, (int)encvid->bitstream);
679 }
680 if (video != NULL)
681 {
682 avcHandle->CBAVC_Free(userData, (int)video);
683 }
684 }
685
686 avcHandle->CBAVC_Free(userData, (int)encvid);
687
688 avcHandle->AVCObject = NULL;
689 }
690
691 return ;
692 }
693
PVAVCEncUpdateBitRate(AVCHandle * avcHandle,uint32 bitrate)694 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateBitRate(AVCHandle *avcHandle, uint32 bitrate)
695 {
696 OSCL_UNUSED_ARG(avcHandle);
697 OSCL_UNUSED_ARG(bitrate);
698
699 return AVCENC_FAIL;
700 }
701
PVAVCEncUpdateFrameRate(AVCHandle * avcHandle,uint32 num,uint32 denom)702 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateFrameRate(AVCHandle *avcHandle, uint32 num, uint32 denom)
703 {
704 OSCL_UNUSED_ARG(avcHandle);
705 OSCL_UNUSED_ARG(num);
706 OSCL_UNUSED_ARG(denom);
707
708 return AVCENC_FAIL;
709 }
710
PVAVCEncUpdateIDRInterval(AVCHandle * avcHandle,int IDRInterval)711 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateIDRInterval(AVCHandle *avcHandle, int IDRInterval)
712 {
713 OSCL_UNUSED_ARG(avcHandle);
714 OSCL_UNUSED_ARG(IDRInterval);
715
716 return AVCENC_FAIL;
717 }
718
PVAVCEncIDRRequest(AVCHandle * avcHandle)719 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncIDRRequest(AVCHandle *avcHandle)
720 {
721 OSCL_UNUSED_ARG(avcHandle);
722
723 return AVCENC_FAIL;
724 }
725
PVAVCEncUpdateIMBRefresh(AVCHandle * avcHandle,int numMB)726 OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateIMBRefresh(AVCHandle *avcHandle, int numMB)
727 {
728 OSCL_UNUSED_ARG(avcHandle);
729 OSCL_UNUSED_ARG(numMB);
730
731 return AVCENC_FAIL;
732 }
733
PVAVCEncGetFrameStats(AVCHandle * avcHandle,AVCEncFrameStats * avcStats)734 void PVAVCEncGetFrameStats(AVCHandle *avcHandle, AVCEncFrameStats *avcStats)
735 {
736 AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
737 AVCRateControl *rateCtrl = encvid->rateCtrl;
738
739 avcStats->avgFrameQP = GetAvgFrameQP(rateCtrl);
740 avcStats->numIntraMBs = encvid->numIntraMB;
741
742 return ;
743 }
744
745
746
747