jpeg_dec.c

基于Linux的ffmepg decoder

#include "jpeg_dec.h"
#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
//#include "jmemsys.h"		/* import the system-dependent declarations */

// reserve space for input bitstream, output YUV, golden bitstream under RTL simulation
#ifdef RTL_PLATFORM
  // Under RTL simulation, we have to embedded the JPEG bitstream inside executable program.
  // So we include the array of JPEG bitstream to compile with program body.
  #include "input_stream.h"
  
  // Under RTL simulation, we reserve the output YUV space inside executable program.
  // So we include the array of decoded image result to compile with program body.
  #include "output_stream.h"  
  // include the 'golden_stream.h' file for the purpose of automatically comparing decoding
  // result durin RTL simulation
  #include "golden_stream.h"
  unsigned char* goldendata[]={ (unsigned char *) goldenstream0, (unsigned char *) goldenstream1,(unsigned char *) goldenstream2 };
  unsigned long int goldendata_len[]={sizeof(goldenstream0),sizeof(goldenstream1),sizeof(goldenstream2)};
#endif


#ifdef USE_INTERNAL_CPU
  //#ifdef FPGA_PLATFORM
    //#include "intercpucode_fpga.h"
  //#elif defined(RTL_PLATFORM)
    //#include "intercpucode_rtl.h"
  //#else
    //#error "Please define the platfrom flags in project setting (either FPGA_PLATFORM or RTL_PLATFORM)"
  //#endif
  #include "intercpucode.h"
#endif

/* Create the add-on message string table. */

#define JMESSAGE(code,string)	string ,

static const char * const cdjpeg_message_table[] = {
#include "cderror.h"
  NULL
};

//struct jpeg_decompress_struct cinfo;
//struct jpeg_error_mgr jerr;

void Init_FTMCP100(j_decompress_ptr cinfo,FJPEG_DEC_PARAM * ptParam)
{
  unsigned int *inbitstr;
  unsigned int vldsts_reg;
  
  // You don't have to free the 'pCodec' since we use the 'alloc_small' function.
  FTMCP100_CODEC *pCodec=(FTMCP100_CODEC *) (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,sizeof(FTMCP100_CODEC));
  
  // attach our FTMCP100 Codec object to decompression object
  cinfo->pCodec=pCodec;
  // To initialize this global variable BASE_ADDRESS in the first place
  // or all other reigster access depend on this global variable
  pCodec->pCoreBaseAddr=ptParam->pu32BaseAddr;
  
  pCodec->pfnDmaMalloc=(void *)ptParam->pfnDmaMalloc;
  pCodec->pfnDmaFree=(void *)ptParam->pfnDmaFree;
  
  #ifdef CORE_VERSION_1
    // ten blocks at most.. and each DMA command set occupies 4 words
    // and we allocate the system DMA memory about 4*10*4=160 bytes with 16-byte alignment
    pCodec->pSDMA_virt=(unsigned char*)(*(DMA_MALLOC_PTR)pCodec->pfnDmaMalloc)(160,16,16,&pCodec->pSDMA_phy);
  #endif
  
  pCodec->pingpong_buf[0] = (unsigned short *) (PINGPONG_BUFFER_0_ADDR);
  pCodec->pingpong_buf[1] = (unsigned short *) (PINGPONG_BUFFER_1_ADDR);
  
  pCodec->pLDMA = (unsigned int *) (DMA_COMMAND_LOCAL_ADDR+pCodec->pCoreBaseAddr);
  
  #ifdef USE_INTERNAL_CPU
    pCodec->pLDMA_INTERNAL_CPU = (unsigned int *) (DMA_COMMAND_INTERNAL_CPU+pCodec->pCoreBaseAddr);
  #endif
  
  // initialize the buffer descriptor
  pCodec->buf_descriptor1=0; // used to select ping pong buffer for VLD output
  pCodec->buf_descriptor2=0; // used to select buffer between DQ-MC stage and DMA stage (indicated by MCIADDR for DQ-MC engine output)

  
  
  // initialze some varaibles here
  #ifdef RTL_PLATFORM
    // 'instream' variable is defined in the file 'input_stream.h'
    inbitstr = (unsigned int *)instream; // set input bitstream location
  #else
    inbitstr = (unsigned int *)ptParam->pu8BitstreamAddr; // set input bitstream location
  #endif
  
  SET_VLDCTL(1<<5) //stop autobuffer in case previous firmware program did not terminate normally
  SET_PYDCR(0)  // set JPEG Previous Y DC Value Register to zero
	SET_PUVDCR(0) // set JPEG Previous UV DC Value Register to zero
	SET_CKR(CKR_RATIO) // set Coprocessor Clock Control Register
	SET_VADR(VLD_AUTOBUFFER_ADDR)  // set VLD Data Address Register (in Local Memory)
	SET_BADR(0) // reset the Bitstream Access Data Regsiter
	SET_BALR(0) // reset the Bitstream Access Length Register 
	SET_ABADR((unsigned int)inbitstr) // set Auto-Buffer System Data Address for VLD read operation
	SET_VLDCTL(0x58)  //Autobuffer Start (1011000) , just enable the VLD autobuffer engine and enable endian swapping (bit 6)
	SET_MCCADDR(0)  // we set MCCADDR to zero on purpose 
	
  #ifdef USE_INTERNAL_CPU
    // we might need to reset the internal CPU before decoding under embedded-CPU architecture
    SET_INCTL(1<<19) // reset internal CPU
  #endif
  // before read the header, we ought to check if the auto-buffer is ready for access or not
  // check autobuffer access is done or not
  do {
    READ_VLDSTS(vldsts_reg)
	} while(!(vldsts_reg&0x0800));
}

