omx_videoenc_component.c

Go to the documentation of this file.
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   //common parameters related to input port
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; //YUV 420
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   //common parameters related to output port
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     // IL client specified an invalid component name 
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   /* frees port/s */
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   /* put sample parameters */
00225   omx_videoenc_component_Private->avCodecContext->bit_rate = 400000; /* bit per second */
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   /* frames per second */
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; /* emit one intra frame every ten frames */
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   /* Check which structure we are being fed and make control its header */
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         /*Check Structure Header and verify component state*/
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: /*Call the base component function*/
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   /* Check which structure we are being fed and fill its header */
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: /*Call the base component function*/
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   // Execute the base message handling
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 }

Generated for OpenMAX Bellagio rel. 0.9.0 by  doxygen 1.5.1
SourceForge.net Logo