buxx_adsc.c

bu1566dsp芯片用来处理ov7660或其他３０万摄像模组的图像预览．图像拍照（jpeg压缩）

    jpeg_info.q_y = &q_y;
    jpeg_info.q_c = &q_c;

    jpeg_info.code = start_add;

    bit_write(MEMCNT, bADRINC, HIGH);

    bit_write(JPG_CNT, bSWRST | bRING_A_RST, HIGH);     // Reset JPEG core
    wait(1);                    // wait 1ms
    bit_write(JPG_CNT, bSWRST | bRING_A_RST, LOW);      // Clear Reset

    mode_change(sREADY);        //READY MODE
    u16ClkCntReg=data_write(CLKCNT, sVD|bVD_EN|bSCKEN|0x0000);
    u16MemCntReg=data_write(MEMCNT, bADRINC|0x0000);

    err_code = analyze_header(start_add, jpeg_size, &jpeg_info);
    if (err_code)  return err_code;

    reg_camif = data_write(CAMIF, 0x0700);      //cam I/F normal丄camvs/camhs LOW sink丄YUV(4:2:2)丄UYVYUYVY
    reg_camtim = data_write(CAMTIM, 0x0000);    //A cam I/F frame start pixel position is set up

    reg_cxsize = data_read(CXSIZE);     // Xsize
    reg_cysize = data_read(CYSIZE);     // Ysize
    cam_size_set(jpeg_info.X, jpeg_info.Y);
    
    if (cam->cst_x + cam->xsize > jpeg_info.X )
        err_code = 0x0110;
    if (cam->cst_y + cam->ysize > jpeg_info.Y )
        err_code = 0x0111;

    *p_u16Rgb_addr++=jpeg_info.X;
    *p_u16Rgb_addr++=jpeg_info.Y ;

    err_code = cam_capture_set(cam);
    if (err_code)
    {
        err_code |= 0x0100;
        goto DEC_END;
    }

    set_jpeg_setting(jpeg_info.X, jpeg_info.Y, jpeg_info.interval,
                     jpeg_info.type);

    mode_change(sHOSTJPEGDEC);

    set_huf_table(jpeg_info.h_y_dc, jpeg_info.h_y_ac, jpeg_info.h_c_dc,
                  jpeg_info.h_c_ac);
    set_q_table(jpeg_info.q_y, jpeg_info.q_c);

    gl_cam_end_chk=0;
    data_write(INTMSK, (UINT16)(~bCAMED_MSK));   //cam_ed_int enable
    bit_write(INTMSK, bCAMED_INT, LOW);  // clear int

    jpeg_info.code_size=5120; //test 20050519
    for (code_offset = 0; code_offset < jpeg_info.code_size;
         code_offset += 5120)
    {
        set_code(jpeg_info.code, code_offset, BU1554_MIN(code_offset + 5120, jpeg_info.code_size));    // (re)start decode
        err_code=JpegIntDisp((UINT16*)p_u16Rgb_addr, &u32CurRgbSize, jpeg_info.X*jpeg_info.Y);
        wait(10);
        if (err_code)
        {
            err_code |= 0x0300;
            goto DEC_END;
        }
        p_u16Rgb_addr+=u32CurRgbSize;
        err_code = bit_read(JPG_ST2, bJD_ERROR);
        if (err_code)
        {
            err_code |= 0x0200;
            goto DEC_END;
        }
    }
/* //test 20050519
    if(gl_cam_end_chk == 0)
    {
        CheckJpegInt();
    }
*/
    reg_write(INDEX, RING_RD_RGB);
//    read_code(&p_u16Rgb_addr, (jpeg_info.X*jpeg_info.Y)%0x2000);  //test 20050519
{ //test 20050519
    UINT16 reg_data;
    reg_data = reg_read(REG);
    reg_data = reg_read(REG);
    read_code(&p_u16Rgb_addr, 0x6000); 
}
#ifdef HOSTJD_TEST        
    gl_intdisp_sequence[gl_intdisp_index]=3;
    gl_intdisp_index++;
