开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
kb_machblue_core_surface.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：13k
源码类别：

DVD

开发平台：

C/C++

kb_machblue_core_surface.c：源码内容
  1. //*****************************************************************************
  2. //File Name: kb_machblue_core_surface.c
  3. //
  4. //Description: surface function
  5. //
  6. // used by Machblue to access the platform's surface api
  7. //
  8. //Author: steven
  9. //
  10. //Date:  2006.12.29
  11. //
  12. //Version:  v1.0
  13. //*****************************************************************************
  15. #include "osd.h"
  16. #include "stddefs.h"
  17. #include "stlayer.h"
  18. #include "layer.h"
  19. #include "stblit.h"
  20. #include "avmem.h"
  21. #include "evt.h"
  23. #include "machblue_defines.h"
  24. #include "machblue_porting_core.h"
  26. #include "kb_machblue_client.h"
  27. #include "kb_machblue_client_define.h"
  30. #define PIXEL_FORMAT_CLUT8     0     // Palettized Clut8 rendering (ex: as seen on OpenTV/DCT)
  31. #define PIXEL_FORMAT_RGB565    1     // RGB565 rendering  (ex: as seen on PTV)
  32. #define PIXEL_FORMAT_RGBA4444  2     // RGBA4444 renderring (ex: as seen on ST7100 for NDS)
  33. #define PIXEL_FORMAT_RGBA8888  3     // RGBA4444 renderring (ex: as seen on ST7100 for OpenTV)
  35. #define PIXEL_FORMAT  PIXEL_FORMAT_RGBA4444
  36. #define AVMEM1_SIZE 720*576*2
  37. #define MEM_PARTITION_HANDLE_COUNT 10
  42. /**
  43.  * Creates a new surface.
  45.  * surface < pointer to surface to create >
  46.  * width < width of the surface to create >
  47.  * height < height of the surface to create >
  48.  * format     < pixel format of the surface to create >
  49.  
  50.  * @return MB_SUCCESS and updates "surface" on success, MB_FAILURE otherwise.
  51.  */
  52. mb_error_t mb_surface_create(mb_surface_t *surface,int width,int height,mb_pixel_format_t format)
  53. {
  54.    ST_ErrorCode_t  ErrCode=ST_NO_ERROR;
  55.    STGXOBJ_BitmapAllocParams_t  BitmapParams1,BitmapParams2;
  56.    STAVMEM_MemoryRange_t  RangeArea[2]; 
  57.    U8  NbForbiddenRange; 
  58.    STAVMEM_AllocBlockParams_t  AllocParams;
  59. kb_movie_surface_t  *p_surface;
  61.    *surface=NULL;
  62.    p_surface=(kb_movie_surface_t*)mb_malloc(sizeof(kb_movie_surface_t));
  63.    if(p_surface==NULL)
  64.      {
  65.      mb_printf("n[Machblue]:Surface create malloc error.");
  66.        return MB_FAILURE ;
  67.      }
  68.    p_surface->m_width=width;
  69.    p_surface->m_height=height;
  70.    p_surface->m_format=format;
  72. #if (PIXEL_FORMAT==PIXEL_FORMAT_RGB565)
  73. p_surface->m_bitmap.ColorType=STGXOBJ_COLOR_TYPE_RGB565;
  74. p_surface->m_bitmap.PreMultipliedColor=FALSE;
  75. #elif (PIXEL_FORMAT==PIXEL_FORMAT_RGBA8888)
  76. p_surface->m_bitmap.ColorType=STGXOBJ_COLOR_TYPE_ARGB8888;
  77. p_surface->m_bitmap.PreMultipliedColor=FALSE;
  78. #elif (PIXEL_FORMAT==PIXEL_FORMAT_RGBA4444)
  79. p_surface->m_bitmap.ColorType=STGXOBJ_COLOR_TYPE_ARGB4444;
  80. p_surface->m_bitmap.PreMultipliedColor=FALSE;
  81. #else
  82. #error "PIXEL_FORMAT not supported"
  83. #endif
  85.    p_surface->m_bitmap.BitmapType=STGXOBJ_BITMAP_TYPE_RASTER_PROGRESSIVE;
  86.    p_surface->m_bitmap.ColorSpaceConversion=STGXOBJ_ITU_R_BT601;
  87.    p_surface->m_bitmap.AspectRatio=STGXOBJ_ASPECT_RATIO_4TO3;
  88.    p_surface->m_bitmap.Width=width;
  89.    p_surface->m_bitmap.Height=height; 
  91. #if (PIXEL_FORMAT==PIXEL_FORMAT_RGB565)
  92.    p_surface->m_bitmap.SubByteFormat=STGXOBJ_SUBBYTE_FORMAT_RPIX_LSB;
  93. #elif (PIXEL_FORMAT==PIXEL_FORMAT_RGBA8888)
  94.    p_surface->m_bitmap.SubByteFormat=STGXOBJ_SUBBYTE_FORMAT_RPIX_MSB;
  95. #elif (PIXEL_FORMAT==PIXEL_FORMAT_RGBA4444)
  96.    p_surface->m_bitmap.SubByteFormat=STGXOBJ_SUBBYTE_FORMAT_RPIX_MSB;
  97. #endif
  99.    p_surface->m_bitmap.BigNotLittle=0; 
  101. #define VIRTUAL_BASE_ADDRESS        0xA0000000
  102. #define VIRTUAL_SIZE                        AVMEM1_SIZE
  103. #define VIRTUAL_WINDOW_SIZE            AVMEM1_SIZE
  104. #define LAYER_OSD                           1
  106.    ErrCode=STLAYER_GetBitmapAllocParams(g_KB_LayerHandle[LAYER_OSD],&p_surface->m_bitmap,&BitmapParams1,&BitmapParams2);
  107.    if (ErrCode!=ST_NO_ERROR)
  108.      {
  109.        mb_printf("n[Machblue]:Surface create get bmp alloc params error.");
  110.        return MB_FAILURE;
  111.      }
  112.    /* Memory allocation for bitmap */  
  113.    NbForbiddenRange=1; 
  114.    RangeArea[0].StartAddr_p=(void *)VIRTUAL_BASE_ADDRESS;
  115.    RangeArea[0].StopAddr_p=(void *)RangeArea[0].StartAddr_p;
  116.    if((VIRTUAL_BASE_ADDRESS+VIRTUAL_WINDOW_SIZE)!=VIRTUAL_SIZE)
  117.      {
  118.        RangeArea[1].StartAddr_p=(void *)((U32)(RangeArea[0].StartAddr_p)+(U32)(0)+(U32)(VIRTUAL_WINDOW_SIZE));
  119.   RangeArea[1].StopAddr_p=(void *)((U32)(VIRTUAL_BASE_ADDRESS)+(U32)(VIRTUAL_SIZE)-1);
  120.        NbForbiddenRange=2;
  121.      }
  122.  
  123.    AllocParams.PartitionHandle=g_KBAvmemPartitionHandle[0];
  124.    AllocParams.ForbiddenBorderArray_p=(void **)NULL; 
  125.    AllocParams.AllocMode=STAVMEM_ALLOC_MODE_BOTTOM_TOP;
  126.    AllocParams.NumberOfForbiddenRanges=NbForbiddenRange;
  127.    AllocParams.ForbiddenRangeArray_p=&RangeArea[0];
  128.    AllocParams.NumberOfForbiddenBorders=0;
  129.    AllocParams.Size=BitmapParams1.AllocBlockParams.Size;
  130.    AllocParams.Alignment=16;
  132.    p_surface->m_bitmap.Pitch=BitmapParams1.Pitch;
  133.    p_surface->m_bitmap.Offset=BitmapParams1.Offset;
  134.    p_surface->m_bitmap.Data1_p=NULL;
  135.    p_surface->m_bitmap.Size1=AllocParams.Size;
  136.    p_surface->m_bitmap.Data2_p=NULL;
  137.    p_surface->m_bitmap.Size2=0;
  139.   p_surface->m_bitmap.Data1_p=mb_malloc(AllocParams.Size);
  141.    *surface=(mb_surface_t)p_surface;
  142.    return MB_SUCCESS ;
  143. }
  147. /**
  148.  * Deletes a surface.
  150.  * surface   < surface to delete >
  151.  
  152.  * @return MB_SUCCESS on success and MB_FAILURE on failure.
  153.  */
  154. mb_error_t mb_surface_delete(mb_surface_t surface)
  155. {
  156. kb_movie_surface_t  *pSurface=(kb_movie_surface_t *)surface;
  158. if(pSurface==NULL)
  159. {
  160. mb_printf("nmb_surface_delete surface NULL.");
  161. return MB_FAILURE;
  162. }
  164. mb_free((void*)pSurface->m_bitmap.Data1_p);
  165.    mb_free((void*)pSurface);
  167.    return MB_SUCCESS;
  168. }
  172. /**
  173.  * Get the pixel size in bytes.
  175.  * format < pixel format >
  176.  
  177.  * @return the pixel bytes success, -1 on failure.
  178.  */
  179. int mb_surface_pixel_bytes(mb_pixel_format_t format)
  180. {
  181. int bytes=-1;
  183.     switch(format)
  184.     {
  185.        case MB_CLUT8_FORMAT:
  186.           bytes=1;
  187. break;
  189.        case MB_ARGB4444_FORMAT:
  190.        case MB_ARGB1555_FORMAT:
  191.        case MB_RGB565_FORMAT:
  192.           bytes=2;
  193. break;
  195.        case MB_ARGB8888_FORMAT:
  196.          bytes=4;
  197. break;
  198.     }
  200.     return bytes;
  201. }
  205. /**
  206.  * Computes the amount of memory that would be required to create a surface
  207.  * with the provided attributes. size_req is updated with the amount of memory 
  208.  * required in case of success.
  210.  * width  < width of the surface to estimate >
  211.  * height  < height of the surface to estimate >
  212.  * format  < pixel format of the surface to estimate >
  213.  * size_req   < pointer to location to store size requirements >
  214.  
  215.  * @return MB_SUCCESS and MB_FAILURE on failure.
  216.  */
  217. mb_error_t mb_surface_requirement_get(int width,int height,mb_pixel_format_t format,mb_size_t *size_req)
  218. {
  219. int pixSize;
  221. if(size_req==NULL)
  222. {
  223. mb_printf("nmb_surface_requirement_get size NULL.");
  224. return MB_FAILURE;
  225. }
  227. pixSize=mb_surface_pixel_bytes(format);
  228. if(pixSize<0)
  229. {
  230. mb_printf("n[Machblue]:Surface requirement get error.");
  231. return MB_FAILURE;
  232. }
  234.     *size_req=width*height*pixSize;
  236.     return  MB_SUCCESS ;
  237. }
  240. /**
  241.  * Queries the attributes of a surface.
  243.  * surface < surface to query >
  244.  * width < pointer to location to store the width of the surface >
  245.  * height < pointer to location to store the height of the surface >
  246.  * format     < pointer to location to store the pixel format of the surface >
  247.  
  248.  * @return MB_SUCCESS and MB_FAILURE on failure.
  249.  */
  250. mb_error_t mb_surface_attributes_get(mb_surface_t surface,int *width,int *height,mb_pixel_format_t *format)
  251. {
  252. kb_movie_surface_t *pSurface=(kb_movie_surface_t *)surface;
  254.    if((pSurface==NULL)||(width==NULL)||(height==NULL)||(format==(mb_pixel_format_t*)NULL))
  255.      {
  256.      mb_printf("n[Machblue]:Surface attributes get error.");
  257.        return MB_FAILURE;
  258.      }
  260.    *width=pSurface->m_width;
  261.    *height=pSurface->m_height;
  262.    *format=pSurface->m_format;
  264.    return MB_SUCCESS;
  265. }
  269. /**
  270.  * Clears a surface.
  272.  * surface < surface to clear >
  273.  * rect < rectangle area to clear >
  274.  * color      < color in surface color format >
  275.  
  276.  * @return MB_SUCCESS on success and MB_FAILURE on failure.
  277.  */
  278. mb_error_t mb_surface_clear(mb_surface_t surface,mb_rect_t *rect,unsigned int  color)
  279. {
  280. kb_movie_surface_t  *pSurface=(kb_movie_surface_t *)surface;
  281. unsigned char  *pDest=pSurface->m_bitmap.Data1_p;
  282. unsigned long  index,desPitch;
  284. for (index=0;index<rect->height;index++)
  285. {
  286. desPitch=((rect->y+index)*pSurface->m_width+rect->x)*KB_OSD_BYTES;
  287. mb_memset(pDest+desPitch,0x00,rect->width*KB_OSD_BYTES);
  288. }     
  290. return MB_SUCCESS;
  291. }
  295. /**
  296.  * Locks a surface.
  298.  * surface < surface to lock >
  299.  * pitch < pointer to int to store surface pitch >
  300.  * locked_ptr < pointer to the location to store pointer to the locked surface buffer >
  301.  
  302.  * @return MB_SUCCESS and updates locked_ptr on success and MB_FAILURE on failure. 
  303.  * The pitch value is updated in case of success. 
  304.  */
  305. mb_error_t mb_surface_lock(mb_surface_t surface,int *pitch,void **locked_ptr)
  306. {
  307. kb_movie_surface_t *pSurface=(kb_movie_surface_t *)surface;
  309. if(pSurface==NULL)
  310. {
  311.      mb_printf("n[Machblue]:Surface lock error.");
  312.        return MB_FAILURE;
  313.      }
  315.    *pitch=pSurface->m_bitmap.Pitch;
  316.    *locked_ptr=pSurface->m_bitmap.Data1_p;
  318.    return MB_SUCCESS;
  319. }
  323. /**
  324.  * Unlocks a surface.
  326.  * surface   < surface to unlock >
  327.  
  328.  * @return MB_SUCCESS on success, MB_FAILURE on failure.
  329.  */
  330. mb_error_t mb_surface_unlock(mb_surface_t surface)
  331. {
  332. return MB_SUCCESS;
  333. }
  338. /**
  339.  * Blits a surface into another surface.
  341.  * dest_surface < destination surface >
  342.  * dest_rect < destination rectangle area to blit to >
  343.  * src_surface < source surface >
  344.  * src_rect < source rectangle area to blit from >
  345.  * options       < blit options >
  346.  
  347.  * @return MB_SUCCESS on success, MB_FAILURE on failure.
  348.  */
  349. mb_error_t mb_surface_blit(mb_surface_t dest_surface,mb_rect_t *dest_rect,mb_surface_t src_surface,mb_rect_t *src_rect,mb_blit_option_t options)
  350. {
  351. kb_movie_surface_t  *pSrcSurface=(kb_movie_surface_t *)src_surface;
  352. kb_movie_surface_t  *pDestSurface=(kb_movie_surface_t *)dest_surface;
  353. unsigned char  *pSrc=pSrcSurface->m_bitmap.Data1_p;
  354. unsigned char  *pDest=pDestSurface->m_bitmap.Data1_p;
  355. unsigned long  index,srcPitch,desPitch;
  357. for (index=0;index<src_rect->height;index++)
  358. {
  359. srcPitch=((src_rect->y+index)*pSrcSurface->m_width+src_rect->x)*KB_OSD_BYTES;
  360. desPitch=((dest_rect->y+index)*pDestSurface->m_width+dest_rect->x)*KB_OSD_BYTES;
  361. mb_memcpy(pDest+desPitch,pSrc+srcPitch,src_rect->width*KB_OSD_BYTES);
  362. }
  364. return MB_SUCCESS;
  365. }
  370. /**
  371.  * Copy data to display buf.
  373.  * pRect < rectangle parameter >
  374.  * pMemory < pointer to source data >
  375.  
  376.  * @return None.
  377.  */
  378. void mb_surface_osd_copy(mb_rect_t *pRect,void *pMemory)
  379. {    
  380. unsigned char *pSrc,*pDest;
  381. unsigned long index,srcPitch,desPitch;
  383. pSrc=(unsigned char*)pMemory;
  384. pDest=(unsigned char*)Bitmap[VPORT_OSD].Data1_p;
  386. for (index=0;index<pRect->height;index++)
  387. {
  388. srcPitch=index*KB_OSD_WIDTH*KB_OSD_BYTES;
  389. desPitch=((pRect->y+index)*KB_OSD_WIDTH+pRect->x)*KB_OSD_BYTES;
  390. mb_memcpy(pDest+desPitch,pSrc+srcPitch,pRect->width*KB_OSD_BYTES);
  391. }     
  392. }
  397. /**
  398.  * Clear display buf. 
  399.  * @return None.
  400.  */
  401. void mb_surface_osd_clear(void)
  402. {    
  403. unsigned char *pDest;
  405. pDest=(unsigned char*)Bitmap[VPORT_OSD].Data1_p;
  406. mb_memset(pDest,0x00,Bitmap[VPORT_OSD].Size1*KB_OSD_BYTES);
  407. }
  411. /**
  412.  * Callback of surface. 
  413.  * @return MB_SUCCESS on success, MB_FAILURE on failure.
  414.  */
  415. mb_error_t mb_surface_notify( mb_gfx_cb_reason_t reason, mb_args_t *args, void *client_data )
  416. {
  417. mb_rect_t  *dirtyRect;
  418. mb_surface_t  src_surface;
  419. unsigned char *bmpData;
  421.     switch(reason)
  422.     {
  423.        case MB_GFX_REDRAW_CB:
  424.           dirtyRect=(mb_rect_t *)MB_GFX_RECT_ARG(args);
  425.           src_surface=(mb_surface_t)MB_GFX_SURFACE_ARG(args);
  426.          
  427. bmpData=((kb_movie_surface_t*)src_surface)->m_bitmap.Data1_p;
  428. bmpData+=((dirtyRect->y*KB_OSD_WIDTH+dirtyRect->x)*2);
  430. mb_surface_osd_copy(dirtyRect,bmpData);
  432. break;
  434.        case MB_GFX_SET_PALETTE_CB:
  435. mb_printf("n[Machblue]:Surface graphics context set pallette notification.");
  436.        break;
  437.     }
  439.    return MB_SUCCESS;
  440. }
  445. /**
  446.  * Init graphics context which include the surface.
  448.  * format < pixel format >
  449.  
  450.  * @return MB_SUCCESS on success, MB_FAILURE on failure.
  451.  */
  452. mb_error_t mb_surface_graphics_init(mb_gfx_ctx_t *p_gfx_ctx, void *client_data)
  453. {
  454.     mb_pixel_format_t format;
  455.     switch(PIXEL_FORMAT)
  456.     {
  457.     case PIXEL_FORMAT_CLUT8:
  458.        format=MB_CLUT8_FORMAT;
  459.        break;
  460.     case PIXEL_FORMAT_RGB565:
  461.        format=MB_RGB565_FORMAT;
  462.        break;
  463.     case PIXEL_FORMAT_RGBA4444:
  464.        format=MB_ARGB4444_FORMAT;
  465.        break;
  466.     case PIXEL_FORMAT_RGBA8888:
  467.        format=MB_ARGB8888_FORMAT;
  468.        break;
  469.     default:
  470.        return MB_FAILURE;
  471.     }
  472.     //* Creates a new surface and return the surface pointer to be initialized.
  473.     if(mb_surface_create(&(p_gfx_ctx->surface),720,576,format)!=MB_SUCCESS)
  474.     {
  475.     mb_printf("n[Machblue]:Surface graphics init error.");
  476.        return MB_FAILURE;
  477.     }
  479.     p_gfx_ctx->bounds.x=0;
  480. p_gfx_ctx->bounds.y=0;
  481.     p_gfx_ctx->bounds.width=720;
  482.     p_gfx_ctx->bounds.height=576;
  483.     p_gfx_ctx->callback_f=mb_surface_notify;
  484.     p_gfx_ctx->cb_client_data=client_data;
  485.     return MB_SUCCESS;
  486. }