omx_fbdev_sink_component.c

Go to the documentation of this file.
00001 
00030 #include <errno.h>
00031 #include <omxcore.h>
00032 #include <omx_fbdev_sink_component.h>
00033 #include <config.h>
00034 
00035 
00037 #define HEIGHT_OFFSET 10
00038 
00040 static OMX_U32 nFrameProcessTime = 40000; // in micro second
00041 
00043 static OMX_U32 nofbdev_sinkInstance=0;
00044 
00046 #define MAX_COMPONENT_FBDEVSINK 2
00047 
00048 #ifdef AV_SYNC_LOG  /* for checking AV sync */
00049 static FILE *fd = NULL;
00050 #endif
00051 
00057 long GetTime() {
00058     struct timeval now;
00059     gettimeofday(&now, NULL);
00060     return ((long)now.tv_sec) * 1000 + ((long)now.tv_usec) / 1000;
00061 }
00062 
00069 OMX_ERRORTYPE omx_fbdev_sink_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
00070   OMX_ERRORTYPE err = OMX_ErrorNone;  
00071   omx_fbdev_sink_component_PortType *pPort;
00072   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private;
00073 
00074   if (!openmaxStandComp->pComponentPrivate) {
00075     DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, allocating component\n", __func__);
00076     openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_fbdev_sink_component_PrivateType));
00077     if(openmaxStandComp->pComponentPrivate == NULL) {
00078       return OMX_ErrorInsufficientResources;
00079     }
00080   } else {
00081     DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int)openmaxStandComp->pComponentPrivate);
00082   }
00083 
00084   omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
00085   omx_fbdev_sink_component_Private->ports = NULL;
00086   
00090   err = omx_base_sink_Constructor(openmaxStandComp, cComponentName);
00091 
00092   omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0;
00093   omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts = 1;
00094 
00095   omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther].nStartPortNumber = 1;
00096   omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts = 1;
00097 
00099   if ((omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts + 
00100        omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)  && !omx_fbdev_sink_component_Private->ports) {
00101     omx_fbdev_sink_component_Private->ports = calloc((omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts + 
00102                                                       omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts), sizeof(omx_base_PortType *));
00103     if (!omx_fbdev_sink_component_Private->ports) {
00104       return OMX_ErrorInsufficientResources;
00105     }
00106     omx_fbdev_sink_component_Private->ports[0] = calloc(1, sizeof(omx_fbdev_sink_component_PortType));
00107     if (!omx_fbdev_sink_component_Private->ports[0]) {
00108       return OMX_ErrorInsufficientResources;
00109     }
00110     base_video_port_Constructor(openmaxStandComp, &omx_fbdev_sink_component_Private->ports[0], 0, OMX_TRUE);
00111     
00112     omx_fbdev_sink_component_Private->ports[1] = calloc(1, sizeof(omx_base_clock_PortType));
00113     if (!omx_fbdev_sink_component_Private->ports[1]) {
00114       return OMX_ErrorInsufficientResources;
00115     }
00116     base_clock_port_Constructor(openmaxStandComp, &omx_fbdev_sink_component_Private->ports[1], 1, OMX_TRUE); 
00117   }
00118 
00119   pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
00120 
00123   pPort->sPortParam.format.video.nFrameWidth = 352;
00124   pPort->sPortParam.format.video.nFrameHeight = 288;
00125   pPort->sPortParam.format.video.nBitrate = 0;
00126   pPort->sPortParam.format.video.xFramerate = 25;
00127   pPort->sPortParam.format.video.eColorFormat = OMX_COLOR_Format24bitRGB888;
00128 
00129   //  Figure out stride, slice height, min buffer size
00130   pPort->sPortParam.format.video.nStride = calcStride(pPort->sPortParam.format.video.nFrameWidth, pPort->sPortParam.format.video.eColorFormat);
00131   pPort->sPortParam.format.video.nSliceHeight = pPort->sPortParam.format.video.nFrameHeight;  //  No support for slices yet
00132   pPort->sPortParam.nBufferSize = (OMX_U32) abs(pPort->sPortParam.format.video.nStride) * pPort->sPortParam.format.video.nSliceHeight;
00133 
00134   pPort->sVideoParam.eColorFormat = OMX_COLOR_Format24bitRGB888;
00135   pPort->sVideoParam.xFramerate = 25;
00136 
00137   DEBUG(DEB_LEV_PARAMS, "In %s, bSize=%d stride=%d\n", __func__,(int)pPort->sPortParam.nBufferSize,(int)pPort->sPortParam.format.video.nStride);
00138   
00140   setHeader(&pPort->omxConfigCrop, sizeof(OMX_CONFIG_RECTTYPE));  
00141   pPort->omxConfigCrop.nPortIndex = OMX_BASE_SINK_INPUTPORT_INDEX;
00142   pPort->omxConfigCrop.nLeft = pPort->omxConfigCrop.nTop = 0;
00143   pPort->omxConfigCrop.nWidth = pPort->omxConfigCrop.nHeight = 0;
00144 
00145   setHeader(&pPort->omxConfigRotate, sizeof(OMX_CONFIG_ROTATIONTYPE));  
00146   pPort->omxConfigRotate.nPortIndex = OMX_BASE_SINK_INPUTPORT_INDEX;
00147   pPort->omxConfigRotate.nRotation = 0;  //Default: No rotation (0 degrees)
00148 
00149   setHeader(&pPort->omxConfigMirror, sizeof(OMX_CONFIG_MIRRORTYPE));  
00150   pPort->omxConfigMirror.nPortIndex = OMX_BASE_SINK_INPUTPORT_INDEX;
00151   pPort->omxConfigMirror.eMirror = OMX_MirrorNone;  //Default: No mirroring
00152 
00153   setHeader(&pPort->omxConfigScale, sizeof(OMX_CONFIG_SCALEFACTORTYPE));  
00154   pPort->omxConfigScale.nPortIndex = OMX_BASE_SINK_INPUTPORT_INDEX;
00155   pPort->omxConfigScale.xWidth = pPort->omxConfigScale.xHeight = 0x10000;  //Default: No scaling (scale factor = 1)
00156 
00157   setHeader(&pPort->omxConfigOutputPosition, sizeof(OMX_CONFIG_POINTTYPE));  
00158   pPort->omxConfigOutputPosition.nPortIndex = OMX_BASE_SINK_INPUTPORT_INDEX;
00159   pPort->omxConfigOutputPosition.nX = pPort->omxConfigOutputPosition.nY = 0; //Default: No shift in output position (0,0)
00160 
00162   omx_fbdev_sink_component_Private->destructor = omx_fbdev_sink_component_Destructor;
00163   omx_fbdev_sink_component_Private->BufferMgmtCallback = omx_fbdev_sink_component_BufferMgmtCallback;
00164   omx_fbdev_sink_component_Private->ports[0]->Port_SendBufferFunction = omx_fbdev_sink_component_port_SendBufferFunction; 
00165   openmaxStandComp->SetParameter = omx_fbdev_sink_component_SetParameter;
00166   openmaxStandComp->GetParameter = omx_fbdev_sink_component_GetParameter;
00167   omx_fbdev_sink_component_Private->messageHandler = omx_fbdev_sink_component_MessageHandler;
00168 
00169  /* testing the A/V sync */
00170 #ifdef AV_SYNC_LOG
00171  fd = fopen("video_timestamps.out","w");
00172 #endif
00173 
00174   nofbdev_sinkInstance++;
00175   if(nofbdev_sinkInstance > MAX_COMPONENT_FBDEVSINK) {
00176     DEBUG(DEB_LEV_ERR, "Reached Max Instances %d\n",(int)nofbdev_sinkInstance);
00177     return OMX_ErrorInsufficientResources;
00178   }
00179 
00180   return err;
00181 }
00182 
00185 OMX_ERRORTYPE omx_fbdev_sink_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
00186   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
00187   OMX_U32 i;
00188  
00189   /* frees port/s */
00190   if (omx_fbdev_sink_component_Private->ports) {
00191     for (i=0; i < (omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts + 
00192                    omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts); i++) {
00193       if(omx_fbdev_sink_component_Private->ports[i])
00194         omx_fbdev_sink_component_Private->ports[i]->PortDestructor(omx_fbdev_sink_component_Private->ports[i]);
00195     }
00196     free(omx_fbdev_sink_component_Private->ports);
00197     omx_fbdev_sink_component_Private->ports=NULL;
00198   }
00199 
00200 #ifdef AV_SYNC_LOG
00201    if(fd != NULL) {
00202       fclose(fd);
00203       fd = NULL;
00204    }
00205 #endif
00206 
00207   omx_base_sink_Destructor(openmaxStandComp);
00208   nofbdev_sinkInstance--;
00209 
00210   return OMX_ErrorNone;
00211 }
00212 
00213 
00214 OMX_S32 calcStride2(omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private) {
00215   OMX_U32 stride;
00216 
00217   if(omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel == 32){
00218     stride = omx_fbdev_sink_component_Private->fscr_info.line_length;
00219   } else if(omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel == 8){
00220     stride = omx_fbdev_sink_component_Private->fscr_info.line_length*4;
00221   } else{
00222     stride = omx_fbdev_sink_component_Private->fscr_info.line_length*
00223            omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel/8;
00224   }
00225   return stride;
00226 }
00231 OMX_ERRORTYPE omx_fbdev_sink_component_Init(OMX_COMPONENTTYPE *openmaxStandComp) {
00232   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
00233   omx_fbdev_sink_component_PortType* pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
00234 
00235   omx_fbdev_sink_component_Private->fd = open(FBDEV_FILENAME, O_RDWR);
00236   if (omx_fbdev_sink_component_Private->fd < 0) {
00237     DEBUG(DEB_LEV_ERR, "Unable to open framebuffer %s!  open returned: %i, errno=%d  ENODEV : %d \n", FBDEV_FILENAME, omx_fbdev_sink_component_Private->fd,errno,ENODEV);
00238     return OMX_ErrorHardware;
00239   } 
00240 
00242   if(ioctl(omx_fbdev_sink_component_Private->fd, FBIOGET_VSCREENINFO, &omx_fbdev_sink_component_Private->vscr_info) != 0 ||
00243     ioctl(omx_fbdev_sink_component_Private->fd, FBIOGET_FSCREENINFO, &omx_fbdev_sink_component_Private->fscr_info) != 0) {
00244     DEBUG(DEB_LEV_ERR, "Error during ioctl to get framebuffer parameters!\n");
00245     return OMX_ErrorHardware;
00246   }
00247 
00251   omx_fbdev_sink_component_Private->fbpxlfmt = find_omx_pxlfmt(&omx_fbdev_sink_component_Private->vscr_info);
00252   if (omx_fbdev_sink_component_Private->fbpxlfmt == OMX_COLOR_FormatUnused) {
00253     DEBUG(DEB_LEV_ERR,"\n in %s finding omx pixel format returned error\n", __func__);
00254     return OMX_ErrorUnsupportedSetting;
00255   }
00256 
00257   DEBUG(DEB_LEV_PARAMS, "xres=%u,yres=%u,xres_virtual %u,yres_virtual=%u,xoffset=%u,yoffset=%u,bits_per_pixel=%u,grayscale=%u,nonstd=%u,height=%u,width=%u\n",
00258           omx_fbdev_sink_component_Private->vscr_info.xres                     /* visible resolution           */
00259         , omx_fbdev_sink_component_Private->vscr_info.yres
00260         , omx_fbdev_sink_component_Private->vscr_info.xres_virtual             /* virtual resolution           */
00261         , omx_fbdev_sink_component_Private->vscr_info.yres_virtual
00262         , omx_fbdev_sink_component_Private->vscr_info.xoffset                  /* offset from virtual to visible */
00263         , omx_fbdev_sink_component_Private->vscr_info.yoffset                  /* resolution                   */
00264         , omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel           /* guess what                   */
00265         , omx_fbdev_sink_component_Private->vscr_info.grayscale                /* != 0 Graylevels instead of colors */
00266         , omx_fbdev_sink_component_Private->vscr_info.nonstd                   /* != 0 Non standard pixel format */
00267         , omx_fbdev_sink_component_Private->vscr_info.height                   /* height of picture in mm    */
00268         , omx_fbdev_sink_component_Private->vscr_info.width);
00269 
00270   DEBUG(DEB_LEV_PARAMS, "Red Off=%u len=%u,Green off=%u,len=%u,blue off=%u len=%u,trans off=%u,len=%u\n",
00271     omx_fbdev_sink_component_Private->vscr_info.red.offset,omx_fbdev_sink_component_Private->vscr_info.red.length,
00272   omx_fbdev_sink_component_Private->vscr_info.green.offset, omx_fbdev_sink_component_Private->vscr_info.green.length,
00273   omx_fbdev_sink_component_Private->vscr_info.blue.offset,omx_fbdev_sink_component_Private->vscr_info.blue.length,
00274   omx_fbdev_sink_component_Private->vscr_info.transp.offset,omx_fbdev_sink_component_Private->vscr_info.transp.length);
00275 
00276 
00277   omx_fbdev_sink_component_Private->fbwidth = omx_fbdev_sink_component_Private->vscr_info.xres;
00278   omx_fbdev_sink_component_Private->fbheight = pPort->sPortParam.format.video.nFrameHeight;
00279   omx_fbdev_sink_component_Private->fbbpp = omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel;
00280   //omx_fbdev_sink_component_Private->fbstride = calcStride(omx_fbdev_sink_component_Private->fbwidth, omx_fbdev_sink_component_Private->fbpxlfmt);
00281   //omx_fbdev_sink_component_Private->fbstride = omx_fbdev_sink_component_Private->fscr_info.line_length*
00282     //         omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel/8;
00283   omx_fbdev_sink_component_Private->fbstride = calcStride2(omx_fbdev_sink_component_Private);
00284 
00288   omx_fbdev_sink_component_Private->product = omx_fbdev_sink_component_Private->fbstride * (omx_fbdev_sink_component_Private->fbheight + HEIGHT_OFFSET); 
00289 
00291   omx_fbdev_sink_component_Private->scr_ptr = (unsigned char*) mmap(0, omx_fbdev_sink_component_Private->product, PROT_READ | PROT_WRITE, MAP_SHARED, omx_fbdev_sink_component_Private->fd,0);
00292   if (omx_fbdev_sink_component_Private->scr_ptr == NULL) {
00293     DEBUG(DEB_LEV_ERR, "in %s Failed to mmap framebuffer memory!\n", __func__);
00294     close (omx_fbdev_sink_component_Private->fd);
00295     return OMX_ErrorHardware;
00296   }
00297 
00298   DEBUG(DEB_LEV_SIMPLE_SEQ, "mmap framebuffer memory =%x omx_fbdev_sink_component_Private->product=%d stride=%d\n",(int)omx_fbdev_sink_component_Private->scr_ptr,(int)omx_fbdev_sink_component_Private->product,(int)omx_fbdev_sink_component_Private->fbstride);
00299   DEBUG(DEB_LEV_SIMPLE_SEQ, "Successfully opened %s for display.\n", "/dev/fb0");
00300   DEBUG(DEB_LEV_SIMPLE_SEQ, "Display Size: %u x %u\n", (int)omx_fbdev_sink_component_Private->fbwidth, (int)omx_fbdev_sink_component_Private->fbheight);
00301   DEBUG(DEB_LEV_SIMPLE_SEQ, "Bitdepth: %u\n", (int)omx_fbdev_sink_component_Private->fbbpp);
00302 
00303   return OMX_ErrorNone;
00304 }
00305 
00309 OMX_ERRORTYPE omx_fbdev_sink_component_Deinit(OMX_COMPONENTTYPE *openmaxStandComp) {
00310   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
00311 
00312   if (omx_fbdev_sink_component_Private->scr_ptr) {
00313     munmap(omx_fbdev_sink_component_Private->scr_ptr, omx_fbdev_sink_component_Private->product);
00314   }
00315   if (close(omx_fbdev_sink_component_Private->fd) == -1) {
00316     return OMX_ErrorHardware;
00317   }
00318   return OMX_ErrorNone;
00319 }
00320 
00327 OMX_S32 calcStride(OMX_U32 width, OMX_COLOR_FORMATTYPE omx_pxlfmt) {
00328   OMX_U32 stride;
00329   OMX_U32 bpp; // bit per pixel
00330 
00331   switch(omx_pxlfmt) {
00332     case OMX_COLOR_FormatMonochrome:
00333       bpp = 1;
00334       break;
00335     case OMX_COLOR_FormatL2:
00336       bpp = 2;
00337     case OMX_COLOR_FormatL4:
00338       bpp = 4;
00339       break;
00340     case OMX_COLOR_FormatL8:
00341     case OMX_COLOR_Format8bitRGB332:
00342     case OMX_COLOR_FormatRawBayer8bit:
00343     case OMX_COLOR_FormatRawBayer8bitcompressed:
00344       bpp = 8;  
00345       break;
00346     case OMX_COLOR_FormatRawBayer10bit:
00347       bpp = 10;
00348       break;
00349     case OMX_COLOR_FormatYUV411Planar:
00350     case OMX_COLOR_FormatYUV411PackedPlanar:
00351     case OMX_COLOR_Format12bitRGB444:
00352     case OMX_COLOR_FormatYUV420Planar:
00353     case OMX_COLOR_FormatYUV420PackedPlanar:
00354     case OMX_COLOR_FormatYUV420SemiPlanar:
00355     case OMX_COLOR_FormatYUV444Interleaved:
00356       bpp = 12;
00357       break;
00358     case OMX_COLOR_FormatL16:
00359     case OMX_COLOR_Format16bitARGB4444:
00360     case OMX_COLOR_Format16bitARGB1555:
00361     case OMX_COLOR_Format16bitRGB565:
00362     case OMX_COLOR_Format16bitBGR565:
00363     case OMX_COLOR_FormatYUV422Planar:
00364     case OMX_COLOR_FormatYUV422PackedPlanar:
00365     case OMX_COLOR_FormatYUV422SemiPlanar:
00366     case OMX_COLOR_FormatYCbYCr:
00367     case OMX_COLOR_FormatYCrYCb:
00368     case OMX_COLOR_FormatCbYCrY:
00369     case OMX_COLOR_FormatCrYCbY:
00370       bpp = 16;
00371       break;
00372     case OMX_COLOR_Format18bitRGB666:
00373     case OMX_COLOR_Format18bitARGB1665:
00374       bpp = 18;
00375       break;
00376     case OMX_COLOR_Format19bitARGB1666:
00377       bpp = 19;
00378       break;
00379     case OMX_COLOR_FormatL24:
00380     case OMX_COLOR_Format24bitRGB888:
00381     case OMX_COLOR_Format24bitBGR888:
00382     case OMX_COLOR_Format24bitARGB1887:
00383       bpp = 24;
00384       break;
00385     case OMX_COLOR_Format25bitARGB1888:
00386       bpp = 25;
00387       break;
00388     case OMX_COLOR_FormatL32:
00389     case OMX_COLOR_Format32bitBGRA8888:
00390     case OMX_COLOR_Format32bitARGB8888:
00391       bpp = 32;
00392       break;
00393     default:
00394       bpp = 0;
00395       break;
00396   }
00397   stride = (width * bpp) >> 3; // division by 8 to get byte per pixel value
00398   return (OMX_S32) stride;
00399 }
00400 
00401 
00409 OMX_COLOR_FORMATTYPE find_omx_pxlfmt(struct fb_var_screeninfo *vscr_info) {
00410   OMX_COLOR_FORMATTYPE omx_pxlfmt = OMX_COLOR_FormatUnused;
00411 
00413   if (vscr_info->grayscale) {
00414     switch (vscr_info->bits_per_pixel) {
00415       case 2:
00416         omx_pxlfmt = OMX_COLOR_FormatL2;
00417         break;
00418       case 4:
00419         omx_pxlfmt = OMX_COLOR_FormatL4;
00420         break;
00421       case 8:
00422         omx_pxlfmt = OMX_COLOR_FormatL8;
00423         break;
00424       case 16:
00425         omx_pxlfmt = OMX_COLOR_FormatL16;
00426         break;
00427       case 24:
00428         omx_pxlfmt = OMX_COLOR_FormatL24;
00429         break;
00430       case 32:
00431         omx_pxlfmt = OMX_COLOR_FormatL32;
00432         break;
00433       default:
00434         omx_pxlfmt = OMX_COLOR_FormatUnused;
00435         break;
00436     }
00437   } else {
00439     if(vscr_info->bits_per_pixel == 1) {
00440       omx_pxlfmt = OMX_COLOR_FormatMonochrome;
00441     } else if ( vscr_info->red.length == 3 && vscr_info->red.offset == 5 &&
00442                 vscr_info->green.length == 3 && vscr_info->green.offset == 2 &&
00443                 vscr_info->blue.length == 2 && vscr_info->blue.offset == 0 &&
00444                 vscr_info->transp.length == 0) {
00445       omx_pxlfmt = OMX_COLOR_Format8bitRGB332;
00446     } else if ( vscr_info->red.length == 4 && vscr_info->red.offset == 8 &&
00447                 vscr_info->green.length == 4 && vscr_info->green.offset == 4 &&
00448                 vscr_info->blue.length == 4 && vscr_info->blue.offset == 0 &&
00449                 vscr_info->transp.length == 0) {
00450       omx_pxlfmt = OMX_COLOR_Format12bitRGB444;
00451     } else if ( vscr_info->transp.length == 4 && vscr_info->transp.offset == 12 &&
00452                 vscr_info->red.length == 4 && vscr_info->red.offset == 8 &&
00453                 vscr_info->green.length == 4 && vscr_info->green.offset == 4 &&
00454                 vscr_info->blue.length == 4 && vscr_info->blue.offset == 0) {
00455       omx_pxlfmt = OMX_COLOR_Format16bitARGB4444;
00456     } else if ( vscr_info->red.length == 5 && vscr_info->blue.length == 5 && 
00457                 vscr_info->transp.length == 1 && vscr_info->transp.offset == 15 &&
00458                 vscr_info->green.length == 5 && vscr_info->green.offset == 5 &&
00459                 vscr_info->red.offset == 10 && vscr_info->blue.offset == 0) {
00460       omx_pxlfmt = OMX_COLOR_Format16bitARGB1555;
00461     } else if ( vscr_info->red.length == 5 && vscr_info->blue.length == 5 && 
00462                 vscr_info->green.length == 6 && vscr_info->green.offset == 5 && 
00463                 vscr_info->red.offset == 11 && vscr_info->blue.offset == 0) {
00464       omx_pxlfmt = OMX_COLOR_Format16bitRGB565;
00465     } else if ( vscr_info->red.length == 5 && vscr_info->blue.length == 5 && 
00466                 vscr_info->green.length == 6 && vscr_info->green.offset == 5 &&
00467                 vscr_info->red.offset == 0 && vscr_info->blue.offset == 11) {
00468       omx_pxlfmt = OMX_COLOR_Format16bitBGR565;
00469     } else if ( vscr_info->red.length == 6 && vscr_info->green.length == 6 &&
00470                 vscr_info->transp.length == 0 && vscr_info->red.offset == 12 && vscr_info->green.offset == 6 &&
00471                 vscr_info->blue.length == 6 && vscr_info->blue.offset == 0) {
00472       omx_pxlfmt = OMX_COLOR_Format18bitRGB666;
00473     } else if ( vscr_info->red.length == 6 && vscr_info->green.length == 6 && 
00474                 vscr_info->transp.length == 1 && vscr_info->transp.offset == 17 &&
00475                 vscr_info->red.offset == 11 && vscr_info->green.offset == 5 &&
00476                 vscr_info->blue.length == 5 && vscr_info->blue.offset == 0) {
00477       omx_pxlfmt = OMX_COLOR_Format18bitARGB1665;
00478     } else if ( vscr_info->transp.length == 1 && vscr_info->transp.offset == 18 &&
00479                 vscr_info->red.length == 6 && vscr_info->red.offset ==  12 &&
00480                 vscr_info->green.length == 6 && vscr_info->green.offset == 6 &&
00481                 vscr_info->blue.length == 6 && vscr_info->blue.offset == 0) {
00482       omx_pxlfmt = OMX_COLOR_Format19bitARGB1666;
00483     } else if ( vscr_info->transp.length == 0 && vscr_info->red.length == 8 &&
00484                 vscr_info->green.length == 8 && vscr_info->blue.length == 8 &&
00485                 vscr_info->green.offset == 8 && vscr_info->red.offset == 16 && vscr_info->blue.offset == 0) {
00486       omx_pxlfmt = OMX_COLOR_Format24bitRGB888;
00487     } else if ( vscr_info->transp.length == 0 && vscr_info->red.length == 8 &&
00488                 vscr_info->green.length == 8 && vscr_info->blue.length == 8 &&
00489                 vscr_info->green.offset == 8 && vscr_info->red.offset == 0 && vscr_info->blue.offset == 16) {
00490       omx_pxlfmt = OMX_COLOR_Format24bitBGR888;
00491     } else if ( vscr_info->transp.length == 1 && vscr_info->transp.offset == 23 &&
00492                 vscr_info->red.length == 8 && vscr_info->red.offset == 15 &&
00493                 vscr_info->green.length == 8 && vscr_info->green.offset == 7 &&
00494                 vscr_info->blue.length == 7 && vscr_info->blue.offset == 0) {
00495       omx_pxlfmt = OMX_COLOR_Format24bitARGB1887;
00496     } else if ( vscr_info->transp.length == 1 && vscr_info->transp.offset == 24 &&
00497                 vscr_info->red.length == 8 && vscr_info->red.offset == 16 &&
00498                 vscr_info->green.length == 8 && vscr_info->green.offset == 8 &&
00499                 vscr_info->blue.length == 8 && vscr_info->blue.offset == 0) {
00500       omx_pxlfmt = OMX_COLOR_Format25bitARGB1888;
00501     } else if ( vscr_info->transp.length == 8 && vscr_info->red.length == 8 &&
00502                 vscr_info->green.length == 8 && vscr_info->blue.length == 8 &&
00503                 vscr_info->transp.offset == 24 && vscr_info->red.offset == 16 &&
00504                 vscr_info->green.offset == 8 && vscr_info->blue.offset == 0) {
00505       omx_pxlfmt = OMX_COLOR_Format32bitARGB8888;
00506     } else if ( vscr_info->transp.length == 8 && vscr_info->red.length == 8 &&
00507                 vscr_info->green.length == 8 && vscr_info->blue.length == 8 && 
00508                 vscr_info->transp.offset == 0 && vscr_info->red.offset == 8 &&
00509                 vscr_info->green.offset == 16 && vscr_info->blue.offset == 24) {
00510       omx_pxlfmt = OMX_COLOR_Format32bitBGRA8888;
00511     } else if ( vscr_info->transp.length == 8 && vscr_info->red.length == 8 &&
00512                 vscr_info->green.length == 8 && vscr_info->blue.length == 8 && 
00513                 vscr_info->transp.offset == 0 && vscr_info->red.offset == 0 &&
00514                 vscr_info->green.offset == 0 && vscr_info->blue.offset == 0) {
00515       omx_pxlfmt = OMX_COLOR_Format8bitRGB332;
00516     } else {
00517       omx_pxlfmt = OMX_COLOR_FormatUnused;
00518     }
00519   }
00520   return omx_pxlfmt;
00521 }
00522 
00523 
00542 void omx_img_copy(OMX_U8* src_ptr, OMX_S32 src_stride, OMX_U32 src_width, OMX_U32 src_height, 
00543                   OMX_S32 src_offset_x, OMX_S32 src_offset_y,
00544                   OMX_U8* dest_ptr, OMX_S32 dest_stride, OMX_U32 dest_width,  OMX_U32 dest_height, 
00545                   OMX_S32 dest_offset_x, OMX_S32 dest_offset_y, 
00546                   OMX_S32 cpy_width, OMX_U32 cpy_height, OMX_COLOR_FORMATTYPE colorformat,OMX_COLOR_FORMATTYPE fbpxlfmt) {  
00547 
00548   OMX_U32 i,j;
00549   OMX_U32 cp_byte; //equal to source image byte per pixel value
00550   OMX_U8 r,g,b,a;
00551   OMX_U8* org_src_cpy_ptr;
00552   OMX_U8* org_dst_cpy_ptr;
00557   if (colorformat == OMX_COLOR_FormatYUV411Planar ||    
00558       colorformat == OMX_COLOR_FormatYUV411PackedPlanar || 
00559       colorformat == OMX_COLOR_FormatYUV420Planar ||
00560       colorformat == OMX_COLOR_FormatYUV420PackedPlanar ||
00561       colorformat == OMX_COLOR_FormatYUV422Planar ||
00562       colorformat == OMX_COLOR_FormatYUV422PackedPlanar ) {
00563 
00564     OMX_U32 src_luma_width;      //  Width (in columns) of the source Y plane
00565     OMX_U32 src_luma_height;     //  Height (in rows) of source Y plane
00566     OMX_S32 src_luma_stride;     //  Stride in bytes of each source Y row
00567     OMX_U32 src_luma_offset_x;   //  Horizontal byte offset
00568     OMX_U32 src_luma_offset_y;   //  Vertical offset in rows from top of plane
00569     OMX_U32 src_luma_offset;     //  Total byte offset to rectangle
00570 
00571     OMX_U32 src_chroma_width;    //  Width (in columns) of source chroma planes
00572     OMX_U32 src_chroma_height;   //  Height (in rows) of source chroma planes
00573     OMX_S32 src_chroma_stride;   //  Stride in bytes of each source chroma row
00574     OMX_U32 src_chroma_offset_x; //  Horizontal byte offset
00575     OMX_U32 src_chroma_offset_y; //  Vertical offset in rows from top of plane
00576     OMX_U32 src_chroma_offset;   //  Bytes to crop rectangle from start of chroma plane
00577 
00578     OMX_U32 dest_luma_width;     //  Width (in columns) of the destination Y plane
00579     OMX_U32 dest_luma_height;    //  Height (in rows) of destination Y plane
00580     OMX_S32 dest_luma_stride;    //  Stride in bytes of each destination Y row
00581     OMX_U32 dest_luma_offset_x;  //  Horizontal byte offset
00582     OMX_U32 dest_luma_offset_y;  //  Vertical offset in rows from top of plane
00583     OMX_U32 dest_luma_offset;    //  Bytes to crop rectangle from start of Y plane
00584 
00585     OMX_U32 dest_chroma_width;   //  Width (in columns) of destination chroma planes
00586     OMX_U32 dest_chroma_height;  //  Height (in rows) of destination chroma planes
00587     OMX_S32 dest_chroma_stride;  //  Stride in bytes of each destination chroma row
00588     OMX_U32 dest_chroma_offset_x;//  Horizontal byte offset
00589     OMX_U32 dest_chroma_offset_y;//  Vertical offset in rows from top of plane
00590     OMX_U32 dest_chroma_offset;  //  Bytes to crop rectangle from start of chroma plane
00591 
00592     OMX_U32 luma_crop_width;     //  Width in bytes of a luma row in the crop rectangle
00593     OMX_U32 luma_crop_height;    //  Number of luma rows in the crop rectangle
00594     OMX_U32 chroma_crop_width;   //  Width in bytes of a chroma row in the crop rectangle
00595     OMX_U32 chroma_crop_height;  //  Number of chroma rows in crop rectangle
00596 
00597     switch (colorformat) {
00600       case OMX_COLOR_FormatYUV411Planar:    
00601       case OMX_COLOR_FormatYUV411PackedPlanar:
00606         src_luma_width = src_width;
00607         src_luma_height = src_height;
00608         src_luma_stride = (OMX_S32) src_luma_width;
00609         src_luma_offset_x = src_offset_x;
00610         src_luma_offset_y = src_offset_y;
00611 
00612         src_chroma_width = src_luma_width  >> 2; 
00613         src_chroma_height = src_luma_height;
00614         src_chroma_stride = (OMX_S32) src_chroma_width;
00615         src_chroma_offset_x = src_luma_offset_x  >> 2; 
00616         src_chroma_offset_y = src_luma_offset_y;
00617 
00618         dest_luma_width = dest_width;
00619         dest_luma_height = dest_height;
00620         dest_luma_stride = (OMX_S32) dest_luma_width;
00621         dest_luma_offset_x = dest_offset_x;
00622         dest_luma_offset_y = dest_offset_y;
00623 
00624         dest_chroma_width = dest_luma_width  >> 2;
00625         dest_chroma_height = dest_luma_height;
00626         dest_chroma_stride = (OMX_S32) dest_chroma_width;
00627         dest_chroma_offset_x = dest_luma_offset_x  >> 2; 
00628         dest_chroma_offset_y = dest_luma_offset_y;
00629 
00630         luma_crop_width = (OMX_U32) abs(cpy_width);
00631         luma_crop_height = cpy_height;
00632         chroma_crop_width = luma_crop_width  >> 2; 
00633         chroma_crop_height = luma_crop_height;
00634         break;  
00635 
00637       case OMX_COLOR_FormatYUV420Planar:    
00638       case OMX_COLOR_FormatYUV420PackedPlanar:
00639         src_luma_width = src_width;
00640         src_luma_height = src_height;
00641         src_luma_stride = (OMX_S32) src_luma_width;
00642         src_luma_offset_x = src_offset_x;
00643         src_luma_offset_y = src_offset_y;
00644 
00645         src_chroma_width = src_luma_width >> 1;
00646         src_chroma_height = src_luma_height >> 1;
00647         src_chroma_stride = (OMX_S32) src_chroma_width;
00648         src_chroma_offset_x = src_luma_offset_x >> 1;
00649         src_chroma_offset_y = src_luma_offset_y >> 1;
00650 
00651         dest_luma_width = dest_width;
00652         dest_luma_height = dest_height;
00653         dest_luma_stride = (OMX_S32) dest_luma_width;
00654         dest_luma_offset_x = dest_offset_x;
00655         dest_luma_offset_y = dest_offset_y;
00656 
00657         dest_chroma_width = dest_luma_width >> 1;
00658         dest_chroma_height = dest_luma_height >> 1;
00659         dest_chroma_stride = (OMX_S32) dest_chroma_width;
00660         dest_chroma_offset_x = dest_luma_offset_x >> 1;
00661         dest_chroma_offset_y = dest_luma_offset_y >> 1;
00662 
00663         luma_crop_width = cpy_width;
00664         luma_crop_height = cpy_height;
00665         chroma_crop_width = luma_crop_width >> 1;
00666         chroma_crop_height = luma_crop_height >> 1;
00667         break;
00669       case OMX_COLOR_FormatYUV422Planar:    
00670       case OMX_COLOR_FormatYUV422PackedPlanar:
00671         src_luma_width = src_width;
00672         src_luma_height = src_height;
00673         src_luma_stride = (OMX_S32) src_luma_width;
00674         src_luma_offset_x = src_offset_x;
00675         src_luma_offset_y = src_offset_y;
00676 
00677         src_chroma_width = src_luma_width >> 1;
00678         src_chroma_height = src_luma_height;
00679         src_chroma_stride = (OMX_S32) src_chroma_width;
00680         src_chroma_offset_x = src_luma_offset_x >> 1;
00681         src_chroma_offset_y = src_luma_offset_y;
00682 
00683         dest_luma_width = dest_width;
00684         dest_luma_height = dest_height;
00685         dest_luma_stride = (OMX_S32) dest_luma_width;
00686         dest_luma_offset_x = dest_offset_x;
00687         dest_luma_offset_y = dest_offset_y;
00688 
00689         dest_chroma_width = dest_luma_width >> 1;
00690         dest_chroma_height = dest_luma_height;
00691         dest_chroma_stride = (OMX_S32) dest_chroma_width;
00692         dest_chroma_offset_x = dest_luma_offset_x >> 1;
00693         dest_chroma_offset_y = dest_luma_offset_y;
00694 
00695         luma_crop_width = (OMX_U32) abs(cpy_width);
00696         luma_crop_height = cpy_height;
00697         chroma_crop_width = luma_crop_width >> 1;
00698         chroma_crop_height = luma_crop_height;
00699         break;
00700       default:
00701         DEBUG(DEB_LEV_ERR,"\n color format not supported --error \n");
00702         return;
00703     }
00704 
00706     OMX_U8* Y_input_ptr = src_ptr;
00707     OMX_U8* U_input_ptr = Y_input_ptr + ((OMX_U32) abs(src_luma_stride) * src_luma_height);
00708     OMX_U8* V_input_ptr = U_input_ptr + ((OMX_U32) abs(src_chroma_stride) * src_chroma_height);
00709 
00711     src_luma_offset = (src_luma_offset_y * (OMX_U32) abs(src_luma_stride)) + src_luma_offset_x;
00712     src_chroma_offset = (src_chroma_offset_y * (OMX_U32) abs(src_chroma_stride)) + src_chroma_offset_x;
00713 
00715     if (src_stride < 0) {
00716       src_luma_offset += ((OMX_U32) abs(src_luma_stride)) * (src_luma_height - 1);
00717       src_chroma_offset += ((OMX_U32) abs(src_chroma_stride)) * (src_chroma_height - 1);
00718 
00719       if (src_luma_stride > 0) {
00720         src_luma_stride *= -1;
00721       }
00722 
00723       if (src_chroma_stride > 0) {
00724         src_chroma_stride *= -1;  
00725       }
00726     }
00727 
00729     OMX_U8* src_Y_ptr = Y_input_ptr + src_luma_offset;    
00730     OMX_U8* src_U_ptr = U_input_ptr + src_chroma_offset;
00731     OMX_U8*  src_V_ptr = V_input_ptr + src_chroma_offset;
00732 
00734     OMX_U8* Y_output_ptr = dest_ptr;
00735     OMX_U8* U_output_ptr = Y_output_ptr + ((OMX_U32) abs(dest_luma_stride) * dest_luma_height);
00736     OMX_U8* V_output_ptr = U_output_ptr + ((OMX_U32) abs(dest_chroma_stride) * dest_chroma_height);  
00737 
00739     dest_luma_offset = (dest_luma_offset_y * (OMX_U32) abs(dest_luma_stride)) + dest_luma_offset_x;
00740     dest_chroma_offset = (dest_chroma_offset_y * (OMX_U32) abs(dest_chroma_stride)) + dest_chroma_offset_x;
00741 
00743     if (dest_stride < 0) {
00744       dest_luma_offset += ((OMX_U32) abs(dest_luma_stride)) * (dest_luma_height - 1);
00745       dest_chroma_offset += ((OMX_U32) abs(dest_chroma_stride)) * (dest_chroma_height - 1);
00746       if (dest_luma_stride > 0) {
00747         dest_luma_stride *= -1;
00748       }
00749       if (dest_chroma_stride > 0) {
00750         dest_chroma_stride *= -1;  
00751       }
00752     }
00753 
00755     OMX_U8* dest_Y_ptr = Y_output_ptr + dest_luma_offset;    
00756     OMX_U8* dest_U_ptr = U_output_ptr + dest_chroma_offset;
00757     OMX_U8*  dest_V_ptr = V_output_ptr + dest_chroma_offset;
00758 
00759     //  Y
00760     for (i = 0; i < luma_crop_height; ++i, src_Y_ptr += src_luma_stride, dest_Y_ptr += dest_luma_stride) {
00761       memcpy(dest_Y_ptr, src_Y_ptr, luma_crop_width);    //  Copy Y rows into in_buffer
00762     }
00763     //  U
00764     for (i = 0; i < chroma_crop_height; ++i, src_U_ptr += src_chroma_stride, dest_U_ptr += dest_chroma_stride) {
00765       memcpy(dest_U_ptr, src_U_ptr, chroma_crop_width);  //  Copy U rows into in_buffer
00766     }
00767     //  V
00768     for (i = 0; i < chroma_crop_height; ++i, src_V_ptr += src_chroma_stride, dest_V_ptr += dest_chroma_stride) {
00769       memcpy(dest_V_ptr, src_V_ptr, chroma_crop_width);  //  Copy V rows into in_buffer
00770     }
00771   } else {  
00772 
00773     OMX_U32 cpy_byte_width = calcStride((OMX_U32) abs(cpy_width), colorformat);  //  Bytes width to copy
00774     OMX_U32 src_byte_offset_x = calcStride((OMX_U32) abs(src_offset_x), colorformat);
00775     OMX_U32 dest_byte_offset_x = calcStride((OMX_U32) abs(dest_offset_x), colorformat);
00776     OMX_U32 src_byte_offset_y = src_offset_y * (OMX_U32) abs(src_stride);
00777     OMX_U32 dest_byte_offset_y = dest_offset_y * (OMX_U32) abs(dest_stride);
00778 
00779     if (src_stride < 0)  {
00780       //  If input stride is negative, start from bottom
00781       src_byte_offset_y += cpy_height * (OMX_U32) abs(src_stride);
00782     }  
00783     if (dest_stride < 0) {
00784       //  If output stride is negative, start from bottom
00785       dest_byte_offset_y += cpy_height * (OMX_U32) abs(dest_stride);
00786     }
00787 
00788     OMX_U8* src_cpy_ptr = src_ptr + src_byte_offset_y + src_byte_offset_x;
00789     OMX_U8* dest_cpy_ptr = dest_ptr + dest_byte_offset_y + dest_byte_offset_x;
00790 
00797     DEBUG(DEB_LEV_SIMPLE_SEQ, "height=%d,width=%d,dest_stride=%d\n",(int)cpy_height,(int)cpy_byte_width,(int)dest_stride);
00798 
00799     if(fbpxlfmt == OMX_COLOR_Format8bitRGB332 && colorformat == OMX_COLOR_Format24bitRGB888) {
00800       cp_byte = 3;
00801       for (i = 0; i < cpy_height; ++i) { 
00802         // copy rows
00803         org_src_cpy_ptr = src_cpy_ptr; 
00804         org_dst_cpy_ptr = dest_cpy_ptr;
00805         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00806           //extract source rgba components
00807           r = *(src_cpy_ptr + 0);
00808           g = *(src_cpy_ptr + 1);
00809           b = *(src_cpy_ptr + 2);
00810 
00811           *(dest_cpy_ptr + 0) = b; 
00812           *(dest_cpy_ptr + 1) = g; 
00813           *(dest_cpy_ptr + 2) = r;
00814           //last byte - all 1
00815           *(dest_cpy_ptr + 3) = 0xff;
00816           src_cpy_ptr += cp_byte;     
00817           dest_cpy_ptr += 4;     
00818 
00819           
00820         }
00821         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00822         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00823       }
00824     } else if(fbpxlfmt == OMX_COLOR_Format16bitRGB565 && colorformat == OMX_COLOR_Format24bitRGB888) {
00825       cp_byte = 3;
00826       for (i = 0; i < cpy_height; ++i) { 
00827         // copy rows
00828         org_src_cpy_ptr = src_cpy_ptr; 
00829         org_dst_cpy_ptr = dest_cpy_ptr;
00830         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00831           //extract source rgba components
00832           r = *(src_cpy_ptr + 0);
00833           g = *(src_cpy_ptr + 1);
00834           b = *(src_cpy_ptr + 2);
00835 
00836           *(dest_cpy_ptr + 0) = b; 
00837           *(dest_cpy_ptr + 1) = g; 
00838           *(dest_cpy_ptr + 2) = r;
00839           //last byte - all 1
00840           *(dest_cpy_ptr + 3) = 0xff;
00841           src_cpy_ptr += cp_byte;     
00842           dest_cpy_ptr += 4;     
00843 
00844           
00845         }
00846         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00847         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00848       }
00849     } else if(fbpxlfmt == OMX_COLOR_Format24bitRGB888 && colorformat == OMX_COLOR_Format24bitRGB888) {
00850       cp_byte = 3;
00851       for (i = 0; i < cpy_height; ++i) { 
00852         // copy rows
00853         org_src_cpy_ptr = src_cpy_ptr; 
00854         org_dst_cpy_ptr = dest_cpy_ptr;
00855         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00856           //extract source rgba components
00857           r = *(src_cpy_ptr + 0);
00858           g = *(src_cpy_ptr + 1);
00859           b = *(src_cpy_ptr + 2);
00860           //assign to detination 
00861           *(dest_cpy_ptr + 0) = b; 
00862           *(dest_cpy_ptr + 1) = g; 
00863           *(dest_cpy_ptr + 2) = r;
00864           //last byte - all 1
00865           *(dest_cpy_ptr + 3) = 0xff;
00866           src_cpy_ptr += cp_byte;     
00867           dest_cpy_ptr += 4;     
00868         }
00869         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00870         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00871       }
00872     }else if(fbpxlfmt == OMX_COLOR_Format32bitARGB8888 && colorformat == OMX_COLOR_Format24bitRGB888) {
00873       cp_byte = 3;
00874       for (i = 0; i < cpy_height; ++i) { 
00875         // copy rows
00876         org_src_cpy_ptr = src_cpy_ptr; 
00877         org_dst_cpy_ptr = dest_cpy_ptr;
00878         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00879           //extract source rgba components
00880           r = *(src_cpy_ptr + 0);
00881           g = *(src_cpy_ptr + 1);
00882           b = *(src_cpy_ptr + 2);
00883           //assign to detination 
00884           *(dest_cpy_ptr + 0) = b; 
00885           *(dest_cpy_ptr + 1) = g; 
00886           *(dest_cpy_ptr + 2) = r;
00887           //last byte - all 1
00888           *(dest_cpy_ptr + 3) = 0xff;
00889           src_cpy_ptr += cp_byte;     
00890           dest_cpy_ptr += 4;     
00891         }
00892         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00893         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00894       }
00895     } else if(fbpxlfmt == OMX_COLOR_Format32bitARGB8888 && colorformat == OMX_COLOR_Format24bitBGR888) {
00896       cp_byte = 3;
00897       for (i = 0; i < cpy_height; ++i) { 
00898         // copy rows
00899         org_src_cpy_ptr = src_cpy_ptr; 
00900         org_dst_cpy_ptr = dest_cpy_ptr;
00901         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00902           //extract source rgba components
00903           b = *(src_cpy_ptr + 0);
00904           g = *(src_cpy_ptr + 1);
00905           r = *(src_cpy_ptr + 2);
00906           //assign to detination 
00907           *(dest_cpy_ptr + 0) = b; 
00908           *(dest_cpy_ptr + 1) = g; 
00909           *(dest_cpy_ptr + 2) = r; 
00910           //last byte - all 1
00911           *(dest_cpy_ptr + 3) = 0xff;
00912           src_cpy_ptr += cp_byte;     
00913           dest_cpy_ptr += 4;     
00914         }
00915         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00916         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00917       }
00918     } else if(fbpxlfmt == OMX_COLOR_Format32bitARGB8888 && (colorformat == OMX_COLOR_Format32bitBGRA8888 || colorformat == OMX_COLOR_Format32bitARGB8888)) {
00919       for (i = 0; i < cpy_height; ++i, src_cpy_ptr += src_stride, dest_cpy_ptr += dest_stride ) { 
00920         // same color format - so no extraction - only simple memcpy
00921         memcpy(dest_cpy_ptr, src_cpy_ptr, cpy_byte_width);  //  Copy rows
00922       }
00923     } else if(fbpxlfmt == OMX_COLOR_Format32bitARGB8888 && colorformat == OMX_COLOR_Format16bitARGB1555) { 
00924       cp_byte = 2;
00925       for (i = 0; i < cpy_height; ++i) { 
00926         // copy rows
00927         org_src_cpy_ptr = src_cpy_ptr; 
00928         org_dst_cpy_ptr = dest_cpy_ptr;
00929         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00930           // individual argb components are less than 1 byte 
00931           OMX_U16 temp_old, temp, *temp1;
00932           temp1=(OMX_U16*)src_cpy_ptr;
00933           temp = *temp1;
00934           temp_old = temp;
00935           a = (OMX_U8) ((temp >> 15) && 0x0001); //getting the 1 bit of a and setting all other bits to 0
00936           temp = temp_old;
00937           r = (OMX_U8) ((temp >> 10) & 0x001f); //getting 5 bits of r and setting all other bits to 0
00938           temp = temp_old;
00939           g = (OMX_U8) ((temp >> 5) & 0x001f); //getting 5 bits of g and setting all other bits to 0
00940           temp = temp_old;
00941           b = (OMX_U8) (temp & 0x001f); //getting 5 bits of b and setting all other bits to 0
00942           temp = temp_old;
00943           // assign them in perfect order
00944           *(dest_cpy_ptr + 0) = b<<3; 
00945           *(dest_cpy_ptr + 1) = g<<3; 
00946           *(dest_cpy_ptr + 2) = r<<3; 
00947           *(dest_cpy_ptr + 3) = a<<7; 
00948           src_cpy_ptr += cp_byte;     
00949           dest_cpy_ptr += 4;     
00950         }
00951         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00952         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00953       }
00954     } else if(fbpxlfmt == OMX_COLOR_Format32bitARGB8888 && (colorformat == OMX_COLOR_Format16bitRGB565 || OMX_COLOR_Format16bitBGR565)) {
00955       cp_byte = 2;
00956       for (i = 0; i < cpy_height; ++i) { 
00957         // copy rows
00958         org_src_cpy_ptr = src_cpy_ptr; 
00959         org_dst_cpy_ptr = dest_cpy_ptr;
00960         for(j = 0; j < cpy_byte_width; j += cp_byte) {
00961           // individual rgb components are less than 1 byte 
00962           OMX_U16 temp_old, temp,*temp1;
00963           temp1=(OMX_U16*)src_cpy_ptr;
00964           temp = *temp1;
00965           temp_old = temp;
00966           r = (OMX_U8) ((temp >> 11) & 0x001f); //getting 5 bits of r and setting all other bits to 0
00967           temp = temp_old;
00968           g = (OMX_U8) ((temp >> 5) & 0x003f); //getting 6 bits of g and setting all other bits to 0
00969           temp = temp_old;
00970           b = (OMX_U8) (temp & 0x001f); //getting 5 bits of b and setting all other bits to 0
00971           temp = temp_old;
00972           // assign them in perfect order
00973           *(dest_cpy_ptr + 0) = b<<3; 
00974           *(dest_cpy_ptr + 1) = g<<2; 
00975           *(dest_cpy_ptr + 2) = r<<3; 
00976           // last byte  - all 1
00977           *(dest_cpy_ptr + 3) = 0xff; 
00978           src_cpy_ptr += cp_byte;     
00979           dest_cpy_ptr += 4;     
00980         }
00981         dest_cpy_ptr = org_dst_cpy_ptr + dest_stride;
00982         src_cpy_ptr =  org_src_cpy_ptr + src_stride;
00983       }
00984     } else {
00985       DEBUG(DEB_LEV_ERR, "the frame buffer pixel format %d and colorformat %d NOT supported\n",fbpxlfmt,colorformat);
00986       DEBUG(DEB_LEV_ERR, "or the input rgb format is not supported\n");
00987     }
00988   }
00989 }
00990 
00996 OMX_ERRORTYPE omx_fbdev_sink_component_port_SendBufferFunction(omx_base_PortType *openmaxStandPort, OMX_BUFFERHEADERTYPE* pBuffer) {
00997 
00998   OMX_ERRORTYPE                   err;
00999   OMX_U32                         portIndex;
01000   OMX_COMPONENTTYPE*              omxComponent = openmaxStandPort->standCompContainer;
01001   omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
01002   OMX_BOOL                        SendFrame;
01003   omx_base_clock_PortType*        pClockPort;
01004 #if NO_GST_OMX_PATCH
01005   unsigned int i;
01006 #endif
01007 
01008   portIndex = (openmaxStandPort->sPortParam.eDir == OMX_DirInput)?pBuffer->nInputPortIndex:pBuffer->nOutputPortIndex;
01009   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s portIndex %lu\n", __func__, portIndex);
01010 
01011   if (portIndex != openmaxStandPort->sPortParam.nPortIndex) {
01012     DEBUG(DEB_LEV_ERR, "In %s: wrong port for this operation portIndex=%d port->portIndex=%d\n",
01013            __func__, (int)portIndex, (int)openmaxStandPort->sPortParam.nPortIndex);
01014     return OMX_ErrorBadPortIndex;
01015   }
01016 
01017   if(omx_base_component_Private->state == OMX_StateInvalid) {
01018     DEBUG(DEB_LEV_ERR, "In %s: we are in OMX_StateInvalid\n", __func__);
01019     return OMX_ErrorInvalidState;
01020   }
01021 
01022   if(omx_base_component_Private->state != OMX_StateExecuting &&
01023     omx_base_component_Private->state != OMX_StatePause &&
01024     omx_base_component_Private->state != OMX_StateIdle) {
01025     DEBUG(DEB_LEV_ERR, "In %s: we are not in executing/paused/idle state, but in %d\n", __func__, omx_base_component_Private->state);
01026     return OMX_ErrorIncorrectStateOperation;
01027   }
01028   if (!PORT_IS_ENABLED(openmaxStandPort) || (PORT_IS_BEING_DISABLED(openmaxStandPort) && !PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) ||
01029       (omx_base_component_Private->transientState == OMX_TransStateExecutingToIdle &&
01030       (PORT_IS_TUNNELED(openmaxStandPort) && !PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)))) {
01031     DEBUG(DEB_LEV_ERR, "In %s: Port %d is disabled comp = %s \n", __func__, (int)portIndex,omx_base_component_Private->name);
01032     return OMX_ErrorIncorrectStateOperation;
01033   }
01034 
01035   /* Temporarily disable this check for gst-openmax */
01036 #if NO_GST_OMX_PATCH
01037   {
01038   OMX_BOOL foundBuffer = OMX_FALSE;
01039   if(pBuffer!=NULL && pBuffer->pBuffer!=NULL) {
01040     for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
01041     if (pBuffer->pBuffer == openmaxStandPort->pInternalBufferStorage[i]->pBuffer) {
01042       foundBuffer = OMX_TRUE;
01043       break;
01044     }
01045     }
01046   }
01047   if (!foundBuffer) {
01048     return OMX_ErrorBadParameter;
01049   }
01050   }
01051 #endif
01052 
01053   if ((err = checkHeader(pBuffer, sizeof(OMX_BUFFERHEADERTYPE))) != OMX_ErrorNone) {
01054     DEBUG(DEB_LEV_ERR, "In %s: received wrong buffer header on input port\n", __func__);
01055     return err;
01056   }
01057 
01058   pClockPort  = (omx_base_clock_PortType*)omx_base_component_Private->ports[OMX_BASE_SINK_CLOCKPORT_INDEX];
01059   if(PORT_IS_TUNNELED(pClockPort) && !PORT_IS_BEING_FLUSHED(openmaxStandPort)){
01060     if(pBuffer->nInputPortIndex == OMX_BASE_SINK_INPUTPORT_INDEX && pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME){
01061       SendFrame = OMX_TRUE;
01062     }else{
01063        SendFrame = omx_fbdev_sink_component_ClockPortHandleFunction((omx_fbdev_sink_component_PrivateType*)omx_base_component_Private, pBuffer);
01064        if(!SendFrame) pBuffer->nFilledLen=0; 
01065     }
01066   }
01067 
01068   /* And notify the buffer management thread we have a fresh new buffer to manage */
01069   if(!PORT_IS_BEING_FLUSHED(openmaxStandPort) && !(PORT_IS_BEING_DISABLED(openmaxStandPort) && PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort))){
01070       queue(openmaxStandPort->pBufferQueue, pBuffer);
01071       tsem_up(openmaxStandPort->pBufferSem);
01072       DEBUG(DEB_LEV_FULL_SEQ, "In %s Signalling bMgmtSem Port Index=%d\n",__func__, (int)portIndex);
01073       tsem_up(omx_base_component_Private->bMgmtSem);
01074   }else if(PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)){
01075       DEBUG(DEB_LEV_FULL_SEQ, "In %s: Comp %s received io:%d buffer\n", __func__,omx_base_component_Private->name,(int)openmaxStandPort->sPortParam.nPortIndex);
01076       queue(openmaxStandPort->pBufferQueue, pBuffer);   
01077       tsem_up(openmaxStandPort->pBufferSem);
01078   } else { // If port being flushed and not tunneled then return error
01079     DEBUG(DEB_LEV_FULL_SEQ, "In %s \n", __func__);
01080     return OMX_ErrorIncorrectStateOperation;
01081   }
01082   return OMX_ErrorNone;
01083 }
01084 
01085 OMX_BOOL omx_fbdev_sink_component_ClockPortHandleFunction(omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private, OMX_BUFFERHEADERTYPE* pInputBuffer){
01086   omx_base_clock_PortType               *pClockPort;
01087   OMX_HANDLETYPE                        hclkComponent;
01088   OMX_BUFFERHEADERTYPE*                 clockBuffer;
01089   OMX_TIME_MEDIATIMETYPE*               pMediaTime;
01090   OMX_TIME_CONFIG_TIMESTAMPTYPE         sClientTimeStamp;
01091   OMX_ERRORTYPE                         err;
01092   OMX_BOOL                              SendFrame;
01093 
01094   pClockPort    = (omx_base_clock_PortType*) omx_fbdev_sink_component_Private->ports[OMX_BASE_SINK_CLOCKPORT_INDEX];
01095   hclkComponent = pClockPort->hTunneledComponent; 
01096 
01097   SendFrame = OMX_TRUE;
01098   /* check for any scale change information from the clock component */
01099   if(pClockPort->pBufferSem->semval>0) {
01100     tsem_down(pClockPort->pBufferSem);
01101     clockBuffer = dequeue(pClockPort->pBufferQueue);
01102     pMediaTime  = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
01103     if(pMediaTime->eUpdateType==OMX_TIME_UpdateScaleChanged) {
01104       /* On scale change update the media time base */
01105       sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
01106       sClientTimeStamp.nTimestamp = pInputBuffer->nTimeStamp;
01107       err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeCurrentVideoReference, &sClientTimeStamp);
01108       if(err!=OMX_ErrorNone) {
01109         DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
01110       }
01111       omx_fbdev_sink_component_Private->frameDropFlag = OMX_TRUE;
01112       omx_fbdev_sink_component_Private->dropFrameCount = 0;
01113       omx_fbdev_sink_component_Private->xScale = pMediaTime->xScale;
01114     }
01115     pClockPort->ReturnBufferFunction((omx_base_PortType*)pClockPort,clockBuffer);
01116   }
01117 
01118   /* drop next seven frames on scale change
01119      and rebase the clock time base */
01120   if(omx_fbdev_sink_component_Private->frameDropFlag && omx_fbdev_sink_component_Private->dropFrameCount<7) { //TODO - second check cond can be removed verify
01121      omx_fbdev_sink_component_Private->dropFrameCount ++;
01122      if(omx_fbdev_sink_component_Private->dropFrameCount==7) {
01123         /* rebase the clock time base */
01124         setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE)); 
01125         sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
01126         sClientTimeStamp.nTimestamp = pInputBuffer->nTimeStamp;
01127         err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeCurrentVideoReference, &sClientTimeStamp);
01128         if(err!=OMX_ErrorNone) {
01129           DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
01130         }
01131 
01132         omx_fbdev_sink_component_Private->frameDropFlag  = OMX_FALSE;
01133         omx_fbdev_sink_component_Private->dropFrameCount = 0;
01134         SendFrame = OMX_TRUE;
01135      }
01136      SendFrame = OMX_FALSE;
01137 //     pInputBuffer->nFilledLen=0;
01138 //      return;
01139   }
01140 
01141   /* frame is not to be droppef so send the request for the timestamp for the data delivery */
01142   if(SendFrame){ 
01143     if(PORT_IS_TUNNELED(pClockPort) && !PORT_IS_BEING_FLUSHED(pClockPort)) { 
01144       setHeader(&pClockPort->sMediaTimeRequest, sizeof(OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE));
01145       pClockPort->sMediaTimeRequest.nMediaTimestamp = pInputBuffer->nTimeStamp;
01146       pClockPort->sMediaTimeRequest.nOffset         = 100; /*set the requested offset */
01147       pClockPort->sMediaTimeRequest.nPortIndex      = pClockPort->nTunneledPort;
01148       pClockPort->sMediaTimeRequest.pClientPrivate  = NULL; /* fill the appropriate value */
01149       err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeMediaTimeRequest, &pClockPort->sMediaTimeRequest);
01150       if(err!=OMX_ErrorNone) {
01151         DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
01152       }
01153       if( !PORT_IS_BEING_FLUSHED(pClockPort)) {
01154         tsem_down(pClockPort->pBufferSem); /* wait for the request fullfillment */
01155         clockBuffer = dequeue(pClockPort->pBufferQueue);
01156         pMediaTime  = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
01157         if(pMediaTime->eUpdateType==OMX_TIME_UpdateScaleChanged) {
01158          /* update the media time base */
01159           setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE)); // do not need to setHeader again do once at the top
01160           sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
01161           sClientTimeStamp.nTimestamp = pInputBuffer->nTimeStamp;
01162           err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeCurrentVideoReference, &sClientTimeStamp);
01163           if(err!=OMX_ErrorNone) {
01164             DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
01165           }
01166           omx_fbdev_sink_component_Private->frameDropFlag  = OMX_TRUE;
01167           omx_fbdev_sink_component_Private->dropFrameCount = 0;
01168           omx_fbdev_sink_component_Private->xScale = pMediaTime->xScale;
01169         }
01170        if(pMediaTime->eUpdateType==OMX_TIME_UpdateRequestFulfillment){
01171          if((pMediaTime->nOffset)>0) {
01172 #ifdef AV_SYNC_LOG
01173             fprintf(fd,"%lld %lld\n",pInputBuffer->nTimeStamp,pMediaTime->nWallTimeAtMediaTime);
01174 #endif
01175             SendFrame=OMX_TRUE;
01176          }else {
01177            SendFrame = OMX_FALSE;
01178          }
01179        }
01180        pClockPort->ReturnBufferFunction((omx_base_PortType *)pClockPort,clockBuffer);
01181      }
01182    }
01183  }
01184 
01185   return(SendFrame);
01186 }
01187 
01188 
01192 void omx_fbdev_sink_component_BufferMgmtCallback(OMX_COMPONENTTYPE *openmaxStandComp, OMX_BUFFERHEADERTYPE* pInputBuffer) {
01193   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
01194   omx_fbdev_sink_component_PortType     *pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
01195   static long                           old_time = 0, new_time = 0;
01196   long                                  timediff=0;
01197   OMX_HANDLETYPE                        hclkComponent;
01198   OMX_TIME_CONFIG_TIMESTAMPTYPE         sClientTimeStamp;
01199   OMX_ERRORTYPE                         err;
01200   omx_base_clock_PortType               *pClockPort;
01201   OMX_BUFFERHEADERTYPE*                 clockBuffer;
01202   OMX_TIME_MEDIATIMETYPE*               pMediaTime;
01203 
01204 //  static int                            count=0;
01205 //  static int                            frameDropFlag=0; /* flag=1 implies drop last few frames on a scale change notification */  
01206 
01207   pClockPort = (omx_base_clock_PortType*) omx_fbdev_sink_component_Private->ports[OMX_BASE_SINK_CLOCKPORT_INDEX];
01208   
01209   if(PORT_IS_TUNNELED(pClockPort)) {
01210     DEBUG(DEB_LEV_FULL_SEQ, "In %s Clock Port is Tunneled. Sending Request\n", __func__);
01211     /* if first time stamp is received then notify the clock component */  
01212     if(pInputBuffer->nInputPortIndex == OMX_BASE_SINK_INPUTPORT_INDEX && pInputBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
01213       DEBUG(DEB_LEV_ERR," In %s  first time stamp = %llx \n", __func__,pInputBuffer->nTimeStamp);
01214       pInputBuffer->nFlags = 0;
01215       hclkComponent = pClockPort->hTunneledComponent;
01216       setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
01217       sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
01218       sClientTimeStamp.nTimestamp = pInputBuffer->nTimeStamp;
01219       err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeClientStartTime, &sClientTimeStamp);
01220       if(err!=OMX_ErrorNone) {
01221        DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
01222       }
01223       tsem_down(pClockPort->pBufferSem); /* wait for state change notification */
01224 
01225       /* update the clock state and clock scale info into the fbdev private data */
01226       clockBuffer=dequeue(pClockPort->pBufferQueue);
01227       pMediaTime  = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
01228       omx_fbdev_sink_component_Private->eState      = pMediaTime->eState;
01229       omx_fbdev_sink_component_Private->xScale      = pMediaTime->xScale;
01230       pClockPort->ReturnBufferFunction((omx_base_PortType*)pClockPort,clockBuffer);
01231     }
01232 
01233     /* do not send the data to sink and return back, if the clock is not running*/
01234     if(!omx_fbdev_sink_component_Private->eState==OMX_TIME_ClockStateRunning){
01235       pInputBuffer->nFilledLen=0;
01236       return;
01237     }
01238   }
01239 
01240   OMX_COLOR_FORMATTYPE input_colorformat = pPort->sVideoParam.eColorFormat;
01241   OMX_S32 input_cpy_width = (OMX_S32) pPort->omxConfigCrop.nWidth;      //  Width (in columns) of the crop rectangle
01242   OMX_U32 input_cpy_height = pPort->omxConfigCrop.nHeight;          //  Height (in rows) of the crop rectangle
01243 
01244   OMX_U8* input_src_ptr = (OMX_U8*) (pInputBuffer->pBuffer);
01245   OMX_S32 input_src_stride = pPort->sPortParam.format.video.nStride;      //  Negative means bottom-to-top (think Windows bmp)
01246   OMX_U32 input_src_width = pPort->sPortParam.format.video.nFrameWidth;
01247   OMX_U32 input_src_height = pPort->sPortParam.format.video.nSliceHeight;
01248 
01253   OMX_S32 input_src_offset_x = pPort->omxConfigCrop.nLeft;    //  Offset (in columns) to left side of crop rectangle
01254   OMX_S32 input_src_offset_y = pPort->omxConfigCrop.nTop;    //  Offset (in rows) from top of the image to crop rectangle
01255 
01256   OMX_U8* input_dest_ptr = (OMX_U8*) omx_fbdev_sink_component_Private->scr_ptr + (omx_fbdev_sink_component_Private->fbstride * HEIGHT_OFFSET); 
01257   //OMX_U8* input_dest_ptr = (OMX_U8*) omx_fbdev_sink_component_Private->scr_ptr; 
01258   OMX_S32 input_dest_stride = (input_src_stride < 0) ? -1 * omx_fbdev_sink_component_Private->fbstride : omx_fbdev_sink_component_Private->fbstride;
01259 
01260       
01261   if (pPort->omxConfigMirror.eMirror == OMX_MirrorVertical || pPort->omxConfigMirror.eMirror == OMX_MirrorBoth) {
01262     input_dest_stride *= -1;
01263   }
01264 
01265   OMX_U32 input_dest_width = omx_fbdev_sink_component_Private->fbwidth;
01266   OMX_U32 input_dest_height = omx_fbdev_sink_component_Private->fbheight;
01267 
01268   OMX_U32 input_dest_offset_x = pPort->omxConfigOutputPosition.nX;
01269   OMX_U32 input_dest_offset_y = pPort->omxConfigOutputPosition.nY;
01270 
01272   new_time = GetTime();
01273   if(old_time == 0) {
01274     old_time = new_time;
01275   } else {
01276     timediff = nFrameProcessTime - ((new_time - old_time) * 1000);
01277     if(timediff>0) {
01278       usleep(timediff);
01279     }
01280     old_time = GetTime();
01281   }
01282 
01283 
01285   omx_img_copy(input_src_ptr, input_src_stride, input_src_width, input_src_height, 
01286                input_src_offset_x, input_src_offset_y,
01287                input_dest_ptr, input_dest_stride, input_dest_width, input_dest_height, 
01288                input_dest_offset_x, input_dest_offset_y,
01289                input_cpy_width, input_cpy_height, input_colorformat,omx_fbdev_sink_component_Private->fbpxlfmt);
01290   pInputBuffer->nFilledLen = 0;
01291 }
01292 
01293 
01294 OMX_ERRORTYPE omx_fbdev_sink_component_SetConfig(
01295   OMX_IN  OMX_HANDLETYPE hComponent,
01296   OMX_IN  OMX_INDEXTYPE nIndex,
01297   OMX_IN  OMX_PTR pComponentConfigStructure) {
01298 
01299   OMX_ERRORTYPE err = OMX_ErrorNone;
01300   OMX_U32 portIndex;
01301   OMX_CONFIG_RECTTYPE *omxConfigCrop;
01302   OMX_CONFIG_ROTATIONTYPE *omxConfigRotate;
01303   OMX_CONFIG_MIRRORTYPE *omxConfigMirror;
01304   OMX_CONFIG_SCALEFACTORTYPE *omxConfigScale;
01305   OMX_CONFIG_POINTTYPE *omxConfigOutputPosition;
01306 
01307   /* Check which structure we are being fed and make control its header */
01308   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
01309   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
01310   omx_fbdev_sink_component_PortType *pPort;
01311   if (pComponentConfigStructure == NULL) {
01312     return OMX_ErrorBadParameter;
01313   }
01314 
01315   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Setting parameter %i\n", nIndex);
01316 
01317   switch (nIndex) {
01318     case OMX_IndexConfigCommonInputCrop:
01319       omxConfigCrop = (OMX_CONFIG_RECTTYPE*)pComponentConfigStructure;
01320       portIndex = omxConfigCrop->nPortIndex;
01321       if ((err = checkHeader(pComponentConfigStructure, sizeof(OMX_CONFIG_RECTTYPE))) != OMX_ErrorNone) { 
01322         break;
01323       }
01324       if (portIndex == OMX_BASE_SINK_INPUTPORT_INDEX) {
01325         pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01326         pPort->omxConfigCrop.nLeft = omxConfigCrop->nLeft;
01327         pPort->omxConfigCrop.nTop = omxConfigCrop->nTop;
01328         pPort->omxConfigCrop.nWidth = omxConfigCrop->nWidth;
01329         pPort->omxConfigCrop.nHeight = omxConfigCrop->nHeight;
01330       } else {
01331         return OMX_ErrorBadPortIndex;
01332       }
01333       break;
01334     case OMX_IndexConfigCommonRotate:
01335       omxConfigRotate = (OMX_CONFIG_ROTATIONTYPE*)pComponentConfigStructure;
01336       portIndex = omxConfigRotate->nPortIndex;
01337       if ((err = checkHeader(pComponentConfigStructure, sizeof(OMX_CONFIG_ROTATIONTYPE))) != OMX_ErrorNone) { 
01338         break;
01339       }
01340       if (portIndex == 0) {
01341         pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01342         if (omxConfigRotate->nRotation != 0) {
01343           //  Rotation not supported (yet)
01344           return OMX_ErrorUnsupportedSetting;
01345         }
01346         pPort->omxConfigRotate.nRotation = omxConfigRotate->nRotation;
01347       } else {
01348         return OMX_ErrorBadPortIndex;
01349       }
01350       break;
01351     case OMX_IndexConfigCommonMirror:
01352       omxConfigMirror = (OMX_CONFIG_MIRRORTYPE*)pComponentConfigStructure;
01353       portIndex = omxConfigMirror->nPortIndex;
01354       if ((err = checkHeader(pComponentConfigStructure, sizeof(OMX_CONFIG_MIRRORTYPE))) != OMX_ErrorNone) { 
01355         break;
01356       }
01357       if (portIndex == 0) {
01358         if (omxConfigMirror->eMirror == OMX_MirrorBoth || omxConfigMirror->eMirror == OMX_MirrorHorizontal)  {
01359           //  Horizontal mirroring not yet supported
01360           return OMX_ErrorUnsupportedSetting;
01361         }
01362         pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01363         pPort->omxConfigMirror.eMirror = omxConfigMirror->eMirror;
01364       } else {
01365         return OMX_ErrorBadPortIndex;
01366       }
01367       break;
01368     case OMX_IndexConfigCommonScale:
01369       omxConfigScale = (OMX_CONFIG_SCALEFACTORTYPE*)pComponentConfigStructure;
01370       portIndex = omxConfigScale->nPortIndex;
01371       if ((err = checkHeader(pComponentConfigStructure, sizeof(OMX_CONFIG_SCALEFACTORTYPE))) != OMX_ErrorNone) { 
01372         break;
01373       }
01374       if (portIndex == 0) {
01375         if (omxConfigScale->xWidth != 0x10000 || omxConfigScale->xHeight != 0x10000)  {
01376           //  Scaling not yet supported
01377           return OMX_ErrorUnsupportedSetting;
01378         }
01379         pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01380         pPort->omxConfigScale.xWidth = omxConfigScale->xWidth;
01381         pPort->omxConfigScale.xHeight = omxConfigScale->xHeight;
01382       } else {
01383         return OMX_ErrorBadPortIndex;
01384       }
01385       break;
01386     case OMX_IndexConfigCommonOutputPosition:
01387       omxConfigOutputPosition = (OMX_CONFIG_POINTTYPE*)pComponentConfigStructure;
01388       portIndex = omxConfigOutputPosition->nPortIndex;
01389       if ((err = checkHeader(pComponentConfigStructure, sizeof(OMX_CONFIG_POINTTYPE))) != OMX_ErrorNone) { 
01390         break;
01391       }
01392       if (portIndex == 0) {
01393         pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01394         pPort->omxConfigOutputPosition.nX = omxConfigOutputPosition->nX;
01395         pPort->omxConfigOutputPosition.nY = omxConfigOutputPosition->nY;
01396       } else {
01397         return OMX_ErrorBadPortIndex;
01398       }
01399       break;
01400     default: // delegate to superclass
01401       return omx_base_component_SetConfig(hComponent, nIndex, pComponentConfigStructure);
01402   }
01403   return err;
01404 }
01405 
01406 
01407 
01408 OMX_ERRORTYPE omx_fbdev_sink_component_GetConfig(
01409   OMX_IN  OMX_HANDLETYPE hComponent,
01410   OMX_IN  OMX_INDEXTYPE nIndex,
01411   OMX_INOUT OMX_PTR pComponentConfigStructure) {
01412 
01413   OMX_CONFIG_RECTTYPE *omxConfigCrop;
01414   OMX_CONFIG_ROTATIONTYPE *omxConfigRotate;
01415   OMX_CONFIG_MIRRORTYPE *omxConfigMirror;
01416   OMX_CONFIG_SCALEFACTORTYPE *omxConfigScale;
01417   OMX_CONFIG_POINTTYPE *omxConfigOutputPosition;
01418 
01419   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
01420   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
01421   omx_fbdev_sink_component_PortType *pPort;
01422   if (pComponentConfigStructure == NULL) {
01423     return OMX_ErrorBadParameter;
01424   }
01425   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Getting configuration %i\n", nIndex);
01426   /* Check which structure we are being fed and fill its header */
01427   switch (nIndex) {
01428     case OMX_IndexConfigCommonInputCrop:
01429       omxConfigCrop = (OMX_CONFIG_RECTTYPE*)pComponentConfigStructure;
01430       setHeader(omxConfigCrop, sizeof(OMX_CONFIG_RECTTYPE));
01431       if (omxConfigCrop->nPortIndex == 0) {
01432         pPort = (omx_fbdev_sink_component_PortType *)omx_fbdev_sink_component_Private->ports[omxConfigCrop->nPortIndex];
01433         memcpy(omxConfigCrop, &pPort->omxConfigCrop, sizeof(OMX_CONFIG_RECTTYPE));
01434       } else {
01435         return OMX_ErrorBadPortIndex;
01436       }
01437     break;    
01438     case OMX_IndexConfigCommonRotate:
01439       omxConfigRotate = (OMX_CONFIG_ROTATIONTYPE*)pComponentConfigStructure;
01440       setHeader(omxConfigRotate, sizeof(OMX_CONFIG_ROTATIONTYPE));
01441       if (omxConfigRotate->nPortIndex == 0) {
01442         pPort = (omx_fbdev_sink_component_PortType *)omx_fbdev_sink_component_Private->ports[omxConfigRotate->nPortIndex];
01443         memcpy(omxConfigRotate, &pPort->omxConfigRotate, sizeof(OMX_CONFIG_ROTATIONTYPE));
01444       } else {
01445         return OMX_ErrorBadPortIndex;
01446       }
01447       break;    
01448     case OMX_IndexConfigCommonMirror:
01449       omxConfigMirror = (OMX_CONFIG_MIRRORTYPE*)pComponentConfigStructure;
01450       setHeader(omxConfigMirror, sizeof(OMX_CONFIG_MIRRORTYPE));
01451       if (omxConfigMirror->nPortIndex == 0) {
01452         pPort = (omx_fbdev_sink_component_PortType *)omx_fbdev_sink_component_Private->ports[omxConfigMirror->nPortIndex];
01453         memcpy(omxConfigMirror, &pPort->omxConfigMirror, sizeof(OMX_CONFIG_MIRRORTYPE));
01454       } else {
01455         return OMX_ErrorBadPortIndex;
01456       }
01457       break;      
01458     case OMX_IndexConfigCommonScale:
01459       omxConfigScale = (OMX_CONFIG_SCALEFACTORTYPE*)pComponentConfigStructure;
01460       setHeader(omxConfigScale, sizeof(OMX_CONFIG_SCALEFACTORTYPE));
01461       if (omxConfigScale->nPortIndex == 0) {
01462         pPort = (omx_fbdev_sink_component_PortType *)omx_fbdev_sink_component_Private->ports[omxConfigScale->nPortIndex];
01463         memcpy(omxConfigScale, &pPort->omxConfigScale, sizeof(OMX_CONFIG_SCALEFACTORTYPE));
01464       } else {
01465         return OMX_ErrorBadPortIndex;
01466       }
01467       break;    
01468     case OMX_IndexConfigCommonOutputPosition:
01469       omxConfigOutputPosition = (OMX_CONFIG_POINTTYPE*)pComponentConfigStructure;
01470       setHeader(omxConfigOutputPosition, sizeof(OMX_CONFIG_POINTTYPE));
01471       if (omxConfigOutputPosition->nPortIndex == 0) {
01472         pPort = (omx_fbdev_sink_component_PortType *)omx_fbdev_sink_component_Private->ports[omxConfigOutputPosition->nPortIndex];
01473         memcpy(omxConfigOutputPosition, &pPort->omxConfigOutputPosition, sizeof(OMX_CONFIG_POINTTYPE));
01474       } else {
01475         return OMX_ErrorBadPortIndex;
01476       }
01477       break;    
01478     default: // delegate to superclass
01479       return omx_base_component_GetConfig(hComponent, nIndex, pComponentConfigStructure);
01480   }
01481   return OMX_ErrorNone;
01482 }
01483 
01484 
01485 
01486 OMX_ERRORTYPE omx_fbdev_sink_component_SetParameter(
01487   OMX_IN  OMX_HANDLETYPE hComponent,
01488   OMX_IN  OMX_INDEXTYPE nParamIndex,
01489   OMX_IN  OMX_PTR ComponentParameterStructure) {
01490 
01491   OMX_ERRORTYPE err = OMX_ErrorNone;
01492   OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
01493   OMX_VIDEO_PARAM_PORTFORMATTYPE *pVideoPortFormat;
01494   OMX_OTHER_PARAM_PORTFORMATTYPE *pOtherPortFormat;
01495   OMX_U32 portIndex;
01496 
01497   /* Check which structure we are being fed and make control its header */
01498   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
01499   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
01500   omx_fbdev_sink_component_PortType *pPort;
01501   omx_base_clock_PortType *pClockPort;
01502   if (ComponentParameterStructure == NULL) {
01503     return OMX_ErrorBadParameter;
01504   }
01505 
01506   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Setting parameter %i\n", nParamIndex);
01507   switch(nParamIndex) {
01508      case OMX_IndexParamPortDefinition:
01509       pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
01510       portIndex = pPortDef->nPortIndex;
01511       err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
01512       if(err!=OMX_ErrorNone) { 
01513         DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
01514         break;
01515       }
01516       
01517       if(portIndex > (omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts + 
01518                       omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01519         return OMX_ErrorBadPortIndex;
01520       }
01521 
01522       if(portIndex == 0) {
01523 
01524         pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01525       
01526         pPort->sPortParam.nBufferCountActual = pPortDef->nBufferCountActual;
01527         //  Copy stuff from OMX_VIDEO_PORTDEFINITIONTYPE structure
01528         if(pPortDef->format.video.cMIMEType != NULL) {
01529           strcpy(pPort->sPortParam.format.video.cMIMEType , pPortDef->format.video.cMIMEType);
01530         }
01531         pPort->sPortParam.format.video.nFrameWidth = pPortDef->format.video.nFrameWidth;
01532         pPort->sPortParam.format.video.nFrameHeight = pPortDef->format.video.nFrameHeight;
01533         pPort->sPortParam.format.video.nBitrate = pPortDef->format.video.nBitrate;
01534         pPort->sPortParam.format.video.xFramerate = pPortDef->format.video.xFramerate;
01535         pPort->sPortParam.format.video.bFlagErrorConcealment = pPortDef->format.video.bFlagErrorConcealment;  
01536 
01537         //  Figure out stride, slice height, min buffer size
01538         pPort->sPortParam.format.video.nStride = calcStride(pPort->sPortParam.format.video.nFrameWidth, pPort->sVideoParam.eColorFormat);
01539         pPort->sPortParam.format.video.nSliceHeight = pPort->sPortParam.format.video.nFrameHeight;  //  No support for slices yet
01540         // Read-only field by spec
01541 
01542         pPort->sPortParam.nBufferSize = (OMX_U32) abs(pPort->sPortParam.format.video.nStride) * pPort->sPortParam.format.video.nSliceHeight;
01543         pPort->omxConfigCrop.nWidth = pPort->sPortParam.format.video.nFrameWidth;
01544         pPort->omxConfigCrop.nHeight = pPort->sPortParam.format.video.nFrameHeight;
01545       } else {
01546         pClockPort = (omx_base_clock_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01547 
01548         pClockPort->sPortParam.nBufferCountActual = pPortDef->nBufferCountActual;
01549         pClockPort->sPortParam.format.other.eFormat = pPortDef->format.other.eFormat;
01550       }
01551       break;
01552 
01553     case OMX_IndexParamVideoPortFormat:
01554       //  FIXME: How do we handle the nIndex member?
01555       pVideoPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
01556       portIndex = pVideoPortFormat->nPortIndex;
01557       err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pVideoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
01558       if(err!=OMX_ErrorNone) { 
01559         DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
01560         break;
01561       }
01562       pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01563       if(portIndex != 0) {
01564         return OMX_ErrorBadPortIndex;
01565       }
01566       if (pVideoPortFormat->eCompressionFormat != OMX_VIDEO_CodingUnused)  {
01567         //  No compression allowed
01568         return OMX_ErrorUnsupportedSetting;
01569       }
01570 
01571       if(pVideoPortFormat->xFramerate > 0) {
01572         nFrameProcessTime = 1000000 / pVideoPortFormat->xFramerate;
01573       }
01574       pPort->sVideoParam.xFramerate = pVideoPortFormat->xFramerate;
01575       pPort->sVideoParam.eCompressionFormat = pVideoPortFormat->eCompressionFormat;
01576       pPort->sVideoParam.eColorFormat = pVideoPortFormat->eColorFormat;
01577       //  Figure out stride, slice height, min buffer size
01578       pPort->sPortParam.format.video.nStride = calcStride(pPort->sPortParam.format.video.nFrameWidth, pPort->sVideoParam.eColorFormat);
01579       pPort->sPortParam.format.video.nSliceHeight = pPort->sPortParam.format.video.nFrameHeight;  //  No support for slices yet
01580       break;
01581     case  OMX_IndexParamOtherPortFormat:
01582       pOtherPortFormat = (OMX_OTHER_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
01583       portIndex = pOtherPortFormat->nPortIndex;
01584       err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pOtherPortFormat, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE));
01585       if(err!=OMX_ErrorNone) { 
01586         DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
01587         break;
01588       }
01589       if(portIndex != 1) {
01590         return OMX_ErrorBadPortIndex;
01591       }
01592       pClockPort = (omx_base_clock_PortType *) omx_fbdev_sink_component_Private->ports[portIndex];
01593 
01594       pClockPort->sOtherParam.eFormat = pOtherPortFormat->eFormat;
01595       break;
01596 
01597     default: /*Call the base component function*/
01598       return omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
01599   }
01600   return err;
01601 }
01602 
01603 
01604 OMX_ERRORTYPE omx_fbdev_sink_component_GetParameter(
01605   OMX_IN  OMX_HANDLETYPE hComponent,
01606   OMX_IN  OMX_INDEXTYPE nParamIndex,
01607   OMX_INOUT OMX_PTR ComponentParameterStructure) {
01608 
01609   OMX_VIDEO_PARAM_PORTFORMATTYPE *pVideoPortFormat; 
01610   OMX_OTHER_PARAM_PORTFORMATTYPE *pOtherPortFormat;
01611   OMX_ERRORTYPE err = OMX_ErrorNone;
01612   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
01613   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = openmaxStandComp->pComponentPrivate;
01614   omx_fbdev_sink_component_PortType *pPort = (omx_fbdev_sink_component_PortType *) omx_fbdev_sink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];  
01615   omx_base_clock_PortType *pClockPort = (omx_base_clock_PortType *) omx_fbdev_sink_component_Private->ports[1];
01616   if (ComponentParameterStructure == NULL) {
01617     return OMX_ErrorBadParameter;
01618   }
01619   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Getting parameter %i\n", nParamIndex);
01620   /* Check which structure we are being fed and fill its header */
01621   switch(nParamIndex) {
01622     case OMX_IndexParamVideoInit:
01623       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) { 
01624         break;
01625       }
01626       memcpy(ComponentParameterStructure, &omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainVideo], sizeof(OMX_PORT_PARAM_TYPE));
01627       break;    
01628     case OMX_IndexParamOtherInit:
01629       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) { 
01630         break;
01631       }
01632       memcpy(ComponentParameterStructure, &omx_fbdev_sink_component_Private->sPortTypesParam[OMX_PortDomainOther], sizeof(OMX_PORT_PARAM_TYPE));
01633       break;
01634     case OMX_IndexParamVideoPortFormat:
01635       pVideoPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
01636       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) { 
01637         break;
01638       }
01639       if (pVideoPortFormat->nPortIndex < 1) {
01640         memcpy(pVideoPortFormat, &pPort->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
01641       } else {
01642         return OMX_ErrorBadPortIndex;
01643       }
01644       break;  
01645     case  OMX_IndexParamOtherPortFormat:
01646 
01647       pOtherPortFormat = (OMX_OTHER_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
01648 
01649       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) { 
01650         break;
01651       }
01652       if (pOtherPortFormat->nPortIndex == 1) {
01653         memcpy(pOtherPortFormat, &pClockPort->sOtherParam, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE));
01654       } else {
01655         return OMX_ErrorBadPortIndex;
01656       }
01657       break;
01658       
01659     default: /*Call the base component function*/
01660       return omx_base_component_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
01661   }
01662   return err;
01663 }
01664 
01665 
01666 OMX_ERRORTYPE omx_fbdev_sink_component_MessageHandler(OMX_COMPONENTTYPE* openmaxStandComp,internalRequestMessageType *message) {
01667 
01668   omx_fbdev_sink_component_PrivateType* omx_fbdev_sink_component_Private = (omx_fbdev_sink_component_PrivateType*)openmaxStandComp->pComponentPrivate;
01669   OMX_ERRORTYPE err;
01670   OMX_STATETYPE eState;
01671 
01672   DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s\n", __func__);
01673   eState = omx_fbdev_sink_component_Private->state; //storing current state
01674 
01675   if (message->messageType == OMX_CommandStateSet){
01676     if ((message->messageParam == OMX_StateExecuting ) && (omx_fbdev_sink_component_Private->state == OMX_StateIdle)) {
01677       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s sink component from loaded to idle \n", __func__);
01678       err = omx_fbdev_sink_component_Init(openmaxStandComp);
01679       if(err!=OMX_ErrorNone) { 
01680         DEBUG(DEB_LEV_ERR, "In %s Video Sink Init Failed Error=%x\n",__func__,err); 
01681         return err;
01682       }
01683     } 
01684   }
01685   // Execute the base message handling
01686   err = omx_base_component_MessageHandler(openmaxStandComp,message);
01687 
01688   if (message->messageType == OMX_CommandStateSet) {
01689     if ((message->messageParam == OMX_StateIdle ) && (omx_fbdev_sink_component_Private->state == OMX_StateIdle) && eState == OMX_StateExecuting) {
01690       err = omx_fbdev_sink_component_Deinit(openmaxStandComp);
01691       if(err!=OMX_ErrorNone) { 
01692         DEBUG(DEB_LEV_ERR, "In %s Video Sink Deinit Failed Error=%x\n",__func__,err); 
01693         return err;
01694       }
01695     }
01696   }
01697   return err;
01698 }

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