framebuf.c

C语言编写的监控中心终端程序。基于GPRS上传收发数据功能

/*
** FILE
** framebuf.c
**
** DESCRIPTION
** access framebuffer.
*/

#include "config.h"
#include "global.h"
#include "dma.h"
#include "mon.h"
#include "fs9660.h"
#include "framebuf.h"
#include "memmap.h"
#include "avd.h"
#include "hwsetup.h"
#define LUMA_ROW    ((mode_decode==MODE_NTSC) ? 480 : 576)
#define CHROMA_ROW  ((mode_decode==MODE_NTSC) ? 240 : 288)
#define REF_ROW     ((mode_decode==MODE_NTSC) ? 720 : 864)

#define BIDIR_LUMA_ROW  (2*LUMA_ROW)
#define BIDIR_CHROMA_ROW (2*CHROMA_ROW)

#define REF0_LUMA   0
#define REF0_CHROMA regs0->ref0_chroma
#define REF1_LUMA   regs0->ref1_luma
#define REF1_CHROMA regs0->ref1_chroma
#define BIDIR_LUMA  regs0->bidir_luma
#define BIDIR_CHROMA    regs0->bidir_chroma

#define REF0_LUMA_ROW_START regs0->ref0_luma
#define REF1_LUMA_ROW_START regs0->ref1_luma
#define BIDIR_LUMA_ROW_START    regs0->bidir_luma

#define REF0_LUMA_ROW_END   regs0->ref0_chroma
#define REF1_LUMA_ROW_END   regs0->ref1_chroma
#define BIDIR_LUMA_ROW_END  regs0->bidir_chroma

#define REF0_CHROMA_ROW_START   regs0->ref0_chroma
#define REF1_CHROMA_ROW_START   regs0->ref1_chroma
#define BIDIR_CHROMA_ROW_START  regs0->bidir_chroma

#define REF0_CHROMA_ROW_END regs0->ref1_luma
#define REF1_CHROMA_ROW_END regs0->bidir_luma
#define BIDIR_CHROMA_ROW_END    regs0->bidir_chroma+50  //for emu //512

/*
** used during LUMA processing
*/
#define ROM_BASED
#ifdef  ROM_BASED
static const BYTE bitr_luma_array[] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    16, 17, 18, 19, 20, 21, 22, 23,
    8, 9, 10, 11, 12, 13, 14, 15,
    24, 25, 26, 27, 28, 29, 30, 31
};

/*
** used during CHROMA processing
*/
static const BYTE bitr_chroma_array[] = {
    0, 1, 2, 3,
    8, 9, 10, 11,
    4, 5, 6, 7,
    12, 13, 14, 15
};

#define bitr_luma(x)    (bitr_luma_array[x])
#define bitr_chroma(x)  (bitr_chroma_array[x])
#else
#define bitr_luma(x)    (((x)&0xffe0) | (((x)&0x0008)<<1) | (((x)&0x0010)>>1))
#define bitr_chroma(x)  (((x)&0xfff0) | (((x)&0x0004)<<1) | (((x)&0x0008)>>1))
#endif

#if 0
const static BYTE lma_array[128] = {
    0, 2, 4, 6, 8, 10, 12, 14,
    32, 34, 36, 38, 40, 42, 44, 46,
    16, 18, 20, 22, 24, 26, 28, 30,
    48, 50, 52, 54, 56, 58, 60, 62,

    64, 66, 68, 70, 72, 74, 76, 78,
    96, 98, 100, 102, 104, 106, 108, 110,
    80, 82, 84, 86, 88, 90, 92, 94,
    112, 114, 116, 118, 120, 122, 124, 126,

    128, 130, 132, 134, 136, 138, 140, 142,
    160, 162, 164, 166, 168, 170, 172, 174,
    144, 146, 148, 150, 152, 154, 156, 158,
    176, 178, 180, 182, 184, 186, 188, 190,

    192, 194, 196, 198, 200, 202, 204, 206,
    224, 226, 228, 230, 232, 234, 236, 238,
    208, 210, 212, 214, 216, 218, 220, 222,
    240, 242, 244, 246, 248, 250, 252, 254
};
#endif

