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

#include "DHL_OSAL.h"

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

#define TICK_CUR OS_GetTickCount()
#define TICK_1SEC OS_GetTicksPerSecond()
#define TICK_10MS (TICK_1SEC/100)
#define TICK_PASS(s) (TICK_CUR-(s))

#define MAX_NUM_PIC_UD_Q 32

//configure...

#define FONT_JUNGLE 0x1
#define FONT_MLF 0x2 /* multi lanaguage font */

#define FONT_ID FONT_JUNGLE

#define IS_FONT_JUNGLE (FONT_ID==FONT_JUNGLE)
#define IS_FONT_MLF (FONT_ID==FONT_MLF)


static tDCC_PicUDRaw p_ud_buf[MAX_NUM_PIC_UD_Q];

static OS_MESSAGEQUEUE_ID p_ud_msgq;
static int p_ud_buf_wr_idx=0;
static tDCC_UserCallback p_ud_callback;


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

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




#if 0
__Local_Func__() {}
#endif

static UINT16 p_remap_char(UINT16 ch)
{
        UINT16 ret;
        
        switch(ch) {
                case 0x121: 
                case 0x120:
                        ret=0x120; break;
                
                case 0x125:
                case 0x12a:
                case 0x12c:
                case 0x130:
                case 0x131:
                case 0x132:
                case 0x133:
                case 0x134:
                case 0x135:
                case 0x139:
                case 0x13a:
                case 0x13c:
                case 0x13d:
                case 0x13f:
                case 0x176:
                case 0x177:
                case 0x178:
                case 0x179:
                case 0x17a:
                case 0x17b:
                case 0x17c:
                case 0x17d:
                case 0x17e:
                case 0x17f:
                case 0x1a0:
                        ret=ch; break;
                
                default:
                        ret=0x20;
        }
        
        return ret;
}


#if 0
__Common__() {}
#endif



#define OS_TICK2MS(tick) (tick*(1000/OS_GetTicksPerSecond()))
#define OS_MS2TICK(ms) (ms*OS_GetTicksPerSecond()/1000)


void *DCCDDI_Malloc(int size)
{
        return 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);

        printf("%s", buf);
}

void DCCDDI_SpawnTask(void *func)
{
        OS_SpawnTask((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)OS_CreateMessageQueue(pname, 0, num_msgq, size_msgq);
}


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


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


void DCCDDI_SendMessage(tDCCDDI_MSGQ id, void *buf, UINT32 len)
{
        OS_SendMessage((OS_MESSAGEQUEUE_ID)id, buf, len);
}


int DCCDDI_ReceiveMessage(tDCCDDI_MSGQ id, void *buf, UINT32 max_len, int *rcv_len)
{
        return OS_ReceiveMessage((OS_MESSAGEQUEUE_ID)id, buf, max_len, rcv_len);
}


int DCCDDI_ReceiveMessage_Wait(tDCCDDI_MSGQ id, void *buf, UINT32 max_len, int *rcv_len, UINT32 msec)
{
        return OS_ReceiveMessage_Wait((OS_MESSAGEQUEUE_ID)id, buf, max_len, rcv_len, OS_MS2TICK(msec));
}

int DCCDDI_ReceiveMessage_NoWait(tDCCDDI_MSGQ id, void *buf, UINT32 max_len, int *rcv_len)
{
        return OS_ReceiveMessage_NoWait((OS_MESSAGEQUEUE_ID)id, buf, max_len, rcv_len);
}


void DCCDDI_TakeSemaphore(tDCCDDI_SEM id)
{
        OS_TakeSemaphore((DHL_OS_SEMA_ID)id);
}

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

void DCCDDI_Delay(UINT32 msec)
{
        OS_Delay(OS_MS2TICK(msec));
}

UINT32 DCCDDI_GetCurMs()
{
        return OS_TICK2MS(OS_GetTickCount());
}


#if 0
__Picture_User_Data__() {}
#endif


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


tDCC_PicUDRaw *DCCDDI_GetUserData()
{
        int err;
        int rcv_len;
        int idx;
        
        err=OS_ReceiveMessage_Wait(p_ud_msgq, &idx, sizeof(idx), &rcv_len, TICK_10MS);
        
        if(err) return NULL;
                
        return &p_ud_buf[idx];
}


static BOOL p_user_data(tDHL_AVCBType cb_type, tDHL_VideoContextHandle handle, UINT32 param)
{
        tDHL_UserData *pud=(tDHL_UserData *)param;
        
        if(cb_type!=eDHL_CB_VDC_CCUDP) {
                CCPRINT("warn", "!! %s : callback type is not cc callback\n");
                return FALSE;
        }
        
        memcpy(p_ud_buf[p_ud_buf_wr_idx].data, pud->pdata, pud->hdr.payload_size);
        p_ud_buf[p_ud_buf_wr_idx].size=pud->hdr.payload_size;

        p_ud_buf[p_ud_buf_wr_idx].pic_type=eDCC_PIC_CT_I;//pud->hdr.pic_coding;
        
        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;
                
        return TRUE;
}


int DCCDDI_Feeding608(BOOL is_even, UINT8 data1, UINT8 data2)
{
        
        return 0;
}

#if 0
__Graphic__() {}
#endif



void DCCDDI_GraphicStart(UINT8 resolution)
{
        DMG_SetFont(eDMG_FONT_JUNGLE);
}

void DCCDDI_GraphicStop()
{
        DMG_SetFont(eDMG_FONT_DHL_E2);
}

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;

        DMG_EraseRect(x, y, w, h, color);
}

//height°¡ -À̸é up, +À̸é down
void DCCDDI_BLT(int x, int y, int w, int h, int height)
{
        CCPRINT("ddi", "DCCDDI_BLT(%d,%d,%d,%d,%d)\n", x, y, w, h, height);
        
        if(height==0 || h==0) return;

        tDHL_GrpRect r1, r2;
        
        DHL_FILLRECT(&r1, x, y, w, h);
        DHL_FILLRECT(&r2, x, y+height, w, h);
        
        DMG_BLT(0, 0, &r1, &r2);
}

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

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


void DCCDDI_Refresh()
{
        DMG_AutoRefresh();
}


#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;
#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;


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);
        }
        
        DMG_GetFontAttr(&attr);
        attr.c_edge=c_edge;
        DMG_SetFontAttr(&attr);
        
        width=DMG_PrintCh(x, y, ch, c_font);
        
        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);
        }
        
        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);
        }
        
        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=eDCC_FS_KOREAN;
        }
        else {
                attr.font_style=font_style;
        }
        
        attr.edge_type=edge_type;
        
        DMG_SetFontAttr(&attr);
        
}



#if 0
__Init__() {}
#endif



void DCCDDI_Init()
{
        p_ud_msgq=OS_CreateMessageQueue("udmsgq", 0, 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);
#endif

        DHL_AV_PresetCallback(p_user_data, eDHL_CB_VDC_CCUDP, 0);
}

void DCCDDI_SetKoreanMode(BOOL is_unicode)
{

}


#if 0
___Debug___()
#endif

void cc_ddi_info()
{

}