source: svn/newcon3bcm2_21bu/dst/dmw/src/cc/cc_ddi_nec.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
#if CC_TRACE_PIC_UD_Q
int g_total_using_pic_ud = 0;
#endif

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



//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 void p_user_data(MMAC_VIDEO_USER_DATA* pUd, MMAC_VIDEO_PICTURE_INFO* pPic)
{
#if 0
        // zooyouny Å×½ºÆ®¿ë Àӽà ÄÚµå..
        // todo »ç¿ë·® traceÇÏ´Â ÄÚµå ³ÖÀ» °Í
        DHL_ASSERT(p_ud_buf[p_ud_buf_wr_idx].pic_type == 0, "!!ud_buf is overflow.. \n");
#else
        if(p_ud_buf[p_ud_buf_wr_idx].isUsing != 0)
        {
                CCPRINT("error", "!! ud_buf is overflow.. \n");
                return ;
        }
        p_ud_buf[p_ud_buf_wr_idx].isUsing = 1;
        #if CC_TRACE_PIC_UD_Q
        g_total_using_pic_ud++;
        CCPRINT("ddi", "max pic userdata: %d, cur used pic userdata: %d\n", MAX_NUM_PIC_UD_Q, g_total_using_pic_ud);
        #endif
#endif
                
        memcpy(p_ud_buf[p_ud_buf_wr_idx].data, pUd->userDataBuffer, pUd->userDataSize);
        p_ud_buf[p_ud_buf_wr_idx].size = pUd->userDataSize;

        p_ud_buf[p_ud_buf_wr_idx].pic_type = pPic->pictureCodingType;
        
        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)
{
        return 0;
}


#if 0
__Graphic__() {}
#endif



void DCCDDI_GraphicStart(UINT8 resolution)
{
        //DMG_SetFont(eDMG_FONT_BMF); //Ç×»ó BMF¸¸ »ç¿ëÇÔ
}

void DCCDDI_GraphicStop()
{
        //DMG_SetFont(eDMG_FONT_BMF); //Ç×»ó BMF¸¸ »ç¿ëÇÔ
}

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)
{
        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;
        
        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;

        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);
        }
        
        DMG_GetFontAttr(&attr);
        attr.c_edge=c_edge;
        DMG_SetFontAttr(&attr);
        
        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);
        }
        
        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=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_set_userdata_callback(p_user_data);
}

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


#if 0
___Debug___()
#endif

void cc_ddi_info()
{

}