#endif
    gl_cam_end_chk=0;
    data_write(INTMSK, 0xffff);   //cam_ed_int disable
    bit_write(INTMSK, bCAMED_INT, LOW);  // clear int

  DEC_END:
    data_write(CAMIF, reg_camif);       //cam I/F normal丄camvs/camhs LOW sink丄YUV(4:2:2)丄UYVYUYVY
    data_write(CAMTIM, reg_camtim);     //A cam I/F frame start pixel position is set up
    data_write(CXSIZE, reg_cxsize);     // Xsize
    data_write(CYSIZE, reg_cysize);     // Ysize
    data_write(CLKCNT, u16ClkCntReg);
    data_write(MEMCNT,u16MemCntReg);
    mode_change(sREADY);
    bit_write(MEMCNT, bADRINC, LOW);

    return err_code;

}

static int jpeg_decode(UINT8 * start_add, UINT32 * const jpeg_size,
                       const CAMSET * const cam)
{

    JPEG_INFO jpeg_info = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    static QTABLE q_c;
    static QTABLE q_y;
    UINT32 code_offset;
    UINT16 reg_camif, reg_camtim, reg_cxsize, reg_cysize;
    int err_code = 0;

    jpeg_info.q_y = &q_y;
    jpeg_info.q_c = &q_c;

    jpeg_info.code = start_add;

    bit_write(MEMCNT, bADRINC, HIGH);

    bit_write(JPG_CNT, bSWRST | bRING_A_RST, HIGH);     // Reset JPEG core
    wait(1);                    // wait 1ms
    bit_write(JPG_CNT, bSWRST | bRING_A_RST, LOW);      // Clear Reset

    mode_change(sREADY);        //READY MODE
    mode_change(sJPEGDECODE);

    err_code = analyze_header(start_add, jpeg_size, &jpeg_info);
    if (err_code)  return err_code;

    ////////////////////////////////////////////////////////////
    // jpeg decode camera parameter setting
    //
    reg_camif = data_write(CAMIF, 0x0700);      //cam I/F normal丄camvs/camhs LOW sink丄YUV(4:2:2)丄UYVYUYVY
    reg_camtim = data_write(CAMTIM, 0x0000);    //A cam I/F frame start pixel position is set up

    reg_cxsize = data_read(CXSIZE);     // Xsize
    reg_cysize = data_read(CYSIZE);     // Ysize
    cam_size_set(jpeg_info.X, jpeg_info.Y);

    if (cam->cst_x + cam->xsize > jpeg_info.X / cam->srkx)
        err_code = 0x0110;
    if (cam->cst_y + cam->ysize > jpeg_info.Y / cam->srky)
        err_code = 0x0111;

    err_code = cam_capture_set(cam);
    if (err_code)
    {
        err_code |= 0x0100;
        goto DEC_END;
    }

    ////////////////////////////////////////////////////////////
    // jpeg decode parameter setting
    //

    set_jpeg_setting(jpeg_info.X, jpeg_info.Y, jpeg_info.interval,
                     jpeg_info.type);

    ////////////////////////////////////////////////////////////
    // Write Huffman table[L]
    //

    set_huf_table(jpeg_info.h_y_dc, jpeg_info.h_y_ac, jpeg_info.h_c_dc,
                  jpeg_info.h_c_ac);


    ////////////////////////////////////////////////////////////
    // Write Q table

    set_q_table(jpeg_info.q_y, jpeg_info.q_c);


    /////////////////////////////////////////////////
    // Write jpeg code

    //
    // Main Loop
    //


    for (code_offset = 0; code_offset < jpeg_info.code_size;
         code_offset += 5120)
    {
        set_code(jpeg_info.code, code_offset, BU1554_MIN(code_offset + 5120, jpeg_info.code_size));    // (re)start decode
        bit_write(JPG_CNT, bJD_ST, HIGH);
        wait_int0_jpeg(bJD_ED_MSK);     // wait JD_ED interrupt
        err_code = bit_read(JPG_ST2, bJD_ERROR);
        if (err_code)
        {
            err_code |= 0x0200;
            goto DEC_END;
        }
    }


    // if JD_STAT is 1, then restart decode
    if (bit_read(JPG_ST1, bJD_STAT))
    {
        bit_write(JPG_CNT, bJD_ST, HIGH);       // (re)start decode
        wait_int0_jpeg(bJD_ED_MSK);     // wait JD_ED interrupt
        err_code = bit_read(JPG_ST2, bJD_ERROR);
        if (err_code)
        {
            err_code |= 0x0200;
            goto DEC_END;
        }
    }



  DEC_END:
    data_write(CAMIF, reg_camif);       //cam I/F normal丄camvs/camhs LOW sink丄YUV(4:2:2)丄UYVYUYVY
    data_write(CAMTIM, reg_camtim);     //A cam I/F frame start pixel position is set up
    data_write(CXSIZE, reg_cxsize);     // Xsize
    data_write(CYSIZE, reg_cysize);     // Ysize
    mode_change(sREADY);
    bit_write(MEMCNT, bADRINC, LOW);

    return err_code;

}