void *FJpegDecCreate(FJPEG_DEC_PARAM * ptParam)
{ 
  struct jpeg_decompress_struct *cinfo;
  struct jpeg_error_mgr *jerr;
  
  #ifdef USE_INTERNAL_CPU
    FTMCP100_CODEC *pCodec;
    volatile MDMA *pmdma;
    unsigned int internal_cpu_code_word_length;
    int ci; unsigned int *p;  
  #endif
   
  #ifdef RTL_PLATFORM
    __rt_lib_init(0x50000, 0x200000);    
    _fp_init();
  #endif

  // start the out operation
  #ifdef VPE_OUTPUT
    RTL_DEBUG_OUT(0x91111111) // begin VPE operation
  #endif
  
  cinfo=malloc(sizeof(struct jpeg_decompress_struct));
  jerr=malloc(sizeof(struct jpeg_error_mgr));

  // Initialize the JPEG decompression object with default error handling.
  cinfo->err = jpeg_std_error(jerr); //cinfo.err = jpeg_std_error(&jerr);
  jpeg_create_decompress(cinfo); //jpeg_create_decompress(&cinfo);
  // Add some application-specific error messages (from cderror.h)
  jerr->addon_message_table = cdjpeg_message_table; //jerr.addon_message_table = cdjpeg_message_table;
  jerr->first_addon_message = JMSG_FIRSTADDONCODE; //jerr.first_addon_message = JMSG_FIRSTADDONCODE;
  jerr->last_addon_message = JMSG_LASTADDONCODE; //jerr.last_addon_message = JMSG_LASTADDONCODE;
  
  Init_FTMCP100(cinfo,ptParam);
  
  #ifdef USE_INTERNAL_CPU
    pCodec=(FTMCP100_CODEC *)cinfo->pCodec;
#ifndef LINUX
    pmdma = MDMA1; // used to access the DMA register
    pmdma->Status = 1;

    // let's set the DMA command buffer for loading the internal CPU code to internal
    // local memory, seems not work...let's use data move ...
    // improve it by DMA later
    internal_cpu_code_word_length=sizeof(InterCPUcode) / sizeof(unsigned int);
    #ifdef VPE_OUTPUT
      //RTL_DEBUG_OUT(0x90000000 | internal_cpu_code_word_length) // print the word length of internal cpu code
    #endif

    // copy from Winnie's code
    pCodec->pLDMA_INTERNAL_CPU[0]=InterCPUcode;
	pCodec->pLDMA_INTERNAL_CPU[1]=pCodec->pCoreBaseAddr;
	pCodec->pLDMA_INTERNAL_CPU[2]=0x0;
	pCodec->pLDMA_INTERNAL_CPU[3]=0x0<<26 | 0x8<<20 | internal_cpu_code_word_length;
	pmdma->CCA = (((unsigned int) pCodec->pLDMA_INTERNAL_CPU)&0xfffffff0) | 0x2;
	pmdma->Control = 0xa<<20 | 0x1<<26;				//start DMA
#else
     memcpy (pCodec->pCoreBaseAddr, InterCPUcode, sizeof(InterCPUcode));
#endif
    // to print the internal CPU code
    /*
    p=(unsigned int*)ptParam->pu32BaseAddr;
    for(ci=0;ci<internal_cpu_code_word_length;ci++)
      {
        #ifdef VPE_OUTPUT
          //RTL_DEBUG_OUT(0x90000000 | (InterCPUcode[ci]&0x0fffffff))
        #endif
        *p=InterCPUcode[ci];
        p++;
      }
    */ 
  #endif
  
  // Specify data source for decompression
  jpeg_stdio_src(cinfo, NULL); //jpeg_stdio_src(&cinfo, NULL);
  
  return (void *)cinfo;
}

