source: svn/newcon3bcm2_21bu/dst/dmw/src/cc/cc_ddi_lg2500.c

#include "DHL_DBG.h"
#include "DHL_OSAL.h"
#include "DHL_OSAL_Config.h"

#include "cc_config.h"
#include "cc_def.h"
#include "cc_private.h"

#include "DMW_Dummy.h"

#include <stdarg.h> /* for va_list */
//#include <string.h>

#define MAX_NUM_PIC_UD_Q CC_NUM_PIC_USER_Q

#define IS_FONT_BMF (FONT_ID==FONT_BMF)

static tDCC_PicUDRaw p_ud_buf[MAX_NUM_PIC_UD_Q];

// zooyouny: »ç¿ëµÇ´Â °÷ ¾øÀ½
// static tDCCDDI_MSGQ p_ud_msgq;
static int p_ud_buf_wr_idx=0;
static tDCC_UserCallback p_ud_callback = NULL;

#include "DHL_Graphic.h"
#include "DHL_AVCAP.h"
//#include "DHL_AVCAP_Priv.h"
#include "DMG_Draw.h"

#if IS_FONT_JUNGLE
//.#include "utfAPI.h"
#elif IS_FONT_MLF
#include "MLSupport.h"
#elif IS_FONT_BMF
#include "BMF.h"
#endif


#if 0
__Local_Func__() {}
#endif


static void p_check_region(int x, int y, int w, int h)
{
        BOOL bvalid=((x>=0) && (y>=0) && (x+w<720) && (y+h<480));
        
        if(!bvalid) 
                CCPRINT("error", "! fatal error : region(%d,%d,%d,%d)\n", x, y, w, h);
        //DHL_ASSERT(bvalid, "!! FATAL ERROR : CC check region failed\n");
}



static UINT16 p_remap_char(UINT16 ch)
{
#if FONT_ID==FONT_BMF
        struct {
                UINT16 orig;
                UINT16 dst;
        } table[]={
                {0x520, 0x20},{0x521, 0x20},{0x522, 0x20},{0x525, 0x2026},
                {0x52a, 0x0160},{0x52c, 0x0152},{0x530, 0xb7},{0x531, 0x2018},
                {0x532, 0x2019},{0x533, 0x201c},{0x534, 0x201d},{0x535, 0x2022},
                {0x539, 0x2122},{0x53a, 0x0161},{0x53c, 0x0153},{0x53d, 0x2120},
                {0x53f, 0x0178},{0x576, 0x215b},{0x577, 0x215c},{0x578, 0x215d},
                {0x579, 0x215e},{0x57a, 0x2503},{0x57b, 0x2512},{0x57c, 0x2517},
                {0x57d, 0x2501},{0x57e, 0x251b},{0x57f, 0x250f},{0x5ff, 0x266a},
                {0x5a0, 0x1a0}
        };
        
        int i;
        
        for(i=0; i<sizeof(table)/sizeof(table[0]); i++) {
                if(ch==table[i].orig) return table[i].dst;
        }
        
        return ch;

#elif FONT_ID==FONT_JUNGLE
        //0x5xx´ë¸¦ 0x1xx´ë·Î ¿Å±è
        if((ch&0x500)==0x500)
                return ch&(~0x400);
        else
                return ch;

#endif
}

//static FILE *p_fd;


void *DCCDDI_Malloc(int size)
{
        return DHL_OS_Malloc(size);
}


void DCCDDI_Printf(const char *fmt, ...)
{
        char buf[512];
        va_list v;

        va_start(v, fmt);

        vsnprintf(buf, 512, fmt, v);

        va_end(v);

        DHL_OS_Printf("%s", buf);
}



void DCCDDI_SpawnTask(void *func)
{
        DHL_OS_CreateTask((DHL_OS_TASKFUNCTION)func, "CC", TASK_PRI_DCC_DMX, 16384, 0);
}


tDCCDDI_MSGQ DCCDDI_CreateMessageQueue(char *pname, UINT32 num_msgq, UINT32 size_msgq)
{
        return (tDCCDDI_MSGQ)DHL_OS_CreateMessageQueue(pname, 0, num_msgq, size_msgq);
}