static void CheckJpegInt(void)
{
#if defined BUXX_POLLING
    UINT16 u16JpgIntStatus=0,u16IntStatus=0;
    UINT16 idx_push = reg_read(INDEX);
    while (u16JpgIntStatus == 0 && u16IntStatus==0)
    {
        u16JpgIntStatus=(data_read(JPG_INTST) & 0x0007);
        u16IntStatus=(data_read(INTST) & 0x0004);
    }
    if (u16JpgIntStatus & bJE_RING_INT)
    {                       // JE_RING_INT
        bit_write(JPG_INTST, bJE_RING_INT, LOW);      //RING_INT clear
        gl_bank_chk++;
#ifdef HOSTJD_TEST        
        gl_intcheck_sequence[gl_intcheck_index]=1;
        gl_intcheck_index++;
#endif
    }
    if (u16JpgIntStatus & bJD_ED_INT)
    {
        bit_write(JPG_INTST, bJD_ED_INT, LOW);                // JE_ED_INT clear
        gl_jd_end_chk++;
#ifdef HOSTJD_TEST        
        gl_intcheck_sequence[gl_intcheck_index]=2;
        gl_intcheck_index++;
#endif
    }
    if(u16IntStatus & bCAMED_INT)
    {
        bit_write(INTST, bCAMED_INT, LOW);                // CAM_ED_INT clear
        gl_cam_end_chk++;
#ifdef HOSTJD_TEST        
        gl_intcheck_sequence[gl_intcheck_index]=3;
        gl_intcheck_index++;
#endif
    }
    reg_write(INDEX,idx_push);
#else
    while (gl_bank_chk == 0 && gl_jd_end_chk == 0 /*&& gl_cam_end_chk==0*/);
#endif

}

static int JpegIntDisp(UINT16* u16Rgb_addr, UINT32* p_u32CurRgbSize, UINT32 u32TotalRgbSize)
{   
    UINT32 count=0,i;
    UINT16 bank_count=0;
    UINT16 reg_data=0;
//    static UINT16 u16BankMaxNumber=0;
    gl_bank_chk = 0;
    gl_jd_end_chk = 0;
    
    data_write(JPG_INTMSK, (UINT16)(~(bJD_ED_MSK|bJE_RING_MSK)));   //jped_int enable
    bit_write(JPG_INTMSK, bJE_RING_INT | bJD_ED_INT, LOW);  // clear int

    bit_write(JPG_CNT, bJD_ST, HIGH);
    for(i=0;i<10;i++);
    
    while (1)
    {
        CheckJpegInt(); //check RING_INT and JD_ED_INT

        if (gl_bank_chk != 0 || (gl_bank_chk == 0 && gl_jd_end_chk == 1)) 
        {
            if (gl_bank_chk != 0)  //RING_INT appear
            {
#ifdef HOSTJD_TEST        
                gl_intdisp_sequence[gl_intdisp_index]=1;
                gl_intdisp_index++;
#endif
                count = BANK_SIZE;
                if(*p_u32CurRgbSize==0) //first time RGB read should include twice dummy read 
                {
                    bit_write(MEMCNT, bRGB_FRAME, HIGH);
                    reg_write(INDEX, RING_RD_RGB);
                    reg_data=reg_read(REG);
                    reg_data=reg_read(REG);
                }
                else
                {
                    reg_write(INDEX, RING_RD_RGB);
                }
#if BUSACCESS_BIT == 8 && ENDIAN == sLITTLE_END
                hostcnt_bitwrite(bHOST_END, HIGH);
                reg_write(INDEX, RING_RD_RGB);
#endif
                read_code(&u16Rgb_addr, count / 2);

#if BUSACCESS_BIT == 8 && ENDIAN == sLITTLE_END
                reg_data = hostcnt_bitread(0xffff);
                reg_data = ((reg_data & 0xff00) >> 8) | ((reg_data & 0x00ff) << 8);
                hostcnt_write(reg_data & (UINT16) (~(bHOST_END)));      //rectangle increment丄auto increment on        
#endif
                gl_bank_chk--;
                bank_count++;
                if (gl_bank_chk >= BANK_NUM)   return 0x03;
            }

            if (gl_bank_chk == 0 && gl_jd_end_chk == 1)  //JD_ED_INT appear
            {
#ifdef HOSTJD_TEST        
                gl_intdisp_sequence[gl_intdisp_index]=2;
                gl_intdisp_index++;
#endif
                gl_jd_end_chk--;
                *p_u32CurRgbSize = BANK_SIZE * bank_count/2; //word unit
//                u16BankMaxNumber+=bank_count;
                break;
            }
        }
    }

    data_write(JPG_INTMSK, 0xffff);   //lcded_int disable
    bit_write(JPG_INTMSK, bJE_RING_INT | bJD_ED_INT, LOW);  // clear int

    return 0;
}

