00001
00030 #include <omxcore.h>
00031 #include <omx_base_video_port.h>
00032 #include <omx_videoenc_component.h>
00033 #include<OMX_Video.h>
00034
00036 #define MAX_COMPONENT_VIDEOENC 4
00037
00039 static OMX_U32 noVideoEncInstance = 0;
00040
00042 #define OUTPUT_ENCODED_COLOR_FMT OMX_COLOR_FormatYUV420Planar
00043
00048 OMX_ERRORTYPE omx_videoenc_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
00049
00050 OMX_ERRORTYPE eError = OMX_ErrorNone;
00051 omx_videoenc_component_PrivateType* omx_videoenc_component_Private;
00052 omx_base_video_PortType *inPort,*outPort;
00053 OMX_U32 i;
00054
00055 if (!openmaxStandComp->pComponentPrivate) {
00056 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, allocating component\n", __func__);
00057 openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_videoenc_component_PrivateType));
00058 if(openmaxStandComp->pComponentPrivate == NULL) {
00059 return OMX_ErrorInsufficientResources;
00060 }
00061 } else {
00062 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int)openmaxStandComp->pComponentPrivate);
00063 }
00064
00065 omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00066 omx_videoenc_component_Private->ports = NULL;
00067
00071 eError = omx_base_filter_Constructor(openmaxStandComp, cComponentName);
00072
00073 omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0;
00074 omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts = 2;
00075
00077 if (omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts && !omx_videoenc_component_Private->ports) {
00078 omx_videoenc_component_Private->ports = calloc(omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts, sizeof(omx_base_PortType *));
00079 if (!omx_videoenc_component_Private->ports) {
00080 return OMX_ErrorInsufficientResources;
00081 }
00082 for (i=0; i < omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts; i++) {
00083 omx_videoenc_component_Private->ports[i] = calloc(1, sizeof(omx_base_video_PortType));
00084 if (!omx_videoenc_component_Private->ports[i]) {
00085 return OMX_ErrorInsufficientResources;
00086 }
00087 }
00088 }
00089
00090 base_video_port_Constructor(openmaxStandComp, &omx_videoenc_component_Private->ports[0], 0, OMX_TRUE);
00091 base_video_port_Constructor(openmaxStandComp, &omx_videoenc_component_Private->ports[1], 1, OMX_FALSE);
00092
00096
00097 inPort = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00098 inPort->sPortParam.format.video.nFrameWidth = 176;
00099 inPort->sPortParam.format.video.nFrameHeight = 144;
00100 inPort->sPortParam.nBufferSize = inPort->sPortParam.format.video.nFrameWidth*
00101 inPort->sPortParam.format.video.nFrameHeight*3/2;
00102 inPort->sPortParam.format.video.xFramerate = 25;
00103 inPort->sPortParam.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
00104 inPort->sVideoParam.eColorFormat = OMX_COLOR_FormatYUV420Planar;
00105
00106
00107 outPort = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
00108 outPort->sPortParam.nBufferSize = FF_MIN_BUFFER_SIZE;
00109 outPort->sPortParam.format.video.xFramerate = 25;
00110 outPort->sPortParam.format.video.nFrameWidth = 176;
00111 outPort->sPortParam.format.video.nFrameHeight = 144;
00112
00114 if(!strcmp(cComponentName, VIDEO_ENC_MPEG4_NAME)) {
00115 omx_videoenc_component_Private->video_encoding_type = OMX_VIDEO_CodingMPEG4;
00116 } else if (!strcmp(cComponentName, VIDEO_ENC_BASE_NAME)) {
00117 omx_videoenc_component_Private->video_encoding_type = OMX_VIDEO_CodingUnused;
00118 } else {
00119
00120 DEBUG(DEB_LEV_ERR, "In valid component name\n");
00121 return OMX_ErrorInvalidComponentName;
00122 }
00123
00124 if(!omx_videoenc_component_Private->avCodecSyncSem) {
00125 omx_videoenc_component_Private->avCodecSyncSem = malloc(sizeof(tsem_t));
00126 if(omx_videoenc_component_Private->avCodecSyncSem == NULL) {
00127 return OMX_ErrorInsufficientResources;
00128 }
00129 tsem_init(omx_videoenc_component_Private->avCodecSyncSem, 0);
00130 }
00131
00132 SetInternalVideoEncParameters(openmaxStandComp);
00133
00134 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_YUV420P;
00135
00136 if(omx_videoenc_component_Private->video_encoding_type == OMX_VIDEO_CodingMPEG4) {
00137 omx_videoenc_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
00138 }
00139
00143 omx_videoenc_component_Private->avCodec = NULL;
00144 omx_videoenc_component_Private->avCodecContext= NULL;
00145 omx_videoenc_component_Private->avcodecReady = OMX_FALSE;
00146 omx_videoenc_component_Private->BufferMgmtCallback = omx_videoenc_component_BufferMgmtCallback;
00147
00149 omx_videoenc_component_Private->messageHandler = omx_videoenc_component_MessageHandler;
00150 omx_videoenc_component_Private->destructor = omx_videoenc_component_Destructor;
00151 openmaxStandComp->SetParameter = omx_videoenc_component_SetParameter;
00152 openmaxStandComp->GetParameter = omx_videoenc_component_GetParameter;
00153 openmaxStandComp->ComponentRoleEnum = omx_videoenc_component_ComponentRoleEnum;
00154
00155 noVideoEncInstance++;
00156
00157 if(noVideoEncInstance > MAX_COMPONENT_VIDEOENC) {
00158 return OMX_ErrorInsufficientResources;
00159 }
00160 return eError;
00161 }
00162
00163
00166 OMX_ERRORTYPE omx_videoenc_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
00167 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00168 OMX_U32 i;
00169
00170 if(omx_videoenc_component_Private->avCodecSyncSem) {
00171 free(omx_videoenc_component_Private->avCodecSyncSem);
00172 omx_videoenc_component_Private->avCodecSyncSem = NULL;
00173 }
00174
00175
00176 if (omx_videoenc_component_Private->ports) {
00177 for (i=0; i < omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts; i++) {
00178 if(omx_videoenc_component_Private->ports[i])
00179 omx_videoenc_component_Private->ports[i]->PortDestructor(omx_videoenc_component_Private->ports[i]);
00180 }
00181 free(omx_videoenc_component_Private->ports);
00182 omx_videoenc_component_Private->ports=NULL;
00183 }
00184
00185 DEBUG(DEB_LEV_FUNCTION_NAME, "Destructor of video encoder component is called\n");
00186
00187 omx_base_filter_Destructor(openmaxStandComp);
00188 noVideoEncInstance--;
00189
00190 return OMX_ErrorNone;
00191 }
00192
00193
00196 OMX_ERRORTYPE omx_videoenc_component_ffmpegLibInit(omx_videoenc_component_PrivateType* omx_videoenc_component_Private) {
00197
00198 omx_base_video_PortType *inPort = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00199 OMX_U32 target_coencID;
00200 avcodec_init();
00201 av_register_all();
00202
00203 DEBUG(DEB_LEV_SIMPLE_SEQ, "FFmpeg library/encoder initialized\n");
00204
00205 switch(omx_videoenc_component_Private->video_encoding_type) {
00206 case OMX_VIDEO_CodingMPEG4 :
00207 target_coencID = CODEC_ID_MPEG4;
00208 break;
00209 default :
00210 DEBUG(DEB_LEV_ERR, "\n encoders other than MPEG-4 are not supported -- encoder not found\n");
00211 return OMX_ErrorComponentNotFound;
00212 }
00213
00215 omx_videoenc_component_Private->avCodec = avcodec_find_encoder(target_coencID);
00216 if (omx_videoenc_component_Private->avCodec == NULL) {
00217 DEBUG(DEB_LEV_ERR, "Encoder Not found\n");
00218 return OMX_ErrorInsufficientResources;
00219 }
00220
00221 omx_videoenc_component_Private->avCodecContext = avcodec_alloc_context();
00222 omx_videoenc_component_Private->picture = avcodec_alloc_frame ();
00223
00224
00225 omx_videoenc_component_Private->avCodecContext->bit_rate = 400000;
00226 omx_videoenc_component_Private->avCodecContext->width = inPort->sPortParam.format.video.nFrameWidth;
00227 omx_videoenc_component_Private->avCodecContext->height = inPort->sPortParam.format.video.nFrameHeight;
00228
00229
00230 DEBUG(DEB_LEV_SIMPLE_SEQ, "Frame Rate=%d\n",(int)inPort->sPortParam.format.video.xFramerate);
00231 omx_videoenc_component_Private->avCodecContext->time_base= (AVRational){1,inPort->sPortParam.format.video.xFramerate};
00232 omx_videoenc_component_Private->avCodecContext->gop_size = 5;
00233 omx_videoenc_component_Private->avCodecContext->max_b_frames=1;
00234 omx_videoenc_component_Private->avCodecContext->pix_fmt = PIX_FMT_YUV420P;
00235
00236 if (avcodec_open(omx_videoenc_component_Private->avCodecContext, omx_videoenc_component_Private->avCodec) < 0) {
00237 DEBUG(DEB_LEV_ERR, "Could not open encoder\n");
00238 return OMX_ErrorInsufficientResources;
00239 }
00240 tsem_up(omx_videoenc_component_Private->avCodecSyncSem);
00241 DEBUG(DEB_LEV_SIMPLE_SEQ, "done\n");
00242
00243 return OMX_ErrorNone;
00244 }
00245
00248 void omx_videoenc_component_ffmpegLibDeInit(omx_videoenc_component_PrivateType* omx_videoenc_component_Private) {
00249
00250 avcodec_close(omx_videoenc_component_Private->avCodecContext);
00251 if (omx_videoenc_component_Private->avCodecContext->priv_data) {
00252 avcodec_close (omx_videoenc_component_Private->avCodecContext);
00253 }
00254 if (omx_videoenc_component_Private->avCodecContext->extradata) {
00255 av_free (omx_videoenc_component_Private->avCodecContext->extradata);
00256 omx_videoenc_component_Private->avCodecContext->extradata = NULL;
00257 }
00258 av_free (omx_videoenc_component_Private->avCodecContext);
00259
00260 av_free(omx_videoenc_component_Private->picture);
00261
00262 }
00263
00266 void SetInternalVideoEncParameters(OMX_COMPONENTTYPE *openmaxStandComp) {
00267
00268 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00269 omx_base_video_PortType *outPort = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
00270
00271 if (omx_videoenc_component_Private->video_encoding_type == OMX_VIDEO_CodingMPEG4) {
00272 strcpy(outPort->sPortParam.format.video.cMIMEType,"video/mpeg4");
00273 outPort->sPortParam.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
00274 outPort->sVideoParam.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
00275
00276 setHeader(&omx_videoenc_component_Private->pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
00277 omx_videoenc_component_Private->pVideoMpeg4.nPortIndex = 1;
00278 omx_videoenc_component_Private->pVideoMpeg4.nSliceHeaderSpacing = 0;
00279 omx_videoenc_component_Private->pVideoMpeg4.bSVH = OMX_FALSE;
00280 omx_videoenc_component_Private->pVideoMpeg4.bGov = OMX_FALSE;
00281 omx_videoenc_component_Private->pVideoMpeg4.nPFrames = 0;
00282 omx_videoenc_component_Private->pVideoMpeg4.nBFrames = 0;
00283 omx_videoenc_component_Private->pVideoMpeg4.nIDCVLCThreshold = 0;
00284 omx_videoenc_component_Private->pVideoMpeg4.bACPred = OMX_FALSE;
00285 omx_videoenc_component_Private->pVideoMpeg4.nMaxPacketSize = 0;
00286 omx_videoenc_component_Private->pVideoMpeg4.nTimeIncRes = 0;
00287 omx_videoenc_component_Private->pVideoMpeg4.eProfile = OMX_VIDEO_MPEG4ProfileSimple;
00288 omx_videoenc_component_Private->pVideoMpeg4.eLevel = OMX_VIDEO_MPEG4Level0;
00289 omx_videoenc_component_Private->pVideoMpeg4.nAllowedPictureTypes = 0;
00290 omx_videoenc_component_Private->pVideoMpeg4.nHeaderExtension = 0;
00291 omx_videoenc_component_Private->pVideoMpeg4.bReversibleVLC = OMX_FALSE;
00292
00293 }
00294 }
00295
00296
00299 OMX_ERRORTYPE omx_videoenc_component_Init(OMX_COMPONENTTYPE *openmaxStandComp) {
00300
00301 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00302 OMX_ERRORTYPE eError = OMX_ErrorNone;
00303
00305 omx_videoenc_component_Private->isFirstBuffer = 1;
00306 omx_videoenc_component_Private->isNewBuffer = 1;
00307
00308 return eError;
00309 }
00310
00313 OMX_ERRORTYPE omx_videoenc_component_Deinit(OMX_COMPONENTTYPE *openmaxStandComp) {
00314
00315 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00316 OMX_ERRORTYPE eError = OMX_ErrorNone;
00317
00318 if (omx_videoenc_component_Private->avcodecReady) {
00319 omx_videoenc_component_ffmpegLibDeInit(omx_videoenc_component_Private);
00320 omx_videoenc_component_Private->avcodecReady = OMX_FALSE;
00321 }
00322
00323 return eError;
00324 }
00325
00328 static inline void UpdateFrameSize(OMX_COMPONENTTYPE *openmaxStandComp) {
00329 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00330 omx_base_video_PortType *inPort = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00331 switch(inPort->sPortParam.format.video.eColorFormat) {
00332 case OMX_COLOR_FormatYUV420Planar:
00333 inPort->sPortParam.nBufferSize = inPort->sPortParam.format.video.nFrameWidth * inPort->sPortParam.format.video.nFrameHeight * 3/2;
00334 break;
00335 default:
00336 inPort->sPortParam.nBufferSize = inPort->sPortParam.format.video.nFrameWidth * inPort->sPortParam.format.video.nFrameHeight * 3;
00337 break;
00338 }
00339 }
00340
00343 void omx_videoenc_component_BufferMgmtCallback(OMX_COMPONENTTYPE *openmaxStandComp, OMX_BUFFERHEADERTYPE* pInputBuffer, OMX_BUFFERHEADERTYPE* pOutputBuffer) {
00344
00345 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00346 omx_base_video_PortType *inPort = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00347
00348 OMX_S32 nOutputFilled = 0;
00349 OMX_U8* outputCurrBuffer;
00350 OMX_S32 nLen = 0;
00351 int size;
00352
00353 size= inPort->sPortParam.format.video.nFrameWidth*inPort->sPortParam.format.video.nFrameHeight;
00354
00355 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00357 if(omx_videoenc_component_Private->isNewBuffer) {
00358 omx_videoenc_component_Private->isNewBuffer = 0;
00359 DEBUG(DEB_LEV_FULL_SEQ, "New Buffer FilledLen = %d\n", (int)pInputBuffer->nFilledLen);
00360
00361 omx_videoenc_component_Private->picture->data[0] = pInputBuffer->pBuffer;
00362 omx_videoenc_component_Private->picture->data[1] = omx_videoenc_component_Private->picture->data[0] + size;
00363 omx_videoenc_component_Private->picture->data[2] = omx_videoenc_component_Private->picture->data[1] + size / 4;
00364 omx_videoenc_component_Private->picture->linesize[0] = inPort->sPortParam.format.video.nFrameWidth;
00365 omx_videoenc_component_Private->picture->linesize[1] = inPort->sPortParam.format.video.nFrameWidth / 2;
00366 omx_videoenc_component_Private->picture->linesize[2] = inPort->sPortParam.format.video.nFrameWidth / 2;
00367 }
00368
00369 outputCurrBuffer = pOutputBuffer->pBuffer;
00370 pOutputBuffer->nFilledLen = 0;
00371 pOutputBuffer->nOffset = 0;
00372
00373 while (!nOutputFilled) {
00374 if (omx_videoenc_component_Private->isFirstBuffer) {
00375 tsem_down(omx_videoenc_component_Private->avCodecSyncSem);
00376 omx_videoenc_component_Private->isFirstBuffer = 0;
00377 }
00378 omx_videoenc_component_Private->avCodecContext->frame_number++;
00379
00380 nLen = avcodec_encode_video(omx_videoenc_component_Private->avCodecContext,
00381 outputCurrBuffer,
00382 pOutputBuffer->nAllocLen,
00383 omx_videoenc_component_Private->picture);
00384
00385 if (nLen < 0) {
00386 DEBUG(DEB_LEV_ERR, "----> A general error or simply frame not encoded?\n");
00387 }
00388
00389 pInputBuffer->nFilledLen = 0;
00390 omx_videoenc_component_Private->isNewBuffer = 1;
00391 if ( nLen >= 0) {
00392 pOutputBuffer->nFilledLen = nLen;
00393 }
00394 nOutputFilled = 1;
00395 }
00396 DEBUG(DEB_LEV_FULL_SEQ, "One output buffer %x nLen=%d is full returning in video encoder\n",
00397 (int)pOutputBuffer->pBuffer, (int)pOutputBuffer->nFilledLen);
00398 }
00399
00400 OMX_ERRORTYPE omx_videoenc_component_SetParameter(
00401 OMX_IN OMX_HANDLETYPE hComponent,
00402 OMX_IN OMX_INDEXTYPE nParamIndex,
00403 OMX_IN OMX_PTR ComponentParameterStructure) {
00404
00405 OMX_ERRORTYPE eError = OMX_ErrorNone;
00406 OMX_U32 portIndex;
00407
00408
00409 OMX_COMPONENTTYPE *openmaxStandComp = hComponent;
00410 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00411 omx_base_video_PortType *port;
00412 if (ComponentParameterStructure == NULL) {
00413 return OMX_ErrorBadParameter;
00414 }
00415
00416 DEBUG(DEB_LEV_SIMPLE_SEQ, " Setting parameter %i\n", nParamIndex);
00417 switch(nParamIndex) {
00418 case OMX_IndexParamPortDefinition:
00419 {
00420 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
00421 pPortDef = ComponentParameterStructure;
00422 eError = omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00423 if(eError != OMX_ErrorNone) {
00424 break;
00425 }
00426 UpdateFrameSize (openmaxStandComp);
00427 port = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[pPortDef->nPortIndex];
00428 port->sVideoParam.eColorFormat = port->sPortParam.format.video.eColorFormat;
00429 port->sVideoParam.eCompressionFormat = port->sPortParam.format.video.eCompressionFormat;
00430 break;
00431 }
00432 case OMX_IndexParamVideoPortFormat:
00433 {
00434 OMX_VIDEO_PARAM_PORTFORMATTYPE *pVideoPortFormat;
00435 pVideoPortFormat = ComponentParameterStructure;
00436 portIndex = pVideoPortFormat->nPortIndex;
00437
00438 eError = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pVideoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
00439 if(eError!=OMX_ErrorNone) {
00440 DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,eError);
00441 break;
00442 }
00443 if (portIndex <= 1) {
00444 port = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[portIndex];
00445 memcpy(&port->sVideoParam, pVideoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
00446 omx_videoenc_component_Private->ports[portIndex]->sPortParam.format.video.eColorFormat = port->sVideoParam.eColorFormat;
00447 omx_videoenc_component_Private->ports[portIndex]->sPortParam.format.video.eCompressionFormat = port->sVideoParam.eCompressionFormat;
00448
00449 if (portIndex == 1) {
00450 switch(port->sVideoParam.eColorFormat) {
00451 case OMX_COLOR_Format24bitRGB888 :
00452 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_RGB24;
00453 break;
00454 case OMX_COLOR_Format24bitBGR888 :
00455 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_BGR24;
00456 break;
00457 case OMX_COLOR_Format32bitBGRA8888 :
00458 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_BGR32;
00459 break;
00460 case OMX_COLOR_Format32bitARGB8888 :
00461 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_RGB32;
00462 break;
00463 case OMX_COLOR_Format16bitARGB1555 :
00464 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_RGB555;
00465 break;
00466 case OMX_COLOR_Format16bitRGB565 :
00467 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_RGB565;
00468 break;
00469 case OMX_COLOR_Format16bitBGR565 :
00470 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_BGR565;
00471 break;
00472 default:
00473 omx_videoenc_component_Private->eOutFramePixFmt = PIX_FMT_YUV420P;
00474 break;
00475 }
00476 UpdateFrameSize (openmaxStandComp);
00477 }
00478 } else {
00479 return OMX_ErrorBadPortIndex;
00480 }
00481 break;
00482 }
00483 case OMX_IndexParamStandardComponentRole:
00484 {
00485 OMX_PARAM_COMPONENTROLETYPE *pComponentRole;
00486 pComponentRole = ComponentParameterStructure;
00487 if (!strcmp((char *)pComponentRole->cRole, VIDEO_ENC_MPEG4_ROLE)) {
00488 omx_videoenc_component_Private->video_encoding_type = OMX_VIDEO_CodingMPEG4;
00489 } else {
00490 return OMX_ErrorBadParameter;
00491 }
00492 SetInternalVideoEncParameters(openmaxStandComp);
00493 break;
00494 }
00495 case OMX_IndexParamVideoMpeg4:
00496 {
00497 OMX_VIDEO_PARAM_MPEG4TYPE *pVideoMpeg4;
00498 pVideoMpeg4 = ComponentParameterStructure;
00499 portIndex = pVideoMpeg4->nPortIndex;
00500 eError = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
00501 if(eError!=OMX_ErrorNone) {
00502 DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,eError);
00503 break;
00504 }
00505 if (pVideoMpeg4->nPortIndex == 1) {
00506 memcpy(&omx_videoenc_component_Private->pVideoMpeg4, pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
00507 } else {
00508 return OMX_ErrorBadPortIndex;
00509 }
00510 break;
00511 }
00512 default:
00513 return omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00514 }
00515 return eError;
00516 }
00517
00518 OMX_ERRORTYPE omx_videoenc_component_GetParameter(
00519 OMX_IN OMX_HANDLETYPE hComponent,
00520 OMX_IN OMX_INDEXTYPE nParamIndex,
00521 OMX_INOUT OMX_PTR ComponentParameterStructure) {
00522
00523 omx_base_video_PortType *port;
00524 OMX_ERRORTYPE eError = OMX_ErrorNone;
00525
00526 OMX_COMPONENTTYPE *openmaxStandComp = hComponent;
00527 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00528 if (ComponentParameterStructure == NULL) {
00529 return OMX_ErrorBadParameter;
00530 }
00531 DEBUG(DEB_LEV_SIMPLE_SEQ, " Getting parameter %i\n", nParamIndex);
00532
00533 switch(nParamIndex) {
00534 case OMX_IndexParamVideoInit:
00535 if ((eError = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
00536 break;
00537 }
00538 memcpy(ComponentParameterStructure, &omx_videoenc_component_Private->sPortTypesParam[OMX_PortDomainVideo], sizeof(OMX_PORT_PARAM_TYPE));
00539 break;
00540 case OMX_IndexParamVideoPortFormat:
00541 {
00542 OMX_VIDEO_PARAM_PORTFORMATTYPE *pVideoPortFormat;
00543 pVideoPortFormat = ComponentParameterStructure;
00544 if ((eError = checkHeader(ComponentParameterStructure, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) {
00545 break;
00546 }
00547 if (pVideoPortFormat->nPortIndex <= 1) {
00548 port = (omx_base_video_PortType *)omx_videoenc_component_Private->ports[pVideoPortFormat->nPortIndex];
00549 memcpy(pVideoPortFormat, &port->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
00550 } else {
00551 return OMX_ErrorBadPortIndex;
00552 }
00553 break;
00554 }
00555 case OMX_IndexParamVideoMpeg4:
00556 {
00557 OMX_VIDEO_PARAM_MPEG4TYPE *pVideoMpeg4;
00558 pVideoMpeg4 = ComponentParameterStructure;
00559 if (pVideoMpeg4->nPortIndex != 1) {
00560 return OMX_ErrorBadPortIndex;
00561 }
00562 if ((eError = checkHeader(ComponentParameterStructure, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE))) != OMX_ErrorNone) {
00563 break;
00564 }
00565 memcpy(pVideoMpeg4, &omx_videoenc_component_Private->pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
00566 break;
00567 }
00568 case OMX_IndexParamStandardComponentRole:
00569 {
00570 OMX_PARAM_COMPONENTROLETYPE * pComponentRole;
00571 pComponentRole = ComponentParameterStructure;
00572 if ((eError = checkHeader(ComponentParameterStructure, sizeof(OMX_PARAM_COMPONENTROLETYPE))) != OMX_ErrorNone) {
00573 break;
00574 }
00575 if (omx_videoenc_component_Private->video_encoding_type == OMX_VIDEO_CodingMPEG4) {
00576 strcpy((char *)pComponentRole->cRole, VIDEO_ENC_MPEG4_ROLE);
00577 } else {
00578 strcpy((char *)pComponentRole->cRole,"\0");
00579 }
00580 break;
00581 }
00582 default:
00583 return omx_base_component_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00584 }
00585 return OMX_ErrorNone;
00586 }
00587
00588 OMX_ERRORTYPE omx_videoenc_component_MessageHandler(OMX_COMPONENTTYPE* openmaxStandComp,internalRequestMessageType *message) {
00589
00590 omx_videoenc_component_PrivateType* omx_videoenc_component_Private = openmaxStandComp->pComponentPrivate;
00591 OMX_ERRORTYPE eError;
00592
00593 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s\n", __func__);
00594
00595 if (message->messageType == OMX_CommandStateSet){
00596 if ((message->messageParam == OMX_StateIdle ) && (omx_videoenc_component_Private->state == OMX_StateLoaded)) {
00597 if (!omx_videoenc_component_Private->avcodecReady) {
00598 eError = omx_videoenc_component_ffmpegLibInit(omx_videoenc_component_Private);
00599 if (eError != OMX_ErrorNone) {
00600 return OMX_ErrorNotReady;
00601 }
00602 omx_videoenc_component_Private->avcodecReady = OMX_TRUE;
00603 }
00604 eError = omx_videoenc_component_Init(openmaxStandComp);
00605 if(eError!=OMX_ErrorNone) {
00606 DEBUG(DEB_LEV_ERR, "In %s Video Encoder Init Failed Error=%x\n",__func__,eError);
00607 return eError;
00608 }
00609 } else if ((message->messageParam == OMX_StateLoaded) && (omx_videoenc_component_Private->state == OMX_StateIdle)) {
00610 eError = omx_videoenc_component_Deinit(openmaxStandComp);
00611 if(eError!=OMX_ErrorNone) {
00612 DEBUG(DEB_LEV_ERR, "In %s Video Encoder Deinit Failed Error=%x\n",__func__,eError);
00613 return eError;
00614 }
00615 }
00616 }
00617
00618 return omx_base_component_MessageHandler(openmaxStandComp,message);
00619 }
00620
00621 OMX_ERRORTYPE omx_videoenc_component_ComponentRoleEnum(
00622 OMX_IN OMX_HANDLETYPE hComponent,
00623 OMX_OUT OMX_U8 *cRole,
00624 OMX_IN OMX_U32 nIndex) {
00625
00626 if (nIndex == 0) {
00627 strcpy((char *)cRole, VIDEO_ENC_MPEG4_ROLE);
00628 } else {
00629 return OMX_ErrorUnsupportedIndex;
00630 }
00631 return OMX_ErrorNone;
00632 }