tDCCDDI_SEM DCCDDI_CreateMutexSemaphore(char *pname)
{
        return (tDCCDDI_SEM)DHL_OS_CreateMutexSemaphore(pname);
}


tDCCDDI_SEM DCCDDI_CreateBinarySemaphore(char *pname)
{
        return (tDCCDDI_SEM)DHL_OS_CreateBinarySemaphore(pname, 0, 0);
}


void DCCDDI_SendMessage(tDCCDDI_MSGQ id, void *buf, UINT32 len)
{
        DHL_OS_SendMessage((DHL_OS_MSGQ_ID)id, buf);
}


int DCCDDI_ReceiveMessage(tDCCDDI_MSGQ id, void *buf, UINT32 max_len, int *rcv_len)
{
        return DHL_OS_ReceiveMessage((DHL_OS_MSGQ_ID)id, buf, DHL_TIMEOUT_FOREVER);
}


int DCCDDI_ReceiveMessage_Wait(tDCCDDI_MSGQ id, void *buf, UINT32 max_len, int *rcv_len, UINT32 msec)
{
        return DHL_OS_ReceiveMessage((DHL_OS_MSGQ_ID)id, buf, msec);
}

int DCCDDI_ReceiveMessage_NoWait(tDCCDDI_MSGQ id, void *buf, UINT32 max_len, int *rcv_len)
{
        return DHL_OS_ReceiveMessage((DHL_OS_MSGQ_ID)id, buf, 0);
}


void DCCDDI_TakeSemaphore(tDCCDDI_SEM id)
{
        DHL_OS_TakeSemaphore((DHL_OS_SEMA_ID)id, DHL_TIMEOUT_FOREVER);
}

void DCCDDI_GiveSemaphore(tDCCDDI_SEM id)
{
        DHL_OS_GiveSemaphore((DHL_OS_SEMA_ID)id);
}

void DCCDDI_Delay(UINT32 msec)
{
        DHL_OS_Delay(msec);
}

UINT32 DCCDDI_GetCurMs()
{
        return DHL_OS_GetMsCount();
}


#if 0
__Picture_User_Data__() {}
#endif

static BOOL p_check_cc_validity(UINT8 *buf, int *psize, int *ofs)
{
        int i;
        BOOL batsc=FALSE;
        BOOL bscte=FALSE;
        int size=*psize;
        
        //atsc identifier ȤÀº scte20ÀÇ 03ÀÌ ¿Í¾ßÇϴµ¥, ±×·¸Áö ¾ÊÀº °æ¿ìµµ ÀÖÀ½
        //±×·¸Áö ¾ÊÀº °æ¿ì¶ó¸é user_data_start_code¸¦ °Ë»öÇغÁ¾ß ÇÔ(0x000001b2)
        //atsc id
        
        for(i=0, *ofs=0; i<size-4; i++) {
                if(buf[i]==0x47 && buf[i+1]==0x41 && buf[i+2]==0x39 && buf[i+3]==0x34) {
                        batsc=TRUE;
                        *ofs=i;
                        size-=i;
                        break;
                }

#if 0   //¾Æ·¡ ÄÚµå´Â ÀÇ¹Ì ¾ø´Â ÄÚµåÀÓ..¿ÀÈ÷·Á ºÎÀÛ¿ëÀ» ÀÏÀ¸Å³ ¼ö ÀÖÀ¸¹Ç·Î
                        //¿¹¸¦ µé¾î 0x000001b2 ´ÙÀ½¿¡ ¹Ù·Î 0x47413934°¡ ¿À´Â °Ô ¾Æ´Ï¶ó
                        //Áß°£¿¡ ´Ù¸¥ ÄÚµå °ªÀÌ ¿Ã ¼ö ÀÖÀ½.
                if(i<size-8 && buf[i]==0x0 && buf[i+1]==0x0 && buf[i+2]==0x1 && buf[i+3]==0xb2) {
                        
                        if(buf[i+4]==0x47 && buf[i+5]==0x41 && buf[i+6]==0x39 && buf[i+7]==0x34)
                                batsc=TRUE;
                        else
                                bscte=TRUE;
                        *ofs=i+4;
                        size-=i+4;
                        break;
                }
#endif
        }
        
        if(!batsc && !bscte && buf[0]==0x3) bscte=TRUE; //¹Ù·Î 0x3ºÎÅÍ ³¯¶ó¿È.
        
        if(!batsc && !bscte) {
                CCPRINT("ddi", "bad cc data\n");
                return FALSE;
        }
        
        if(size<5+2+(buf[*ofs+5]&0x1f)*3) { //size°¡ ½ÇÁ¦ CC dataº¸´Ù ÀÛÀ¸¸é ¿¡·¯ÀÓ.
                CCPRINT("ddi", "cc data size is not enough(%d)\n", size);
                return FALSE;
        }
        
        *psize=5+2+(buf[*ofs+5]&0x1f)*3; //½ÇÁ¦ ó¸®ÇÒ sizeÀÓ.

        return TRUE;
}