#if CONFIG==CONFIG_COMBO_VCD
void fillPattern_HIRES(int row_lo, int row_hi, BYTE p0, BYTE p1, BYTE p2)
{
    UINT32  i;
    BYTE   *buf;

    buf = (BYTE *) (SDRAM_BASE + row_lo * 1024);

    for(i = 0; i < (row_hi - row_lo) * 1024; i += 3)
    {
        buf[i] = p0;
        buf[i + 1] = p1;
        buf[i + 2] = p2;
    }
}
#endif

void fillPattern(int row_lo, int row_hi, UINT32 p)
{
    int     i;

    for(i = 0; i < 32 / 4; i++)
        dma_buf.w[i] = p;
    for(; row_lo < row_hi; row_lo++)
    {
        //JJDing 2002/08/22
#if CONFIG==CONFIG_COMBO_SVCD
        for(i = 0; i < 720; i += 32)
#else
        for(i = 0; i < 1024; i += 32)
#endif
        {
            DMA_save(VADDR_MODE_GLOBAL, row_lo, i, 0, 32);
            DMA_wait();
        }
    }
}

/*
** DigestCopy
**
** copy from one of the reference buffer to B-buffer
**
** oX,oY -> destination X,Y in B-buffer
** lX,lY -> size of source frame
*/
#define DIGEST_ZOOMX    4
#define DIGEST_ZOOMY    4

#define FILTER_TYPE_LUMA_NOFILTER   0
#define FILTER_TYPE_LUMA_4POINT     1
#define FILTER_TYPE_LUMA_16POINT    2

#define FILTER_TYPE_CHROMA_NOFILTER 0
#define FILTER_TYPE_CHROMA_4POINT   1

#define FILTER_TYPE_LUMA    FILTER_TYPE_LUMA_4POINT
#define FILTER_TYPE_CHROMA  FILTER_TYPE_CHROMA_NOFILTER

