cg.c

ESS3890+SL原代码（1*16内存）

/************************************************************************
  for graphic requirement.
*************************************************************************/
#ifdef NOT_USED
int cg_line_to(int x1, int y1, int dx, int dy, int color)
{
    OSD_line_to(x1, y1, dx, dy, color);
    cg_on = 1; OSD_on(1);
    return 0;
} 
#endif

/************************************************************************
  Function:
  Description:
*************************************************************************/
int CG_show_frame(int x, int y, int dx, int dy, int mode)
{
    int start_x, start_y, end_x, end_y;
    start_x = x;
    start_y = y;
    end_x   = x + dx;
    end_y   = y + dy;
    cg_ch2pixel(&start_x, &start_y);
    cg_ch2pixel(&end_x, &end_y);
    OSD_frame(start_x, start_y, end_x, end_y, mode);
    return 0;
}

/************************************************************************
  Function:
  Description:
*************************************************************************/
int CG_show_window(int x, int y, int dx, int dy, int mode, int depth, int color)
{
    int start_x, start_y, end_x, end_y;
    start_x = x;
    start_y = y;
    end_x   = x + dx;
    end_y   = y + dy;
    cg_ch2pixel(&start_x, &start_y);
    cg_ch2pixel(&end_x, &end_y);
    OSD_window(start_x, start_y, end_x - 1, end_y - 1, mode, depth, color);
    return 0;
}
/************************************************************************
  save and restore back ground color for icon.
*************************************************************************/
void CG_bkcolor_saver(int saver)
{
#ifdef SCR_SAVER
    if (saver) {
	icon_bcolor_sav = icon_back_color;
	icon_back_color = 0;	
    } else
        icon_back_color = icon_bcolor_sav;
#endif
}
/************************************************************************
  set up back ground color for icon.
*************************************************************************/
void ICON_set_bkcolor(int bkcolor)
{
    icon_back_color = bkcolor;
}
/************************************************************************
  set up auto color mapping on/off.
*************************************************************************/
void ICON_auto_mapping(int on_off)
{
    icon_auto_mapping = on_off;
}
/************************************************************************
  set up auto color mapping on/off.
*************************************************************************/
void ICON_color_mapping(int index, int color)
{
    if (index<0||index>15||color<0||color>15)
	return;
    icon_mapping[index]=color;
}
/************************************************************************
  select charset to be display.
*************************************************************************/
void ICON_charset_select(int charset)
{
    current_charset = charset&0xf;
}

/************************************************************************
  restore original charset.
*************************************************************************/
#define player_in_setup() 0
void ICON_charset_restore(void)
{
#ifdef BILINGUAL_OSD
    if (osd_lang == CHINESE_OSD)  current_charset = 1;
    else
#endif
    if (player_in_setup()/*&&osd_lang==ENGLISH_OSD*/)
        current_charset = VWENGLISH_FONTS;
    else
        current_charset = 0;
}
/************************************************************************
 ************************************************************************/
static void set_rect_value(RECT *rect, int xs, int ys, int xe, int ye)
{
    rect->xstart = xs;
    rect->ystart = ys;
    rect->xend = xe;
    rect->yend = ye;
}
/************************************************************************
 ************************************************************************/
static void get_rect_value(RECT *rect, int *xs, int *ys, int *xe, int *ye)
{
    *xs = rect->xstart;
    *ys = rect->ystart;
    *xe = rect->xend;
    *ye = rect->yend;
}
/************************************************************************
 ************************************************************************/
static void get_area_rect_value(int entry, int *xs, int *ys, int *xe, int *ye)
{
    int j, x0, y0, x1;
    RECT *rect_ptr;
    

    rect_ptr = &(gi_msg[entry].rect);
    x0 = rect_ptr->xstart;
    y0 = rect_ptr->ystart;
    x1 = rect_ptr->xend;

    /* Check to see if there is a message currently being displayed in
     * the same area, and compare the message lengths.
     */
    for (j=0; j<MAX_MESSAGE_NUMBER; j++) {
	rect_ptr = &(gi_msg[j].rect);
	if ((j != entry) && (rect_ptr->xstart == x0) &&
	    (rect_ptr->ystart == y0) && (rect_ptr->xend > x1)) {	    
	    /* currently displayed msg is longer */ 
	    icon_back_erase = 1;
	    break;
	}
    }

    if (j == MAX_MESSAGE_NUMBER) {
	/* use new msg area */
	rect_ptr = &(gi_msg[entry].rect);
    }
    
    *xs = rect_ptr->xstart;
    *ys = rect_ptr->ystart;
    *xe = rect_ptr->xend;
    *ye = rect_ptr->yend;
}
/************************************************************************
 ************************************************************************/
