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;
00041
00043 static OMX_U32 nofbdev_sinkInstance=0;
00044
00046 #define MAX_COMPONENT_FBDEVSINK 2
00047
00048 #ifdef AV_SYNC_LOG
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
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;
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;
00148
00149 setHeader(&pPort->omxConfigMirror, sizeof(OMX_CONFIG_MIRRORTYPE));
00150 pPort->omxConfigMirror.nPortIndex = OMX_BASE_SINK_INPUTPORT_INDEX;
00151 pPort->omxConfigMirror.eMirror = OMX_MirrorNone;
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;
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;
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
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
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
00259 , omx_fbdev_sink_component_Private->vscr_info.yres
00260 , omx_fbdev_sink_component_Private->vscr_info.xres_virtual
00261 , omx_fbdev_sink_component_Private->vscr_info.yres_virtual
00262 , omx_fbdev_sink_component_Private->vscr_info.xoffset
00263 , omx_fbdev_sink_component_Private->vscr_info.yoffset
00264 , omx_fbdev_sink_component_Private->vscr_info.bits_per_pixel
00265 , omx_fbdev_sink_component_Private->vscr_info.grayscale
00266 , omx_fbdev_sink_component_Private->vscr_info.nonstd
00267 , omx_fbdev_sink_component_Private->vscr_info.height
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
00281
00282
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;
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;
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;
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;
00565 OMX_U32 src_luma_height;
00566 OMX_S32 src_luma_stride;
00567 OMX_U32 src_luma_offset_x;
00568 OMX_U32 src_luma_offset_y;
00569 OMX_U32 src_luma_offset;
00570
00571 OMX_U32 src_chroma_width;
00572 OMX_U32 src_chroma_height;
00573 OMX_S32 src_chroma_stride;
00574 OMX_U32 src_chroma_offset_x;
00575 OMX_U32 src_chroma_offset_y;
00576 OMX_U32 src_chroma_offset;
00577
00578 OMX_U32 dest_luma_width;
00579 OMX_U32 dest_luma_height;
00580 OMX_S32 dest_luma_stride;
00581 OMX_U32 dest_luma_offset_x;
00582 OMX_U32 dest_luma_offset_y;
00583 OMX_U32 dest_luma_offset;
00584
00585 OMX_U32 dest_chroma_width;
00586 OMX_U32 dest_chroma_height;
00587 OMX_S32 dest_chroma_stride;
00588 OMX_U32 dest_chroma_offset_x;
00589 OMX_U32 dest_chroma_offset_y;
00590 OMX_U32 dest_chroma_offset;
00591
00592 OMX_U32 luma_crop_width;
00593 OMX_U32 luma_crop_height;
00594 OMX_U32 chroma_crop_width;
00595 OMX_U32 chroma_crop_height;
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
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);
00762 }
00763
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);
00766 }
00767
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);
00770 }
00771 } else {
00772
00773 OMX_U32 cpy_byte_width = calcStride((OMX_U32) abs(cpy_width), colorformat);
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
00781 src_byte_offset_y += cpy_height * (OMX_U32) abs(src_stride);
00782 }
00783 if (dest_stride < 0) {
00784
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
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
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
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
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
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
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
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
00857 r = *(src_cpy_ptr + 0);
00858 g = *(src_cpy_ptr + 1);
00859 b = *(src_cpy_ptr + 2);
00860
00861 *(dest_cpy_ptr + 0) = b;
00862 *(dest_cpy_ptr + 1) = g;
00863 *(dest_cpy_ptr + 2) = r;
00864
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
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
00880 r = *(src_cpy_ptr + 0);
00881 g = *(src_cpy_ptr + 1);
00882 b = *(src_cpy_ptr + 2);
00883
00884 *(dest_cpy_ptr + 0) = b;
00885 *(dest_cpy_ptr + 1) = g;
00886 *(dest_cpy_ptr + 2) = r;
00887
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
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
00903 b = *(src_cpy_ptr + 0);
00904 g = *(src_cpy_ptr + 1);
00905 r = *(src_cpy_ptr + 2);
00906
00907 *(dest_cpy_ptr + 0) = b;
00908 *(dest_cpy_ptr + 1) = g;
00909 *(dest_cpy_ptr + 2) = r;
00910
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
00921 memcpy(dest_cpy_ptr, src_cpy_ptr, cpy_byte_width);
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
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
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);
00936 temp = temp_old;
00937 r = (OMX_U8) ((temp >> 10) & 0x001f);
00938 temp = temp_old;
00939 g = (OMX_U8) ((temp >> 5) & 0x001f);
00940 temp = temp_old;
00941 b = (OMX_U8) (temp & 0x001f);
00942 temp = temp_old;
00943
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
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
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);
00967 temp = temp_old;
00968 g = (OMX_U8) ((temp >> 5) & 0x003f);
00969 temp = temp_old;
00970 b = (OMX_U8) (temp & 0x001f);
00971 temp = temp_old;
00972
00973 *(dest_cpy_ptr + 0) = b<<3;
00974 *(dest_cpy_ptr + 1) = g<<2;
00975 *(dest_cpy_ptr + 2) = r<<3;
00976
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
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
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 {
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
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
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
01119
01120 if(omx_fbdev_sink_component_Private->frameDropFlag && omx_fbdev_sink_component_Private->dropFrameCount<7) {
01121 omx_fbdev_sink_component_Private->dropFrameCount ++;
01122 if(omx_fbdev_sink_component_Private->dropFrameCount==7) {
01123
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
01138
01139 }
01140
01141
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;
01147 pClockPort->sMediaTimeRequest.nPortIndex = pClockPort->nTunneledPort;
01148 pClockPort->sMediaTimeRequest.pClientPrivate = NULL;
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);
01155 clockBuffer = dequeue(pClockPort->pBufferQueue);
01156 pMediaTime = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
01157 if(pMediaTime->eUpdateType==OMX_TIME_UpdateScaleChanged) {
01158
01159 setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
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
01205
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
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);
01224
01225
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
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;
01242 OMX_U32 input_cpy_height = pPort->omxConfigCrop.nHeight;
01243
01244 OMX_U8* input_src_ptr = (OMX_U8*) (pInputBuffer->pBuffer);
01245 OMX_S32 input_src_stride = pPort->sPortParam.format.video.nStride;
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;
01254 OMX_S32 input_src_offset_y = pPort->omxConfigCrop.nTop;
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
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
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
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
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
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:
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
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:
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
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
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
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;
01540
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
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
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
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;
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:
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
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:
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;
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
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 }