JPEGDEC_EXPOPRT void FJpegDecReadHeader(void *dec_handle,FJPEG_DEC_RESULT *pDecResult)
{
  int ci;
  jpeg_component_info *compptr;
  struct jpeg_decompress_struct *cinfo=(struct jpeg_decompress_struct *) dec_handle;
  
  (void) jpeg_read_header(cinfo, TRUE); //(void) jpeg_read_header(&cinfo, TRUE);
  
  // Start decompressor
  (void) jpeg_start_decompress(cinfo); //(void) jpeg_start_decompress(&cinfo);
  
  // fill the members of FJPEG_DEC_RESULT data structure for return
  pDecResult->u32ImageWidth=cinfo->image_width;
  pDecResult->u32ImageHeight=cinfo->image_height;
  pDecResult->u8NumComponents=cinfo->num_components;
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;ci++, compptr++) 
    {
      pDecResult->rgComponentInfo[ci].m_u8HSamplingFrequency=compptr->h_samp_factor;
      pDecResult->rgComponentInfo[ci].m_u8VSamplingFrequency=compptr->v_samp_factor;
      if(jpeg_has_multiple_scans(cinfo))
        { // it the image is non-interleaved format , one block per MCU
          pDecResult->rgComponentInfo[ci].m_u32ComponentWidth= compptr->width_in_blocks * DCTSIZE;
          pDecResult->rgComponentInfo[ci].m_u32ComponentHeight= compptr->height_in_blocks * DCTSIZE;
          //m=compptr->MCU_blocks*compptr->width_in_blocks * compptr->height_in_blocks;
        }
      else
        {
          pDecResult->rgComponentInfo[ci].m_u32ComponentWidth= cinfo->MCUs_per_row * compptr->MCU_width * DCTSIZE;
          pDecResult->rgComponentInfo[ci].m_u32ComponentHeight= cinfo->MCU_rows_in_scan * compptr->MCU_height * DCTSIZE;          
          //m=compptr->MCU_blocks*cinfo->MCUs_per_row*cinfo->MCU_rows_in_scan;
        }        
      pDecResult->rgComponentInfo[ci].m_u32ComponentTotalSize=pDecResult->rgComponentInfo[ci].m_u32ComponentWidth * pDecResult->rgComponentInfo[ci].m_u32ComponentHeight;
    }

}