static void color_map_set(ICON_CHAR *pichar, int *map, int bkcolor)
{
    int i, j, k1, k2, n=pichar->format, tmp1[4], tmp2[4];
    assert(n<=2);
    for (i=0; i<n; i++) {
        j = i<<1;
        if (icon_auto_mapping) {
            k1 = pichar->color_mapping[i]>>4;
            k2 = pichar->color_mapping[i]&0xf;
        } else {
            k1 = icon_mapping[j];
            k2 = icon_mapping[j+1];
        }
        if (!k1) k1=bkcolor;
        if (!k2) k2=bkcolor;
	tmp1[j] = k1;
	tmp1[j+1] = k2; 
        tmp2[j] = k1<<4;
        tmp2[j+1] = k2<<4;
    }
    n *= 2;
    for (i=0; i<n; i++)
        for (j=0; j<n; j++)
            map[i*n+j]=tmp2[i]+tmp1[j];
}
/************************************************************************
   check icon_id if it is control character.
*************************************************************************/
static int icon_control(int icon_id)
{
    if (icon_id>=MIN_CONTROL_HEADER&&icon_id<=MAX_CONTROL_HEADER) {
        switch (icon_id) {
        case CN_HEADER:
	    font_header = CHINESE_FONTS; break;

        case ENORI_HEADER: font_header = ENGLISH_FONTS; break; 
        case ENVSF_HEADER: font_header = VWENGLISH_FONTS; break;
#ifdef EXTRA_VWFONTS
        case FRVSF_HEADER: font_header = VWFRENCH_FONTS; break;
#endif
#ifdef NEWVSE_FONT 
        case BIGVSE_HEADER: font_header = BIGVSE_FONTS; break;
#endif
        case HLION_HEADER: icon_hli_flag = 1; break;
        case HLIOFF_HEADER: icon_hli_flag = 0; break;
        default: break;
        }
        return 1;
    }
    return 0;
}   
/************************************************************************
*************************************************************************/
static int data_width(unsigned char width, unsigned char depth)
{
    int k, mask=0xff, shift;
    if (depth==4)
	shift = 1;
    else if (depth==2)
	shift = 2;
    else if (depth==1)
	shift = 3;
    else
	return 0;
    k = (width&(~(mask<<shift)))?1:0;
    k <<= shift;
    k += width&(mask<<shift);
    return k;
}
/************************************************************************
*************************************************************************/
static void align_transfer(int align, RECT *rect)
{
    int dot, x1, x2, y1, y2;
    int x=rect->xstart, y=rect->ystart;
    int width=rect->xend-rect->xstart;
    int height=rect->yend-rect->ystart;
    switch (align&0xf) {
        case 0: x1=x; x2=x+width; y1=y; y2=y+height; break;
        case 3: x1=x; x2=x+width; y1=y-(height>>1);
                y2=y1+height; break;
        case 6: x1=x; x2=x+width; y1=y-height; y2=y; break;
        case 7: x1=x-(width>>1); x2=x1+width;
                y1=y-height; y2=y; break;
        case 8: x1=x-width; x2=x; y1=y-height; y2=y; break;
        case 5: x1=x-width; x2=x; y1=y-(height>>1);
                y2=y1+height; break;
        case 2: x1=x-width; x2=x; y1=y; y2=y+height; break;
        case 1: x1=x-(width>>1); x2=x1+width; y1=y;
                y2=y+height; break;
        case 4: x1=x-(width>>1); x2=x1+width;
                y1=y-(height>>1); y2=y1+height; break;
        default: return;
    }
    dot = 1&x1;
    rect->xstart = x1-dot;
    rect->ystart = y1;
    rect->xend = x2-dot;
    rect->yend = y2;
}
/************************************************************************
*************************************************************************/
static uchar * hli_insert(uchar* target, uchar* msg, int maxlength, 
	int hli_s, int hli_e)
{
    int i=0, j=0;
    if (hli_s>=0&&hli_e>=0&&hli_e>hli_s) {
        while (msg[i]&&(i+j<maxlength)) {
            if (i==hli_s) {
                target[i+j] = HLION_HEADER;
                j++; 
            }
            target[i+j]=msg[i];
            i++;
            if (i==hli_e+1) {
                target[i+j] = HLIOFF_HEADER;
                j++; 
            }
        }
        if (i+j<maxlength)
            target[i+j] = 0;
	else
	    target[i+j-1] = 0;
	return target;
    } else
	return msg; 
}
/*************************************************************************************************************************************************/
static int icon_extension(uchar *buffer, ICON_CHAR *pic, int bkcolor)
{
    int i=-1, bytes, format=pic->format;
    uchar *c = pic->data;
    bkcolor &= 0xf;
    bytes=icon_size(pic->data-pic->format-4, 0);
    if (format==FORMAT0) {    /* 4 bits */
        int byte_bkc, upper_bkc=bkcolor<<4;
        byte_bkc = upper_bkc+bkcolor;
        while (i<bytes) {
            int data = c[++i];
            if (data==0) c[i] = byte_bkc;
            else if (data<=0xf) c[i] |= upper_bkc;
            else if ((data&0xf0)==0) c[i] |= bkcolor;
        }
    } else {
        int j=0, k, data, map[16], width=pic->width;
        color_map_set(pic, map, bkcolor);
        if (format==FORMAT2) {
            while (i<bytes) {
                k = data = c[++i];
                data>>=4;
                *buffer++ = map[data];
                j+=2; if (j<width) { *buffer++ = map[k&0xf]; j+=2; }
                if (j>=width) j=0;
            }
        } else {
            while (i<bytes) {
                int tmp[4];
                data = c[++i];
                for (k=3; k>=0; k--) { tmp[k] = data&0x3; data>>=2; }
                *buffer++ = map[tmp[0]];
                j+=2; if (j<width) {
                    *buffer++ = map[tmp[1]];
                    j+=2; if (j<width) {
                        *buffer++ = map[tmp[2]];
                        j+=2; if (j<width) {
                            *buffer++ = map[tmp[3]];
                             j+=2;
                        }
                    }    
                }    
                if (j>=width) j=0;
            }
        }    
    }    
    return format;
}
/************************************************************************
*************************************************************************/
static int icon_index(int icon_id)
{
    int i, start, end;
    int font = (font_header<0)?current_charset:font_header;
    if (font<VWENGLISH_FONTS)
        return icon_id;
    icon_id += cg_font_attr[font].id_offset;
    if (icon_table[0].id==icon_id) return 0;
    start = 0;
    end = icon_total_number-1;
    while (start<end) {
        i = end-start;
        i = (i>1)?(i>>1):i;
        i += start;
        if (icon_table[i].id == icon_id)
            return i;
        else if (icon_table[i].id < icon_id)
            start=i;
        else if (end>i) /* if (icon_table[i].id > icon_id) */
            end=i;
        else
            break;
    }
    if (icon_table[start].id==icon_id)
        return i;
    else
        return -1;
}
/************************************************************************
*************************************************************************/
#ifdef NOT_USED
static unsigned char *icon_address(int icon_id)
{
    FONT_ATR *pfont_atr;
    int i = icon_index(icon_id);
    if (i>=0)
        return (uchar*)cg_font_info(current_charset, i, 1, &pfont_atr);
    return 0;
}
#endif
/*************************************************************************************************************************************************/
static FONT_ATR *charset_index2font(int charset, int index)
{
    FONT_ATR *pfont_atr;
    if (charset>=FONT_LANGUAGES||index<0) return 0;
    if (font_header<0) {
    	if (charset<VWENGLISH_FONTS) {
            if (index < OTHER_ONE_SPACE_FONTS_START) {
                pfont_atr = &cg_font_attr[ENGLISH_FONTS];
            } else {
                pfont_atr = &cg_font_attr[CHINESE_FONTS];
	    }
	} else
            pfont_atr = &cg_font_attr[charset];
    } else if (font_header<FONT_LANGUAGES) {
        pfont_atr = &cg_font_attr[font_header];
    } else
        return 0;
    return pfont_atr;
}
/*************************************************************************************************************************************************/
static uchar *cg_font_info(FONT_ATR *pfont_atr, int charset, int index, int *size)
{
    uint k;
    int *offset_tbl;
    if (charset>=FONT_LANGUAGES||index<0) return 0;
#if 0
    /* this sanity check have some problem */
    if (index>=pfont_atr->max_char) return 0;
#endif
    index -= pfont_atr->start_offset;
    if (index<0) return 0;
    offset_tbl = pfont_atr->offset_tbl;
    *size = offset_tbl[index+1]-offset_tbl[index];
    k = (uint)(pfont_atr->comp_font + offset_tbl[index]);
    return (uchar*)k;
}
/************************************************************************
*************************************************************************/
static int icon_char_info(FONT_ATR *pfont_atr, uchar *p, ICON_CHAR *pichar)
{
    int font = (font_header<0)?current_charset:font_header;
    if (font<VWENGLISH_FONTS) {
        pichar->width = pfont_atr->width;
        pichar->height = pfont_atr->height;
        pichar->base = 0;
        pichar->format = FORMAT2;
        pichar->data = p;
    } else /*if (current_charset==VWENGLISH_FONTS)*/ {
        pichar->width = p[0];
        pichar->height = p[1];
        pichar->base = p[2];
        pichar->format = p[3]>>6;
        if (pichar->format) {
            pichar->color_mapping = p