void DigestCopy(int oX, int oY, int lX, int lY)
{

    int     sX, sY, dY;
    int     Previewing_PAL;
    int     PAL_NTSC;

    /* copy luma */
    dY = oY;

    PAL_NTSC = 0;
    Previewing_PAL = (lY == 288);   //jjding
    //psprintf(LineBuffer,"Previewing_PAL:%x\n",Previewing_PAL);
    //epp_write(LineBuffer);
    for(sY = 0; sY < lY; dY++, sY += DIGEST_ZOOMY)
    {
        BYTE   *dP, *sP;

        sP = (BYTE *) (SDRAM_BASE + regs0->ref0_luma * 1024 + sY * 352);
        dP = (BYTE *) (SDRAM_BASE + regs0->bidir_luma * 1024 + dY * 352 + oX);

        if(Previewing_PAL == 1)
            PAL_NTSC++;
        if(PAL_NTSC == 6)
        {
            PAL_NTSC = 0;
            dY--;
        }
        else
        {
            for(sX = 0; sX < lX; sX += DIGEST_ZOOMX)
            {
#if (FILTER_TYPE_LUMA==FILTER_TYPE_LUMA_4POINT)
                int     value;

                value = sP[0] + sP[1] + sP[2] + sP[3];
                dP[0] = value / 4;
#elif   (FILTER_TYPE_LUMA==FILTER_TYPE_LUMA_16POINT)
                int     value;

                value = sP[0] + sP[1] + sP[2] + sP[3]
                    + sP[352 * 1 + 0] + sP[352 * 1 + 1] + sP[352 * 1 + 2] + sP[352 * 1 +
                                                                                                                                         3] +
                    sP[352 * 2 + 0] + sP[352 * 2 + 1] + sP[352 * 2 + 2] + sP[352 * 2 +
                                                                                                                                     3] +
                    sP[352 * 3 + 0] + sP[352 * 3 + 1] + sP[352 * 3 + 2] + sP[352 * 3 +
                                                                                                                                     3];
                dP[0] = value / 16;
#else   /* DEFAULT(0) */
                dP[0] = sP[0];
#endif /* FILTER_TYPE_LUMA */
                dP += 1;
                sP += 4;
            }
        }
    }

    /* copy chroma */
    lX = lX >> 1;
    lY = lY >> 1;
    oX = oX >> 1;
    dY = oY >> 1;

    PAL_NTSC = 0;
    for(sY = 0; sY < lY; dY++, sY += DIGEST_ZOOMY)
    {
        UINT16 *dP, *sP;

        if(Previewing_PAL == 1)
            PAL_NTSC++;

#if (FILTER_TYPE_CHROMA==FILTER_TYPE_CHROMA_4POINT)
        BYTE   *dP, *sP;

        sP = (BYTE *) (SDRAM_BASE + regs0->ref0_chroma * 1024 + sY * 352);
        dP =
            (BYTE *) (SDRAM_BASE + regs0->bidir_chroma * 1024 + dY * 352 + oX * 2);
        for(sX = 0; sX < lX; sX += DIGEST_ZOOMX)
        {
            int     value_cb;
            int     value_cr;

            value_cb = sP[0] + sP[2] + sP[4] + sP[6];
            value_cr = sP[1] + sP[3] + sP[5] + sP[7];
            dP[0] = value_cb / 4;
            dP[1] = value_cr / 4;
            dP += 2;
            sP += 8;
        }
#else   /* DEFAULT(0) */
        sP = (UINT16 *) (SDRAM_BASE + regs0->ref0_chroma * 1024 + sY * 352);
        dP =
            (UINT16 *) (SDRAM_BASE + regs0->bidir_chroma * 1024 + dY * 352 +
                                    oX * 2);

        if(PAL_NTSC == 6)
        {
            PAL_NTSC = 0;
            dY--;
        }
        else
        {
            for(sX = 0; sX < lX; sX += DIGEST_ZOOMX)
            {
                *dP++ = *sP;
                sP += 4;
            }
        }
#endif /* FILTER_TYPE_CHROMA */
    }
}

//remove code 2002/9/24 11:35AM by jackie//charles reopen
void clrBuffer(void)
{
    int     m, n;

    //m = MEM_REF0_LUMA_DEF;
    //n = MEM_REF1_LUMA_DEF;
    m = MEM_REF0_LUMA_DEF;
    n = MEM_REF0_CHROMA_DEF;
    fillPattern(m, n, 0x00000000);

    //m = MP3_REF0_CHROMA_DEF;
    //n = MP3_REF0_CHROMA_DEF + 288;//MP3_EVBYA_DEF;
    m = MP3_REF0_CHROMA_DEF;
    n = MP3_REF1_LUMA_DEF;
    fillPattern(m, n, 0x80808080);
}


#ifdef SUPPORT_JPG_DOUBLE_BUFFER
void clrJPGbuffer(BYTE pid)
{
    if(pid == 1)
    {
        int     m, n;

        //m = MP3_REF0_LUMA_DEF;
        //n = MP3_REF1_LUMA_DEF;
        m = MP3_REF0_LUMA_DEF;
        n = MP3_REF0_CHROMA_DEF;
        fillPattern(m, n, 0x00000000);

        //m = MP3_REF0_CHROMA_DEF;
        //n = MP3_REF0_CHROMA_DEF + 288;//MP3_EVBYA_DEF;

        m = MP3_REF0_CHROMA_DEF;
        n = MP3_REF1_LUMA_DEF;
        fillPattern(m, n, 0x80808080);
    }
    else
    {
        int     m, n;

        // m = MP3_REF1_LUMA_DEF;
        //n = MP3_REF1_CHROMA_DEF;
        m = MP3_REF1_LUMA_DEF;
        n = MP3_REF1_CHROMA_DEF;
        fillPattern(m, n, 0x00000000);

        //m = MP3_REF1_CHROMA_DEF;
        //n = MP3_REF0_CHROMA_DEF;
        m = MP3_REF1_CHROMA_DEF;
        n = MP3_REF1_CHROMA_DEF + 288;
        fillPattern(m, n, 0x80808080);
    }
}