JPEGDEC_EXPOPRT void FJpegDecDecode(void *dec_handle,FJPEG_DEC_PARAM *ptParam)
{
  struct jpeg_decompress_struct *cinfo=(struct jpeg_decompress_struct *) dec_handle;
  FTMCP100_CODEC *pCodec=(FTMCP100_CODEC *)cinfo->pCodec;
  int ci;
  #ifdef USE_INTERNAL_CPU
    volatile MDMA *pmdma = MDMA1;
  #endif
  
  // And record the output YUV buffer 8-byte aligned address to the pCodec object
  #ifdef RTL_PLATFORM
    unsigned char* outdata[]={ (unsigned char *) outstream0, (unsigned char *) outstream1,(unsigned char *) outstream2 };
    for(ci=0; ci<ptParam->u8NumComponents; ci++)
      pCodec->outdata[ci]=outdata[ci];
  #else
    for(ci=0; ci<ptParam->u8NumComponents; ci++)
      pCodec->outdata[ci]=ptParam->pu8YUVAddr[ci];

  #endif

  // if it is interleaved image, we set the DMA stuff here...
  if(! jpeg_has_multiple_scans(cinfo)) //if(! jpeg_has_multiple_scans(&cinfo))  
    (void) ftmcp100_set_mcu_dma_params(cinfo); //(void) ftmcp100_set_mcu_dma_params(&cinfo); // to set the MCUTIR and MCUBR register 
  // we need to flush the D cache or the result will be wrong 
  FA526_CleanInvalidateDCacheAll();
  
  // Process data
  #ifdef VPE_OUTPUT
    RTL_DEBUG_OUT(0x94000000 | 6) // beginning of decoding
  #endif
  
  #ifdef USE_INTERNAL_CPU
    // remember that we have start the DMA trasnfer of internal CPU code in
    // FJpegDecCreate() function, so we need to check the DMA status right here... 
  #ifndef LINUX
    while(!(pmdma->Status & 0x1)) ; // check DMA is done
  #endif
  #endif
    
  while (cinfo->output_scanline < cinfo->output_height) { //while (cinfo.output_scanline < cinfo.output_height) {
    jpeg_read_scanlines(cinfo, NULL,0);
    
    /*
    num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
					dest_mgr->buffer_height);
    
    (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
    */
  } 
  
  #ifdef VPE_OUTPUT
    RTL_DEBUG_OUT(0x94000000 | 7) // end of decoding
  #endif

  // dump the YUV data in System Memory which was moved from Local Memory
  //...................... 
  #ifdef VPE_OUTPUT
  #ifdef VPE_DUMP_YUV 
  (void) ftmcp100_dump_yuv(cinfo); // to dump the final result for YUV data
  #endif
  #endif
  SET_VLDCTL(0x28)  //Autobuffer Stop
}


void FJpegDecDestroy(void *dec_handle)
{ 
  struct jpeg_decompress_struct *cinfo=(struct jpeg_decompress_struct *) dec_handle;  
  struct jpeg_error_mgr *jerr=cinfo->err;
  
  #if (defined(RTL_PLATFORM) || defined(CORE_VERSION_1) )
    FTMCP100_CODEC *pCodec=(FTMCP100_CODEC *)cinfo->pCodec;
  #endif
    
  #ifdef RTL_PLATFORM  
  if(cinfo->num_components)
    {
      int ci,gi;
      for (ci=0;ci<cinfo->num_components;ci++)
        {
          int error_flag=0;
          for(gi=0;gi<goldendata_len[ci];gi++)
            {
              // to show bitstream data
		      RTL_DEBUG_OUT(0x97000000 | (unsigned int)(pCodec->outdata[ci])[gi]) // dump the encoded bitstream data
              if ((pCodec->outdata[ci])[gi]!=(goldendata[ci])[gi])
                { 
                  // to show the gloden data since there is error
                  RTL_DEBUG_OUT(0x98000000 | (unsigned int)(goldendata[ci])[gi]) // dump the encoded bitstream data
                  error_flag=1;
                  break;
                }
            }
          if(error_flag)
            { RTL_DEBUG_OUT(0x01234569) break; }  // Fail!
          else
            RTL_DEBUG_OUT(0x01234568) // Pass!
        }
    }
  #endif  
  
  #ifdef CORE_VERSION_1
    // ten blocks at most.. and each DMA command set occupies 4 words
    // and we free the allocated system DMA memory with physical address and virtual address
    (*(DMA_FREE_PTR)pCodec->pfnDmaFree)(pCodec->pSDMA_virt,pCodec->pSDMA_phy);
  #endif
  
  #ifdef VPE_OUTPUT
    RTL_DEBUG_OUT(0x91222222) // means end of entire jpeg decoder
  #endif
  
  (void) jpeg_finish_decompress(cinfo);
  
  #ifdef VPE_OUTPUT
    RTL_DEBUG_OUT(0x01234567) // VPE Debug Finish
  #endif
  
  jpeg_destroy_decompress(cinfo);

  //free(pCodec); // we don't have to free the pCodec since we use (*cinfo->mem->alloc_small) function to allocate the memory
  free(jerr);
  free(cinfo);
}