static void p_user_data(tDHL_AVCallbackType cb_type, UINT32 param)
{
        static UINT32 count=0;
        static BOOL bprev_valid=FALSE;
        BOOL bcur_valid;
        int offset=0;

        UINT8 *pdata=(UINT8 *)((UINT32 *)param)[0];
        int size=((UINT32 *)param)[1];

        if (cb_type != eDHL_CB_VideoUserData)
        {
                DHL_OS_Printf("|%s| wrong userdata callback(cb_type:0x%x).\n",
                              __FUNCTION__, cb_type);
                
                return;
        }
        
        //p_print_pic_ud(pdata, size);
        
        //¿©±â¼­ ¾à°£ÀÇ Å×½ºÆ®¸¦ °ÅÃÄ ¾µ¸ð ¾ø´Â ÆÄÀϵéÀ» °É·¯³½´Ù.
        bcur_valid=p_check_cc_validity(pdata, &size, &offset);

        if (MAX_SIZE_PIC_UD <= size)
        {
                //ÀÌ °æ¿ì additional cc data°¡ ÀÖÀ¸¸é ¹ß»ýÇÒ ¼ö ÀÖÀ½.
                //additional cc data¸¦ Áö¿ö¹ö¸®°í ³²Àº ³ª¸ÓÁö¸¸ ó¸®ÇÔ.
                
                DHL_OS_Printf("|%s| too big userdata size(MAX : %d, data : %d). discard.\n", 
                        __FUNCTION__, MAX_SIZE_PIC_UD, size);
                
                return;
        }       
        
        
        
        if(!bcur_valid) {
                CCPRINT("ddi", "!! all invalid packet!!\n");
                if(bprev_valid) bprev_valid=FALSE;
                else            return;
        }
        else {
                bprev_valid=TRUE;
        }
        
        pdata = &(pdata[offset]);
        memcpy(p_ud_buf[p_ud_buf_wr_idx].data, (void *)pdata,
               size);
        p_ud_buf[p_ud_buf_wr_idx].size = size;

#if 0
        p_ud_buf[p_ud_buf_wr_idx].pic_type = ((UINT32 *)param)[2];
#else
        p_ud_buf[p_ud_buf_wr_idx].pic_type = eDCC_PIC_CT_I;
#endif

#if 0 //scte20_21À» Áö¿øÇÒ °æ¿ì ¾Æ·¡ ±¸ÇöÀÌ ¹Ýµå½Ã ÇÊ¿äÇÔ.
        p_ud_buf[p_ud_buf_wr_idx].pic_structure=pPic->pictureStructure[0];
        p_ud_buf[p_ud_buf_wr_idx].top_field_first = pPic->topFieldFirst;
        p_ud_buf[p_ud_buf_wr_idx].repeat_first_field = pPic->repeatFirstField;
        p_ud_buf[p_ud_buf_wr_idx].ms_rcv=count++;
#endif
        
        if(p_ud_callback) 
                p_ud_callback(&p_ud_buf[p_ud_buf_wr_idx]);
                
        if(++p_ud_buf_wr_idx>=MAX_NUM_PIC_UD_Q) 
                p_ud_buf_wr_idx=0;
}


void DCCDDI_SetUserCallback(tDCC_UserCallback func)
{
        p_ud_callback=func;
}


