1 2/* 3 * Copyright (C) Texas Instruments - http://www.ti.com/ 4 * 5 * This library is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU Lesser General Public 7 * License as published by the Free Software Foundation; either 8 * version 2.1 of the License, or (at your option) any later version. 9 * 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21/* ============================================================================= 22* Texas Instruments OMAP(TM) Platform Software 23* (c) Copyright Texas Instruments, Incorporated. All Rights Reserved. 24* 25* Use of this software is controlled by the terms and conditions found 26* in the license agreement under which this software has been supplied. 27* ============================================================================*/ 28/** 29* @file OMX_VideoEnc_Utils.c 30* 31* This file implements OMX Component for MPEG-4 encoder that 32* is fully compliant with the OMX specification 1.5. 33* 34* @path $(CSLPATH)\src 35* 36* @rev 0.1 37*/ 38/* ---------------------------------------------------------------------------*/ 39/* ============================================================================= 40*! 41*! Revision History 42*! ============================================================================= 43*! 44*! 02-Feb-2006 mf: Revisions appear in reverse chronological order; 45*! that is, newest first. The date format is dd-Mon-yyyy. 46* ============================================================================*/ 47 48/* ------compilation control switches ----------------------------------------*/ 49/****************************************************************************** 50* INCLUDE FILES 51*******************************************************************************/ 52/* ----- system and platform files -------------------------------------------*/ 53#ifdef UNDER_CE 54 #include <windows.h> 55 #include <omx_core.h> 56 #include <stdlib.h> 57 #include <pthread.h> 58#else 59 #include <wchar.h> 60 #include <unistd.h> 61 #include <sys/types.h> 62 #include <sys/wait.h> 63 #include <sys/types.h> 64 #include <sys/select.h> 65 #include <sys/stat.h> 66 #include <dlfcn.h> 67 #include <malloc.h> 68 #include <memory.h> 69 #include <fcntl.h> 70#endif 71 72#include <dbapi.h> 73#include <string.h> 74#include <stdlib.h> 75#include <stdio.h> 76 77/*------- Program Header Files -----------------------------------------------*/ 78#include "OMX_VideoEnc_Utils.h" 79#include "OMX_VideoEnc_Thread.h" 80#include "OMX_VideoEnc_DSP.h" 81 82#define DSP_MMU_FAULT_HANDLING 83 84// We cannot request the same MHz for all resolutions. 85// we have to change this implementation once we modify 86// opencore to request the correct level based on resolution/bitrate/etc 87#define VIDEO_ENCODER_MHZ (400 - 45 + 2) 88 89/* H264 Specific */ 90#define SPS_CODE_PREFIX 0x07 91#define PPS_CODE_PREFIX 0x08 92 93#ifdef UNDER_CE 94 HINSTANCE g_hLcmlDllHandle = NULL; 95#endif 96#ifdef UNDER_CE 97void sleep(DWORD Duration) 98{ 99 Sleep(Duration); 100} 101#endif 102/******************************************************************************* 103* EXTERNAL REFERENCES NOTE : only use if not found in header file 104*******************************************************************************/ 105/*--------data declarations --------------------------------------------------*/ 106/*--------function prototypes ------------------------------------------------*/ 107 108/******************************************************************************* 109* PUBLIC DECLARATIONS Defined here, used elsewhere 110*******************************************************************************/ 111/*--------data declarations --------------------------------------------------*/ 112 113 114/*--------function prototypes ------------------------------------------------*/ 115 116/******************************************************************************* 117* PRIVATE DECLARATIONS Defined here, used only here 118*******************************************************************************/ 119/*--------data declarations --------------------------------------------------*/ 120struct DSP_UUID H264VESOCKET_TI_UUID = { 121 0x63A3581A, 0x09D7, 0x4AD0, 0x80, 0xB8, { 122 0x5F, 0x2C, 0x4D, 0x4D, 0x59, 0xC9 123 } 124}; 125 126struct DSP_UUID MP4VESOCKET_TI_UUID = { 127 0x98c2e8d8, 0x4644, 0x11d6, 0x81, 0x18, { 128 0x00, 0xb0, 0xd0, 0x8d, 0x72, 0x9f 129 } 130}; 131 132struct DSP_UUID USN_UUID = { 133 0x79A3C8B3, 0x95F2, 0x403F, 0x9A, 0x4B, { 134 0xCF, 0x80, 0x57, 0x73, 0x05, 0x41 135 } 136}; 137 138OMX_U32 VIDENC_STRUCT_H264DEFBITRATE [VIDENC_MAXBITRATES][2] = { 139/*1*/ {176 * 144, 128000}, /*128KBps*/ 140/*2*/ {320 * 240, 400000}, /*400KBps*/ 141/*3*/ {352 * 288, 500000}, /*500kBps*/ 142/*4*/ {640 * 480, 1500000}, /*1.5MBps*/ 143/*5*/ {720 * 480, 2000000}, /*2MBps*/ 144/*6*/ {720 * 576, 3000000}, /*3MBps*/ 145/*7*/ {1280 * 720, 3000000}, /*3MBps*/ 146}; 147 148OMX_U32 VIDENC_STRUCT_MPEG4DEFBITRATE [VIDENC_MAXBITRATES][2] = { 149/*1*/ {176 * 144, 128000}, /*128KBps*/ 150/*2*/ {320 * 240, 400000}, /*400KBps*/ 151/*3*/ {352 * 288, 500000}, /*500kBps*/ 152/*4*/ {640 * 480, 1500000}, /*1.5MBps*/ 153/*5*/ {720 * 480, 2000000}, /*2MBps*/ 154/*6*/ {720 * 576, 3000000}, /*3MBps*/ 155/*7*/ {1280 * 720, 3000000}, /*3MBps*/ 156}; 157 158OMX_U32 VIDENC_STRUCT_H263DEFBITRATE [VIDENC_MAXBITRATES][2] = { 159/*1*/ {176 * 144, 128000}, /*128KBps*/ 160/*2*/ {320 * 240, 400000}, /*400KBps*/ 161/*3*/ {352 * 288, 500000}, /*500kBps*/ 162/*4*/ {640 * 480, 1500000}, /*1.5MBps*/ 163/*5*/ {720 * 480, 2000000}, /*2MBps*/ 164/*6*/ {720 * 576, 3000000}, /*3MBps*/ 165/*7*/ {1280 * 720, 3000000}, /*3MBps*/ 166}; 167/*--------macro definitions ---------------------------------------------------*/ 168 169static const int iQ16_Const = 1 << 16; 170static const float fQ16_Const = (float)(1 << 16); 171 172static float Q16Tof(int nQ16) 173{ 174 return nQ16 / fQ16_Const; 175} 176 177 178 179/*-----------------------------------------------------------------------------*/ 180/** 181 * ListCreate() 182 * 183 * Function call in OMX_ComponentInit(). Creates the List Head of the Component Memory List. 184 * 185 * @param pListHead VIDENC_NODE double pointer with the List Header of the Memory List. 186 * 187 * @retval OMX_ErrorNone 188 * OMX_ErrorInsufficientResources if the malloc fails 189 * 190 **/ 191/*-----------------------------------------------------------------------------*/ 192OMX_ERRORTYPE OMX_VIDENC_ListCreate(struct OMX_TI_Debug *dbg, struct VIDENC_NODE** pListHead) 193{ 194 OMX_ERRORTYPE eError = OMX_ErrorNone; 195 196 *pListHead = (VIDENC_NODE*)malloc(sizeof(VIDENC_NODE)); /* need to malloc!!! */ 197 if (*pListHead == NULL) 198 { 199 OMX_TRACE4(*dbg, "malloc() out of memory error\n"); 200 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources); 201 } 202 203 OMX_TRACE1(*dbg, "Create MemoryListHeader[%p]\n", *pListHead); 204 memset(*pListHead, 0x0, sizeof(VIDENC_NODE)); 205 206OMX_CONF_CMD_BAIL: 207 return eError; 208} 209 210/*-----------------------------------------------------------------------------*/ 211/** 212 * ListAdd() 213 * 214 * Called inside VIDENC_MALLOC Macro to add a new node to Component Memory List 215 * 216 * @param pListHead VIDENC_NODE Points List Header of the Memory List. 217 * pData OMX_PTR points to the new allocated data. 218 * @retval OMX_ErrorNone 219 * OMX_ErrorInsufficientResources if the malloc fails 220 * 221 **/ 222/*-----------------------------------------------------------------------------*/ 223 224OMX_ERRORTYPE OMX_VIDENC_ListAdd(struct OMX_TI_Debug *dbg, struct VIDENC_NODE* pListHead, OMX_PTR pData) 225{ 226 OMX_ERRORTYPE eError = OMX_ErrorNone; 227 VIDENC_NODE* pTmp = NULL; 228 VIDENC_NODE* pNewNode = NULL; 229 pNewNode = (VIDENC_NODE*)malloc(sizeof(VIDENC_NODE)); /* need to malloc!!! */ 230 if (pNewNode == NULL) 231 { 232 OMX_TRACE4(*dbg, "malloc() out of memory error\n"); 233 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources); 234 } 235 memset(pNewNode, 0x0, sizeof(VIDENC_NODE)); 236 pNewNode->pData = pData; 237 pNewNode->pNext = NULL; 238 OMX_TRACE1(*dbg, "Add MemoryNode[%p] -> [%p]\n", pNewNode, pNewNode->pData); 239 pTmp = pListHead; 240 241 while (pTmp->pNext != NULL) 242 { 243 pTmp = pTmp->pNext; 244 } 245 pTmp->pNext = pNewNode; 246 247OMX_CONF_CMD_BAIL: 248 return eError; 249} 250 251/*-----------------------------------------------------------------------------*/ 252/** 253 * ListRemove() 254 * 255 * Called inside VIDENC_FREE Macro remove node from Component Memory List and free the memory pointed by the node. 256 * 257 * @param pListHead VIDENC_NODE Points List Header of the Memory List. 258 * pData OMX_PTR points to the new allocated data. 259 * @retval OMX_ErrorNone 260 * 261 * 262 **/ 263/*-----------------------------------------------------------------------------*/ 264 265OMX_ERRORTYPE OMX_VIDENC_ListRemove(struct OMX_TI_Debug *dbg, struct VIDENC_NODE* pListHead, 266 OMX_PTR pData) 267{ 268 OMX_ERRORTYPE eError = OMX_ErrorNone; 269 VIDENC_NODE* pNode = NULL; 270 VIDENC_NODE* pTmp = NULL; 271 272 pNode = pListHead; 273 274 while (pNode->pNext != NULL) 275 { 276 if (pNode->pNext->pData == pData) 277 { 278 pTmp = pNode->pNext; 279 pNode->pNext = pTmp->pNext; 280 OMX_TRACE1(*dbg, "Remove MemoryNode[%p] -> [%p]\n", pTmp, pTmp->pData); 281 free(pTmp->pData); 282 free(pTmp); 283 pTmp = NULL; 284 break; 285 /* VIDENC_ListPrint2(pListHead); */ 286 } 287 pNode = pNode->pNext; 288 } 289 return eError; 290} 291 292/*-----------------------------------------------------------------------------*/ 293/** 294 * ListDestroy() 295 * 296 * Called inside OMX_ComponentDeInit() Remove all nodes and free all the memory in the Component Memory List. 297 * 298 * @param pListHead VIDENC_NODE Points List Header of the Memory List. 299 * 300 * @retval OMX_ErrorNone 301 * 302 * 303 **/ 304/*-----------------------------------------------------------------------------*/ 305 306OMX_ERRORTYPE OMX_VIDENC_ListDestroy(struct OMX_TI_Debug *dbg, struct VIDENC_NODE* pListHead) 307{ 308 OMX_ERRORTYPE eError = OMX_ErrorNone; 309 VIDENC_NODE* pTmp = NULL; 310 VIDENC_NODE* pNode = NULL; 311 pNode = pListHead; 312 313 while (pNode->pNext != NULL) 314 { 315 pTmp = pNode->pNext; 316 pNode->pNext=pTmp->pNext; 317 if (pTmp->pData != NULL) 318 { 319 OMX_TRACE0(*dbg, "Remove MemoryNode[%p] -> [%p]\n", pTmp, pTmp->pData); 320 free(pTmp->pData); 321 pTmp->pData = NULL; 322 } 323 free(pTmp); 324 pTmp = NULL; 325 } 326 327 OMX_TRACE1(*dbg, "Destroy MemoryListHeader[%p]\n", pListHead); 328 free(pListHead); 329 return eError; 330} 331 332 333 334/*---------------------------------------------------------------------------------------*/ 335/** 336 * OMX_VIDENC_EmptyDataPipes Wait until all buffers are processed 337 * 338 * @param pComponentPrivate pointer to the private video encoder structure 339 * 340 * @return None 341 * 342 **/ 343/*---------------------------------------------------------------------------------------*/ 344void OMX_VIDENC_EmptyDataPipes (VIDENC_COMPONENT_PRIVATE *pComponentPrivate) 345{ 346 pthread_mutex_lock(&bufferReturned_mutex); 347 while (pComponentPrivate->EmptythisbufferCount != pComponentPrivate->EmptybufferdoneCount || 348 pComponentPrivate->FillthisbufferCount != pComponentPrivate->FillbufferdoneCount) { 349 pthread_cond_wait(&bufferReturned_condition, &bufferReturned_mutex); 350 } 351 pthread_mutex_unlock(&bufferReturned_mutex); 352 ALOGI("Video encoder has returned all buffers"); 353} 354 355void OMX_VIDENC_IncrementBufferCountByOne(OMX_U32 *count) 356{ 357 pthread_mutex_lock(&bufferReturned_mutex); 358 (*count)++; 359 pthread_mutex_unlock(&bufferReturned_mutex); 360} 361 362void OMX_VIDENC_SignalIfAllBuffersAreReturned(VIDENC_COMPONENT_PRIVATE *pComponentPrivate) 363{ 364 pthread_mutex_lock(&bufferReturned_mutex); 365 if ((pComponentPrivate->EmptythisbufferCount == pComponentPrivate->EmptybufferdoneCount) && 366 (pComponentPrivate->FillthisbufferCount == pComponentPrivate->FillbufferdoneCount)) { 367 pthread_cond_broadcast(&bufferReturned_condition); 368 ALOGI("Sending pthread signal that video encoder has returned all buffers to app"); 369 } 370 pthread_mutex_unlock(&bufferReturned_mutex); 371} 372 373/*---------------------------------------------------------------------------------------*/ 374/** 375 * OMX_VIDENC_HandleError() will handle the error and pass the component to Invalid 376 * State, and send the event to the client. 377 * @param eError - OMX_ERRORTYPE that occur. 378 * 379 * @retval OMX_NoError Success, ready to roll 380 * OMX_Error_BadParameter The input parameter pointer is null 381 **/ 382/*---------------------------------------------------------------------------------------*/ 383OMX_ERRORTYPE OMX_VIDENC_HandleError(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 384 OMX_ERRORTYPE eErrorCmp) 385{ 386 OMX_ERRORTYPE eError = OMX_ErrorNone; 387 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 388 389 pComponentPrivate->bHandlingFatalError = OMX_TRUE; 390 391 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 392 OMX_EventError, 393 eErrorCmp, 394 OMX_TI_ErrorSevere, 395 NULL); 396 397 switch (eErrorCmp) 398 { 399 case OMX_ErrorBadParameter: 400 case OMX_ErrorPortUnresponsiveDuringAllocation: 401 case OMX_ErrorUnsupportedIndex: 402 case OMX_ErrorInsufficientResources: 403 goto OMX_CONF_CMD_BAIL; 404 default: 405 ; 406 } 407 408 pComponentPrivate->bHideEvents = OMX_TRUE; 409 410 eError = eErrorCmp; 411 pComponentPrivate->eState = OMX_StateInvalid; 412 413 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 414 OMX_EventError, 415 OMX_ErrorInvalidState, 416 OMX_TI_ErrorCritical, 417 NULL); 418 419OMX_CONF_CMD_BAIL: 420 if (pComponentPrivate) 421 pComponentPrivate->bHandlingFatalError = OMX_FALSE; 422 return eError; 423} 424 425/*---------------------------------------------------------------------------------------*/ 426/** 427 * OMX_VIDENC_HandleLcmlEvent() will handle the event from the LCML 428 * thread. 429 * @param eError - OMX_ERRORTYPE that occur. 430 * 431 * @retval OMX_NoError Success, ready to roll 432 * OMX_Error_BadParameter The input parameter pointer is null 433 **/ 434/*---------------------------------------------------------------------------------------*/ 435OMX_ERRORTYPE OMX_VIDENC_HandleLcmlEvent(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 436 TUsnCodecEvent eEvent, void* argsCb []) 437{ 438 OMX_ERRORTYPE eError = OMX_ErrorNone; 439 440 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 441 442 switch(eEvent) 443 { 444 case EMMCodecDspMessageRecieved: 445 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecDspMessageRecieved\n"); 446 break; 447 case EMMCodecBufferProcessed: 448 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecBufferProcessed\n"); 449 break; 450 case EMMCodecProcessingStarted: 451 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecProcessingStarted\n"); 452 break; 453 case EMMCodecProcessingPaused: 454 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecProcessingPaused\n"); 455 break; 456 case EMMCodecProcessingStoped: 457 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecProcessingStoped\n"); 458 break; 459 case EMMCodecProcessingEof: 460 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecProcessingEof\n"); 461 break; 462 case EMMCodecBufferNotProcessed: 463 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecBufferNotProcessed\n"); 464 break; 465 case EMMCodecAlgCtrlAck: 466 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecAlgCtrlAck\n"); 467 break; 468 case EMMCodecStrmCtrlAck: 469 OMX_PRDSP1(pComponentPrivate->dbg, "EMMCodecStrmCtrlAck\n"); 470 break; 471 case EMMCodecInternalError: 472 OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecInternalError\n"); 473#ifdef DSP_MMU_FAULT_HANDLING 474 if((argsCb[4] == (void *)USN_ERR_UNKNOWN_MSG) && (argsCb[5] == (void*)NULL)) 475 { 476 OMX_VIDENC_SET_ERROR_BAIL(eError, OMX_ErrorInvalidState, pComponentPrivate); 477 } 478 else 479 { 480 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 481 OMX_EventError, 482 OMX_ErrorHardware, 483 OMX_TI_ErrorCritical, 484 "Error Hardware\n"); 485 eError = OMX_ErrorHardware; 486 } 487#else 488 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 489 OMX_EventError, 490 OMX_ErrorHardware, 491 OMX_TI_ErrorCritical, 492 "Error Hardware\n"); 493 eError = OMX_ErrorHardware; 494#endif 495 break; 496 case EMMCodecInitError: 497 OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecInitError\n"); 498#ifdef DSP_MMU_FAULT_HANDLING 499 if((argsCb[4] == (void *)USN_ERR_UNKNOWN_MSG) && (argsCb[5] == (void*)NULL)) 500 { 501 OMX_VIDENC_SET_ERROR_BAIL(eError, OMX_ErrorInvalidState, pComponentPrivate); 502 } 503 else 504 { 505 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 506 OMX_EventError, 507 OMX_ErrorHardware, 508 OMX_TI_ErrorCritical, 509 "Error Hardware\n"); 510 eError = OMX_ErrorHardware; 511 } 512#else 513 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 514 OMX_EventError, 515 OMX_ErrorHardware, 516 OMX_TI_ErrorCritical, 517 "Error Hardware\n"); 518 eError = OMX_ErrorHardware; 519#endif 520 break; 521 case EMMCodecDspError: 522 OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecDspError\n"); 523#ifdef DSP_MMU_FAULT_HANDLING 524 if((argsCb[4] == (void *)NULL) && (argsCb[5] == (void*)NULL)) 525 { 526 OMX_VIDENC_SET_ERROR_BAIL(eError, OMX_ErrorInvalidState, pComponentPrivate); 527 } 528 else 529 { 530 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 531 OMX_EventError, 532 OMX_ErrorHardware, 533 OMX_TI_ErrorCritical, 534 "Error Hardware\n"); 535 eError = OMX_ErrorHardware; 536 } 537#else 538 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 539 OMX_EventError, 540 OMX_ErrorHardware, 541 OMX_TI_ErrorCritical, 542 "Error Hardware\n"); 543 eError = OMX_ErrorHardware; 544#endif 545 break; 546 } 547 548OMX_CONF_CMD_BAIL: 549 return eError; 550} 551 552/*-----------------------------------------------------------------------------*/ 553/** 554 * Disable Port() 555 * 556 * Called by component thread, handles commands sent by the app. 557 * 558 * @param 559 * 560 * @retval OMX_ErrorNone success, ready to roll 561 * 562 **/ 563/*-----------------------------------------------------------------------------*/ 564OMX_ERRORTYPE OMX_VIDENC_HandleCommandDisablePort (VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 565 OMX_U32 nParam1) 566{ 567 OMX_U8 i = 0; 568 OMX_BOOL bFlushFlag; 569 OMX_COMPONENTTYPE* pHandle = NULL; 570 VIDENC_NODE* pMemoryListHead = NULL; 571 OMX_ERRORTYPE eError = OMX_ErrorNone; 572 VIDEOENC_PORT_TYPE* pCompPortIn = NULL; 573 VIDEOENC_PORT_TYPE* pCompPortOut = NULL; 574 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 575 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 576 577 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 578 579 pHandle = (OMX_COMPONENTTYPE*)pComponentPrivate->pHandle; 580 pCompPortIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]; 581 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]; 582 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 583 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 584 pMemoryListHead = pComponentPrivate->pMemoryListHead; 585 586 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pHandle, pPortDefIn, pPortDefOut); 587 588 if (nParam1 == VIDENC_INPUT_PORT || nParam1 == (OMX_U32)-1) 589 { 590 /* Flush the DSP side before sending buffers back to the client */ 591 bFlushFlag = OMX_FALSE; 592 for (i = 0; i < pPortDefIn->nBufferCountActual; i++) 593 { 594 if(pCompPortIn->pBufferPrivate[i]->eBufferOwner != VIDENC_BUFFER_WITH_CLIENT) 595 { 596 bFlushFlag = OMX_TRUE; 597 } 598 } 599 600 if(bFlushFlag == OMX_TRUE) 601 { 602 eError = OMX_VIDENC_HandleCommandFlush(pComponentPrivate, VIDENC_INPUT_PORT, OMX_TRUE); 603 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRBUFFER3, 604 "Flush command failed (%x)\n", eError); 605 bFlushFlag = OMX_FALSE; 606 } 607 608 /*Return buffer to client*/ 609 if (pCompPortIn->hTunnelComponent == NULL) 610 { 611 for (i = 0; i < pPortDefIn->nBufferCountActual; i++) 612 { 613 if (pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT || 614 pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_DSP) 615 { 616 pCompPortIn->pBufferPrivate[i]->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 617#ifdef __PERF_INSTRUMENTATION__ 618 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 619 PREF(pCompPortIn->pBufferPrivate[i]->pBufferHdr, pBuffer), 620 0, 621 PERF_ModuleHLMM); 622#endif 623 pComponentPrivate->sCbData.EmptyBufferDone(pComponentPrivate->pHandle, 624 pComponentPrivate->pHandle->pApplicationPrivate, 625 pCompPortIn->pBufferPrivate[i]->pBufferHdr); 626 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->EmptybufferdoneCount); 627 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 628 } 629 } 630 } 631 else 632 { 633 for (i = 0; i < pPortDefIn->nBufferCountActual; i++) 634 { 635 if (pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT || 636 pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_DSP) 637 { 638 pCompPortIn->pBufferPrivate[i]->eBufferOwner = VIDENC_BUFFER_WITH_TUNNELEDCOMP; 639#ifdef __PERF_INSTRUMENTATION__ 640 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 641 PREF(pCompPortIn->pBufferPrivate[i]->pBufferHdr, pBuffer), 642 0, 643 PERF_ModuleLLMM); 644#endif 645 eError = OMX_FillThisBuffer(pCompPortIn->hTunnelComponent, 646 pCompPortIn->pBufferPrivate[i]->pBufferHdr); 647 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRBUFFER4, 648 "FillThisBuffer failed (%x)\n", eError); 649 } 650 } 651 } 652 } 653 if (nParam1 == VIDENC_OUTPUT_PORT || nParam1 == (OMX_U32)-1) 654 { 655 /* Flush the DSP side before sending buffers back to the client */ 656 bFlushFlag = OMX_FALSE; 657 for (i = 0; i < pPortDefOut->nBufferCountActual; i++) 658 { 659 if(pCompPortOut->pBufferPrivate[i]->eBufferOwner != VIDENC_BUFFER_WITH_CLIENT) 660 { 661 bFlushFlag = OMX_TRUE; 662 } 663 } 664 665 if(bFlushFlag == OMX_TRUE) 666 { 667 eError = OMX_VIDENC_HandleCommandFlush(pComponentPrivate, VIDENC_OUTPUT_PORT, OMX_TRUE); 668 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRBUFFER3, 669 "Flush command failed (%x)\n", eError); 670 bFlushFlag = OMX_FALSE; 671 } 672 673 /*Return buffer to client*/ 674 if (pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->hTunnelComponent == NULL) 675 { 676 for (i = 0; i < pPortDefOut->nBufferCountActual; i++) 677 { 678 if (pCompPortOut->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT || 679 pCompPortOut->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_DSP) 680 { 681 682 pCompPortOut->pBufferPrivate[i]->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 683#ifdef __PERF_INSTRUMENTATION__ 684 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 685 pCompPortOut->pBufferPrivate[i]->pBufferHdr ? 686 pCompPortOut->pBufferPrivate[i]->pBufferHdr->pBuffer : 687 NULL, 688 pCompPortOut->pBufferPrivate[i]->pBufferHdr ? 689 pCompPortOut->pBufferPrivate[i]->pBufferHdr->nFilledLen : 690 0, 691 PERF_ModuleHLMM); 692#endif 693 OMX_CONF_CIRCULAR_BUFFER_MOVE_HEAD(pCompPortOut->pBufferPrivate[i]->pBufferHdr, 694 pComponentPrivate->sCircularBuffer, 695 pComponentPrivate); 696 /* trigger event handler if we are supposed to */ 697 if (pCompPortOut->pBufferPrivate[i]->pBufferHdr->hMarkTargetComponent == pComponentPrivate->pHandle && 698 pCompPortOut->pBufferPrivate[i]->pBufferHdr->pMarkData) 699 { 700 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 701 OMX_EventMark, 702 0x0, 703 0x0, 704 pCompPortOut->pBufferPrivate[i]->pBufferHdr->pMarkData); 705 } 706 pComponentPrivate->sCbData.FillBufferDone(pComponentPrivate->pHandle, 707 pComponentPrivate->pHandle->pApplicationPrivate, 708 pCompPortOut->pBufferPrivate[i]->pBufferHdr); 709 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->FillbufferdoneCount); 710 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 711 } 712 } 713 } 714 else 715 { 716 /* If tunneled with VPP - NOT Implemented*/ 717#ifdef __PERF_INSTRUMENTATION__ 718 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 719 PREF(pCompPortOut->pBufferPrivate[i]->pBufferHdr,pBuffer), 720 PREF(pCompPortOut->pBufferPrivate[i]->pBufferHdr,nFilledLen), 721 PERF_ModuleLLMM); 722#endif 723 } 724 } 725 726 OMX_PRBUFFER2(pComponentPrivate->dbg, "Flushing Pipes!\n"); 727 OMX_VIDENC_EmptyDataPipes (pComponentPrivate); 728 729 /*while (1) 730 {*/ 731 732 if (nParam1 == VIDENC_INPUT_PORT) 733 { 734 while ((pPortDefIn->bPopulated)) 735 { 736 /*Send event*/ 737#ifndef UNDER_CE 738 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 739 pthread_cond_wait(&pComponentPrivate->unpopulate_cond, &pComponentPrivate->videoe_mutex_app); 740 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 741#else 742 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 743#endif 744 break; 745 } 746 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 747 OMX_EventCmdComplete, 748 OMX_CommandPortDisable, 749 VIDENC_INPUT_PORT, 750 NULL); 751 752 } 753 754 else if (nParam1 == VIDENC_OUTPUT_PORT) 755 { 756 while ((pPortDefOut->bPopulated)) 757 { 758 /*Send event*/ 759#ifndef UNDER_CE 760 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 761 pthread_cond_wait(&pComponentPrivate->unpopulate_cond, &pComponentPrivate->videoe_mutex_app); 762 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 763#else 764 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 765#endif 766 break; 767 } 768 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 769 OMX_EventCmdComplete, 770 OMX_CommandPortDisable, 771 VIDENC_OUTPUT_PORT, 772 NULL); 773 774 } 775 776 else if (nParam1 == (OMX_U32)-1) 777 { 778 while ((pPortDefIn->bPopulated) || (pPortDefOut->bPopulated)) 779 { 780 /*Send events*/ 781#ifndef UNDER_CE 782 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 783 pthread_cond_wait(&pComponentPrivate->unpopulate_cond, &pComponentPrivate->videoe_mutex_app); 784 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 785#else 786 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 787#endif 788 break; 789 } 790 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 791 OMX_EventCmdComplete, 792 OMX_CommandPortDisable, 793 VIDENC_INPUT_PORT, 794 NULL); 795 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 796 OMX_EventCmdComplete, 797 OMX_CommandPortDisable, 798 VIDENC_OUTPUT_PORT, 799 NULL); 800 801 802 } 803 804 805OMX_CONF_CMD_BAIL: 806 return eError; 807} 808 809/*-----------------------------------------------------------------------------*/ 810/** 811 * Enable Port() 812 * 813 * Called by component thread, handles commands sent by the app. 814 * 815 * @param 816 * 817 * @retval OMX_ErrorNone success, ready to roll 818 * 819 **/ 820/*-----------------------------------------------------------------------------*/ 821 822OMX_ERRORTYPE OMX_VIDENC_HandleCommandEnablePort (VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 823 OMX_U32 nParam1) 824{ 825 OMX_U32 nTimeout = 0x0; 826 OMX_COMPONENTTYPE* pHandle = NULL; 827 VIDENC_NODE* pMemoryListHead = NULL; 828 OMX_ERRORTYPE eError = OMX_ErrorNone; 829 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 830 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 831 832 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 833 834 pHandle = (OMX_COMPONENTTYPE*)pComponentPrivate->pHandle; 835 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 836 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 837 pMemoryListHead = pComponentPrivate->pMemoryListHead; 838 839 nTimeout = 0x0; 840 /*while(1) 841 {*/ 842 if(nParam1 == VIDENC_INPUT_PORT) 843 { 844 if (pComponentPrivate->eState != OMX_StateLoaded) 845 { 846 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 847 while (!pPortDefIn->bPopulated) 848 { 849#ifndef UNDER_CE 850 pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->videoe_mutex_app); 851#else 852 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 853#endif 854 855 } 856 } 857 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 858 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 859 OMX_EventCmdComplete, 860 OMX_CommandPortEnable, 861 VIDENC_INPUT_PORT, 862 NULL); 863 864 865 } 866 else if(nParam1 == VIDENC_OUTPUT_PORT) 867 { 868 if (pComponentPrivate->eState != OMX_StateLoaded) 869 { 870 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 871 while(!pPortDefOut->bPopulated) 872 { 873#ifndef UNDER_CE 874 pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->videoe_mutex_app); 875#else 876 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 877#endif 878 879 } 880 } 881 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 882 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 883 OMX_EventCmdComplete, 884 OMX_CommandPortEnable, 885 VIDENC_OUTPUT_PORT, 886 NULL); 887 888 889 } 890 else if(nParam1 == (OMX_U32)-1) 891 { 892 if (pComponentPrivate->eState != OMX_StateLoaded) 893 { 894 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 895 while(!pPortDefOut->bPopulated && !pPortDefIn->bPopulated) 896 { 897#ifndef UNDER_CE 898 pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->videoe_mutex_app); 899#else 900 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 901#endif 902 break; 903 } 904 } 905 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 906 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 907 OMX_EventCmdComplete, 908 OMX_CommandPortEnable, 909 VIDENC_INPUT_PORT, 910 NULL); 911 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 912 OMX_EventCmdComplete, 913 OMX_CommandPortEnable, 914 VIDENC_OUTPUT_PORT, 915 NULL); 916 917 918 } 919 920 921OMX_CONF_CMD_BAIL: 922 return eError; 923} 924 925/*----------------------------------------------------------------------------*/ 926/** 927 * OMX_OMX_VIDENC_HandleCommandFlush() 928 * 929 * Called by component thread, handles commands sent by the app. 930 * 931 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 932 * 933 * @retval OMX_ErrorNone success, ready to roll 934 * OMX_ErrorInsufficientResources if the malloc fails 935 **/ 936/*----------------------------------------------------------------------------*/ 937 938OMX_ERRORTYPE OMX_VIDENC_HandleCommandFlush(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 939 OMX_U32 nParam1, 940 OMX_BOOL bInternalFlush) 941{ 942 OMX_U16 i = 0; 943 OMX_U32 aParam[3] = {0}; 944 OMX_COMPONENTTYPE* pHandle = NULL; 945 VIDENC_NODE* pMemoryListHead = NULL; 946 OMX_ERRORTYPE eError = OMX_ErrorNone; 947 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 948 VIDEOENC_PORT_TYPE* pCompPortIn = NULL; 949 VIDEOENC_PORT_TYPE* pCompPortOut = NULL; 950 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 951 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 952 953 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 954 955 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 956 pCompPortIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]; 957 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]; 958 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 959 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 960 pHandle = (OMX_COMPONENTTYPE*)pComponentPrivate->pHandle; 961 pMemoryListHead = pComponentPrivate->pMemoryListHead; 962 963 if (nParam1 == VIDENC_INPUT_PORT || nParam1 == (OMX_U32)-1) 964 { 965 aParam[0] = USN_STRMCMD_FLUSH; 966 aParam[1] = VIDENC_INPUT_PORT; 967 aParam[2] = 0x0; 968 969 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 970 EMMCodecControlStrmCtrl, 971 (void*)aParam); 972 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 973 "DSP Input flush failed (%x).\n", eError); 974 975#ifndef UNDER_CE 976 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 977 while (pComponentPrivate->bFlushComplete == OMX_FALSE) 978 { 979 pthread_cond_wait(&pComponentPrivate->flush_cond, &pComponentPrivate->videoe_mutex_app); 980 } 981 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 982#else 983 while (pComponentPrivate->bFlushComplete == OMX_FALSE) 984 { 985 sched_yield(); 986 } 987#endif 988 989 pComponentPrivate->bFlushComplete = OMX_FALSE; 990 991 if (pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->hTunnelComponent == NULL) 992 { 993 for (i = 0; i < pPortDefIn->nBufferCountActual; i++) 994 { 995 if (pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT || 996 pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_DSP) 997 { 998 999 pCompPortIn->pBufferPrivate[i]->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 1000#ifdef __PERF_INSTRUMENTATION__ 1001 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 1002 PREF(pCompPortIn->pBufferPrivate[i]->pBufferHdr,pBuffer), 1003 0, 1004 PERF_ModuleHLMM); 1005#endif 1006 pComponentPrivate->sCbData.EmptyBufferDone(pComponentPrivate->pHandle, 1007 pComponentPrivate->pHandle->pApplicationPrivate, 1008 pCompPortIn->pBufferPrivate[i]->pBufferHdr); 1009 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->EmptybufferdoneCount); 1010 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 1011 } 1012 } 1013 } 1014 else 1015 { 1016 for (i = 0; i < pPortDefIn->nBufferCountActual; i++) 1017 { 1018 if (pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT || 1019 pCompPortIn->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_DSP) 1020 { 1021 1022 pCompPortIn->pBufferPrivate[i]->eBufferOwner = VIDENC_BUFFER_WITH_TUNNELEDCOMP; 1023#ifdef __PERF_INSTRUMENTATION__ 1024 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 1025 PREF(pCompPortOut->pBufferPrivate[i]->pBufferHdr,pBuffer), 1026 0, 1027 PERF_ModuleLLMM); 1028#endif 1029 eError = OMX_FillThisBuffer(pCompPortIn->hTunnelComponent, 1030 pCompPortIn->pBufferPrivate[i]->pBufferHdr); 1031 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRBUFFER4, 1032 "FillThisBuffer failed (%x)\n", eError); 1033 } 1034 } 1035 } 1036 if (bInternalFlush == OMX_FALSE) 1037 { 1038 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1039 OMX_EventCmdComplete, 1040 OMX_CommandFlush, 1041 VIDENC_INPUT_PORT, 1042 NULL); 1043 } 1044 } 1045 if (nParam1 == VIDENC_OUTPUT_PORT || nParam1 == (OMX_U32)-1) 1046 { 1047 aParam[0] = USN_STRMCMD_FLUSH; 1048 aParam[1] = VIDENC_OUTPUT_PORT; 1049 aParam[2] = 0x0; 1050 1051 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 1052 EMMCodecControlStrmCtrl, 1053 (void*)aParam); 1054 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 1055 "DSP Output flush failed (%x).\n", eError); 1056#ifndef UNDER_CE 1057 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 1058 while (pComponentPrivate->bFlushComplete == OMX_FALSE) 1059 { 1060 pthread_cond_wait(&pComponentPrivate->flush_cond, &pComponentPrivate->videoe_mutex_app); 1061 } 1062 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 1063#else 1064 while (pComponentPrivate->bFlushComplete == OMX_FALSE) 1065 { 1066 sched_yield(); 1067 } 1068#endif 1069 1070 pComponentPrivate->bFlushComplete = OMX_FALSE; 1071 1072 if (pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->hTunnelComponent == NULL) 1073 { 1074 for (i = 0; i < pPortDefOut->nBufferCountActual; i++) 1075 { 1076 if (pCompPortOut->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT || 1077 pCompPortOut->pBufferPrivate[i]->eBufferOwner == VIDENC_BUFFER_WITH_DSP) 1078 { 1079 1080 pCompPortOut->pBufferPrivate[i]->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 1081#ifdef __PERF_INSTRUMENTATION__ 1082 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 1083 PREF(pCompPortOut->pBufferPrivate[i]->pBufferHdr,pBuffer), 1084 PREF(pCompPortOut->pBufferPrivate[i]->pBufferHdr,nFilledLen), 1085 PERF_ModuleHLMM); 1086#endif 1087 /*Copy Buffer Data to be propagated*/ 1088 OMX_CONF_CIRCULAR_BUFFER_MOVE_HEAD(pCompPortOut->pBufferPrivate[i]->pBufferHdr, 1089 pComponentPrivate->sCircularBuffer, 1090 pComponentPrivate); 1091 /* trigger event handler if we are supposed to */ 1092 if (pCompPortOut->pBufferPrivate[i]->pBufferHdr->hMarkTargetComponent == pComponentPrivate->pHandle && 1093 pCompPortOut->pBufferPrivate[i]->pBufferHdr->pMarkData) 1094 { 1095 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1096 OMX_EventMark, 1097 0x0, 1098 0x0, 1099 pCompPortOut->pBufferPrivate[i]->pBufferHdr->pMarkData); 1100 } 1101 pComponentPrivate->sCbData.FillBufferDone(pComponentPrivate->pHandle, 1102 pComponentPrivate->pHandle->pApplicationPrivate, 1103 pCompPortOut->pBufferPrivate[i]->pBufferHdr); 1104 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->FillbufferdoneCount); 1105 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 1106 } 1107 } 1108 } 1109 else 1110 { 1111 /* If tunneled with VPP - NOT Implemented*/ 1112 } 1113 if (bInternalFlush == OMX_FALSE) 1114 { 1115 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1116 OMX_EventCmdComplete, 1117 OMX_CommandFlush, 1118 VIDENC_OUTPUT_PORT, 1119 NULL); 1120 } 1121 } 1122 1123OMX_CONF_CMD_BAIL: 1124 return eError; 1125} 1126 1127/*----------------------------------------------------------------------------*/ 1128/** 1129 * OMX_VIDENC_HandleCommand() 1130 * 1131 * Called by component thread, handles commands sent by the app. 1132 * 1133 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 1134 * 1135 * @retval OMX_ErrorNone success, ready to roll 1136 * OMX_ErrorInsufficientResources if the malloc fails 1137 **/ 1138/*----------------------------------------------------------------------------*/ 1139OMX_ERRORTYPE OMX_VIDENC_HandleCommandStateSet (VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 1140 OMX_U32 nParam1) 1141{ 1142 VIDENC_NODE* pMemoryListHead = NULL; 1143 OMX_ERRORTYPE eError = OMX_ErrorNone; 1144 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 1145 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 1146 1147 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 1148 1149 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 1150 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 1151 pMemoryListHead = pComponentPrivate->pMemoryListHead; 1152 1153 switch (nParam1) 1154 { 1155 case OMX_StateIdle: 1156 eError = OMX_VIDENC_HandleCommandStateSetIdle (pComponentPrivate); 1157 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRSTATE3, 1158 "Failed to move to Idle state (%x).\n", eError); 1159 break; 1160 case OMX_StateExecuting: 1161 eError = OMX_VIDENC_HandleCommandStateSetExecuting (pComponentPrivate); 1162 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRSTATE3, 1163 "Failed to move to Execute state (%x).\n", eError); 1164 break; 1165 case OMX_StateLoaded: 1166 eError = OMX_VIDENC_HandleCommandStateSetLoaded (pComponentPrivate); 1167 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRSTATE3, 1168 "Failed to move to Loaded state (%x).\n", eError); 1169 break; 1170 case OMX_StatePause: 1171 eError = OMX_VIDENC_HandleCommandStateSetPause (pComponentPrivate); 1172 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRSTATE3, 1173 "Failed to move to Pause state (%x).\n", eError); 1174 break; 1175 case OMX_StateInvalid: 1176 if (pComponentPrivate->eState == OMX_StateInvalid) 1177 { 1178 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1179 OMX_EventError, 1180 OMX_ErrorSameState, 1181 OMX_TI_ErrorSevere, 1182 NULL); 1183 } 1184 else 1185 { 1186 pComponentPrivate->eState = OMX_StateInvalid; 1187 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1188 OMX_EventError, 1189 OMX_ErrorInvalidState, 1190 OMX_TI_ErrorSevere, 1191 NULL); 1192 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1193 OMX_EventCmdComplete, 1194 OMX_CommandStateSet, 1195 OMX_StateInvalid, 1196 NULL); 1197 } 1198 break; 1199 case OMX_StateWaitForResources: 1200 if (pComponentPrivate->eState == OMX_StateWaitForResources) 1201 { 1202 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1203 OMX_EventError, 1204 OMX_ErrorSameState, 1205 OMX_TI_ErrorMinor, 1206 NULL); 1207 } 1208 else if (pComponentPrivate->eState == OMX_StateLoaded) 1209 { 1210 pComponentPrivate->eState = OMX_StateWaitForResources; 1211 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1212 OMX_EventCmdComplete, 1213 OMX_CommandStateSet, 1214 OMX_StateWaitForResources, 1215 NULL); 1216 } 1217 else 1218 { 1219 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1220 OMX_EventError, 1221 OMX_ErrorIncorrectStateTransition, 1222 OMX_TI_ErrorMinor, 1223 NULL); 1224 } 1225 break; 1226 case OMX_StateMax: 1227 break; 1228 } /* End of Switch */ 1229 1230OMX_CONF_CMD_BAIL: 1231 return eError; 1232} 1233 1234/*----------------------------------------------------------------------------*/ 1235/** 1236 * OMX_VIDENC_HandleCommandStateSet() 1237 * 1238 * Called by component thread, handles commands sent by the app. 1239 * 1240 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 1241 * 1242 * @retval OMX_ErrorNone success, ready to roll 1243 * OMX_ErrorInsufficientResources if the malloc fails 1244 **/ 1245/*----------------------------------------------------------------------------*/ 1246OMX_ERRORTYPE OMX_VIDENC_HandleCommandStateSetIdle(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 1247{ 1248 OMX_U8 nCount = 0; 1249 OMX_ERRORTYPE eError = OMX_ErrorNone; 1250 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 1251 VIDEOENC_PORT_TYPE* pCompPortIn = NULL; 1252 VIDEOENC_PORT_TYPE* pCompPortOut = NULL; 1253 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 1254 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 1255 1256 1257 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 1258 1259 pCompPortIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]; 1260 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]; 1261 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 1262 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 1263 1264 1265 switch (pComponentPrivate->eState) 1266 { 1267 case OMX_StateIdle: 1268 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1269 OMX_EventError, 1270 OMX_ErrorSameState, 1271 OMX_TI_ErrorMinor, 1272 NULL); 1273 break; 1274 case OMX_StateInvalid: 1275 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1276 OMX_EventError, 1277 OMX_ErrorIncorrectStateTransition, 1278 OMX_TI_ErrorMajor, 1279 NULL); 1280 break; 1281 case OMX_StateLoaded: 1282 case OMX_StateWaitForResources: 1283#ifdef __PERF_INSTRUMENTATION__ 1284 PERF_Boundary(pComponentPrivate->pPERFcomp, 1285 PERF_BoundaryStart | PERF_BoundarySetup); 1286#endif 1287 if ( pPortDefIn->bEnabled == OMX_TRUE || pPortDefOut->bEnabled == OMX_TRUE ) 1288 { 1289 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 1290 while ( (!pPortDefIn->bPopulated) || (!pPortDefOut->bPopulated)) 1291 { 1292#ifndef UNDER_CE 1293 pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->videoe_mutex_app); 1294#else 1295 OMX_WaitForEvent(&(pComponentPrivate->InLoaded_event)); 1296#endif 1297 } 1298 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 1299 } 1300 /* Make sure the DSP node has been deleted first to cover 1301 any idle->loaded->idle or idle->wfr->idle combinations 1302 */ 1303 if (pComponentPrivate->bCodecStarted == OMX_TRUE || 1304 pComponentPrivate->bCodecLoaded == OMX_TRUE) 1305 { 1306 OMX_PRDSP2(pComponentPrivate->dbg, "Attempting to destroy the node...\n"); 1307 pLcmlHandle = NULL; 1308 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 1309 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 1310 EMMCodecControlDestroy, 1311 NULL); 1312 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP3, 1313 "Failed to destroy socket node (%x).\n", eError); 1314 1315 1316 /*Unload LCML */ 1317 if(pComponentPrivate->pModLcml != NULL) 1318 { 1319#ifndef UNDER_CE 1320 dlclose(pComponentPrivate->pModLcml); 1321#else 1322 FreeLibrary(pComponentPrivate->pModLcml); 1323 FreeLibrary(g_hLcmlDllHandle); 1324 g_hLcmlDllHandle = NULL; 1325 1326#endif 1327 pComponentPrivate->pModLcml = NULL; 1328 pComponentPrivate->pLCML = NULL; 1329 } 1330 1331 if (pComponentPrivate->sps) { 1332 free(pComponentPrivate->sps); 1333 pComponentPrivate->sps = NULL; 1334 pComponentPrivate->spsLen = 0; 1335 } 1336 1337 pComponentPrivate->bCodecStarted = OMX_FALSE; 1338 pComponentPrivate->bCodecLoaded = OMX_FALSE; 1339 } 1340 1341 eError = OMX_VIDENC_InitLCML(pComponentPrivate); 1342 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 1343 "Failed to initialize LCML (%x).\n", eError); 1344 1345#ifdef __PERF_INSTRUMENTATION__ 1346 pComponentPrivate->nLcml_nCntIp = 0; 1347 pComponentPrivate->nLcml_nCntOpReceived = 0; 1348#endif 1349 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 1350 { 1351 eError = OMX_VIDENC_InitDSP_H264Enc(pComponentPrivate); 1352 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 1353 "Failed to initialize H264 SN (%x).\n", eError); 1354 } 1355 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 || 1356 pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 1357 { 1358 eError = OMX_VIDENC_InitDSP_Mpeg4Enc(pComponentPrivate); 1359 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 1360 "Failed to initialize MPEG4 SN (%x).\n", eError); 1361 } 1362 else 1363 { 1364 OMX_PRSTATE4(pComponentPrivate->dbg, "Unsupported compression format (%d)\n", 1365 pPortDefOut->format.video.eCompressionFormat); 1366 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 1367 } 1368 1369#ifdef RESOURCE_MANAGER_ENABLED 1370 1371 OMX_PRMGR2(pComponentPrivate->dbg, "Setting CallBack In Video Encoder component\n"); 1372 pComponentPrivate->cRMCallBack.RMPROXY_Callback = (void*)OMX_VIDENC_ResourceManagerCallBack; 1373 switch (pPortDefOut->format.video.eCompressionFormat) 1374 { 1375 case OMX_VIDEO_CodingAVC: 1376 switch(pComponentPrivate->pH264->eLevel) 1377 { 1378 case OMX_VIDEO_AVCLevel1: 1379 case OMX_VIDEO_AVCLevel1b: 1380 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1381 RMProxy_RequestResource, 1382 OMX_H264_Encode_COMPONENT, 1383 VIDEO_ENCODER_MHZ, 1384 3456, 1385 &(pComponentPrivate->cRMCallBack)); 1386 1387 break; 1388 case OMX_VIDEO_AVCLevel11: 1389 case OMX_VIDEO_AVCLevel12: 1390 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1391 RMProxy_RequestResource, 1392 OMX_H264_Encode_COMPONENT, 1393 VIDEO_ENCODER_MHZ, 1394 3456, 1395 &(pComponentPrivate->cRMCallBack)); 1396 break; 1397 case OMX_VIDEO_AVCLevel13: 1398 case OMX_VIDEO_AVCLevel2: 1399 case OMX_VIDEO_AVCLevel21: 1400 case OMX_VIDEO_AVCLevel22: 1401 case OMX_VIDEO_AVCLevel3: 1402 default: 1403 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1404 RMProxy_RequestResource, 1405 OMX_H264_Encode_COMPONENT, 1406 VIDEO_ENCODER_MHZ, 1407 3456, 1408 &(pComponentPrivate->cRMCallBack)); 1409 } 1410 break; 1411 case OMX_VIDEO_CodingMPEG4: 1412 switch(pComponentPrivate->pMpeg4->eLevel) 1413 { 1414 case 0: 1415 case 1: 1416 case 100: 1417 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1418 RMProxy_RequestResource, 1419 OMX_MPEG4_Encode_COMPONENT, 1420 VIDEO_ENCODER_MHZ, 1421 3456, 1422 &(pComponentPrivate->cRMCallBack)); 1423 break; 1424 case 2: 1425 case 3: 1426 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1427 RMProxy_RequestResource, 1428 OMX_MPEG4_Encode_COMPONENT, 1429 VIDEO_ENCODER_MHZ, 1430 3456, 1431 &(pComponentPrivate->cRMCallBack)); 1432 break; 1433 case 4: 1434 default: 1435 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1436 RMProxy_RequestResource, 1437 OMX_MPEG4_Encode_COMPONENT, 1438 VIDEO_ENCODER_MHZ, 1439 3456, 1440 &(pComponentPrivate->cRMCallBack)); 1441 } 1442 break; 1443 case OMX_VIDEO_CodingH263: 1444 switch(pComponentPrivate->pH263->eLevel) 1445 { 1446 case OMX_VIDEO_H263Level10: 1447 case OMX_VIDEO_H263Level40: 1448 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1449 RMProxy_RequestResource, 1450 OMX_H263_Encode_COMPONENT, 1451 VIDEO_ENCODER_MHZ, 1452 3456, 1453 &(pComponentPrivate->cRMCallBack)); 1454 break; 1455 case OMX_VIDEO_H263Level20: 1456 case OMX_VIDEO_H263Level30: 1457 default: 1458 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1459 RMProxy_RequestResource, 1460 OMX_H263_Encode_COMPONENT, 1461 VIDEO_ENCODER_MHZ, 1462 3456, 1463 &(pComponentPrivate->cRMCallBack)); 1464 } 1465 break; 1466 default: 1467 OMX_PRSTATE4(pComponentPrivate->dbg, "Unsupported compression format (%d)\n", 1468 pPortDefOut->format.video.eCompressionFormat); 1469 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 1470 } 1471 1472 /* Resource Manager Proxy Calls */ 1473 if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 1474 { 1475 /* TODO: Disable RM Send for now */ 1476 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H264_Encode_COMPONENT, 0); */ 1477 OMX_PRMGR2(pComponentPrivate->dbg, "RMProxy_SendCommand: Setting state to Idle from Loaded\n"); 1478 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1479 RMProxy_StateSet, 1480 OMX_H264_Encode_COMPONENT, 1481 OMX_StateIdle, 1482 3456, 1483 NULL); 1484 } 1485 else if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 1486 { 1487 /* TODO: Disable RM Send for now */ 1488 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_MPEG4_Encode_COMPONENT, 0); */ 1489 OMX_PRMGR2(pComponentPrivate->dbg, "RMProxy_SendCommand: Setting state to Idle from Loaded\n"); 1490 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1491 RMProxy_StateSet, 1492 OMX_MPEG4_Encode_COMPONENT, 1493 OMX_StateIdle, 1494 3456, 1495 NULL); 1496 } 1497 else if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 1498 { 1499 /* TODO: Disable RM Send for now */ 1500 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H263_Encode_COMPONENT, 0); */ 1501 OMX_PRMGR2(pComponentPrivate->dbg, "RMProxy_SendCommand: Setting state to Idle from Loaded\n"); 1502 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1503 RMProxy_StateSet, 1504 OMX_H263_Encode_COMPONENT, 1505 OMX_StateIdle, 1506 3456, 1507 NULL); 1508 } 1509 if (eError != OMX_ErrorNone) 1510 { 1511 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1512 OMX_EventError, 1513 OMX_ErrorHardware, 1514 OMX_TI_ErrorSevere, 1515 NULL); 1516 } 1517 1518 if (eError == OMX_ErrorNone) { 1519 1520 pComponentPrivate->eState = OMX_StateIdle; 1521#ifdef __PERF_INSTRUMENTATION__ 1522 PERF_Boundary(pComponentPrivate->pPERFcomp, 1523 PERF_BoundaryComplete | PERF_BoundarySetup); 1524#endif 1525 1526 /* Decrement reference count with signal enabled */ 1527 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 1528 return OMX_ErrorUndefined; 1529 } 1530 1531 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1532 OMX_EventCmdComplete, 1533 OMX_CommandStateSet, 1534 OMX_StateIdle, 1535 NULL); 1536 } 1537 else if (eError == OMX_ErrorInsufficientResources) 1538 { 1539 pComponentPrivate->eState = OMX_StateWaitForResources; 1540 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1541 OMX_EventError, 1542 OMX_ErrorInsufficientResources, 1543 OMX_TI_ErrorMajor, 1544 NULL); 1545 } 1546#else /* WinCE MM will not use Linux RM, so do this... */ 1547 pComponentPrivate->eState = OMX_StateIdle; 1548#ifdef __PERF_INSTRUMENTATION__ 1549 PERF_Boundary(pComponentPrivate->pPERFcomp, 1550 PERF_BoundaryComplete | PERF_BoundarySetup); 1551#endif 1552 1553 /* Decrement reference count with signal enabled */ 1554 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 1555 return OMX_ErrorUndefined; 1556 } 1557 1558 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1559 OMX_EventCmdComplete, 1560 OMX_CommandStateSet, 1561 OMX_StateIdle, 1562 NULL); 1563#endif 1564 break; 1565 case OMX_StateExecuting: 1566 case OMX_StatePause: 1567 pLcmlHandle = NULL; 1568#ifdef __PERF_INSTRUMENTATION__ 1569 PERF_Boundary(pComponentPrivate->pPERF, 1570 PERF_BoundaryComplete | PERF_BoundarySteadyState); 1571#endif 1572 1573 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 1574 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 1575 MMCodecControlStop, 1576 NULL); 1577 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP3, 1578 "Failed to stop socket node (%x).\n", eError); 1579 pComponentPrivate->bCodecStarted = OMX_FALSE; 1580 OMX_PRDSP2(pComponentPrivate->dbg, "MMCodecControlStop called...\n"); 1581 1582#ifndef UNDER_CE 1583 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 1584 while (pComponentPrivate->bDSPStopAck == OMX_FALSE) 1585 { 1586 pthread_cond_wait(&pComponentPrivate->stop_cond, &pComponentPrivate->videoe_mutex_app); 1587 } 1588 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 1589#else 1590 while (pComponentPrivate->bDSPStopAck == OMX_FALSE) 1591 { 1592 sched_yield(); 1593 } 1594#endif 1595 pComponentPrivate->bDSPStopAck = OMX_FALSE; 1596 1597 for (nCount = 0; nCount < pPortDefIn->nBufferCountActual; nCount++) 1598 { 1599 OMX_PRBUFFER2(pComponentPrivate->dbg, "Buffer[%d]:port[%d] -> %p [OWNER = %d]\n", 1600 nCount, 1601 VIDENC_INPUT_PORT, 1602 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr, 1603 pCompPortIn->pBufferPrivate[nCount]->eBufferOwner); 1604 1605 if (pCompPortIn->pBufferPrivate[nCount]->eBufferOwner == VIDENC_BUFFER_WITH_DSP || 1606 pCompPortIn->pBufferPrivate[nCount]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT) 1607 { 1608 OMX_PRBUFFER1(pComponentPrivate->dbg, "Buffer[%d]:port[%d] -> %p [SEND BACK TO SUPPLIER]\n", 1609 nCount, 1610 VIDENC_INPUT_PORT, 1611 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr); 1612 1613 if (pCompPortIn->hTunnelComponent == NULL) 1614 { 1615 1616 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->nFilledLen = 0; 1617 OMX_PRBUFFER1(pComponentPrivate->dbg, "Buffer[%d]:port[%d] -> %p [memset %lu bytes]\n", 1618 nCount, 1619 VIDENC_INPUT_PORT, 1620 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr, 1621 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->nAllocLen); 1622 1623 memset(pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->pBuffer, 1624 0x0, 1625 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->nAllocLen); 1626 1627 pCompPortIn->pBufferPrivate[nCount]->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 1628#ifdef __PERF_INSTRUMENTATION__ 1629 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 1630 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->pBuffer, 1631 0, 1632 PERF_ModuleHLMM); 1633#endif 1634 pComponentPrivate->sCbData.EmptyBufferDone(pComponentPrivate->pHandle, 1635 pComponentPrivate->pHandle->pApplicationPrivate, 1636 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr); 1637 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->EmptybufferdoneCount); 1638 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 1639 } 1640 else 1641 { 1642 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->nFilledLen = 0; 1643 pCompPortIn->pBufferPrivate[nCount]->eBufferOwner = VIDENC_BUFFER_WITH_TUNNELEDCOMP; 1644#ifdef __PERF_INSTRUMENTATION__ 1645 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 1646 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr->pBuffer, 1647 0, 1648 PERF_ModuleLLMM); 1649#endif 1650 eError = OMX_FillThisBuffer(pCompPortIn->hTunnelComponent, 1651 pCompPortIn->pBufferPrivate[nCount]->pBufferHdr); 1652 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRBUFFER4, 1653 "FillThisBuffer failed (%x).\n", eError); 1654 } 1655 } 1656 } 1657 1658 for (nCount = 0; nCount < pPortDefOut->nBufferCountActual; nCount++) 1659 { 1660 OMX_PRBUFFER2(pComponentPrivate->dbg, "Buffer[%d]:port[%d] -> %p [OWNER = %d]\n", 1661 nCount, 1662 VIDENC_OUTPUT_PORT, 1663 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr, 1664 pCompPortOut->pBufferPrivate[nCount]->eBufferOwner); 1665 1666 if (pCompPortOut->pBufferPrivate[nCount]->eBufferOwner == VIDENC_BUFFER_WITH_DSP || 1667 pCompPortOut->pBufferPrivate[nCount]->eBufferOwner == VIDENC_BUFFER_WITH_COMPONENT) 1668 { 1669 1670 if (pCompPortOut->hTunnelComponent == NULL) 1671 { 1672 OMX_PRBUFFER1(pComponentPrivate->dbg, "Buffer[%d]:port[%d] -> %p [memset %lu bytes]\n", 1673 nCount, 1674 VIDENC_OUTPUT_PORT, 1675 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr, 1676 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->nAllocLen); 1677 1678 memset(pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->pBuffer, 1679 0x0, 1680 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->nAllocLen); 1681 } 1682 1683 OMX_PRBUFFER1(pComponentPrivate->dbg, "Buffer[%d]:port[%d] -> %p [SEND BACK TO SUPPLIER]\n", nCount, 1684 VIDENC_OUTPUT_PORT, 1685 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr); 1686 1687 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->nFilledLen = 0; 1688 pCompPortOut->pBufferPrivate[nCount]->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 1689#ifdef __PERF_INSTRUMENTATION__ 1690 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 1691 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->pBuffer, 1692 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->nFilledLen, 1693 PERF_ModuleHLMM); 1694#endif 1695 /*Propagate pBufferHeader Data*/ 1696 OMX_CONF_CIRCULAR_BUFFER_MOVE_HEAD(pCompPortOut->pBufferPrivate[nCount]->pBufferHdr, 1697 pComponentPrivate->sCircularBuffer, 1698 pComponentPrivate); 1699 /* trigger event handler if we are supposed to */ 1700 if (pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->hMarkTargetComponent == pComponentPrivate->pHandle && 1701 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->pMarkData) 1702 { 1703 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1704 OMX_EventMark, 1705 0x0, 1706 0x0, 1707 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr->pMarkData); 1708 } 1709 pComponentPrivate->sCbData.FillBufferDone(pComponentPrivate->pHandle, 1710 pComponentPrivate->pHandle->pApplicationPrivate, 1711 pCompPortOut->pBufferPrivate[nCount]->pBufferHdr); 1712 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->FillbufferdoneCount); 1713 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 1714 } 1715 } 1716 1717#ifdef RESOURCE_MANAGER_ENABLED /* Resource Manager Proxy Calls */ 1718 if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 1719 { 1720 /* TODO: Disable RM Send for now */ 1721 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H264_Encode_COMPONENT, 0); */ 1722 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1723 RMProxy_StateSet, 1724 OMX_H264_Encode_COMPONENT, 1725 OMX_StateIdle, 1726 3456, 1727 NULL); 1728 } 1729 else if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 1730 { 1731 /* TODO: Disable RM Send for now */ 1732 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_MPEG4_Encode_COMPONENT, 0); */ 1733 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1734 RMProxy_StateSet, 1735 OMX_MPEG4_Encode_COMPONENT, 1736 OMX_StateIdle, 1737 3456, 1738 NULL); 1739 } 1740 else if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 1741 { 1742 /* TODO: Disable RM Send for now */ 1743 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H263_Encode_COMPONENT, 0); */ 1744 OMX_PRMGR2(pComponentPrivate->dbg, "Setting Idle state from Executing to RMProxy\n"); 1745 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1746 RMProxy_StateSet, 1747 OMX_H263_Encode_COMPONENT, 1748 OMX_StateIdle, 1749 3456, 1750 NULL); 1751 } 1752 if (eError != OMX_ErrorNone) 1753 { 1754 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1755 OMX_EventError, 1756 OMX_ErrorHardware, 1757 OMX_TI_ErrorMajor, 1758 NULL); 1759 } 1760 1761#endif 1762 OMX_PRBUFFER2(pComponentPrivate->dbg, "Flushing Pipes!\n"); 1763 OMX_VIDENC_EmptyDataPipes (pComponentPrivate); 1764 1765 pComponentPrivate->eState = OMX_StateIdle; 1766 1767 /* Decrement reference count with signal enabled */ 1768 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 1769 return OMX_ErrorUndefined; 1770 } 1771 1772 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1773 OMX_EventCmdComplete, 1774 OMX_CommandStateSet, 1775 OMX_StateIdle, 1776 NULL); 1777 break; 1778 default: 1779 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1780 OMX_EventError, 1781 OMX_ErrorIncorrectStateTransition, 1782 OMX_TI_ErrorMinor, 1783 NULL); 1784 } 1785OMX_CONF_CMD_BAIL: 1786 return eError; 1787} 1788 1789/*----------------------------------------------------------------------------*/ 1790/** 1791 * OMX_VIDENC_HandleCommandStateSet() 1792 * 1793 * Called by component thread, handles commands sent by the app. 1794 * 1795 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 1796 * 1797 * @retval OMX_ErrorNone success, ready to roll 1798 * OMX_ErrorInsufficientResources if the malloc fails 1799 **/ 1800/*----------------------------------------------------------------------------*/ 1801OMX_ERRORTYPE OMX_VIDENC_HandleCommandStateSetExecuting(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 1802{ 1803 OMX_ERRORTYPE eError = OMX_ErrorNone; 1804 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 1805 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 1806 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 1807 1808 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 1809 1810 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 1811 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 1812 1813 switch (pComponentPrivate->eState) 1814 { 1815 case OMX_StateExecuting: 1816 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, OMX_EventError, OMX_ErrorSameState, OMX_TI_ErrorMinor, NULL); 1817 break; 1818 case OMX_StateIdle: 1819 OMX_CONF_CIRCULAR_BUFFER_RESTART(pComponentPrivate->sCircularBuffer); 1820 case OMX_StatePause: 1821 if (pComponentPrivate->bCodecStarted == OMX_FALSE) 1822 { 1823 pLcmlHandle = NULL; 1824 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 1825 pLcmlHandle->pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pComponentPrivate; 1826 1827 OMX_PRDSP2(pComponentPrivate->dbg, "Starting the codec...\n"); 1828 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 1829 EMMCodecControlStart, 1830 NULL); 1831 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 1832 "Failed to start socket node (%x).\n", eError); 1833 1834 pComponentPrivate->bCodecStarted = OMX_TRUE; 1835 } 1836 1837#ifdef RESOURCE_MANAGER_ENABLED /* Resource Manager Proxy Calls */ 1838 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 1839 { 1840 /* TODO: Disable RM Send for now */ 1841 OMX_PRMGR2(pComponentPrivate->dbg, "Setting executing state to RMProxy\n"); 1842 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H264_Encode_COMPONENT, 0); */ 1843 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1844 RMProxy_StateSet, 1845 OMX_H264_Encode_COMPONENT, 1846 OMX_StateExecuting, 1847 3456, 1848 NULL); 1849 } 1850 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 1851 { 1852 /* TODO: Disable RM Send for now */ 1853 OMX_PRMGR2(pComponentPrivate->dbg, "Setting executing state to RMProxy\n"); 1854 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_MPEG4_Encode_COMPONENT, 0); */ 1855 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1856 RMProxy_StateSet, 1857 OMX_MPEG4_Encode_COMPONENT, 1858 OMX_StateExecuting, 1859 3456, 1860 NULL); 1861 1862 } 1863 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 1864 { 1865 /* TODO: Disable RM Send for now */ 1866 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H263_Encode_COMPONENT, 0); */ 1867 OMX_PRMGR2(pComponentPrivate->dbg, "Setting executing state to RMProxy\n"); 1868 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 1869 RMProxy_StateSet, 1870 OMX_H263_Encode_COMPONENT, 1871 OMX_StateExecuting, 1872 3456, 1873 NULL); 1874 } 1875 if (eError != OMX_ErrorNone) 1876 { 1877 pComponentPrivate->eState = OMX_StateWaitForResources; 1878 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1879 OMX_EventError, 1880 OMX_ErrorHardware, 1881 OMX_TI_ErrorMajor, 1882 NULL); 1883 } 1884#endif 1885 pComponentPrivate->eState = OMX_StateExecuting; 1886#ifdef __PERF_INSTRUMENTATION__ 1887 PERF_Boundary(pComponentPrivate->pPERFcomp, 1888 PERF_BoundaryStart | PERF_BoundarySteadyState); 1889#endif 1890 1891 /* Decrement reference count with signal enabled */ 1892 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 1893 return OMX_ErrorUndefined; 1894 } 1895 1896 /*Send state change notificaiton to Application*/ 1897 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1898 OMX_EventCmdComplete, 1899 OMX_CommandStateSet, 1900 OMX_StateExecuting, 1901 NULL); 1902 break; 1903 default: 1904 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1905 OMX_EventError, 1906 OMX_ErrorIncorrectStateTransition, 1907 OMX_TI_ErrorMinor, 1908 NULL); 1909 } 1910OMX_CONF_CMD_BAIL: 1911 return eError; 1912} 1913 1914/*----------------------------------------------------------------------------*/ 1915/** 1916 * OMX_VIDENC_HandleCommandStateSetPause() 1917 * 1918 * Called by component thread, handles commands sent by the app. 1919 * 1920 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 1921 * 1922 * @retval OMX_ErrorNone success, ready to roll 1923 * OMX_ErrorInsufficientResources if the malloc fails 1924 **/ 1925/*----------------------------------------------------------------------------*/ 1926OMX_ERRORTYPE OMX_VIDENC_HandleCommandStateSetPause (VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 1927{ 1928 OMX_ERRORTYPE eError = OMX_ErrorNone; 1929 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 1930 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 1931 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 1932 1933 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 1934 1935 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 1936 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 1937 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 1938 1939 1940 switch (pComponentPrivate->eState) 1941 { 1942 case OMX_StatePause: 1943 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1944 OMX_EventError, 1945 OMX_ErrorSameState, 1946 OMX_TI_ErrorMinor, 1947 NULL); 1948 break; 1949 case OMX_StateIdle: 1950 case OMX_StateExecuting: 1951 pLcmlHandle = NULL; 1952#ifdef __PERF_INSTRUMENTATION__ 1953 PERF_Boundary(pComponentPrivate->pPERFcomp, 1954 PERF_BoundaryComplete | PERF_BoundarySteadyState); 1955#endif 1956 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 1957 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 1958 EMMCodecControlPause, 1959 NULL); 1960 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4, 1961 "Failed to pause socket node (%x).\n", eError); 1962 1963 1964 pComponentPrivate->bCodecStarted = OMX_FALSE; 1965 OMX_PRDSP2(pComponentPrivate->dbg, "MMCodecControlPaused called...\n"); 1966 1967 1968#ifndef UNDER_CE 1969 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 1970 while (pComponentPrivate->bDSPStopAck == OMX_FALSE) 1971 { 1972 pthread_cond_wait(&pComponentPrivate->stop_cond, &pComponentPrivate->videoe_mutex_app); 1973 } 1974 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 1975#else 1976 while (pComponentPrivate->bDSPStopAck == OMX_FALSE) 1977 { 1978 sched_yield(); 1979 } 1980#endif 1981 1982 pComponentPrivate->bDSPStopAck = OMX_FALSE; 1983 1984 pComponentPrivate->eState = OMX_StatePause; 1985 1986 /* Decrement reference count with signal enabled */ 1987 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 1988 return OMX_ErrorUndefined; 1989 } 1990 1991 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1992 OMX_EventCmdComplete, 1993 OMX_CommandStateSet, 1994 OMX_StatePause, 1995 NULL); 1996 break; 1997 default: 1998 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 1999 OMX_EventError, 2000 OMX_ErrorIncorrectStateTransition, 2001 OMX_TI_ErrorMinor, 2002 NULL); 2003 } 2004 2005OMX_CONF_CMD_BAIL: 2006 return eError; 2007} 2008 2009/*----------------------------------------------------------------------------*/ 2010/** 2011 * OMX_VIDENC_HandleCommandStateSetLoaded() 2012 * 2013 * Called by component thread, handles commands sent by the app. 2014 * 2015 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 2016 * 2017 * @retval OMX_ErrorNone success, ready to roll 2018 * OMX_ErrorInsufficientResources if the malloc fails 2019 **/ 2020/*----------------------------------------------------------------------------*/ 2021OMX_ERRORTYPE OMX_VIDENC_HandleCommandStateSetLoaded (VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 2022{ 2023 OMX_ERRORTYPE eError = OMX_ErrorNone; 2024 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 2025 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 2026 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 2027 2028 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 2029 2030 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 2031 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 2032 2033 switch (pComponentPrivate->eState) 2034 { 2035 case OMX_StateLoaded: 2036 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 2037 OMX_EventError, 2038 OMX_ErrorSameState, 2039 OMX_TI_ErrorMinor, 2040 NULL); 2041 break; 2042 case OMX_StateWaitForResources: 2043 OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning from WFR to Loaded\n"); 2044#ifdef RESOURCE_MANAGER_ENABLED 2045 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 2046 { 2047 /* TODO: Disable RM Send for now */ 2048 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H264_Encode_COMPONENT, 0); */ 2049 OMX_PRMGR2(pComponentPrivate->dbg, "RMProxy_SendCommand: Setting state to Loaded from WFR\n"); 2050 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 2051 RMProxy_StateSet, 2052 OMX_H264_Encode_COMPONENT, 2053 OMX_StateLoaded, 2054 3456, 2055 NULL); 2056 } 2057 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 2058 { 2059 /* TODO: Disable RM Send for now */ 2060 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_MPEG4_Encode_COMPONENT, 0); */ 2061 OMX_PRMGR2(pComponentPrivate->dbg, "RMProxy_SendCommand: Setting state to Loaded from WFR\n"); 2062 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 2063 RMProxy_StateSet, 2064 OMX_MPEG4_Encode_COMPONENT, 2065 OMX_StateLoaded, 2066 3456, 2067 NULL); 2068 } 2069 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 2070 { 2071 /* TODO: Disable RM Send for now */ 2072 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H263_Encode_COMPONENT, 0); */ 2073 OMX_PRMGR2(pComponentPrivate->dbg, "RMProxy_SendCommand: Setting state to Loaded from WFR\n"); 2074 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 2075 RMProxy_StateSet, 2076 OMX_H263_Encode_COMPONENT, 2077 OMX_StateLoaded, 2078 3456, 2079 NULL); 2080 } 2081 if (eError != OMX_ErrorNone) 2082 { 2083 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 2084 OMX_EventError, 2085 OMX_ErrorHardware, 2086 OMX_TI_ErrorMajor, 2087 NULL); 2088 break; 2089 } 2090#endif 2091 pComponentPrivate->eState = OMX_StateLoaded; 2092 /* Decrement reference count with signal enabled */ 2093 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 2094 return OMX_ErrorUndefined; 2095 } 2096 2097 #ifdef __PERF_INSTRUMENTATION__ 2098 PERF_Boundary(pComponentPrivate->pPERFcomp, 2099 PERF_BoundaryComplete | PERF_BoundaryCleanup); 2100 #endif 2101 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 2102 OMX_EventCmdComplete, 2103 OMX_CommandStateSet, 2104 OMX_StateLoaded, 2105 NULL); 2106 break; 2107 case OMX_StateIdle: 2108 OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning from Idle to Loaded\n"); 2109 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 2110 #ifdef __PERF_INSTRUMENTATION__ 2111 PERF_Boundary(pComponentPrivate->pPERFcomp, 2112 PERF_BoundaryStart | PERF_BoundaryCleanup); 2113 #endif 2114 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 2115 while ( (pPortDefIn->bPopulated) || (pPortDefOut->bPopulated)) 2116 { 2117 #ifndef UNDER_CE 2118 pthread_cond_wait(&pComponentPrivate->unpopulate_cond, &pComponentPrivate->videoe_mutex_app); 2119 #else 2120 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event)); 2121 #endif 2122 } 2123 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 2124 2125 #ifdef RESOURCE_MANAGER_ENABLED /* Resource Manager Proxy Calls */ 2126 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 2127 { 2128 /* TODO: Disable RM Send for now */ 2129 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H264_Encode_COMPONENT, 0); */ 2130 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 2131 RMProxy_FreeResource, 2132 OMX_H264_Encode_COMPONENT, 2133 0, 2134 3456, 2135 NULL); 2136 } 2137 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 2138 { 2139 /* TODO: Disable RM Send for now */ 2140 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_MPEG4_Encode_COMPONENT, 0); */ 2141 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 2142 RMProxy_FreeResource, 2143 OMX_MPEG4_Encode_COMPONENT, 2144 0, 2145 3456, 2146 NULL); 2147 } 2148 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 2149 { 2150 /* TODO: Disable RM Send for now */ 2151 /* eError = RMProxy_SendCommand(pHandle, RMProxy_RequestResource, OMX_H263_Encode_COMPONENT, 0); */ 2152 eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, 2153 RMProxy_FreeResource, 2154 OMX_H263_Encode_COMPONENT, 2155 0, 2156 3456, 2157 NULL); 2158 } 2159 if (eError != OMX_ErrorNone) 2160 { 2161 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 2162 OMX_EventError, 2163 OMX_ErrorHardware, 2164 OMX_TI_ErrorMajor, 2165 NULL); 2166 } 2167 #endif 2168 /* Make sure the DSP node has been deleted */ 2169 if (pComponentPrivate->bCodecStarted == OMX_TRUE || pComponentPrivate->bCodecLoaded == OMX_TRUE) 2170 { 2171 OMX_TRACE2(pComponentPrivate->dbg, "LCML_ControlCodec EMMCodecControlDestroy\n"); 2172 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 2173 EMMCodecControlDestroy, 2174 NULL); 2175 OMX_CONF_BAIL_IF_ERROR(eError); 2176 OMX_TRACE2(pComponentPrivate->dbg,"Atempting to Unload LCML"); 2177 /*Unload LCML */ 2178 if(pComponentPrivate->pModLcml != NULL) 2179 { 2180 OMX_TRACE2(pComponentPrivate->dbg,"Unloading LCML"); 2181 dlclose(pComponentPrivate->pModLcml); 2182 pComponentPrivate->pModLcml = NULL; 2183 pComponentPrivate->pLCML = NULL; 2184 } 2185 2186 pComponentPrivate->bCodecStarted = OMX_FALSE; 2187 pComponentPrivate->bCodecLoaded = OMX_FALSE; 2188 } 2189 2190 OMX_CONF_BAIL_IF_ERROR(eError); 2191 2192#ifdef __KHRONOS_CONF__ 2193 pComponentPrivate->bPassingIdleToLoaded = OMX_FALSE; 2194#endif 2195 pComponentPrivate->eState = OMX_StateLoaded; 2196 2197#ifdef __PERF_INSTRUMENTATION__ 2198 PERF_Boundary(pComponentPrivate->pPERFcomp, 2199 PERF_BoundaryComplete | PERF_BoundaryCleanup); 2200#endif 2201 2202 /* Decrement reference count with signal enabled */ 2203 if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) { 2204 return OMX_ErrorUndefined; 2205 } 2206 2207 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 2208 OMX_EventCmdComplete, 2209 OMX_CommandStateSet, 2210 OMX_StateLoaded, 2211 NULL); 2212 break; 2213 default: 2214 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 2215 OMX_EventError, 2216 OMX_ErrorIncorrectStateTransition, 2217 OMX_TI_ErrorMinor, 2218 NULL); 2219 } 2220OMX_CONF_CMD_BAIL: 2221 return eError; 2222} 2223 2224 2225/*---------------------------------------------------------------------------------------*/ 2226/** 2227 * OMX_OMX_VIDENC_Process_FreeOutBuf() 2228 * 2229 * Called by component thread, handles free output buffers from app. 2230 * 2231 * @param pComponentPrivate private component structure for this instance of the component 2232 * 2233 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 2234 * 2235 * @retval OMX_ErrorNone success, ready to roll 2236 * OMX_ErrorInsufficientResources if the malloc fails 2237 **/ 2238/*---------------------------------------------------------------------------------------*/ 2239 2240OMX_ERRORTYPE OMX_VIDENC_Process_FreeOutBuf(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 2241{ 2242 int nRet = -1; 2243 void *pUalgOutParams = NULL; 2244 VIDENC_NODE* pMemoryListHead = NULL; 2245 OMX_ERRORTYPE eError = OMX_ErrorNone; 2246 OMX_BUFFERHEADERTYPE* pBufHead = NULL; 2247 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 2248 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL; 2249 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 2250 2251 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 2252 2253 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 2254 pLcmlHandle = (LCML_DSP_INTERFACE*)(((VIDENC_COMPONENT_PRIVATE*)pComponentPrivate)->pLCML); 2255 pMemoryListHead = pComponentPrivate->pMemoryListHead; 2256 2257#ifndef UNDER_CE 2258 if (pthread_mutex_lock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0) 2259 { 2260 OMX_TRACE4(pComponentPrivate->dbg, "pthread_mutex_lock() failed.\n"); 2261 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2262 } 2263 nRet = read(pComponentPrivate->nFree_oPipe[0], &pBufHead, sizeof(pBufHead)); 2264 if ((nRet == -1) || !pBufHead || !pBufHead->pOutputPortPrivate) 2265 { 2266 pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex)); 2267 OMX_ERROR4(pComponentPrivate->dbg, "Error while reading from the pipe\n"); 2268 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2269 } 2270 2271 pBufferPrivate = pBufHead->pOutputPortPrivate; 2272 2273 pBufferPrivate->bReadFromPipe = OMX_TRUE; 2274 if (pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0) 2275 { 2276 OMX_TRACE4(pComponentPrivate->dbg, "pthread_mutex_unlock() failed.\n"); 2277 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2278 } 2279#else 2280 nRet = read(pComponentPrivate->nFree_oPipe[0], &pBufHead, sizeof(pBufHead)); 2281 if ((nRet == -1) || (pBufHead == NULL) || (pBufHead->pOutputPortPrivate == NULL)) 2282 { 2283 OMX_ERROR4(pComponentPrivate->dbg, "Error while reading from the pipe\n"); 2284 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2285 } 2286 if (pBufHead != NULL) 2287 { 2288 pBufferPrivate = pBufHead->pOutputPortPrivate; 2289 } 2290 pBufferPrivate->bReadFromPipe = OMX_TRUE; 2291#endif 2292 2293#ifdef __PERF_INSTRUMENTATION__ 2294 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 2295 PREF(pBufHead,pBuffer), 2296 0, 2297 PERF_ModuleCommonLayer); 2298#endif 2299 2300if (pBufferPrivate->eBufferOwner == VIDENC_BUFFER_WITH_DSP || 2301 pBufferPrivate->eBufferOwner == VIDENC_BUFFER_WITH_CLIENT) 2302 { 2303goto EXIT; 2304 2305} 2306 2307 if(!pBufferPrivate || !pLcmlHandle || !pPortDefOut) 2308 goto EXIT; 2309 2310 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 2311 { 2312 pUalgOutParams =(H264VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam; 2313 OMX_PRBUFFER1(pComponentPrivate->dbg, " %p \n", (void*)pBufHead); 2314 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_DSP; 2315 eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 2316 EMMCodecOuputBuffer, 2317 pBufHead->pBuffer, 2318 pBufHead->nAllocLen, 2319 0, 2320 (OMX_U8*)pUalgOutParams, 2321 sizeof(H264VE_GPP_SN_UALGOutputParams), 2322 (void*)pBufHead); 2323 if (eError != OMX_ErrorNone) 2324 { 2325 OMX_PRDSP4(pComponentPrivate->dbg, "LCML QueueBuffer failed: %x\n", eError); 2326 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2327 } 2328 2329 } 2330 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 || 2331 pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 2332 { 2333 pUalgOutParams = (MP4VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam; 2334 OMX_PRBUFFER1(pComponentPrivate->dbg, " %p\n", (void*)pBufHead); 2335 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_DSP; 2336 eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 2337 EMMCodecOuputBuffer, 2338 pBufHead->pBuffer, 2339 pBufHead->nAllocLen, 2340 0, 2341 (OMX_U8*)pUalgOutParams, 2342 sizeof(MP4VE_GPP_SN_UALGOutputParams), 2343 (void*)pBufHead); 2344 if (eError != OMX_ErrorNone) 2345 { 2346 OMX_PRDSP4(pComponentPrivate->dbg, "LCML QueueBuffer failed: %x\n", eError); 2347 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2348 } 2349 } 2350 else 2351 { 2352 OMX_PRBUFFER4(pComponentPrivate->dbg, "Unsupported compression format (%d)\n", 2353 pPortDefOut->format.video.eCompressionFormat); 2354 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 2355 } 2356 EXIT: 2357OMX_CONF_CMD_BAIL: 2358 return eError; 2359} 2360 2361/*---------------------------------------------------------------------------------------*/ 2362/** 2363 * OMX_VIDENC_Process_FilledInBuf() 2364 * 2365 * Called by component thread, handles filled input buffers from app. 2366 * 2367 * @param pComponentPrivate private component structure for this instance of the component 2368 * 2369 * @param phandle LCML_DSP_INTERFACE handle for this instance of the component 2370 * 2371 * @retval OMX_ErrorNone success, ready to roll 2372 * OMX_ErrorInsufficientResources if the malloc fails 2373 **/ 2374/*---------------------------------------------------------------------------------------*/ 2375 2376OMX_ERRORTYPE OMX_VIDENC_Process_FilledInBuf(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 2377{ 2378 OMX_U8 i = 0; 2379 int nRet = -1; 2380 void* pUalgInpParams = NULL; 2381 VIDENC_NODE* pMemoryListHead = NULL; 2382 OMX_ERRORTYPE eError = OMX_ErrorNone; 2383 OMX_BUFFERHEADERTYPE* pBufHead = NULL; 2384 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 2385 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL; 2386 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 2387 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 2388 VIDEOENC_PORT_TYPE* pCompPortOut = NULL; 2389 2390 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 2391 2392 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 2393 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 2394 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]; 2395 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 2396 pMemoryListHead = pComponentPrivate->pMemoryListHead; 2397 2398 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pLcmlHandle, pPortDefIn, 1); 2399 2400#ifndef UNDER_CE 2401 if (pthread_mutex_lock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0) 2402 { 2403 OMX_TRACE4(pComponentPrivate->dbg, "pthread_mutex_lock() failed.\n"); 2404 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2405 } 2406 nRet = read(pComponentPrivate->nFilled_iPipe[0], &(pBufHead), sizeof(pBufHead)); 2407 if ((nRet == -1) || !pBufHead || !pBufHead->pInputPortPrivate) 2408 { 2409 pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex)); 2410 OMX_TRACE4(pComponentPrivate->dbg, "Error while reading from the pipe\n"); 2411 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2412 } 2413 2414 if (pBufHead != NULL) 2415 { 2416 pBufferPrivate = (VIDENC_BUFFER_PRIVATE*)pBufHead->pInputPortPrivate; 2417 } 2418 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, pBufferPrivate, 1); 2419 pBufferPrivate->bReadFromPipe = OMX_TRUE; 2420 2421 if (pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0) 2422 { 2423 OMX_TRACE4(pComponentPrivate->dbg, "pthread_mutex_unlock() failed.\n"); 2424 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2425 } 2426#else 2427 nRet = read(pComponentPrivate->nFilled_iPipe[0], &(pBufHead), sizeof(pBufHead)); 2428 if (nRet == -1) 2429 { 2430 OMX_TRACE4(pComponentPrivate->dbg, "Error while reading from the pipe\n"); 2431 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2432 } 2433 pBufferPrivate = (VIDENC_BUFFER_PRIVATE*)pBufHead->pInputPortPrivate; 2434 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, pBufferPrivate, 1); 2435 pBufferPrivate->bReadFromPipe = OMX_TRUE; 2436#endif 2437 2438#ifdef __PERF_INSTRUMENTATION__ 2439 /*For Steady State Instumentation*/ 2440 #if 0 2441 if ((pComponentPrivate->nLcml_nCntIp == 1)) 2442 { 2443 PERF_Boundary(pComponentPrivate->pPERFcomp, 2444 PERF_BoundaryStart | PERF_BoundarySteadyState); 2445 } 2446 #endif 2447 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 2448 PREF(pBufHead,pBuffer), 2449 pPortDefIn->nBufferSize, 2450 PERF_ModuleCommonLayer); 2451#endif 2452 2453 if (pBufferPrivate->eBufferOwner == VIDENC_BUFFER_WITH_DSP || 2454 pBufferPrivate->eBufferOwner == VIDENC_BUFFER_WITH_CLIENT) 2455 { 2456 goto EXIT; 2457 } 2458 2459 2460 2461 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 2462 { 2463 2464 pUalgInpParams = (H264VE_GPP_SN_UALGInputParams*)pBufferPrivate->pUalgParam; 2465 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pUalgInpParams, 1, 1); 2466 2467 /*< must be followed for all video encoders*/ 2468 /* size of this structure */ 2469 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.size = sizeof(H264VE_GPP_SN_UALGInputParams); 2470 /* Input frame height */ 2471 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.inputHeight = pPortDefIn->format.video.nFrameHeight; 2472 /* Input frame width */ 2473 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.inputWidth = pPortDefIn->format.video.nFrameWidth; 2474 /* Reference or input frame rate*1000 */ 2475 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.refFrameRate = (OMX_U32)(Q16Tof(pPortDefIn->format.video.xFramerate)*1000.0); 2476 /* Target frame rate * 1000 */ 2477 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.targetFrameRate = pComponentPrivate->nTargetFrameRate; 2478 /* Target bit rate in bits per second */ 2479 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.targetBitRate = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig->nEncodeBitrate; 2480 /* I frame interval e.g. 30 */ 2481 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.intraFrameInterval = pComponentPrivate->nIntraFrameInterval; 2482 /* XDM_ENCODE_AU, XDM_GENERATE_HEADER */ 2483 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.generateHeader = 0; 2484 /* DEFAULT(0): use imagewidth as pitch 2485 * else use given capture width for 2486 * pitch provided it is greater than 2487 * image width.*/ 2488 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.captureWidth = 0; 2489 /* Force given frame as I or IDR (in H.264) frame */ 2490 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.videncDynamicParams.forceIFrame = pComponentPrivate->bForceIFrame; 2491 2492 2493 2494 /*< initial QP of I frames Range[-1,51]. -1 is for auto initialization.*/ 2495 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.qpIntra = 0x0000001c; 2496 /*< initial QP of P frames Range[-1,51]. -1 is for auto initialization.*/ 2497 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.qpInter = 0x0000001c; 2498 /*< Maximum QP to be used Range[0,51]*/ 2499 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.qpMax = 0x00000033; 2500 /*< Minimum QP to be used Range[0,51]*/ 2501 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.qpMin = 0x00000000; 2502 /*< Controls enable/disable loop filter, See IH264VENC_LoopFilterParams for more details*/ 2503 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.lfDisableIdc = 0x00000000; 2504 /*< enable/disable Quarter Pel Interpolation*/ 2505 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.quartPelDisable = 0x00000000; 2506 /*< Adaptive Intra Refesh MB Period: Period at which intra macro blocks should be insterted in a frame*/ 2507 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.airMbPeriod = pComponentPrivate->nAIRRate; 2508 /*< Maximum number of macro block in a slice <minimum value is 8>*/ 2509 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.maxMBsPerSlice = 0; 2510 /*< Maximum number of bytes in a slice */ 2511 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.maxBytesPerSlice = 0; 2512 /*< Row number from which slice needs to be intra coded*/ 2513 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceRefreshRowStartNumber = 0; 2514 /*< Number of rows to be coded as intra slice*/ 2515 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceRefreshRowNumber = 0; 2516 /*< alpha offset for loop filter [-12, 12] even number*/ 2517 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.filterOffsetA = 0; 2518 /*< beta offset for loop filter [-12, 12] even number*/ 2519 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.filterOffsetB = 0 ; 2520 /*< Limits the maximum frame number in the bit-stream to (1<< (log2MaxFNumMinus4 + 4)) Range[0,12]*/ 2521 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.log2MaxFNumMinus4 = 0; 2522 /*< Specifies offset to be added to luma QP for addressing QPC values table for chroma components. Valid value is between -12 and 12, (inclusive)*/ 2523 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.chromaQPIndexOffset = 0; 2524 /*< Controls the intra macroblock coding in P slices [0,1]*/ 2525 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.constrainedIntraPredEnable = 0; 2526 /*< Picture Order count type Valid values 0, 2*/ 2527 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.picOrderCountType = 0; 2528 /*< enable/Disable Multiple Motion vector per MB, valid values are [1, 4] [For DM6446, allowed value is only 1]*/ 2529 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.maxMVperMB = pComponentPrivate->maxMVperMB; 2530 /*< See IH264VENC_Intra4x4Params for more details*/ 2531 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.intra4x4EnableIdc = pComponentPrivate->intra4x4EnableIdc; 2532 /*< enable/Disable Motion vector access*/ 2533 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.mvDataEnable = 0; 2534 /*< Enable/Disable Hierarchical P Frame (non-reference P frame) Coding. [Not useful for DM6446]*/ 2535 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.hierCodingEnable = 0; /* should be 1; */ 2536 /*< Signals the type of stream generated with Call-back*/ 2537 if (pComponentPrivate->AVCNALFormat == VIDENC_AVC_NAL_UNIT) 2538 { 2539 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.streamFormat = IH264_BYTE_STREAM; 2540 } 2541 else 2542 { 2543 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.streamFormat = IH264_NALU_STREAM; 2544 } 2545 /*< Mechanism to do intra Refresh, see IH264VENC_IntraRefreshMethods for valid values*/ 2546 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.intraRefreshMethod = IH264_INTRAREFRESH_NONE; 2547 /* Enable Perceptual Quantization a.k.a. Perceptual Rate Control*/ 2548 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.perceptualQuant = 0; 2549 /* Enable Scene Change Detection*/ 2550 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sceneChangeDet = 0; 2551 /*< Function pointer of the call-back function to be used by Encoder*/ 2552 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.pfNalUnitCallBack = NULL; 2553 2554 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.pContext = NULL; 2555 2556 /*< Following Parameter are related to Arbitrary Slice Ordering (ASO)*/ 2557 /*< Number of valid enteries in asoSliceOrder array valid range is [0,8], 2558 //!< where 0 and 1 doesn't have any effect*/ 2559 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.numSliceASO = pComponentPrivate->numSliceASO; 2560 /*!< Array containing the order of slices in which they should 2561 //!< be present in bit-stream. vaild enteries are [0, any entry lesser than numSlicesASO]*/ 2562 for( i=0; i<MAXNUMSLCGPS;i++) 2563 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.asoSliceOrder[i] = pComponentPrivate->asoSliceOrder[i]; 2564 2565 /*< Following Parameter are related to Flexible macro block ordering (FMO)*/ 2566 /*< Total Number of slice groups, valid enteries are [0,8]*/ 2567 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.numSliceGroups = pComponentPrivate->numSliceGroups; 2568 /*< Slice GroupMapType : For Valid enteries see IH264VENC_SliceGroupMapType*/ 2569 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceGroupMapType = pComponentPrivate->sliceGroupMapType; 2570 /*< Slice Group Change Direction Flag: Only valid when sliceGroupMapType 2571 //!< is equal to IH264_RASTER_SCAN_SLICE_GRP. 2572 //!< For valid values refer IH264VENC_SliceGroupChangeDirection*/ 2573 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceGroupChangeDirectionFlag = pComponentPrivate->sliceGroupChangeDirectionFlag; 2574 /*< Slice Group Change Rate: Only valid when sliceGroupMapType 2575 //!< is equal to IH264_RASTER_SCAN_SLICE_GRP. 2576 //!< valid values are : [0, factor of number of Mbs in a row]*/ 2577 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceGroupChangeRate = pComponentPrivate->sliceGroupChangeRate; 2578 /*< Slice Group Change Cycle: Only valid when sliceGroupMapType 2579 //!< is equal to IH264_RASTER_SCAN_SLICE_GRP. 2580 //!< Valid values can be 0 to numMbsRowsInPicture, also constrained 2581 //!< by sliceGroupChangeRate*sliceGroupChangeCycle < totalMbsInFrame*/ 2582 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceGroupChangeCycle = pComponentPrivate->sliceGroupChangeCycle; 2583 /*< This field is useful in case of sliceGroupMapType equal to either 2584 //!< IH264_INTERLEAVED_SLICE_GRP or IH264_FOREGRND_WITH_LEFTOVER_SLICE_GRP 2585 //!< In both cases it has different meaning: 2586 //!< In case of IH264_INTERLEAVED_SLICE_GRP: 2587 //!< The i-th entery in this array is used to specify the number of consecutive 2588 //!< slice group macroblocks to be assigned to the i-th slice group in 2589 //!< raster scan order of slice group macroblock units. 2590 //!< Valid values are 0 to totalMbsInFrame again constrained by sum of all the elements 2591 //!< shouldn't exceed totalMbsInFrame 2592 //!< In case of IH264_FOREGRND_WITH_LEFTOVER_SLICE_GRP: 2593 //!< First entry in the array specify the start position of foreground region in terms 2594 //!< of macroblock number, valid values are [0, totalMbsInFrame-1] 2595 //!< Second entry in the array specify the end position of foreground region in terms 2596 //!< of macroblock number, valid values are [0, totalMbsInFrame-1] with following constrains: 2597 //!< endPos > startPos && endPos%mbsInOneRow > startPos%mbsInOneRow*/ 2598 for( i=0; i<MAXNUMSLCGPS;i++) 2599 { 2600 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->H264VENC_TI_DYNAMICPARAMS.sliceGroupParams[i] = pComponentPrivate->sliceGroupParams[i]; 2601 } 2602 2603 ((H264VE_GPP_SN_UALGInputParams*)pUalgInpParams)->ulFrameIndex = pComponentPrivate->nFrameCnt; 2604 2605 pComponentPrivate->bForceIFrame = 0; 2606 ++pComponentPrivate->nFrameCnt; 2607 2608 printH264UAlgInParam(pUalgInpParams, 0, &pComponentPrivate->dbg); 2609 OMX_CONF_CIRCULAR_BUFFER_MOVE_TAIL(pBufHead, 2610 pComponentPrivate->sCircularBuffer, 2611 pComponentPrivate); 2612 2613 /*Send Buffer to LCML*/ 2614 OMX_PRBUFFER1(pComponentPrivate->dbg, " %p\n", (void*)pBufHead); 2615 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_DSP; 2616 eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle, 2617 EMMCodecInputBuffer, 2618 pBufHead->pBuffer, 2619 pBufHead->nAllocLen, 2620 pBufHead->nFilledLen, 2621 (OMX_U8*)pUalgInpParams, 2622 sizeof(H264VE_GPP_SN_UALGInputParams), 2623 (OMX_U8*)pBufHead); 2624 if (eError != OMX_ErrorNone) 2625 { 2626 OMX_PRDSP4(pComponentPrivate->dbg, "LCML QueueBuffer failed: %x\n", eError); 2627 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorHardware); 2628 } 2629 2630 } 2631 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 || 2632 pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 2633 { 2634 eError = OMX_VIDENC_Queue_Mpeg4_Buffer(pComponentPrivate, pBufHead); 2635 } 2636 else 2637 { 2638 OMX_PRBUFFER4(pComponentPrivate->dbg, "Unsupported compression format (%d)\n", 2639 pPortDefOut->format.video.eCompressionFormat); 2640 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 2641 } 2642OMX_CONF_CMD_BAIL: 2643EXIT: 2644 return eError; 2645} 2646 2647OMX_ERRORTYPE OMX_VIDENC_Queue_Mpeg4_Buffer(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE* pBufHead) 2648{ 2649 MP4VE_GPP_SN_UALGInputParams* pUalgInpParams = NULL; 2650 OMX_ERRORTYPE eError = OMX_ErrorNone; 2651 VIDENC_BUFFER_PRIVATE* pBufferPrivate; 2652 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 2653 VIDEOENC_PORT_TYPE* pCompPortOut = NULL; 2654 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 2655 2656 pBufferPrivate = (VIDENC_BUFFER_PRIVATE*)pBufHead->pInputPortPrivate; 2657 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]; 2658 pPortDefOut = pCompPortOut->pPortDef; 2659 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 2660 2661 pUalgInpParams = (MP4VE_GPP_SN_UALGInputParams*)pBufferPrivate->pUalgParam; 2662 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pUalgInpParams, 1, 1); 2663 2664 pUalgInpParams->ulFrameIndex = pComponentPrivate->nFrameCnt; 2665 pUalgInpParams->ulTargetFrameRate = pComponentPrivate->nTargetFrameRate; 2666 pUalgInpParams->ulTargetBitRate = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig->nEncodeBitrate; 2667 pUalgInpParams->ulGenerateHeader = 0; 2668 pUalgInpParams->ulForceIFrame = pComponentPrivate->bForceIFrame; 2669 pUalgInpParams->ulResyncInterval = pCompPortOut->pErrorCorrectionType->nResynchMarkerSpacing; 2670 if(pCompPortOut->pErrorCorrectionType->bEnableHEC) 2671 pUalgInpParams->ulHecInterval = 3; 2672 else 2673 pUalgInpParams->ulHecInterval = 0; 2674 pUalgInpParams->ulAIRRate = pCompPortOut->pIntraRefreshType->nAirRef; 2675 pUalgInpParams->ulMIRRate = pComponentPrivate->nMIRRate; 2676 pUalgInpParams->ulfCode = 5; 2677 pUalgInpParams->ulHalfPel = 1; 2678 pUalgInpParams->ul4MV = 0; 2679 pUalgInpParams->ulIntraFrameInterval = pComponentPrivate->nIntraFrameInterval; 2680 2681 /*Set nQPI Value*/ 2682 if (pUalgInpParams->ulForceIFrame == OMX_TRUE) 2683 { 2684 pUalgInpParams->ulQPIntra = pComponentPrivate->nQPI; 2685 } 2686 else 2687 { 2688 pUalgInpParams->ulQPIntra = 0; 2689 } 2690 2691 /*Set segment mode params*/ 2692 if (pComponentPrivate->bMVDataEnable) 2693 { 2694 pUalgInpParams->ul4MV =1; 2695 pUalgInpParams->uluseUMV =1; 2696 pUalgInpParams->ulMVDataEnable =1; 2697 } 2698 else 2699 { 2700 pUalgInpParams->ul4MV =0; 2701 pUalgInpParams->uluseUMV =0; 2702 pUalgInpParams->ulMVDataEnable =0; 2703 } 2704 if (pComponentPrivate->bResyncDataEnable) 2705 pUalgInpParams->ulResyncDataEnable =1; 2706 else 2707 pUalgInpParams->ulResyncDataEnable =0; 2708 /* Reset bForceMPEG4IFrame to zero */ 2709 pComponentPrivate->bForceIFrame = OMX_FALSE; 2710 2711 /*Set ulACPred Value*/ 2712 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 2713 { 2714 pUalgInpParams->ulACPred = pComponentPrivate->pMpeg4->bACPred; 2715 } 2716 else 2717 { 2718 pUalgInpParams->ulACPred = 0; 2719 } 2720 pUalgInpParams->ulQPInter = 8; 2721 pUalgInpParams->ulLastFrame = 0; 2722 pUalgInpParams->ulcapturewidth = 0; 2723 pUalgInpParams->ulQpMax = 31; 2724 pUalgInpParams->ulQpMin = 2; 2725 ++pComponentPrivate->nFrameCnt; 2726 2727 if(pComponentPrivate->bRequestVOLHeader == OMX_TRUE) 2728 { 2729 /*In the case of Mpeg4 we have to send an extra Buffer to LCML requesting for VOL Header*/ 2730 memcpy(pComponentPrivate->pTempUalgInpParams,pUalgInpParams,sizeof(MP4VE_GPP_SN_UALGInputParams)); 2731 pComponentPrivate->pTempUalgInpParams->ulGenerateHeader = 1; 2732 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_DSP; 2733 eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle, 2734 EMMCodecInputBuffer, 2735 pComponentPrivate->pTempUalgInpParams,/*send any buffer*/ 2736 1, 2737 0, 2738 pComponentPrivate->pTempUalgInpParams, 2739 sizeof(MP4VE_GPP_SN_UALGInputParams), 2740 (OMX_U8*)pBufHead); 2741 if (eError != OMX_ErrorNone) 2742 { 2743 OMX_PRDSP2(pComponentPrivate->dbg, "LCML QueueBuffer failed: %x\n", eError); 2744 } 2745 pComponentPrivate->bRequestVOLHeader = OMX_FALSE; 2746 } 2747 2748 OMX_PRDSP1(pComponentPrivate->dbg, 2749 "TargetFrameRate -> %d\n\ 2750 TargetBitRate -> %d\n\ 2751 QPI -> %d\n", pComponentPrivate->nTargetFrameRate, 2752 (int)pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig->nEncodeBitrate, 2753 pComponentPrivate->nQPI); 2754 2755 printMpeg4UAlgInParam(pUalgInpParams, 0, &pComponentPrivate->dbg); 2756 OMX_CONF_CIRCULAR_BUFFER_MOVE_TAIL(pBufHead, 2757 pComponentPrivate->sCircularBuffer, 2758 pComponentPrivate); 2759 2760 /*Send Buffer to LCML*/ 2761 OMX_PRBUFFER1(pComponentPrivate->dbg, " %p\n", (void*)pBufHead); 2762 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_DSP; 2763 eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle, 2764 EMMCodecInputBuffer, 2765 pBufHead->pBuffer, 2766 pBufHead->nAllocLen, 2767 pBufHead->nFilledLen, 2768 (OMX_U8*)pUalgInpParams, 2769 sizeof(MP4VE_GPP_SN_UALGInputParams), 2770 (OMX_U8*)pBufHead); 2771 if (eError != OMX_ErrorNone) 2772 { 2773 OMX_PRDSP4(pComponentPrivate->dbg, "LCML QueueBuffer failed: %x\n", eError); 2774 } 2775 2776OMX_CONF_CMD_BAIL: 2777 2778 return eError; 2779} 2780 2781 2782/*---------------------------------------------------------------------------------------*/ 2783/** 2784 * OMX_VIDENC_Process_FilledOutBuf() 2785 * 2786 * Called by component thread, handles filled output buffers from DSP. 2787 * 2788 * @param pComponentPrivate private component structure for this instance of the component 2789 * 2790 * @retval OMX_ErrorNone success, ready to roll 2791 * OMX_ErrorInsufficientResources if the malloc fails 2792 **/ 2793/*---------------------------------------------------------------------------------------*/ 2794 2795OMX_ERRORTYPE OMX_VIDENC_Process_FilledOutBuf(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE* pBufHead) 2796{ 2797 OMX_ERRORTYPE eError = OMX_ErrorNone; 2798 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL; 2799 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 2800 OMX_OTHER_EXTRADATATYPE_1_1_2* pExtraDataType; 2801 H264VE_GPP_SN_UALGOutputParams* pSNPrivateParams; 2802 OMX_U8* pTemp; 2803 OMX_U32* pIndexNal; 2804 2805 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 2806 2807 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 2808 2809 if (pComponentPrivate->bCodecStarted == OMX_TRUE) 2810 { 2811 2812 pBufferPrivate = pBufHead->pOutputPortPrivate; 2813 pSNPrivateParams = (H264VE_GPP_SN_UALGOutputParams*)(pBufferPrivate->pUalgParam); 2814 pBufHead->nFilledLen = ((H264VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->ulBitstreamSize; 2815 2816 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 2817 { 2818 pBufHead->nFlags &= ~OMX_BUFFERFLAG_CODECCONFIG; 2819 2820 /*Copy Buffer Data to be propagated*/ 2821 if((pComponentPrivate->AVCNALFormat == VIDENC_AVC_NAL_SLICE) && 2822 (pSNPrivateParams->ulNALUnitsPerFrame != (pSNPrivateParams->ulNALUnitIndex+1)) && 2823 (pSNPrivateParams->ulNALUnitsPerFrame != 0)) 2824 { 2825 2826 pBufHead->pMarkData = NULL; 2827 pBufHead->hMarkTargetComponent = NULL; 2828 pBufHead->nTickCount = pComponentPrivate->sCircularBuffer.pHead->nTickCount; 2829 pBufHead->nTimeStamp = pComponentPrivate->sCircularBuffer.pHead->nTimeStamp; 2830 pBufHead->nFlags = 0; 2831 } 2832 else 2833 { 2834 OMX_CONF_CIRCULAR_BUFFER_MOVE_HEAD(pBufHead, pComponentPrivate->sCircularBuffer, 2835 pComponentPrivate); 2836 pBufHead->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME; 2837 } 2838 2839 2840 /* Set lFrameType*/ 2841 if (((H264VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->lFrameType == OMX_LFRAMETYPE_H264 || 2842 ((H264VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->lFrameType == OMX_LFRAMETYPE_IDR_H264) 2843 { 2844 /* IDR Frame */ 2845 OMX_S32 nalType = pBufHead->pBuffer[0] & 0x1F; 2846 if (nalType == SPS_CODE_PREFIX || nalType == PPS_CODE_PREFIX) { 2847 /* Need to drop subsequent SPS or PPS NAL unit since opencore does not 2848 * correctly handle storage */ 2849 if (!pComponentPrivate->bSentFirstSpsPps) { 2850 if (nalType == SPS_CODE_PREFIX) { 2851 // Save SPS and send it along with PPS later in a single buffer 2852 // Workaround to send a 0-length buffer first. 2853 // Ideally, we should not send a buffer at all. 2854 pComponentPrivate->sps = malloc(4 + pBufHead->nFilledLen); 2855 pComponentPrivate->spsLen = 4 + pBufHead->nFilledLen; 2856 memcpy(pComponentPrivate->sps, "\x00\x00\x00\x01", 4); 2857 memcpy(pComponentPrivate->sps + 4, pBufHead->pBuffer, pBufHead->nFilledLen); 2858 pBufHead->nFilledLen = 0; 2859 } 2860 2861 /* we can assume here that PPS always comes second */ 2862 if (nalType == PPS_CODE_PREFIX) { 2863 pComponentPrivate->bSentFirstSpsPps = OMX_TRUE; 2864 if (pComponentPrivate->sps == NULL || 2865 pComponentPrivate->spsLen == 0) { 2866 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 2867 } 2868 memmove(pBufHead->pBuffer + pComponentPrivate->spsLen + 4, 2869 pBufHead->pBuffer, pBufHead->nFilledLen); 2870 memmove(pBufHead->pBuffer, 2871 pComponentPrivate->sps, pComponentPrivate->spsLen); 2872 memcpy(pBufHead->pBuffer + pComponentPrivate->spsLen, "\x00\x00\x00\x01", 4); 2873 pBufHead->nFilledLen += pComponentPrivate->spsLen + 4; 2874 pBufHead->nFlags |= OMX_BUFFERFLAG_CODECCONFIG; 2875 free(pComponentPrivate->sps); 2876 pComponentPrivate->sps = NULL; 2877 pComponentPrivate->spsLen = 0; 2878 } 2879 } else { 2880 pBufHead->nFilledLen = 0; 2881 } 2882 } 2883 2884 pBufHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME; 2885 } 2886 2887 /* if NAL frame mode */ 2888 if (pComponentPrivate->AVCNALFormat == VIDENC_AVC_NAL_FRAME) 2889 { 2890 2891 /*H264VE_GPP_SN_UALGOutputParams* pSNPrivateParams;*/ 2892 int nNalSlices; 2893 2894 pBufHead->nFlags |= OMX_BUFFERFLAG_EXTRADATA; 2895 2896 pTemp = pBufHead->pBuffer + pBufHead->nOffset + pBufHead->nFilledLen + 3; 2897 pExtraDataType = (OMX_OTHER_EXTRADATATYPE_1_1_2*) (((OMX_U32) pTemp) & ~3); 2898 pIndexNal = (OMX_U32*)(pExtraDataType->data); 2899 /*pSNPrivateParams = (H264VE_GPP_SN_UALGOutputParams*)(pBufferPrivate->pUalgParam);*/ 2900 2901 pExtraDataType->nVersion.s.nVersionMajor = 1; 2902 pExtraDataType->nVersion.s.nVersionMinor = 1; 2903 pExtraDataType->nVersion.s.nRevision = 2; 2904 pExtraDataType->nPortIndex = VIDENC_OUTPUT_PORT; 2905 pExtraDataType->eType = OMX_ExtraDataQuantization; 2906 pExtraDataType->nDataSize = (1+pSNPrivateParams->ulNALUnitsPerFrame)*sizeof(OMX_U32); 2907 2908 *pIndexNal = pSNPrivateParams->ulNALUnitsPerFrame; 2909 pIndexNal++; 2910 for (nNalSlices = 0; (OMX_U32)nNalSlices < pSNPrivateParams->ulNALUnitsPerFrame; nNalSlices++, pIndexNal++) 2911 { 2912 2913 *pIndexNal = (OMX_U32)(pSNPrivateParams->ulNALUnitsSizes[nNalSlices]); 2914 } 2915 2916 pTemp = (OMX_U8*)((((OMX_U32)pIndexNal)+3) & ~3); 2917 pExtraDataType->nSize = (OMX_U32)pTemp-(OMX_U32)pExtraDataType; 2918 2919 pExtraDataType = (OMX_OTHER_EXTRADATATYPE_1_1_2*) pTemp; 2920 pExtraDataType->nSize = (sizeof(OMX_OTHER_EXTRADATATYPE_1_1_2)+3) & ~3; 2921 pExtraDataType->nVersion.s.nVersionMajor = 1; 2922 pExtraDataType->nVersion.s.nVersionMinor = 1; 2923 pExtraDataType->nVersion.s.nRevision = 2; 2924 pExtraDataType->nPortIndex = VIDENC_OUTPUT_PORT; 2925 pExtraDataType->eType = OMX_ExtraDataNone; 2926 pExtraDataType->nDataSize = 0; 2927 } 2928 } 2929 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 || 2930 pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 2931 { 2932 pBufHead->nFlags &= ~OMX_BUFFERFLAG_CODECCONFIG; 2933 2934 /*We ignore the first Mpeg4 buffer which contains VOL Header since we did not add it to the circular list*/ 2935 if(pComponentPrivate->bWaitingForVOLHeaderBuffer == OMX_FALSE) 2936 { 2937 OMX_CONF_CIRCULAR_BUFFER_MOVE_HEAD(pBufHead, pComponentPrivate->sCircularBuffer, 2938 pComponentPrivate); 2939 } 2940 else 2941 { 2942 pComponentPrivate->bWaitingForVOLHeaderBuffer = OMX_FALSE; 2943 pBufHead->nFlags |= OMX_BUFFERFLAG_CODECCONFIG; 2944 } 2945 2946 pBufHead->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME; 2947 2948 /* Set cFrameType*/ 2949 if (((MP4VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->cFrameType == OMX_CFRAMETYPE_MPEG4) 2950 { 2951 /* I-VOP Frame */ 2952 pBufHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME; 2953 } 2954 VIDENC_MPEG4_SEGMENTMODE_METADATA* pMetaData; 2955 /*copy MPEG4 segment mode meta data */ 2956 pMetaData=(VIDENC_MPEG4_SEGMENTMODE_METADATA*)pBufferPrivate->pMetaData; 2957 if (pComponentPrivate->bMVDataEnable==OMX_TRUE) 2958 { 2959 pMetaData->mvDataSize=((MP4VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->mvDataSize; 2960 pMetaData->pMVData=((MP4VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->MVData; 2961 } 2962 if (pComponentPrivate->bResyncDataEnable==OMX_TRUE) 2963 { 2964 pMetaData->pResyncData=((MP4VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->ResyncData; 2965 pMetaData->numPackets=((MP4VE_GPP_SN_UALGOutputParams*)pBufferPrivate->pUalgParam)->numPackets; 2966 } 2967 } 2968 else 2969 { 2970 OMX_PRBUFFER4(pComponentPrivate->dbg, "Unsupported compression format (%d)\n", 2971 pPortDefOut->format.video.eCompressionFormat); 2972 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 2973 } 2974 2975 if (pBufHead->nFlags & OMX_BUFFERFLAG_EOS) 2976 { 2977 /* trigger event handler */ 2978 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, OMX_EventBufferFlag, 0x1, pBufHead->nFlags, NULL); 2979 /* clear flag */ 2980 pComponentPrivate->nFlags = 0; 2981 } 2982 2983 if (pBufHead->pMarkData != NULL) 2984 { 2985 /* trigger event handler if we are supposed to */ 2986 if (pBufHead->hMarkTargetComponent == pComponentPrivate->pHandle && 2987 pBufHead->pMarkData) 2988 { 2989 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, OMX_EventMark, 0x0, 0x0, 2990 pBufHead->pMarkData); 2991 } 2992 } 2993 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 2994#ifdef __PERF_INSTRUMENTATION__ 2995 PERF_SendingBuffer(pComponentPrivate->pPERFcomp, 2996 pBufHead->pBuffer, 2997 pBufHead->nFilledLen, 2998 PERF_ModuleHLMM); 2999#endif 3000 pComponentPrivate->sCbData.FillBufferDone(pComponentPrivate->pHandle, 3001 pComponentPrivate->pHandle->pApplicationPrivate, 3002 pBufHead); 3003 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->FillbufferdoneCount); 3004 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 3005 } 3006OMX_CONF_CMD_BAIL: 3007 return eError; 3008} 3009 3010/*---------------------------------------------------------------------------------------*/ 3011/** 3012 * OMX_VIDENC_Process_FreeInBuf() 3013 * 3014 * Called by component thread, handles free input buffers from DSP. 3015 * 3016 * @param pComponentPrivate private component structure for this instance of the component 3017 * 3018 * @retval OMX_ErrorNone success, ready to roll 3019 * OMX_ErrorInsufficientResources if the malloc fails 3020 **/ 3021/*---------------------------------------------------------------------------------------*/ 3022 3023OMX_ERRORTYPE OMX_VIDENC_Process_FreeInBuf(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE* pBufHead) 3024{ 3025 VIDENC_NODE* pMemoryListHead = NULL; 3026 OMX_ERRORTYPE eError = OMX_ErrorNone; 3027 OMX_HANDLETYPE hTunnelComponent = NULL; 3028 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL; 3029 3030 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 3031 3032 hTunnelComponent = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->hTunnelComponent; 3033 pMemoryListHead = pComponentPrivate->pMemoryListHead; 3034 3035 /*pBufHead is checked for NULL*/ 3036 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, 1, 1); 3037 pBufferPrivate = pBufHead->pInputPortPrivate; 3038 3039 if (hTunnelComponent != NULL) 3040 { 3041 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_TUNNELEDCOMP; 3042#ifdef __PERF_INSTRUMENTATION__ 3043 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 3044 PREF(pBufHead,pBuffer), 3045 pBufHead->nFilledLen, 3046 PERF_ModuleLLMM); 3047#endif 3048 3049 eError = OMX_FillThisBuffer(hTunnelComponent, pBufHead); 3050 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, 3051 OMX_PRBUFFER4, "FillThisBuffer failed (%x)", eError); 3052 } 3053 else 3054 { 3055 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT; 3056#ifdef __PERF_INSTRUMENTATION__ 3057 PERF_SendingFrame(pComponentPrivate->pPERFcomp, 3058 PREF(pBufHead,pBuffer), 3059 0, 3060 PERF_ModuleHLMM); 3061#endif 3062 pComponentPrivate->sCbData.EmptyBufferDone(pComponentPrivate->pHandle, 3063 pComponentPrivate->pHandle->pApplicationPrivate, 3064 pBufHead); 3065 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->EmptybufferdoneCount); 3066 OMX_VIDENC_SignalIfAllBuffersAreReturned(pComponentPrivate); 3067 } 3068 3069OMX_CONF_CMD_BAIL: 3070 return eError; 3071} 3072/*---------------------------------------------------------------------------------------*/ 3073/** 3074 * Function to initialize LCML 3075 * 3076 * 3077 * 3078 * @retval OMX_NoError Success, ready to roll 3079 * 3080 **/ 3081/*---------------------------------------------------------------------------------------*/ 3082 3083OMX_ERRORTYPE OMX_VIDENC_InitLCML(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 3084{ 3085 OMX_ERRORTYPE eError = OMX_ErrorNone; 3086 OMX_HANDLETYPE hLCML = NULL; 3087 VIDENC_NODE* pMemoryListHead = NULL; 3088#ifdef UNDER_CE 3089 typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE); 3090 LPFNDLLFUNC1 fpGetHandle1; 3091#else 3092 void* pMyLCML = NULL; 3093 fpo fpGetHandle = NULL; 3094 char* error = NULL; 3095#endif 3096 3097 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 3098 3099#ifndef UNDER_CE 3100 pMyLCML = dlopen("libLCML.so", RTLD_LAZY); 3101 pComponentPrivate->pModLcml = pMyLCML; 3102 if (!pMyLCML) 3103 { 3104 OMX_ERROR5(pComponentPrivate->dbg, "Could not open LCML library\n"); 3105 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 3106 } 3107 3108 fpGetHandle = dlsym(pMyLCML, "GetHandle"); 3109 if ((error = dlerror()) != NULL) 3110 { 3111 OMX_ERROR4(pComponentPrivate->dbg, "No GetHandle in LCML library\n"); 3112 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 3113 } 3114 3115 eError = (*fpGetHandle)(&hLCML); 3116 if (eError != OMX_ErrorNone) 3117 { 3118 OMX_ERROR5(pComponentPrivate->dbg, "Error While Getting LCML Handle (%x)...\n", eError); 3119 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 3120 } 3121 3122 pComponentPrivate->pLCML = (LCML_DSP_INTERFACE*)hLCML; 3123 pMemoryListHead = pComponentPrivate->pMemoryListHead; 3124 pComponentPrivate->pLCML->pComponentPrivate = (VIDENC_COMPONENT_PRIVATE *)pComponentPrivate; 3125 3126#else 3127 g_hLcmlDllHandle = LoadLibraryEx(TEXT("oaf_bml.dll"), NULL, 0); 3128 if (g_hLcmlDllHandle == NULL) 3129 { 3130 OMX_ERROR5(pComponentPrivate->dbg, "BML Load Failed!!!, %d\n", GetLastError()); 3131 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 3132 } 3133 fpGetHandle1 = (LPFNDLLFUNC1)GetProcAddress(g_hLcmlDllHandle,TEXT("GetHandle")); 3134 if (!fpGetHandle1) 3135 { 3136 FreeLibrary(g_hLcmlDllHandle); 3137 g_hLcmlDllHandle = NULL; 3138 OMX_ERROR4(pComponentPrivate->dbg, "No GetHandle in BML\n"); 3139 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 3140 } 3141 eError = fpGetHandle1(&hLCML); 3142 if (eError != OMX_ErrorNone) 3143 { 3144 FreeLibrary(g_hLcmlDllHandle); 3145 g_hLcmlDllHandle = NULL; 3146 OMX_ERROR5(pComponentPrivate->dbg, "Error While Getting LCML Handle (%x)...\n", eError); 3147 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 3148 } 3149 (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML = (LCML_DSP_INTERFACE*)hLCML; 3150 pComponentPrivate->pLCML->pComponentPrivate = (VIDENC_COMPONENT_PRIVATE *)pComponentPrivate; 3151#endif 3152OMX_CONF_CMD_BAIL: 3153 return eError; 3154} 3155 3156/*---------------------------------------------------------------------------------------*/ 3157/** 3158 * Function to fill DSP structures via LCML 3159 * 3160 * 3161 * 3162 * @retval OMX_NoError Success, ready to roll 3163 * 3164 **/ 3165/*---------------------------------------------------------------------------------------*/ 3166 3167OMX_ERRORTYPE OMX_VIDENC_InitDSP_H264Enc(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 3168{ 3169 OMX_U16 nArr[100]; 3170 OMX_U32* pTmp = NULL; 3171 LCML_CALLBACKTYPE sCb; 3172 LCML_DSP* pLcmlDSP = NULL; 3173 VIDENC_NODE* pMemoryListHead = NULL; 3174 OMX_ERRORTYPE eError = OMX_ErrorNone; 3175 OMX_VIDEO_PARAM_AVCTYPE* pH264 = NULL; 3176 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 3177 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 3178 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 3179 OMX_VIDEO_PARAM_BITRATETYPE* pVidParamBitrate = NULL; 3180 OMX_VIDEO_PARAM_QUANTIZATIONTYPE* pQuantization = NULL; 3181 H264VE_GPP_SN_Obj_CreatePhase* pCreatePhaseArgs = NULL; 3182 /* OMX_VIDEO_CONFIG_AVCINTRAPERIOD* pH264IntraPeriod = NULL; */ 3183 OMX_VIDEO_PARAM_MOTIONVECTORTYPE* pMotionVector = NULL; 3184 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 3185 3186 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 3187 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 3188 pH264 = pComponentPrivate->pH264; 3189 pVidParamBitrate = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType; 3190 pQuantization = pComponentPrivate->pQuantization; 3191 pMemoryListHead = pComponentPrivate->pMemoryListHead; 3192 /* pH264IntraPeriod = pComponentPrivate->pH264IntraPeriod; */ 3193 pMotionVector = pComponentPrivate->pMotionVector; 3194 pComponentPrivate->bErrorLcmlHandle = OMX_FALSE; 3195 3196 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 3197 pLcmlDSP = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec); 3198 pLcmlDSP = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec); 3199 3200 pLcmlDSP->In_BufInfo.nBuffers = pPortDefIn->nBufferCountActual; 3201 pLcmlDSP->In_BufInfo.nSize = pComponentPrivate->nInBufferSize; 3202 pLcmlDSP->In_BufInfo.DataTrMethod = DMM_METHOD; 3203 3204 pLcmlDSP->Out_BufInfo.nBuffers = pPortDefOut->nBufferCountActual; 3205 pLcmlDSP->Out_BufInfo.nSize = pComponentPrivate->nOutBufferSize; 3206 pLcmlDSP->Out_BufInfo.DataTrMethod = DMM_METHOD; 3207 3208 pLcmlDSP->NodeInfo.nNumOfDLLs = OMX_H264ENC_NUM_DLLS; 3209 pLcmlDSP->NodeInfo.AllUUIDs[0].uuid = &H264VESOCKET_TI_UUID; 3210 strcpy ((char *)pLcmlDSP->NodeInfo.AllUUIDs[0].DllName,H264_ENC_NODE_DLL); 3211 pLcmlDSP->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT; 3212 3213 pLcmlDSP->NodeInfo.AllUUIDs[1].uuid = &H264VESOCKET_TI_UUID; 3214 strcpy ((char *)pLcmlDSP->NodeInfo.AllUUIDs[1].DllName,H264_ENC_NODE_DLL); 3215 pLcmlDSP->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT; 3216 3217 pLcmlDSP->NodeInfo.AllUUIDs[2].uuid = &USN_UUID; 3218 strcpy ((char *)pLcmlDSP->NodeInfo.AllUUIDs[2].DllName,USN_DLL); 3219 pLcmlDSP->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT; 3220 3221 pLcmlDSP->SegID = 0; 3222 pLcmlDSP->Timeout = -1; 3223 pLcmlDSP->Alignment = 0; 3224 pLcmlDSP->Priority = 5; 3225 3226 #ifdef GPP_PRIVATE_NODE_HEAP 3227 if ((pPortDefIn->format.video.nFrameWidth <= 176) && 3228 (pPortDefIn->format.video.nFrameHeight <= 144)) 3229 { 3230 pLcmlDSP->ProfileID = 0; 3231 } 3232 else if ((pPortDefIn->format.video.nFrameWidth <= 352) && 3233 (pPortDefIn->format.video.nFrameHeight <= 288)) 3234 { 3235 pLcmlDSP->ProfileID = 1; 3236 } 3237 else 3238 { 3239 pLcmlDSP->ProfileID = 2; 3240 } 3241 #else 3242 pLcmlDSP->ProfileID = 0xff; /* Use DSP node heap */ 3243 #endif 3244 3245 /* pLcmlDSP->buffindx = 999; */ 3246 3247 VIDENC_MALLOC(pCreatePhaseArgs, 3248 sizeof(H264VE_GPP_SN_Obj_CreatePhase), 3249 H264VE_GPP_SN_Obj_CreatePhase, 3250 pMemoryListHead, 3251 pComponentPrivate->dbg); 3252 3253 pCreatePhaseArgs->usNumStreams = 2; 3254 pCreatePhaseArgs->usStreamId = VIDENC_INPUT_PORT; 3255 pCreatePhaseArgs->usBuffTypeInStream = 0; 3256 pCreatePhaseArgs->usMaxBuffsInStream = (OMX_U16)pPortDefIn->nBufferCountActual; 3257 pCreatePhaseArgs->usStreamId2 = VIDENC_OUTPUT_PORT; 3258 pCreatePhaseArgs->usBuffTypeInStream2 = 0; 3259 pCreatePhaseArgs->usMaxBuffsInStream2 = (OMX_U16)pPortDefOut->nBufferCountActual; 3260 3261 pCreatePhaseArgs->ulWidth = pPortDefIn->format.video.nFrameWidth; 3262 pCreatePhaseArgs->ulHeight = pPortDefIn->format.video.nFrameHeight; 3263 pCreatePhaseArgs->ulTargetBitRate = pPortDefOut->format.video.nBitrate; 3264 pCreatePhaseArgs->ulBitstreamBuffSize = pComponentPrivate->nOutBufferSize; 3265 pCreatePhaseArgs->ulFrameRate = (unsigned int)(Q16Tof(pPortDefIn->format.video.xFramerate)*1000.0); 3266 3267 /* set run-time frame and bit rates to create-time values */ 3268 pComponentPrivate->nTargetFrameRate = pCreatePhaseArgs->ulFrameRate; 3269 pComponentPrivate->nPrevTargetFrameRate = 0; 3270 pComponentPrivate->bSentFirstSpsPps = OMX_FALSE; 3271 3272 if (pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) 3273 { 3274 pCreatePhaseArgs->ucYUVFormat = 0; 3275 } 3276 else if (pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatCbYCrY) /*422 LE UYVY*/ 3277 { 3278 pCreatePhaseArgs->ucYUVFormat = 2; 3279 } 3280 else if (pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatYCbYCr) /*422 BE YUYV */ 3281 { 3282 pCreatePhaseArgs->ucYUVFormat = 1; 3283 } 3284 else 3285 { 3286 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported YUV format.\n"); 3287 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3288 } 3289 3290 pCreatePhaseArgs->ucUnrestrictedMV = pComponentPrivate->ucUnrestrictedMV; 3291 pCreatePhaseArgs->ucNumRefFrames = 1; 3292 3293 if (pVidParamBitrate->eControlRate == OMX_Video_ControlRateVariable) 3294 { 3295 pCreatePhaseArgs->ucRateControlAlgorithm = 0; 3296 } 3297 else if (pVidParamBitrate->eControlRate == OMX_Video_ControlRateConstant) 3298 { 3299 pCreatePhaseArgs->ucRateControlAlgorithm = 1; 3300 } 3301 else if (pVidParamBitrate->eControlRate == OMX_Video_ControlRateDisable) 3302 { 3303 pCreatePhaseArgs->ucRateControlAlgorithm = 2; 3304 } 3305 else 3306 { 3307 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported rate control algorithm.\n"); 3308 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3309 } 3310 3311 pCreatePhaseArgs->ucIDREnable = 1; 3312 3313 if (pComponentPrivate->bDeblockFilter == OMX_FALSE) 3314 { 3315 pCreatePhaseArgs->ucDeblockingEnable = 0; 3316 } 3317 else if (pComponentPrivate->bDeblockFilter == OMX_TRUE) 3318 { 3319 pCreatePhaseArgs->ucDeblockingEnable = 1; 3320 } 3321 else 3322 { 3323 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported deblocking setting.\n"); 3324 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter); 3325 } 3326 3327 pCreatePhaseArgs->ucMVRange = (pMotionVector->sXSearchRange > pMotionVector->sYSearchRange ? pMotionVector->sXSearchRange : pMotionVector->sYSearchRange); 3328 pCreatePhaseArgs->ucQPIFrame = 28; 3329 pCreatePhaseArgs->ucProfile = 66; 3330 pCreatePhaseArgs->ulIntraFramePeriod = pCreatePhaseArgs->ulFrameRate > 15000 ? 29 : 14; 3331 3332 if (pH264->eLevel == OMX_VIDEO_AVCLevel1b) 3333 { 3334 pCreatePhaseArgs->ucLevel = 9; 3335 } 3336 else if (pH264->eLevel == OMX_VIDEO_AVCLevel1) 3337 { 3338 pCreatePhaseArgs->ucLevel = 10; 3339 } 3340 else if (pH264->eLevel == OMX_VIDEO_AVCLevel11) 3341 { 3342 pCreatePhaseArgs->ucLevel = 11; 3343 } 3344 else if (pH264->eLevel == OMX_VIDEO_AVCLevel12) 3345 { 3346 pCreatePhaseArgs->ucLevel = 12; 3347 } 3348 else if (pH264->eLevel == OMX_VIDEO_AVCLevel13) 3349 { 3350 pCreatePhaseArgs->ucLevel = 13; 3351 } 3352 else if (pH264->eLevel == OMX_VIDEO_AVCLevel2) 3353 { 3354 pCreatePhaseArgs->ucLevel = 20; 3355 } 3356 else if (pH264->eLevel == OMX_VIDEO_AVCLevel21) 3357 { 3358 pCreatePhaseArgs->ucLevel = 21; 3359 } 3360 else if (pH264->eLevel == OMX_VIDEO_AVCLevel22) 3361 { 3362 pCreatePhaseArgs->ucLevel = 22; 3363 } 3364 else if (pH264->eLevel == OMX_VIDEO_AVCLevel3) 3365 { 3366 pCreatePhaseArgs->ucLevel = 30; 3367 if ((pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) && 3368 (pPortDefIn->format.video.nFrameWidth == 320) && 3369 (pPortDefIn->format.video.nFrameHeight == 240)) 3370 { 3371 pCreatePhaseArgs->ucQPIFrame = 0; 3372 } 3373 } 3374 else 3375 { 3376 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting, 3377 pComponentPrivate->dbg, OMX_PRDSP2, 3378 "Unsupported level.\n"); 3379 } 3380 3381 /* override parameters for VGA & D1 encoding */ 3382 if ((pPortDefIn->format.video.nFrameWidth >= 640 || 3383 pPortDefIn->format.video.nFrameHeight >= 480) && 3384 pCreatePhaseArgs->ulFrameRate > 15000) 3385 { 3386 pComponentPrivate->maxMVperMB = 1; 3387 pComponentPrivate->intra4x4EnableIdc = INTRA4x4_ISLICES; 3388 pComponentPrivate->nIntraFrameInterval = 30; 3389 pComponentPrivate->nAIRRate = 0; 3390 /* Encoding preset = 4 enables DSP side optimizations for high resolutions */ 3391 pComponentPrivate->nEncodingPreset = 4; 3392 pCreatePhaseArgs->ulIntraFramePeriod = 0; 3393 /* Constant bit rate control enabled */ 3394 pCreatePhaseArgs->ucRateControlAlgorithm = 1; 3395 pCreatePhaseArgs->ucLevel = 30; 3396 } 3397 /* Ensure frame rate update interval, which forces IDR frames, is same as I-Slice interval */ 3398 pComponentPrivate->nFrameRateUpdateInterval = pComponentPrivate->nIntraFrameInterval; 3399 pCreatePhaseArgs->usNalCallback = pComponentPrivate->AVCNALFormat; 3400 pCreatePhaseArgs->ulEncodingPreset = pComponentPrivate->nEncodingPreset; 3401 pCreatePhaseArgs->ulRcAlgo = 0; 3402 pCreatePhaseArgs->endArgs = END_OF_CR_PHASE_ARGS; 3403 printH264CreateParams(pCreatePhaseArgs, &pComponentPrivate->dbg); 3404 3405 pTmp = memcpy (nArr, pCreatePhaseArgs, sizeof(H264VE_GPP_SN_Obj_CreatePhase)); 3406 if (pTmp == NULL) 3407 { 3408 OMX_TRACE4(pComponentPrivate->dbg, "memcpy() out of memory error.\n"); 3409 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources); 3410 } 3411 pLcmlDSP->pCrPhArgs = nArr; 3412 sCb.LCML_Callback = (void *)OMX_VIDENC_LCML_Callback; 3413 3414 eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 3415 NULL, 3416 &pLcmlHandle, 3417 NULL, 3418 &sCb); 3419 if (eError != OMX_ErrorNone) 3420 { 3421 OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...\n"); 3422 /*TODO: Validate eError from LCML_InitMMCodec for ResourceExhaustionTest */ 3423 pComponentPrivate->bErrorLcmlHandle = OMX_TRUE; 3424 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources); 3425 } 3426 pComponentPrivate->bCodecLoaded = OMX_TRUE; 3427 VIDENC_FREE(pCreatePhaseArgs, pMemoryListHead, 3428 pComponentPrivate->dbg); 3429OMX_CONF_CMD_BAIL: 3430 return eError; 3431} 3432 3433/*---------------------------------------------------------------------------------------*/ 3434/** 3435 * Function to fill DSP structures via LCML 3436 * 3437 * 3438 * 3439 * @retval OMX_NoError Success, ready to roll 3440 * 3441 **/ 3442/*---------------------------------------------------------------------------------------*/ 3443 3444OMX_ERRORTYPE OMX_VIDENC_InitDSP_Mpeg4Enc(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 3445{ 3446 OMX_U16 nArr[100]; 3447 OMX_U32* pTmp = NULL; 3448 LCML_CALLBACKTYPE sCb; 3449 LCML_DSP* pLcmlDSP = NULL; 3450 VIDENC_NODE* pMemoryListHead = NULL; 3451 OMX_ERRORTYPE eError = OMX_ErrorNone; 3452 LCML_DSP_INTERFACE* pLcmlHandle = NULL; 3453 OMX_VIDEO_PARAM_H263TYPE* pH263 = NULL; 3454 OMX_VIDEO_PARAM_MPEG4TYPE* pMpeg4 = NULL; 3455 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL; 3456 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 3457 MP4VE_GPP_SN_Obj_CreatePhase* pCreatePhaseArgs = NULL; 3458 OMX_VIDEO_PARAM_BITRATETYPE* pVidParamBitrate = NULL; 3459 OMX_VIDEO_PARAM_QUANTIZATIONTYPE* pQuantization = NULL; 3460 VIDEOENC_PORT_TYPE* pCompPortOut = NULL; 3461 3462 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 3463 3464 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef; 3465 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 3466 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]; 3467 pVidParamBitrate = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType; 3468 pQuantization = pComponentPrivate->pQuantization; 3469 pH263 = pComponentPrivate->pH263; 3470 pMpeg4 = pComponentPrivate->pMpeg4; 3471 pMemoryListHead = pComponentPrivate->pMemoryListHead; 3472 3473 pComponentPrivate->bErrorLcmlHandle = OMX_FALSE; 3474 3475 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML; 3476 pLcmlDSP = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec); 3477 3478 pLcmlDSP->In_BufInfo.nBuffers = pPortDefIn->nBufferCountActual; 3479 pLcmlDSP->In_BufInfo.nSize = pComponentPrivate->nInBufferSize; 3480 pLcmlDSP->In_BufInfo.DataTrMethod = DMM_METHOD; 3481 3482 pLcmlDSP->Out_BufInfo.nBuffers = pPortDefOut->nBufferCountActual; 3483 pLcmlDSP->Out_BufInfo.nSize = pComponentPrivate->nOutBufferSize; 3484 pLcmlDSP->Out_BufInfo.DataTrMethod = DMM_METHOD; 3485 3486 pLcmlDSP->NodeInfo.nNumOfDLLs = OMX_MP4ENC_NUM_DLLS; 3487 pLcmlDSP->NodeInfo.AllUUIDs[0].uuid = &MP4VESOCKET_TI_UUID; 3488 strcpy ((char *)pLcmlDSP->NodeInfo.AllUUIDs[0].DllName,MP4_ENC_NODE_DLL); 3489 pLcmlDSP->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT; 3490 3491 pLcmlDSP->NodeInfo.AllUUIDs[1].uuid = &MP4VESOCKET_TI_UUID; 3492 strcpy ((char *)pLcmlDSP->NodeInfo.AllUUIDs[1].DllName,MP4_ENC_NODE_DLL); 3493 pLcmlDSP->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT; 3494 3495 pLcmlDSP->NodeInfo.AllUUIDs[2].uuid = &USN_UUID; 3496 strcpy ((char *)pLcmlDSP->NodeInfo.AllUUIDs[2].DllName,USN_DLL); 3497 pLcmlDSP->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT; 3498 3499 pLcmlDSP->SegID = 0; 3500 pLcmlDSP->Timeout = -1; 3501 pLcmlDSP->Alignment = 0; 3502 pLcmlDSP->Priority = 5; 3503 3504 #ifdef GPP_PRIVATE_NODE_HEAP 3505 if ((pPortDefIn->format.video.nFrameWidth <= 176) && 3506 (pPortDefIn->format.video.nFrameHeight <= 144)) 3507 { 3508 pLcmlDSP->ProfileID = 0; 3509 } 3510 else if ((pPortDefIn->format.video.nFrameWidth <= 352) && 3511 (pPortDefIn->format.video.nFrameHeight <= 288)) 3512 { 3513 pLcmlDSP->ProfileID = 1; 3514 } 3515 else if ((pPortDefIn->format.video.nFrameWidth <= 640) && 3516 (pPortDefIn->format.video.nFrameHeight <= 480)) 3517 { 3518 pLcmlDSP->ProfileID = 2; 3519 } 3520 else if ((pPortDefIn->format.video.nFrameWidth <= 720) && 3521 (pPortDefIn->format.video.nFrameHeight <= 480)) 3522 { 3523 pLcmlDSP->ProfileID = 3; 3524 } 3525 else if ((pPortDefIn->format.video.nFrameWidth <= 720) && 3526 (pPortDefIn->format.video.nFrameHeight <= 576)) 3527 { 3528 pLcmlDSP->ProfileID = 4; 3529 } 3530 else 3531 { 3532 pLcmlDSP->ProfileID = 4; 3533 } 3534 #else 3535 pLcmlDSP->ProfileID = 0xff; /* Use DSP node heap */ 3536 #endif 3537 3538 /* pLcmlDSP->buffindx = 999; */ 3539 3540 VIDENC_MALLOC(pCreatePhaseArgs, 3541 sizeof(MP4VE_GPP_SN_Obj_CreatePhase), 3542 MP4VE_GPP_SN_Obj_CreatePhase, 3543 pMemoryListHead, 3544 pComponentPrivate->dbg); 3545 3546 pCreatePhaseArgs->ucUnrestrictedMV = pComponentPrivate->ucUnrestrictedMV; 3547 pCreatePhaseArgs->ucProfile = 1; 3548 3549 pCreatePhaseArgs->usNumStreams = 2; 3550 pCreatePhaseArgs->usStreamId = 0; 3551 pCreatePhaseArgs->usBuffTypeInStream = 0; 3552 pCreatePhaseArgs->usMaxBuffsInStream = (OMX_U16)pPortDefIn->nBufferCountActual; 3553 pCreatePhaseArgs->usStreamId2 = 1; 3554 pCreatePhaseArgs->usBuffTypeInStream2 = 0; 3555 pCreatePhaseArgs->usMaxBuffsInStream2 = (OMX_U16)pPortDefOut->nBufferCountActual; 3556 3557 pCreatePhaseArgs->ulWidth = pPortDefIn->format.video.nFrameWidth; 3558 pCreatePhaseArgs->ulHeight = pPortDefIn->format.video.nFrameHeight; 3559 pCreatePhaseArgs->ulTargetBitRate = pPortDefOut->format.video.nBitrate; 3560 pCreatePhaseArgs->ulVBVSize = pComponentPrivate->nVBVSize; 3561 3562 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 3563 { 3564 pCreatePhaseArgs->ulGOBHeadersInterval = pH263->nGOBHeaderInterval; 3565 } 3566 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 3567 { 3568 pCreatePhaseArgs->ulGOBHeadersInterval = 0; 3569 } 3570 3571 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) 3572 { 3573 pCreatePhaseArgs->ucIsMPEG4 = 0; 3574 } 3575 else if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 3576 { 3577 pCreatePhaseArgs->ucIsMPEG4 = 1; 3578 /*Initialize variables for the generation of VOL Header*/ 3579 pComponentPrivate->bRequestVOLHeader = OMX_TRUE; 3580 pComponentPrivate->bWaitingForVOLHeaderBuffer = OMX_TRUE; 3581 pComponentPrivate->bWaitingVOLHeaderCallback = OMX_TRUE; 3582 } 3583 else 3584 { 3585 OMX_PRDSP4(pComponentPrivate->dbg, "Unsupported video format (%d).\n", 3586 pPortDefOut->format.video.eCompressionFormat); 3587 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3588 } 3589 3590 if (pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) 3591 { 3592 pCreatePhaseArgs->ucYUVFormat = 0; 3593 } 3594 else if (pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatCbYCrY) /*422 LE UYVY*/ 3595 { 3596 pCreatePhaseArgs->ucYUVFormat = 2; 3597 } 3598 else if (pPortDefIn->format.video.eColorFormat == OMX_COLOR_FormatYCbYCr) /*422 BE YUYV */ 3599 { 3600 pCreatePhaseArgs->ucYUVFormat = 1; 3601 } 3602 else 3603 { 3604 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported YUV format.\n"); 3605 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3606 } 3607 if(pCompPortOut->pErrorCorrectionType->bEnableHEC) 3608 pCreatePhaseArgs->ucHEC = 1; 3609 else 3610 pCreatePhaseArgs->ucHEC = 0;/**/ 3611 3612 if(pCompPortOut->pErrorCorrectionType->bEnableResync) 3613 pCreatePhaseArgs->ucResyncMarker = 1; 3614 else 3615 pCreatePhaseArgs->ucResyncMarker = 0;/**/ 3616 3617 if(pCompPortOut->pErrorCorrectionType->bEnableDataPartitioning) 3618 pCreatePhaseArgs->ucDataPartitioning = 1; 3619 else 3620 pCreatePhaseArgs->ucDataPartitioning = 0;/**/ 3621 3622 if(pCompPortOut->pErrorCorrectionType->bEnableRVLC) 3623 pCreatePhaseArgs->ucReversibleVLC = 1; 3624 else 3625 pCreatePhaseArgs->ucReversibleVLC = 0;/**/ 3626 3627 pCreatePhaseArgs->ucFrameRate = (OMX_U8) Q16Tof(pPortDefIn->format.video.xFramerate); 3628 3629 /* set run-time frame and bit rates to create-time values */ 3630 pComponentPrivate->nTargetFrameRate = pCreatePhaseArgs->ucFrameRate; 3631 pComponentPrivate->nPrevTargetFrameRate = 0; 3632 pComponentPrivate->nTargetBitRate = pCreatePhaseArgs->ulTargetBitRate; 3633 3634 if (pVidParamBitrate->eControlRate == OMX_Video_ControlRateConstant) 3635 { 3636 pCreatePhaseArgs->ucRateControlAlgorithm = IVIDEO_LOW_DELAY; 3637 } 3638 else if (pVidParamBitrate->eControlRate == OMX_Video_ControlRateVariable) 3639 { 3640 pCreatePhaseArgs->ucRateControlAlgorithm = IVIDEO_STORAGE; 3641 } 3642 else if (pVidParamBitrate->eControlRate == OMX_Video_ControlRateDisable) 3643 { 3644 pCreatePhaseArgs->ucRateControlAlgorithm = IVIDEO_NONE; 3645 } 3646 else 3647 { 3648 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported rate control algorithm.\n"); 3649 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3650 } 3651 3652 pCreatePhaseArgs->ucQPFirstIFrame = (OMX_U8)pQuantization->nQpI; 3653 3654 if (pCreatePhaseArgs->ucIsMPEG4 == 1) 3655 { 3656#ifdef __KHRONOS_CONF_1_1__ 3657 if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level0) 3658 { 3659 pCreatePhaseArgs->ucLevel = 0; 3660 } 3661 else if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level1) 3662 { 3663 pCreatePhaseArgs->ucLevel = 1; 3664 } 3665 else if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level2) 3666 { 3667 pCreatePhaseArgs->ucLevel = 2; 3668 } 3669 else if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level3) 3670 { 3671 pCreatePhaseArgs->ucLevel = 3; 3672 } 3673 else if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level4a || 3674 pMpeg4->eLevel == OMX_VIDEO_MPEG4Level4) 3675 { 3676 pCreatePhaseArgs->ucLevel = 4; 3677 } 3678 else if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level5) 3679 { 3680 pCreatePhaseArgs->ucLevel = 5; 3681 } 3682 else if (pMpeg4->eLevel == OMX_VIDEO_MPEG4Level0b) 3683 { 3684 pCreatePhaseArgs->ucLevel = 100; 3685 } 3686 else 3687 { 3688 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported level.\n"); 3689 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3690 } 3691#else 3692 pCreatePhaseArgs->ucLevel = pMpeg4->eLevel; 3693#endif 3694 pCreatePhaseArgs->enableH263AnnexI = 0; 3695 pCreatePhaseArgs->enableH263AnnexJ = 0; 3696 pCreatePhaseArgs->enableH263AnnexT = 0; 3697 3698 } 3699 else 3700 { 3701 if (pH263->eLevel == OMX_VIDEO_H263Level10) 3702 { 3703 pCreatePhaseArgs->ucLevel = 10; 3704 } 3705 else if (pH263->eLevel == OMX_VIDEO_H263Level20) 3706 { 3707 pCreatePhaseArgs->ucLevel = 20; 3708 } 3709 else if (pH263->eLevel == OMX_VIDEO_H263Level30) 3710 { 3711 pCreatePhaseArgs->ucLevel = 30; 3712 } 3713 else if (pH263->eLevel == OMX_VIDEO_H263Level40) 3714 { 3715 pCreatePhaseArgs->ucLevel = 40; 3716 } 3717 else if (pH263->eLevel == OMX_VIDEO_H263Level45) 3718 { 3719 pCreatePhaseArgs->ucLevel = 45; 3720 } 3721 else if (pH263->eLevel == OMX_VIDEO_H263Level50) 3722 { 3723 pCreatePhaseArgs->ucLevel = 50; 3724 } 3725 else if (pH263->eLevel == OMX_VIDEO_H263Level60) 3726 { 3727 pCreatePhaseArgs->ucLevel = 60; 3728 } 3729 else if (pH263->eLevel == OMX_VIDEO_H263Level70) 3730 { 3731 pCreatePhaseArgs->ucLevel = 70; 3732 } 3733 else 3734 { 3735 OMX_PRDSP2(pComponentPrivate->dbg, "Unsupported level.\n"); 3736 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUnsupportedSetting); 3737 } 3738 3739 pCreatePhaseArgs->enableH263AnnexI = 0; 3740 pCreatePhaseArgs->enableH263AnnexJ = 0; 3741 pCreatePhaseArgs->enableH263AnnexT = 0; 3742 } 3743 pCreatePhaseArgs->ulMaxDelay = 300; 3744 #ifndef MODE_3410 3745 pCreatePhaseArgs->ulVbvParamEnable = 0; 3746 pCreatePhaseArgs->ulH263SliceMode = 0; 3747 #endif 3748 pCreatePhaseArgs->ulUseGOV = 0; 3749 if (pPortDefOut->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 3750 pCreatePhaseArgs->ulUseVOS = 1;//needed to generate VOL Header 3751 else 3752 pCreatePhaseArgs->ulUseVOS = 0; 3753 pCreatePhaseArgs->endArgs = END_OF_CR_PHASE_ARGS; 3754 pTmp = memcpy(nArr, pCreatePhaseArgs, sizeof(MP4VE_GPP_SN_Obj_CreatePhase)); 3755 if (pTmp == NULL) 3756 { 3757 OMX_TRACE4(pComponentPrivate->dbg, "memcpy() out of memory error.\n"); 3758 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources); 3759 } 3760 3761 pLcmlDSP->pCrPhArgs = nArr; 3762 printMpeg4Params(pCreatePhaseArgs, &pComponentPrivate->dbg); 3763 3764 sCb.LCML_Callback = (void *)OMX_VIDENC_LCML_Callback; 3765 eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, 3766 NULL, 3767 &pLcmlHandle, 3768 NULL, 3769 &sCb); 3770 3771 if (eError != OMX_ErrorNone) 3772 { 3773 OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...\n"); 3774 /*TODO: Validate eError from LCML_InitMMCodec for ResourceExhaustionTest */ 3775 pComponentPrivate->bErrorLcmlHandle = OMX_TRUE; 3776 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources); 3777 } 3778 pComponentPrivate->bCodecLoaded = OMX_TRUE; 3779 VIDENC_FREE(pCreatePhaseArgs, pMemoryListHead, 3780 pComponentPrivate->dbg); 3781 3782OMX_CONF_CMD_BAIL: 3783 return eError; 3784} 3785/*----------------------------------------------------------------------------*/ 3786/** 3787 * OMX_VIDENC_Allocate_DSPResources() 3788 * 3789 * 3790 * 3791 * 3792 * @param 3793 * @param 3794 * @param 3795 * 3796 * @retval OMX_NoError Success, ready to roll 3797 * OMX_Error_BadParameter The input parameter pointer is null 3798 **/ 3799/*----------------------------------------------------------------------------*/ 3800 3801OMX_ERRORTYPE OMX_VIDENC_Allocate_DSPResources(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, 3802 OMX_IN OMX_U32 nPortIndex) 3803{ 3804 char* pTemp = NULL; 3805 OMX_U32 nBufferCnt = -1; 3806 VIDENC_NODE* pMemoryListHead = NULL; 3807 OMX_ERRORTYPE eError = OMX_ErrorNone; 3808 VIDEOENC_PORT_TYPE* pCompPort = NULL; 3809 OMX_VIDEO_CODINGTYPE eCompressionFormat = -1; 3810 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL; 3811 3812 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1); 3813 3814 pMemoryListHead = pComponentPrivate->pMemoryListHead; 3815 pCompPort = pComponentPrivate->pCompPort[nPortIndex]; 3816 nBufferCnt = pComponentPrivate->pCompPort[nPortIndex]->nBufferCnt; 3817 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 3818 eCompressionFormat = pPortDefOut->format.video.eCompressionFormat; 3819 3820 if (nPortIndex == VIDENC_INPUT_PORT) 3821 { 3822 if (eCompressionFormat == OMX_VIDEO_CodingAVC) 3823 { 3824 H264VE_GPP_SN_UALGInputParams* pUalgParam; 3825 3826 VIDENC_MALLOC(pUalgParam, 3827 sizeof(H264VE_GPP_SN_UALGInputParams) + 256, 3828 H264VE_GPP_SN_UALGInputParams, 3829 pMemoryListHead, 3830 pComponentPrivate->dbg); 3831 3832 pTemp = (char*)pUalgParam; 3833 pTemp += 128; 3834 pUalgParam = (H264VE_GPP_SN_UALGInputParams*)pTemp; 3835 pCompPort->pBufferPrivate[nBufferCnt]->pUalgParam = pUalgParam; 3836 } 3837 else if (eCompressionFormat == OMX_VIDEO_CodingMPEG4 || 3838 eCompressionFormat == OMX_VIDEO_CodingH263) 3839 { 3840 MP4VE_GPP_SN_UALGInputParams* pUalgParam; 3841 3842 VIDENC_MALLOC(pUalgParam, 3843 sizeof(MP4VE_GPP_SN_UALGInputParams) + 256, 3844 MP4VE_GPP_SN_UALGInputParams, 3845 pMemoryListHead, 3846 pComponentPrivate->dbg); 3847 pTemp = (char*)pUalgParam; 3848 pTemp += 128; 3849 pUalgParam = (MP4VE_GPP_SN_UALGInputParams*)pTemp; 3850 pCompPort->pBufferPrivate[nBufferCnt]->pUalgParam = pUalgParam; 3851 if(eCompressionFormat == OMX_VIDEO_CodingMPEG4) 3852 {/*Structure needed to send the request for VOLHeader to SN*/ 3853 VIDENC_MALLOC(pComponentPrivate->pTempUalgInpParams, 3854 sizeof(MP4VE_GPP_SN_UALGInputParams) + 256, 3855 MP4VE_GPP_SN_UALGInputParams, 3856 pMemoryListHead, 3857 pComponentPrivate->dbg); 3858 pTemp = (char*)pComponentPrivate->pTempUalgInpParams; 3859 pTemp += 128; 3860 pComponentPrivate->pTempUalgInpParams = (MP4VE_GPP_SN_UALGInputParams*)pTemp; 3861 } 3862 } 3863 } 3864 else if (nPortIndex == VIDENC_OUTPUT_PORT) 3865 { 3866 if (eCompressionFormat == OMX_VIDEO_CodingAVC) 3867 { 3868 H264VE_GPP_SN_UALGOutputParams* pUalgParam; 3869 3870 VIDENC_MALLOC(pUalgParam, 3871 sizeof(H264VE_GPP_SN_UALGOutputParams) + 256, 3872 H264VE_GPP_SN_UALGOutputParams, 3873 pMemoryListHead, 3874 pComponentPrivate->dbg); 3875 pTemp = (char*)pUalgParam; 3876 pTemp += 128; 3877 pUalgParam = (H264VE_GPP_SN_UALGOutputParams*)pTemp; 3878 pCompPort->pBufferPrivate[nBufferCnt]->pUalgParam = pUalgParam; 3879 } 3880 else if (eCompressionFormat == OMX_VIDEO_CodingMPEG4 || 3881 eCompressionFormat == OMX_VIDEO_CodingH263) 3882 { 3883 MP4VE_GPP_SN_UALGOutputParams* pUalgParam; 3884 3885 VIDENC_MALLOC(pUalgParam, 3886 sizeof(MP4VE_GPP_SN_UALGOutputParams) + 256, 3887 MP4VE_GPP_SN_UALGOutputParams, 3888 pMemoryListHead, 3889 pComponentPrivate->dbg); 3890 pTemp = (char*)pUalgParam; 3891 pTemp += 128; 3892 pUalgParam = (MP4VE_GPP_SN_UALGOutputParams*)pTemp; 3893 pCompPort->pBufferPrivate[nBufferCnt]->pUalgParam = pUalgParam; 3894 } 3895 } 3896OMX_CONF_CMD_BAIL: 3897 return eError; 3898} 3899 3900/*---------------------------------------------------------------------------------------*/ 3901/** 3902 * Callback() function will be called LCML component to write the msg 3903 * 3904 * @param msgBuffer This buffer will be returned by the LCML 3905 * 3906 * @retval OMX_NoError Success, ready to roll 3907 * OMX_Error_BadParameter The input parameter pointer is null 3908 **/ 3909/*---------------------------------------------------------------------------------------*/ 3910OMX_ERRORTYPE OMX_VIDENC_LCML_Callback(TUsnCodecEvent event,void* argsCb [10]) 3911{ 3912 int nRet = -1; 3913 OMX_COMPONENTTYPE* pHandle = NULL; 3914 OMX_ERRORTYPE eError = OMX_ErrorNone; 3915 OMX_BUFFERHEADERTYPE* pBufHead = NULL; 3916 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL; 3917 LCML_DSP_INTERFACE* pLcmlDspInterface = NULL; 3918 TUsnCodecEvent eEvent = (TUsnCodecEvent)event; 3919 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL; 3920 3921 OMX_CONF_CHECK_CMD(argsCb, 1, 1); 3922 3923 if (argsCb[6]) 3924 { 3925 pLcmlDspInterface = (LCML_DSP_INTERFACE*)argsCb[6]; 3926 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pLcmlDspInterface->pComponentPrivate; 3927 pHandle = (OMX_COMPONENTTYPE *)pComponentPrivate->pHandle; 3928 } 3929 else 3930 { 3931 OMXDBG_PRINT(stderr, DSP, 5, 0, "No LCML handle\n"); 3932 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter); 3933 } 3934 3935 3936 if (eEvent == EMMCodecBufferProcessed) 3937 { 3938 if (((OMX_S32)argsCb[0]) == EMMCodecOuputBuffer) 3939 { 3940 pBufHead = (OMX_BUFFERHEADERTYPE*)argsCb[7]; 3941 pBufferPrivate = (VIDENC_BUFFER_PRIVATE*)pBufHead->pOutputPortPrivate; 3942#ifdef __PERF_INSTRUMENTATION__ 3943 PERF_ReceivedFrame(pComponentPrivate->pPERFcomp, 3944 PREF(pBufHead,pBuffer), 3945 PREF(pBufHead,nFilledLen), 3946 PERF_ModuleCommonLayer); 3947 3948 pComponentPrivate->nLcml_nCntOpReceived++; 3949 3950 if ((pComponentPrivate->nLcml_nCntIp >= 1) && 3951 (pComponentPrivate->nLcml_nCntOpReceived == 1)) 3952 { 3953 PERF_Boundary(pComponentPrivate->pPERFcomp, 3954 PERF_BoundaryStart | PERF_BoundarySteadyState); 3955 } 3956#endif 3957 OMX_PRDSP1(pComponentPrivate->dbg, " [OUT] -> %p\n", pBufHead); 3958 if(pBufHead->nFilledLen > pBufHead->nAllocLen) { 3959 ALOGD("VE Warning!!! Output buffer overflow."); 3960 } 3961 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_COMPONENT; 3962 if (pComponentPrivate->bCodecStarted == OMX_TRUE) 3963 { 3964 OMX_PRDSP1(pComponentPrivate->dbg, "Enters OMX_VIDENC_Process_FilledOutBuf\n"); 3965 eError = OMX_VIDENC_Process_FilledOutBuf(pComponentPrivate, pBufHead); 3966 if (eError != OMX_ErrorNone) 3967 { 3968 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 3969 OMX_EventError, 3970 OMX_ErrorUndefined, 3971 OMX_TI_ErrorCritical, 3972 NULL); 3973 OMX_VIDENC_BAIL_IF_ERROR(eError, pComponentPrivate); 3974 } 3975 } 3976 } 3977 if ((int)argsCb [0] == EMMCodecInputBuffer) 3978 { 3979 pBufHead = (OMX_BUFFERHEADERTYPE*)argsCb[7]; 3980 pBufferPrivate = (VIDENC_BUFFER_PRIVATE*)pBufHead->pInputPortPrivate; 3981 3982#ifdef __PERF_INSTRUMENTATION__ 3983 PERF_ReceivedFrame(pComponentPrivate->pPERFcomp, 3984 PREF(pBufHead,pBuffer), 3985 0, 3986 PERF_ModuleCommonLayer); 3987#endif 3988 3989 OMX_PRDSP1(pComponentPrivate->dbg, " [IN] -> %p\n", pBufHead); 3990 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_COMPONENT; 3991 /*we should ignore the callback asociated to the VOL Header request*/ 3992 if (pComponentPrivate->bCodecStarted == OMX_TRUE && pComponentPrivate->bWaitingVOLHeaderCallback == OMX_FALSE) 3993 { 3994 OMX_PRDSP1(pComponentPrivate->dbg, "Enters OMX_VIDENC_Process_FreeInBuf\n"); 3995 eError = OMX_VIDENC_Process_FreeInBuf(pComponentPrivate, pBufHead); 3996 if (eError != OMX_ErrorNone) 3997 { 3998 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate, 3999 OMX_EventError, 4000 OMX_ErrorUndefined, 4001 OMX_TI_ErrorCritical, 4002 NULL); 4003 OMX_VIDENC_BAIL_IF_ERROR(eError, pComponentPrivate); 4004 } 4005 OMX_PRDSP1(pComponentPrivate->dbg, "Exits OMX_VIDENC_Process_FreeInBuf\n"); 4006 } 4007 else if(pComponentPrivate->bWaitingVOLHeaderCallback == OMX_TRUE) 4008 { 4009 pComponentPrivate->bWaitingVOLHeaderCallback = OMX_FALSE; 4010 } 4011 } 4012 } 4013 4014 if(eEvent == EMMCodecProcessingPaused || 4015 eEvent == EMMCodecProcessingStoped) 4016 { 4017 if (pComponentPrivate != NULL) 4018 { 4019 pComponentPrivate->bDSPStopAck = OMX_TRUE; 4020 #ifndef UNDER_CE 4021 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 4022 pthread_cond_signal(&pComponentPrivate->stop_cond); 4023 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 4024 #endif 4025 } 4026 } 4027 4028 if(eEvent == EMMCodecStrmCtrlAck) 4029 { 4030 if ((int)argsCb [0] == USN_ERR_NONE) 4031 { 4032 pComponentPrivate->bFlushComplete = OMX_TRUE; 4033 #ifndef UNDER_CE 4034 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app); 4035 pthread_cond_signal(&pComponentPrivate->flush_cond); 4036 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app); 4037 #endif 4038 } 4039 } 4040 nRet = OMX_VIDENC_HandleLcmlEvent(pComponentPrivate, eEvent, argsCb); 4041 if (nRet == -1) 4042 { 4043 OMX_ERROR4(pComponentPrivate->dbg, "LCML Event Handler failed.\n"); 4044 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined); 4045 } 4046 4047OMX_CONF_CMD_BAIL: 4048 return eError; 4049} 4050 4051 4052#ifdef UNDER_CE 4053/* ================================================================================= */ 4054/** 4055* @fns Sleep replace for WIN CE 4056*/ 4057/* ================================================================================ */ 4058int OMX_CreateEvent(OMX_Event *event){ 4059 int ret = OMX_ErrorNone; 4060 HANDLE createdEvent = NULL; 4061 if (event == NULL) 4062 { 4063 ret = OMX_ErrorBadParameter; 4064 goto EXIT; 4065 } 4066 event->event = CreateEvent(NULL, TRUE, FALSE, NULL); 4067 if(event->event == NULL) 4068 ret = (int)GetLastError(); 4069EXIT: 4070 return ret; 4071} 4072 4073int OMX_SignalEvent(OMX_Event *event){ 4074 int ret = OMX_ErrorNone; 4075 if (event == NULL) 4076 { 4077 ret = OMX_ErrorBadParameter; 4078 goto EXIT; 4079 } 4080 SetEvent(event->event); 4081 ret = (int)GetLastError(); 4082EXIT: 4083 return ret; 4084} 4085 4086int OMX_WaitForEvent(OMX_Event *event) { 4087 int ret = OMX_ErrorNone; 4088 if (event == NULL) 4089 { 4090 ret = OMX_ErrorBadParameter; 4091 goto EXIT; 4092 } 4093 WaitForSingleObject(event->event, INFINITE); 4094 ret = (int)GetLastError(); 4095EXIT: 4096 return ret; 4097} 4098 4099int OMX_DestroyEvent(OMX_Event *event) { 4100 int ret = OMX_ErrorNone; 4101 if (event == NULL) 4102 { 4103 ret = OMX_ErrorBadParameter; 4104 goto EXIT; 4105 } 4106 CloseHandle(event->event); 4107EXIT: 4108 return ret; 4109} 4110#endif 4111 4112#ifdef RESOURCE_MANAGER_ENABLED 4113/*-----------------------------------------------------------------------------*/ 4114/** 4115 * OMX_VIDENC_ResourceManagerCallBack() 4116 * 4117 * Called from Resource Manager() 4118 * 4119 * 4120 * 4121 **/ 4122/*-----------------------------------------------------------------------------*/ 4123void OMX_VIDENC_ResourceManagerCallBack(RMPROXY_COMMANDDATATYPE cbData) 4124{ 4125 OMX_COMMANDTYPE Cmd = OMX_CommandStateSet; 4126 OMX_STATETYPE state = OMX_StateIdle; 4127 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent; 4128 VIDENC_COMPONENT_PRIVATE *pCompPrivate = NULL; 4129 4130 pCompPrivate = (VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate; 4131 OMX_PRMGR2(pCompPrivate->dbg, "OMX_VIDENC_ResourceManagerCallBack\n"); 4132 OMX_PRMGR2(pCompPrivate->dbg, "Arguments:\ncbData.RM_Error = %dcbData.RM_Cmd = %d\n", *(cbData.RM_Error), cbData.RM_Cmd); 4133 if (*(cbData.RM_Error) == OMX_ErrorResourcesPreempted) 4134 { 4135 if (pCompPrivate->eState== OMX_StateExecuting || 4136 pCompPrivate->eState == OMX_StatePause) 4137 { 4138 4139 pCompPrivate->sCbData.EventHandler ( 4140 pHandle, pHandle->pApplicationPrivate, 4141 OMX_EventError, 4142 OMX_ErrorResourcesPreempted,OMX_TI_ErrorMinor, 4143 "Componentn Preempted\n"); 4144 4145 OMX_PRSTATE2(pCompPrivate->dbg, "Send command to Idle from RM CallBack\n"); 4146 OMX_SendCommand(pHandle, Cmd, state, NULL); 4147 pCompPrivate->bPreempted = 1; 4148 4149 } 4150 } 4151 else if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesAcquired) 4152 { 4153 pCompPrivate->sCbData.EventHandler ( 4154 pHandle, pHandle->pApplicationPrivate, 4155 OMX_EventResourcesAcquired, 0,0, 4156 NULL); 4157 OMX_PRSTATE2(pCompPrivate->dbg, "Send command to Executing from RM CallBack\n"); 4158 OMX_SendCommand(pHandle, Cmd, OMX_StateExecuting, NULL); 4159 } 4160} 4161#endif 4162 4163void CalculateBufferSize(OMX_PARAM_PORTDEFINITIONTYPE* pCompPort, VIDENC_COMPONENT_PRIVATE* pCompPrivate) 4164{ 4165 4166 if(pCompPort->nPortIndex == VIDENC_INPUT_PORT) { 4167 if (pCompPort->format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) 4168 { 4169 pCompPort->nBufferSize = pCompPort->format.video.nFrameWidth * 4170 pCompPort->format.video.nFrameHeight * 1.5; 4171 } 4172 else 4173 { 4174 pCompPort->nBufferSize = pCompPort->format.video.nFrameWidth * 4175 pCompPort->format.video.nFrameHeight * 2; 4176 } 4177 } 4178 else { 4179 if (pCompPort->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) 4180 { 4181 pCompPort->nBufferSize = GetMaxAVCBufferSize(pCompPort->format.video.nFrameWidth, pCompPort->format.video.nFrameHeight); 4182 } 4183 else 4184 {/*coding Mpeg4 or H263*/ 4185 pCompPort->nBufferSize = pCompPort->format.video.nFrameWidth * 4186 pCompPort->format.video.nFrameHeight / 2; 4187 } 4188 pCompPort->nBufferSize += 256; 4189 } 4190} 4191 4192OMX_U32 GetMaxAVCBufferSize(OMX_U32 width, OMX_U32 height) 4193{ 4194 OMX_U32 MaxCPB; 4195 OMX_U32 nMacroBlocks; 4196 4197 /* Calculate output buffer size based on max possible CPB for the resolution 4198 Output bitrate may not be set yet, so only resolution is taken into account */ 4199 4200 nMacroBlocks = (width * height) / 256; 4201 4202 /* Following values are set based on Annex A of AVC Standard */ 4203 if(nMacroBlocks <= 99) { 4204 MaxCPB = 500; 4205 } 4206 else if(nMacroBlocks <= 396) { 4207 MaxCPB = 2000; 4208 } 4209 else if(nMacroBlocks <= 792) { 4210 MaxCPB = 4000; 4211 } 4212 else if(nMacroBlocks <= 1620) { 4213 /* Note - Max bitrate in this case is assumed to max 4 Mbps to limit the buffer size 4214 If bitrate in this particular case could be higher than 4 Mbps, increase MxCPB value */ 4215 MaxCPB = 4000; 4216 } 4217 else 4218 MaxCPB = 14000; 4219 4220 /* MaxCPB are in units of 1200 bits i.e. 150 bytes */ 4221 /* Return buffer size in bytes*/ 4222 /*Last patch to improve the performance*/ 4223 /*return (150 * MaxCPB);*/ 4224 return (width * height) / 2; 4225} 4226OMX_U32 OMX_VIDENC_GetDefaultBitRate(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) 4227{ 4228 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef; 4229 OMX_U32 bitrate; 4230 int nCount; 4231 4232 pPortDef = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef; 4233 for ( nCount = 0; nCount < VIDENC_MAXBITRATES; nCount++ ) { 4234 if (pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) { 4235 bitrate = VIDENC_STRUCT_H264DEFBITRATE [nCount][1]; 4236 if ((pPortDef->format.video.nFrameWidth * pPortDef->format.video.nFrameHeight) 4237 <= VIDENC_STRUCT_H264DEFBITRATE[nCount][0]) { 4238 break; 4239 } 4240 } 4241 else if (pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) { 4242 bitrate = VIDENC_STRUCT_MPEG4DEFBITRATE [nCount][1]; 4243 if ((pPortDef->format.video.nFrameWidth * pPortDef->format.video.nFrameHeight) 4244 <= VIDENC_STRUCT_MPEG4DEFBITRATE[nCount][0]) { 4245 break; 4246 } 4247 } 4248 else { 4249 bitrate = VIDENC_STRUCT_H263DEFBITRATE [nCount][1]; 4250 if ((pPortDef->format.video.nFrameWidth * pPortDef->format.video.nFrameHeight) 4251 <= VIDENC_STRUCT_H263DEFBITRATE[nCount][0]) { 4252 break; 4253 } 4254 } 4255 } 4256 4257 return bitrate; 4258} 4259 4260 4261void printMpeg4Params(MP4VE_GPP_SN_Obj_CreatePhase* pCreatePhaseArgs, 4262 struct OMX_TI_Debug *dbg) 4263{ 4264 OMX_PRDSP2(*dbg, "\nusNumStreams = %d\n", pCreatePhaseArgs->usNumStreams); 4265 OMX_PRDSP2(*dbg, "usStreamId = %d\n", pCreatePhaseArgs->usStreamId); 4266 OMX_PRDSP2(*dbg, "usBuffTypeInStream = %d\n", pCreatePhaseArgs->usBuffTypeInStream); 4267 OMX_PRDSP2(*dbg, "usMaxBuffsInStream = %d\n", pCreatePhaseArgs->usMaxBuffsInStream); 4268 OMX_PRDSP2(*dbg, "usStreamId2 = %d\n", pCreatePhaseArgs->usStreamId2); 4269 OMX_PRDSP2(*dbg, "usBuffTypeInStream2 = %d\n", pCreatePhaseArgs->usBuffTypeInStream2); 4270 OMX_PRDSP2(*dbg, "usMaxBuffsInStream2 = %d\n", pCreatePhaseArgs->usMaxBuffsInStream2); 4271 4272 OMX_PRDSP2(*dbg, "ulWidth = %d\n", pCreatePhaseArgs->ulWidth); 4273 OMX_PRDSP2(*dbg, "ulHeight = %d\n", pCreatePhaseArgs->ulHeight); 4274 OMX_PRDSP2(*dbg, "ulTargetBitRate = %d\n", pCreatePhaseArgs->ulTargetBitRate); 4275 OMX_PRDSP2(*dbg, "ulVBVSize = %d\n", pCreatePhaseArgs->ulVBVSize); 4276 OMX_PRDSP2(*dbg, "ulGOBHeadersInterval = %d\n", pCreatePhaseArgs->ulGOBHeadersInterval); 4277 4278 OMX_PRDSP2(*dbg, "ucIsMPEG4 = %d\n", pCreatePhaseArgs->ucIsMPEG4); 4279 OMX_PRDSP2(*dbg, "ucYUVFormat = %d\n", pCreatePhaseArgs->ucYUVFormat); 4280 OMX_PRDSP2(*dbg, "ucHEC = %d\n", pCreatePhaseArgs->ucHEC); 4281 OMX_PRDSP2(*dbg, "ucResyncMarker = %d\n", pCreatePhaseArgs->ucResyncMarker); 4282 OMX_PRDSP2(*dbg, "ucDataPartitioning = %d\n", pCreatePhaseArgs->ucDataPartitioning); 4283 OMX_PRDSP2(*dbg, "ucReversibleVLC = %d\n", pCreatePhaseArgs->ucReversibleVLC); 4284 OMX_PRDSP2(*dbg, "ucUnrestrictedMV = %d\n", pCreatePhaseArgs->ucUnrestrictedMV); 4285 OMX_PRDSP2(*dbg, "ucFrameRate = %d\n", pCreatePhaseArgs->ucFrameRate); 4286 OMX_PRDSP2(*dbg, "ucRateControlAlgorithm = %d\n", pCreatePhaseArgs->ucRateControlAlgorithm); 4287 OMX_PRDSP2(*dbg, "ucQPFirstIFrame = %d\n", pCreatePhaseArgs->ucQPFirstIFrame); 4288 OMX_PRDSP2(*dbg, "ucProfile = %d\n", pCreatePhaseArgs->ucProfile); 4289 OMX_PRDSP2(*dbg, "ucLevel = %d\n", pCreatePhaseArgs->ucLevel); 4290 OMX_PRDSP2(*dbg, "ulMaxDelay = %d\n", pCreatePhaseArgs->ulMaxDelay); 4291 /* 4292 OMX_PRDSP2(*dbg, "ulVbvParamEnable = %d\n", pCreatePhaseArgs->ulVbvParamEnable); 4293 OMX_PRDSP2(*dbg, "ulH263SliceMode = %d\n", pCreatePhaseArgs->ulH263SliceMode); 4294 */ 4295 OMX_PRDSP2(*dbg, "ulUseGOV = %d\n", pCreatePhaseArgs->ulUseGOV); 4296 OMX_PRDSP2(*dbg, "ulUseVOS = %d\n", pCreatePhaseArgs->ulUseVOS); 4297 OMX_PRDSP2(*dbg, "enableH263AnnexI = %d\n", pCreatePhaseArgs->enableH263AnnexI); 4298 OMX_PRDSP2(*dbg, "enableH263AnnexJ = %d\n", pCreatePhaseArgs->enableH263AnnexJ); 4299 OMX_PRDSP2(*dbg, "enableH263AnnexT = %d\n", pCreatePhaseArgs->enableH263AnnexT); 4300} 4301void printH264CreateParams(H264VE_GPP_SN_Obj_CreatePhase* pCreatePhaseArgs, struct OMX_TI_Debug *dbg) 4302{ 4303 OMX_PRDSP2(*dbg, "\nusNumStreams = %d\n", pCreatePhaseArgs->usNumStreams); 4304 OMX_PRDSP2(*dbg, "usStreamId = %d\n", pCreatePhaseArgs->usStreamId); 4305 OMX_PRDSP2(*dbg, "usBuffTypeInStream = %d\n", pCreatePhaseArgs->usBuffTypeInStream); 4306 OMX_PRDSP2(*dbg, "usMaxBuffsInStream = %d\n", pCreatePhaseArgs->usMaxBuffsInStream); 4307 OMX_PRDSP2(*dbg, "usStreamId2 = %d\n", pCreatePhaseArgs->usStreamId2); 4308 OMX_PRDSP2(*dbg, "usBuffTypeInStream2 = %d\n", pCreatePhaseArgs->usBuffTypeInStream2); 4309 OMX_PRDSP2(*dbg, "usMaxBuffsInStream2 = %d\n", pCreatePhaseArgs->usMaxBuffsInStream2); 4310 4311 OMX_PRDSP2(*dbg, "ulWidth = %d\n", pCreatePhaseArgs->ulWidth); 4312 OMX_PRDSP2(*dbg, "ulHeight = %d\n", pCreatePhaseArgs->ulHeight); 4313 OMX_PRDSP2(*dbg, "ulTargetBitRate = %d\n", pCreatePhaseArgs->ulTargetBitRate); 4314 OMX_PRDSP2(*dbg, "ulBitstreamBuffSize = %d\n", pCreatePhaseArgs->ulBitstreamBuffSize); 4315 OMX_PRDSP2(*dbg, "ulIntraFramePeriod = %d\n", pCreatePhaseArgs->ulIntraFramePeriod); 4316 OMX_PRDSP2(*dbg, "ulFrameRate = %d\n", pCreatePhaseArgs->ulFrameRate); 4317 4318 OMX_PRDSP2(*dbg, "ucYUVFormat = %d\n", pCreatePhaseArgs->ucYUVFormat); 4319 OMX_PRDSP2(*dbg, "ucUnrestrictedMV = %d\n", pCreatePhaseArgs->ucUnrestrictedMV); 4320 OMX_PRDSP2(*dbg, "ucNumRefFrames = %d\n", pCreatePhaseArgs->ucNumRefFrames); 4321 OMX_PRDSP2(*dbg, "ucRateControlAlgorithm = %d\n", pCreatePhaseArgs->ucRateControlAlgorithm); 4322 OMX_PRDSP2(*dbg, "ucIDREnable = %d\n", pCreatePhaseArgs->ucIDREnable); 4323 OMX_PRDSP2(*dbg, "ucDeblockingEnable = %d\n", pCreatePhaseArgs->ucDeblockingEnable); 4324 OMX_PRDSP2(*dbg, "ucMVRange = %d\n", pCreatePhaseArgs->ucMVRange); 4325 OMX_PRDSP2(*dbg, "ucQPIFrame = %d\n", pCreatePhaseArgs->ucQPIFrame); 4326 OMX_PRDSP2(*dbg, "ucProfile = %d\n", pCreatePhaseArgs->ucProfile); 4327 OMX_PRDSP2(*dbg, "ucLevel = %d\n", pCreatePhaseArgs->ucLevel); 4328 4329 OMX_PRDSP2(*dbg, "usNalCallback = %d\n", pCreatePhaseArgs->usNalCallback); 4330 OMX_PRDSP2(*dbg, "ulEncodingPreset = %d\n", pCreatePhaseArgs->ulEncodingPreset); 4331 OMX_PRDSP2(*dbg, "ulRcAlgo = %d\n", pCreatePhaseArgs->ulRcAlgo); 4332} 4333 4334void printMpeg4UAlgInParam(MP4VE_GPP_SN_UALGInputParams* pUalgInpParams, int printAlways, struct OMX_TI_Debug *dbg) 4335{ 4336 static int printed=0; 4337 4338 if(printAlways || !printed) 4339 { 4340 printed++; 4341 OMX_PRDSP2(*dbg, "\nulFrameIndex = %u\n", pUalgInpParams->ulFrameIndex); 4342 OMX_PRDSP2(*dbg, "ulTargetFrameRate = %u\n", pUalgInpParams->ulTargetFrameRate); 4343 OMX_PRDSP2(*dbg, "ulTargetBitRate = %u\n", pUalgInpParams->ulTargetBitRate); 4344 OMX_PRDSP2(*dbg, "ulIntraFrameInterval = %u\n", pUalgInpParams->ulIntraFrameInterval); 4345 OMX_PRDSP2(*dbg, "ulGenerateHeader = %u\n", pUalgInpParams->ulGenerateHeader); 4346 OMX_PRDSP2(*dbg, "ulForceIFrame = %u\n", pUalgInpParams->ulForceIFrame); 4347 OMX_PRDSP2(*dbg, "ulResyncInterval = %u\n", pUalgInpParams->ulResyncInterval); 4348 OMX_PRDSP2(*dbg, "ulHecInterval = %u\n", pUalgInpParams->ulHecInterval); 4349 OMX_PRDSP2(*dbg, "ulAIRRate = %u\n", pUalgInpParams->ulAIRRate); 4350 OMX_PRDSP2(*dbg, "ulMIRRate = %u\n", pUalgInpParams->ulMIRRate); 4351 OMX_PRDSP2(*dbg, "ulQPIntra = %u\n", pUalgInpParams->ulQPIntra); 4352 OMX_PRDSP2(*dbg, "ulfCode = %u\n", pUalgInpParams->ulfCode); 4353 OMX_PRDSP2(*dbg, "ulHalfPel = %u\n", pUalgInpParams->ulHalfPel); 4354 OMX_PRDSP2(*dbg, "ulACPred = %u\n", pUalgInpParams->ulACPred); 4355 OMX_PRDSP2(*dbg, "ul4MV = %u\n", pUalgInpParams->ul4MV); 4356 OMX_PRDSP2(*dbg, "uluseUMV = %u\n", pUalgInpParams->uluseUMV); 4357 OMX_PRDSP2(*dbg, "ulMVDataEnable = %u\n", pUalgInpParams->ulMVDataEnable); 4358 OMX_PRDSP2(*dbg, "ulResyncDataEnable = %u\n", pUalgInpParams->ulResyncDataEnable); 4359 OMX_PRDSP2(*dbg, "ulQPInter = %u\n", pUalgInpParams->ulQPInter); 4360 OMX_PRDSP2(*dbg, "ulLastFrame = %u\n", pUalgInpParams->ulLastFrame); 4361 OMX_PRDSP2(*dbg, "ulcapturewidth = %u\n", pUalgInpParams->ulcapturewidth); 4362 OMX_PRDSP2(*dbg, "ulQpMax = %u\n", pUalgInpParams->ulQpMax); 4363 OMX_PRDSP2(*dbg, "ulQpMin = %u\n", pUalgInpParams->ulQpMin); 4364 } 4365} 4366 4367 4368void printH264UAlgInParam(H264VE_GPP_SN_UALGInputParams* pUalgInpParams, int printAlways, struct OMX_TI_Debug *dbg) 4369{ 4370 static int printed=0; 4371 4372 if(printAlways || !printed) 4373 { 4374 printed++; 4375 OMX_PRDSP2(*dbg, "\nqpIntra = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.qpIntra); 4376 OMX_PRDSP2(*dbg, "qpInter = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.qpInter); 4377 OMX_PRDSP2(*dbg, "qpMax = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.qpMax); 4378 OMX_PRDSP2(*dbg, "qpMin = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.qpMin); 4379 OMX_PRDSP2(*dbg, "lfDisableIdc = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.lfDisableIdc); 4380 OMX_PRDSP2(*dbg, "quartPelDisable = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.quartPelDisable); 4381 OMX_PRDSP2(*dbg, "airMbPeriod = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.airMbPeriod); 4382 OMX_PRDSP2(*dbg, "maxMBsPerSlice = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.maxMBsPerSlice); 4383 OMX_PRDSP2(*dbg, "maxBytesPerSlice = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.maxBytesPerSlice); 4384 OMX_PRDSP2(*dbg, "sliceRefreshRowStartNumber = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sliceRefreshRowStartNumber); 4385 OMX_PRDSP2(*dbg, "sliceRefreshRowNumber = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sliceRefreshRowNumber); 4386 OMX_PRDSP2(*dbg, "filterOffsetA = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.filterOffsetA); 4387 OMX_PRDSP2(*dbg, "filterOffsetB = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.filterOffsetB); 4388 OMX_PRDSP2(*dbg, "log2MaxFNumMinus4 = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.log2MaxFNumMinus4); 4389 OMX_PRDSP2(*dbg, "chromaQPIndexOffset = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.chromaQPIndexOffset); 4390 OMX_PRDSP2(*dbg, "constrainedIntraPredEnable = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.constrainedIntraPredEnable); 4391 OMX_PRDSP2(*dbg, "picOrderCountType = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.picOrderCountType); 4392 OMX_PRDSP2(*dbg, "maxMVperMB = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.maxMVperMB); 4393 OMX_PRDSP2(*dbg, "intra4x4EnableIdc = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.intra4x4EnableIdc); 4394 OMX_PRDSP2(*dbg, "mvDataEnable = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.mvDataEnable); 4395 OMX_PRDSP2(*dbg, "hierCodingEnable = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.hierCodingEnable); 4396 OMX_PRDSP2(*dbg, "streamFormat = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.streamFormat); 4397 OMX_PRDSP2(*dbg, "intraRefreshMethod = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.intraRefreshMethod); 4398 OMX_PRDSP2(*dbg, "perceptualQuant = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.perceptualQuant); 4399 OMX_PRDSP2(*dbg, "sceneChangeDet = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sceneChangeDet); 4400 OMX_PRDSP2(*dbg, "numSliceASO = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.numSliceASO); 4401 OMX_PRDSP2(*dbg, "numSliceGroups = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.numSliceGroups); 4402 OMX_PRDSP2(*dbg, "sliceGroupMapType = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sliceGroupMapType); 4403 OMX_PRDSP2(*dbg, "sliceGroupChangeDirectionFlag = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sliceGroupChangeDirectionFlag); 4404 OMX_PRDSP2(*dbg, "sliceGroupChangeRate = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sliceGroupChangeRate); 4405 OMX_PRDSP2(*dbg, "sliceGroupChangeCycle = %lu\n", pUalgInpParams->H264VENC_TI_DYNAMICPARAMS.sliceGroupChangeCycle); 4406 OMX_PRDSP2(*dbg, "ulFrameIndex = %lu\n", pUalgInpParams->ulFrameIndex); 4407 } 4408} 4409 4410OMX_ERRORTYPE IsResolutionPlayable (OMX_U32 width, OMX_U32 height) 4411{ 4412 if (width > WVGA_MAX_WIDTH || height > WVGA_MAX_HEIGHT) 4413 { 4414 return OMX_ErrorBadParameter; 4415 } 4416 return OMX_ErrorNone; 4417 4418} 4419 4420OMX_ERRORTYPE AddStateTransition(VIDENC_COMPONENT_PRIVATE* pComponentPrivate) { 4421 4422 OMX_ERRORTYPE eError = OMX_ErrorNone; 4423 4424 if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) { 4425 return OMX_ErrorUndefined; 4426 } 4427 4428 /* Increment state change request reference count */ 4429 pComponentPrivate->nPendingStateChangeRequests++; 4430 4431 if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) { 4432 return OMX_ErrorUndefined; 4433 } 4434 4435 return eError; 4436} 4437 4438OMX_ERRORTYPE RemoveStateTransition(VIDENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BOOL bEnableSignal) { 4439 OMX_ERRORTYPE eError = OMX_ErrorNone; 4440 4441 /* Decrement state change request reference count*/ 4442 if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) { 4443 return OMX_ErrorUndefined; 4444 } 4445 4446 pComponentPrivate->nPendingStateChangeRequests--; 4447 4448 /* If there are no more pending requests, signal the thread waiting on this*/ 4449 if(!pComponentPrivate->nPendingStateChangeRequests && bEnableSignal) { 4450 pthread_cond_signal(&(pComponentPrivate->StateChangeCondition)); 4451 } 4452 4453 if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) { 4454 return OMX_ErrorUndefined; 4455 } 4456 4457 return eError; 4458} 4459