//-----------------------------------------------------------------------------
//                           JPEG Header analyze        
//-----------------------------------------------------------------------------
static int analyze_header(UINT8 * const jpeg, UINT32 * const jpeg_size,
                          JPEG_INFO * const jpeg_info)
{
    UINT32 pos;
    UINT16 size;
    UINT8 flag;
    UINT32 htbl_pos[4] = { 0, 0, 0, 0 };
    UINT32 qtbl_pos[4] = { 0, 0, 0, 0 };
    UINT8 c[3] = { 0, 0, 0 };
    UINT8 hv[3] = { 0, 0, 0 };
    UINT8 tq[3] = { 0, 0, 0 };
    UINT8 cs[3] = { 0, 0, 0 };
    UINT8 tdta[3] = { 0, 0, 0 };
    UINT8 nf = 0, ns = 0;
    int j, k, l, eoi_chk = 0;
    struct
    {
        int sof;
        int dht;
        int sos;
        int dqt;
        int dri;
    }
    HEADER_chk =
    {
    0, 0, 0, 0, 0};


    for (pos = 0; pos < *jpeg_size; pos++)
    {
        switch (CHAR_SHORT(((JPEG_data *) (jpeg + pos))->regread))
        {
        case 0xffc0:           //SOF                           
            if (HEADER_chk.sof >= 1)
                return 0x0001;
            HEADER_chk.sof++;
            size = CHAR_SHORT(((SOF_data *) (jpeg + pos + 2))->Lf);

            jpeg_info->X = CHAR_SHORT(((SOF_data *) (jpeg + pos + 2))->X);
            jpeg_info->Y = CHAR_SHORT(((SOF_data *) (jpeg + pos + 2))->Y);
            nf = ((SOF_data *) (jpeg + pos + 2))->Nf;
            if (nf != 1 && nf != 3)
                return 0x0002;

            for (j = 0; j < nf; j++)
            {
                c[j] = ((SOF_data *) (jpeg + pos + 2))->CHVT[j][0];
                hv[j] = ((SOF_data *) (jpeg + pos + 2))->CHVT[j][1];
                tq[j] = ((SOF_data *) (jpeg + pos + 2))->CHVT[j][2];
            }
            if (size != (8 + nf * 3))
                return 0x0003;
            pos += size + 1;
            break;
        case 0xffc1:
        case 0xffc2:
        case 0xffc3:
        case 0xffc5:
        case 0xffc6:
        case 0xffc7:
        case 0xffc9:
        case 0xffca:
        case 0xffcb:
        case 0xffcd:
        case 0xffce:
        case 0xffcf:
            return 0x0004;
            break;
        case 0xffc4:           //DHT
            if (HEADER_chk.dht >= 4)
                return 0x0006;
            HEADER_chk.dht++;
            size = CHAR_SHORT(((DHT_data *) (jpeg + pos + 2))->Lh);

            flag = ((DHT_data *) (jpeg + pos + 2))->TcTh;
            flag =
                (flag & 0xe0) | ((flag & 0x10) >> 3) | ((flag & 0x0e) << 1)
                | (flag & 0