// zooyouny: »ç¿ëµÇ´Â °÷ ¾øÀ½
#if 0
tDCC_PicUDRaw *DCCDDI_GetUserData()
{
        int err;
        int rcv_len;
        int idx;
        
        err=DCCDDI_ReceiveMessage_Wait(p_ud_msgq, &idx, sizeof(idx), &rcv_len, 10);
        
        if(err) return NULL;
                
        return &p_ud_buf[idx];
}
#endif

int DCCDDI_Feeding608(BOOL is_even, UINT8 data1, UINT8 data2, BOOL is_end)
{
        BOOL VDEC_StoreCCData(UINT8 field, UINT8 data1, UINT8 data2, BOOL is_end);

        VDEC_StoreCCData(is_even, data1, data2, is_end);

        return 0;
}


#if 0
__Graphic__() {}
#endif

static tDMG_FontAttr p_backup_font;

void DCCDDI_GraphicStart(UINT8 resolution)
{
        DMG_GetFontAttr(&p_backup_font);
        DMG_SetFont(eDMG_FONT_JUNGLE);
}

void DCCDDI_GraphicStop()
{
        DMG_SetFont(eDMG_FONT_BMF);
        DMG_SetFontAttr(&p_backup_font);
        DMG_EraseRect(0, 0, 720, 480, 0);
        DMG_AutoRefresh();
}

void DCCDDI_DrawBox(int x, int y, int w, int h, int color)
{
        CCPRINT("ddi", "DCCDDI_DrawBox(%d,%d,%d,%d,%d)\n", x, y, w, h, color);
        
        if(w<=0 || h<=0) return;
        
        p_check_region(x, y, w, h);
        
        DMG_EraseRect(x, y, w, h, color);
}

//height°¡ -À̸é up, +À̸é down
void DCCDDI_BLT(int x, int y, int w, int h, int height)
{
        tDHL_GrpRect r1, r2;

        CCPRINT("ddi", "DCCDDI_BLT(%d,%d,%d,%d,%d)\n", x, y, w, h, height);
        
        if(height==0 || h==0) return;
                
        p_check_region(x, y, w, h);
        p_check_region(x, y+height, w, h);
        
        DHL_FILLRECT(&r1, x, y, w, h);
        DHL_FILLRECT(&r2, x, y+height, w, h);
        
        DMG_BLT(CC_PLANE, CC_TEMP_PLANE, &r1, &r1);
        DMG_BLT(CC_TEMP_PLANE, CC_PLANE, &r1, &r2);
}

void DCCDDI_DrawHLine(int x, int y, int w, int color)
{
        if(w<=0) return;
                
        p_check_region(x, y, w, 1);

        DMG_DrawHLine(x, y, w, color);
}


void DCCDDI_Refresh()
{

}


#if 0
__Font__() {}
#endif

#define USE_MARGINE 0

#if IS_FONT_JUNGLE
//static UT_FC p_reg_fc;
#elif IS_FONT_MLF
static RML_FC p_reg_fc;
#elif IS_FONT_BMF
static BMF_FC p_reg_fc;
#endif


static struct {
        int size;
        BOOL is_italic;
        BOOL is_underline;
        BOOL is_unicode; //2byte. ÇѱÛÀÎ °æ¿ì unicode/¿Ï¼ºÇü Áß ¾î´À °ÍÀÎÁö..
        BOOL is_p16; 
        int font_style;
        int edge_type;
} p_font_attr;



#define USE_FONT_CACHE 0
        //font cache¸¦ »ç¿ëÇÔ.
        
#define CH_BLANK 0x20
#define MAX_CH_W (p_font_attr.size*8/10)
        //neverdai analog cc¿¡¸¸ »ç¿ëÇÔ.

#if IS_FONT_JUNGLE


#if USE_FONT_CACHE

#define IMG_CACHE_SIZE 128

static struct {
        UINT16 ch;
        
        SINT8 x;
        SINT8 y;
        SINT8 w;
        SINT8 h;
        SINT8 pitch;
        
        UINT8 buf[512]; //ÃÖ´ë 45»çÀÌÁî ±ÛÀÚ±îÁö ÀúÀåÇÒ ¼ö ÀÖÀ½.
} p_ut_img_cache[IMG_CACHE_SIZE];//¾à 6.5K Á¤µµ