void set_disbuf(int id)
{
    regs0->dis_pic_id = id;
    clrJPGbuffer(id);
}
#endif

/*
** FUNCTION
** clrFrameBuffer(mask)
**
** DESCRIPTION
** clear framebuffer
*/
#if CONFIG==CONFIG_COMBO_SVCD
int clrFrameBuffer(UINT32 bitmask)
{
    int     i, j, row_lo, row_hi;

    //int xlimit = (bitmask&FRAME_720) ? 736 : 480;
    int     xlimit;

    //psprintf(LineBuffer,"H=%d V=%d\n",horizontal_size_value,vertical_size_value);
    //epp_write_wait(LineBuffer);
    //jjding
    if(cd_type_loaded == CDSVCD)
    {
        if(horizontal_size_value > 480)
            xlimit = 720;
        else
            xlimit = 480;
    }
    else
    {
        if(horizontal_size_value > 352)
            xlimit = 704;
        else
            xlimit = 352;
    }

    //psprintf(LineBuffer,"xlimit:(%d) REF0_LUMA:(%d) REF1_LUMA:(%d) REF0_CHROMA:(%d) REF1_CHROMA:(%d)\n",xlimit,regs0->ref0_luma,regs0->ref1_luma,regs0->ref0_chroma,regs0->ref1_chroma);
    //epp_write_wait(LineBuffer);



    DMA_push(0, 128);
    /* clean it */
    if(bitmask & FRAME_REF0)
    {
#ifdef DEBUG_FILL_LUMA
        for(i = 0; i < 128; i++)
            dma_buf.b[i] =
                254 - ((i & 0xe7) | ((i & 0x10) >> 1) | ((i & 0x08) << 1)) * 2;
        //for (i=0; i<128/4; i++) dma_buf.w[i] = ((UINT32 *)lma_array)[i];
        //for (i=0; i<128/4; i++) dma_buf.w[i] = ((i*8)<<24) | ((i*8)<<16) | ((i*8)<<8) | (i*8);
#else
        //for (i=0; i<128/4; i++) dma_buf.w[i] = 0x00;
        for(i = 0; i < 128; i++)
            dma_buf.b[i] = 16;
#endif
        row_lo = REF0_LUMA;
        row_hi = row_lo + vertical_size_value;

        for(j = row_lo; j < row_hi; j++)
        {
            i = 0;
            do
            {
                int     len = (xlimit - i);

                if(len > 128)
                    len = 128;
                DMA_save(VADDR_MODE_GLOBAL, j, i, 0, len);
                i += len;
                DMA_wait();
            } while(i < xlimit);
        }

        //psprintf(LineBuffer,"0->LUMA_ROW_L:(%d) LUMA_ROW_H:(%d)\n",row_lo,row_hi);
        //epp_write_wait(LineBuffer);

        for(i = 0; i < 128 / 4; i++)
            dma_buf.w[i] = 0x80808080;
        row_lo = REF0_CHROMA;
        row_hi = row_lo + vertical_size_value / 2;
        for(j = row_lo; j < row_hi; j++)
        {
            i = 0;
            do
            {
                int     len = (xlimit - i);

                if(len > 128)
                    len = 128;
                DMA_save(VADDR_MODE_GLOBAL, j, i, 0, len);
                i += len;
                DMA_wait();
            } while(i < xlimit);
        }
        //psprintf(LineBuffer,"0->CHROMA_ROW_L:(%d) CHROMA_ROW_H:(%d)\n",row_lo,row_hi);
        //epp_write_wait(LineBuffer);
    }

    if(bitmask & FRAME_REF1)
    {
#if 1
#ifdef DEBUG_FILL_LUMA
        for(i = 0; i < 128; i++)
            dma_buf.b[i] = ((i & 0xe7) | ((i & 0x10) >> 1) | ((i & 0x08) << 1)) * 2;
#else
        for(i = 0; i < 128 / 4; i++)
            dma_buf.w[i] = 16;
#endif
        row_lo = REF1_LUMA;
        row_hi = row_lo + vertical_size_value;
        for(j = row_lo; j < row_hi; j++)
        {
            i = 0;
            do
            {
                int     len = (xlimit - i);

                if(len > 128)
                    len = 128;
                DMA_save(VADDR_MODE_GLOBAL, j, i, 0, len);
                i += len;
                DMA_wait();
            } while(i < xlimit);
        }
//    psprintf(LineBuffer,"1->LUMA_ROW_L:(%d) LUMA_ROW_H:(%d)\n",row_lo,row_hi);
//    epp_write_wait(LineBuffer);
        for(i = 0; i < 128 / 4; i++)
            dma_buf.w[i] = 0x80808080;
        row_lo = REF1_CHROMA;
        row_hi = row_lo + vertical_size_value / 2;  //(cd_type_loaded==CDSVCD ? CHROMA_ROW:CHROMA_ROW/2);
        for(j = row_lo; j < row_hi; j++)
        {
            i = 0;
            do
            {
                int     len = (xlimit - i);

                if(len > 128)
                    len = 128;
                DMA_save(VADDR_MODE_GLOBAL, j, i, 0, len);
                i += len;
                DMA_wait();
            } while(i < xlimit);
        }
//    psprintf(LineBuffer,"1->CHROMA_ROW_L:(%d) CHROMA_ROW_H:(%d)\n",row_lo,row_hi);
//    epp_write_wait(LineBuffer);
#endif
    }

    if(bitmask & FRAME_B)
    {
        /* clear chroma */
        for(i = 0; i < 128 / 4; i++)
            dma_buf.w[i] = 0x80808080;
        row_lo = BIDIR_CHROMA;
        row_hi = row_lo + BIDIR_CHROMA_ROW;
        for(j = row_lo; j < row_hi; j++)
        {
            for(i = 480; i < 736; i += 128)
            {
                DMA_save(VADDR_MODE_GLOBAL, j, i, 0, 128);
                DMA_wait();
            }
        }
        /* clear luma */
#ifdef DEBUG_FILL_LUMA
        for(i = 0; i < 128; i++)
            dma_buf.b[i] = ((i & 0xe7) | ((i & 0x10) >> 1) | ((i & 0x08) << 1)) * 2;
#else
        for(i = 0; i < 128 / 4; i++)
            dma_buf.w[i] = 0;
#endif
        row_lo = BIDIR_LUMA;
        row_hi = row_lo + BIDIR_LUMA_ROW;
        for(j = row_lo; j < row_hi; j++)
        {
            for(i = 480; i < 736; i += 128)
            {
                DMA_save(VADDR_MODE_GLOBAL, j, i, 0, 128);
                DMA_wait();
            }
        }
    }
    //psprintf(LineBuffer,"LUMA_ROW:(%d) CHROMA_ROW:(%d)\n",LUMA_ROW,CHROMA_ROW);
    //epp_write_wait(LineBuffer);
    /* restore it */
    DMA_pop(0, 128);
    return 0;
}
#else
int clrFrameBuffer(UINT32 bitmask)
{
    DMA_push(0, 128);

    if(bitmask & FRAME_REF0)
    {
        int     m, n;

        m = REF0_LUMA_ROW_START;
        n = REF0_LUMA_ROW_END;
        fillPattern(m, n, 0x00000000);

        m = REF0_CHROMA_ROW_START;
        n = REF0_CHROMA_ROW_END;
        if(n <= m)
        {
            if(cd_type_loaded == CDROM)
                n = (492 - 45);                 //rbhung 2002.09.13 Avoid MP3 File Structure 
            // (20K file structure + 45K program)
            else
            {
                if(framebuffer_configuration == MEM_CONFIG_HIRES)   //charles 2002/10/1 modify
                    n = 512;
                else
                    n = REF1_CHROMA_ROW_END;
            }
        }