static int p_cache_idx;

#endif // USE_FONT_CACHE

#endif /* IS_FONT_JUNGLE */



int DCCDDI_PrintCh(int x, int y, UINT16 ch, int c_font, int c_edge)
{
        tDMG_FontAttr attr;
        int width;
        
        if(!p_font_attr.is_unicode) {
                //¿Ï¼ºÇüÀ» unicode·Î º¯°æÇÔ.                    
                ch=DCCUtil_Ksx1001toUnicode(ch);
                CCPRINT("ddi", "convert to ksx1001(0x%x)\n", ch);
        }
        
        ch=p_remap_char(ch);
        
        DMG_GetFontAttr(&attr);
        attr.c_edge=DMG_ConvertDefColor(c_edge);
        DMG_SetFontAttr(&attr);
        
        p_check_region(x, y, 20, 20); //´ë·« width, height¸¦ 20À¸·Î ÇÔ.
        
        width=DMG_PrintCh(x, y, ch, c_font);

        DHL_PostDraw(CC_PLANE, x, y, width, DMG_GetChHeight(ch));
        
        return width;
}


int DCCDDI_GetChWidth(UINT16 ch)
{
        if(!p_font_attr.is_unicode) {
                //¿Ï¼ºÇüÀ» unicode·Î º¯°æÇÔ.                    
                CCPRINT("ddi_ch", "convert to ksx1001(0x%x->0x%x)\n", ch, DCCUtil_Ksx1001toUnicode(ch));
                ch=DCCUtil_Ksx1001toUnicode(ch);
        }

        ch=p_remap_char(ch);
        
        return DMG_GetChWidth(ch);
}


int DCCDDI_GetChHeight(UINT16 ch)
{
        if(!p_font_attr.is_unicode) {
                //¿Ï¼ºÇüÀ» unicode·Î º¯°æÇÔ.                    
                CCPRINT("ddi_ch", "convert to ksx1001(0x%x)\n", ch);
                ch=DCCUtil_Ksx1001toUnicode(ch);
        }

        ch=p_remap_char(ch);

        return DMG_GetChHeight(ch);
}


void DCCDDI_SetFontAttr(int size, BOOL is_italic, BOOL is_underline, UINT8 font_style, 
        UINT8 edge_type, BOOL is_p16)
{
        tDMG_FontAttr attr;
        
        DMG_GetFontAttr(&attr);
        
        attr.size=size;
        attr.is_italic=is_italic;
        attr.is_underline=is_underline;
        
        if(is_p16) {
                attr.font_style=eDMG_FS_KOREAN;
        }
        else {
                attr.font_style=(tDMG_FontStyle)font_style;
        }
        
        attr.edge_type=(tDMG_EdgeType)edge_type;
        
        DMG_SetFontAttr(&attr);
        
}


#if 0
__Init__() {}
#endif

void DCCDDI_Init()
{
// zooyouny: »ç¿ëµÇ´Â °÷ ¾øÀ½
//      p_ud_msgq=DCCDDI_CreateMessageQueue("udmsgq", MAX_NUM_PIC_UD_Q, sizeof(int));
        
#if IS_FONT_JUNGLE
                //ut_InitFontContext(&p_reg_fc, 0, 0);
#elif IS_FONT_MLF
        RML_InitFontContext(&p_reg_fc, 0, 0);
#elif IS_FONT_BMF
        BMF_InitFontContext(&p_reg_fc, 0, 0);
#endif
        memset(p_ud_buf, 0, sizeof(tDCC_PicUDRaw) * MAX_NUM_PIC_UD_Q);

        /* user data callback ¼³Á¤ */
        DHL_AV_SetCallback(eDHL_CB_VideoUserData, p_user_data);
        
        {
                void VDEC_StartVBICaption(void);

                VDEC_StartVBICaption();
        }
}

void DCCDDI_SetKoreanMode(BOOL is_unicode)
{
        //unicode¸¦ ¾µ °ÍÀÎÁö.
        p_font_attr.is_unicode=is_unicode;
}


#if 0
___Debug___()
#endif

void cc_ddi_info()
{

}