Subversion Repositories mb-jpeg

#ifdef __MICROBLAZE
 
#include <stdio.h>
#include <stdlib.h>
 
#include "xup2pro.h"
 
#include "zzq.h" 
#include "io.h"
#include "huffman.h"
#include "dct.h"
 
char* bmpimage;
int bmpsize;
 
INFOHEADER _bmpheader;
 
static  signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],YMatrix[MATRIX_SIZE][MATRIX_SIZE],CrMatrix[MATRIX_SIZE][MATRIX_SIZE],CbMatrix[MATRIX_SIZE][MATRIX_SIZE];
static  signed short temp[MATRIX_SIZE][MATRIX_SIZE], dctresult[MATRIX_SIZE][MATRIX_SIZE];
static  signed char output[MATRIX_SIZE][MATRIX_SIZE];
static  signed char bitstream[NUMBER_OF_PIXELS] ;
static  unsigned char header[389];
 
int ejpgl_error(int errno, void* remark);
 
int main()
{
  SYSACE_FILE *infile;
  SYSACE_FILE *outfile;
  SYSACE_FILE* outfile2;
 
  int i;
  INFOHEADER *bmpheader;
  JPEGHEADER *jpegheader;
  unsigned int col, cols, row, rows, remaining,component;
  unsigned char amount_remaining, Ydcvalue, Cbdcvalue, Crdcvalue ;
  int encode, compression;
 
  encode = 1;
  compression = 0;
 
  bmpimage=(unsigned char*)0x70000000;
  bmpsize=0;
 
  xil_printf("\r\nBMP2JPG Code Compiled at %s %s\r\n", __DATE__, __TIME__);
 
  bmpheader=&_bmpheader;
 
  if ((infile = sysace_fopen("image01.bmp", "r")) == NULL) {
  	ejpgl_error(eOPENINPUT_FILE, 0);
  	}
 
  bmpsize = sysace_fread(bmpimage, 1, 65536, infile);
  xil_printf("bmpsize %d\r\n", bmpsize);
  if (bmpsize==65536) {
  	ejpgl_error(eLARGE_INPUTFILE, 0);
  	}
 
  if ((outfile2 = sysace_fopen("image01b.bmp", "w")) == NULL) {
	ejpgl_error(eOPENOUTPUT_FILE, 0);
  	}
  sysace_fwrite(bmpimage, 1, bmpsize, outfile2);
  sysace_fclose(outfile2);
 
  if (getbmpheader(infile,bmpheader) == 0) { //File is a valid BMP
  	ejpgl_error(eINVALID_BMP, 0);
  	}
 
  xil_printf("Image width: %d pixels\r\n", bmpheader->width);
  xil_printf("Image height: %d pixels\r\n", bmpheader->height);
 
  rows = bmpheader->height>>3;
  cols = bmpheader->width>>3;
  remaining=0x00;
  amount_remaining=0x00;
  Ydcvalue = 0x00;
  Crdcvalue = 0x00;
  Cbdcvalue = 0x00;
 
  if ((outfile = sysace_fopen("image01.jpg", "w")) == NULL) {
  	ejpgl_error(eOPENOUTPUT_FILE, 0);
 	} 
 
  writejpegheader(outfile,bmpheader);
 
  for (row = 0; row < rows; row++) {
      for (col = 0; col < cols; col++) {
          readbmpfile(infile,pixelmatrix,row,col,bmpheader);
          RGB2YCrCb(pixelmatrix,YMatrix,CrMatrix,CbMatrix);
          for(component=0;component<3;component++)  {
		  	switch (component) {
				case 0 ://Y-encoding
				dct(YMatrix,dctresult);
                            zzq(dctresult,bitstream,compression,encode);
                            Ydcvalue = EncodeDataUnit(bitstream,Ydcvalue,outfile, &remaining, &amount_remaining,component);
                            break;
                            case 1 ://Cr-encoding
                            dct(CrMatrix,dctresult);
                            zzq(dctresult,bitstream,compression,encode);
                            Crdcvalue = EncodeDataUnit(bitstream,Crdcvalue,outfile, &remaining, &amount_remaining,component);
                            break;
                            case 2 ://Cb-encoding
                            dct(CbMatrix,dctresult);
                            zzq(dctresult,bitstream,compression,encode);
                            Cbdcvalue = EncodeDataUnit(bitstream,Cbdcvalue,outfile, &remaining, &amount_remaining,component);
                            break;
                            }
                      }
            }
   }
   HuffmanEncodeFinishSend(&remaining,&amount_remaining,outfile);
   xil_printf("\r\nProcessed %d %dx%d-blocks.\r\n",(row-1)*cols+col,MATRIX_SIZE,MATRIX_SIZE);
   writejpegfooter(outfile);
 
 
   sysace_fclose(outfile);
   sysace_fclose(infile);
   return 0;
 
}
 
int ejpgl_error(int errno, void* remark) {
 
	xil_printf("--> Error %d\r\n", errno);
	exit(1);
 
}
 
 
 
#else
 
//---------------------------------------------------------------------------
typedef union {		/* block of pixel-space values */
  unsigned char	block[8][8];
  unsigned char	linear[64];
} PBlock;
 
typedef union {		/* block of frequency-space values */
  int block[8][8];
  int linear[64];
} FBlock;
 
#include <stdio.h>
#include <stdlib.h>
#ifndef __MICROBLAZE
#include <windows.h>
#endif
#include "zzq.h" 
#include "io.h"
#include "huffman.h"
#include "dct.h"
#pragma hdrstop
 
 
//---------------------------------------------------------------------------
 
INFOHEADER _bmpheader;
 
#pragma argsused
int main(int argc, char* argv[])
{
  int encode, compression,i;
  signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],YMatrix[MATRIX_SIZE][MATRIX_SIZE],CrMatrix[MATRIX_SIZE][MATRIX_SIZE],CbMatrix[MATRIX_SIZE][MATRIX_SIZE];
  /*= {{124, 105, 139, 95, 143, 98, 132, 114},
{105, 157, 61, 187, 51, 176, 80, 132},
{139, 61, 205, 17, 221, 32, 176, 98},
{95, 187, 17, 239, 0, 221, 51, 143},
{143, 51, 221, 0, 239, 17, 187, 95},
{98, 176, 32, 221, 17, 205, 61, 139},
{132, 80, 176, 51, 187, 61, 157, 105},
{114, 132, 98, 143, 95, 139, 105, 124}};  */
  signed short temp[MATRIX_SIZE][MATRIX_SIZE], dctresult[MATRIX_SIZE][MATRIX_SIZE];
  signed char output[MATRIX_SIZE][MATRIX_SIZE];
  signed char bitstream[NUMBER_OF_PIXELS] ;//= {15,0,-2,-1,-1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  unsigned char header[389];
  FILE *infile, *outfile;
  INFOHEADER *bmpheader;
  JPEGHEADER *jpegheader;
#ifndef __MICROBLAZE
  LARGE_INTEGER st, en;
#endif  
  unsigned int col, cols, row, rows, remaining,component;
  unsigned char amount_remaining, Ydcvalue, Cbdcvalue, Crdcvalue ;
 
 
//  bmpheader = (INFOHEADER *)malloc(sizeof(INFOHEADER));
  bmpheader=&_bmpheader;
 
  switch (argc) {
        case 3 :
                encode = 0;
        break;
        case 4 :
                encode = 1;
        break;
        case 5 :
                encode = 1;
                compression = atoi(argv[4]);
        break;
        default :
                printf("invalid number of parameters\n\nUSAGE: jpegcodec source_file destination_file [/E] [compression_rate]\n");
                printf("\nsource_file \t\t location of original file");
                printf("\ndestination_file \t location of the new file");
                printf("\n/E \t\t\t When set the source_file will be encoded to JPEG \n\t\t\t otherwise it will be decoded to BMP.");
                printf("\ncompression_rate \t specifies the compression ratio, defaults to the\n\t\t\t standard compression ratio. (Only valid when /D is set)\n");
                system("PAUSE");
                return 0;
  }
 
  infile = fopen(argv[1],"rb");
  if (infile == NULL) {
          printf("Input file %s does not exist!\n\nUSAGE: jpegcodec source_file destination_file [/E] [compression_rate]\n",argv[1]);
          printf("\nsource_file \t\t location of original file");
          printf("\ndestination_file \t location of the new file");
          printf("\n/E \t\t\t When set the source_file will be encoded to JPEG \n\t\t\t otherwise it will be decoded to BMP.");
          printf("\ncompression_rate \t specifies the compression ratio, defaults to the\n\t\t\t standard compression ratio. (Only valid when /D is set)\n");
          system("PAUSE");
  }
  else { //start codec
          outfile = fopen(argv[2],"wb");
#ifndef __MICROBLAZE		  
          QueryPerformanceCounter(&st);
#endif			 
          if(encode) { //encode infile to JPEG
                if (getbmpheader(infile,bmpheader)) { //File is a valid BMP
                        printf("\nImage width: %d pixels", bmpheader->width);
                        printf("\nImage height: %d pixels", bmpheader->height);
                        rows = bmpheader->height>>3;
                        cols = bmpheader->width>>3;
                        remaining=0x00;
                        amount_remaining=0x00;
                        Ydcvalue = 0x00;
                        Crdcvalue = 0x00;
                        Cbdcvalue = 0x00;
                        writejpegheader(outfile,bmpheader);
 
                        for (row = 0; row < rows; row++) {
                                for (col = 0; col < cols; col++) {
                                        readbmpfile(infile,pixelmatrix,row,col,bmpheader);
                                        RGB2YCrCb(pixelmatrix,YMatrix,CrMatrix,CbMatrix);
                                        for(component=0;component<3;component++)
                                        {
                                                switch (component) {
                                                        case 0 ://Y-encoding
                                                                dct(YMatrix,dctresult);
                                                                zzq(dctresult,bitstream,compression,encode);
                                                                Ydcvalue = EncodeDataUnit(bitstream,Ydcvalue,outfile, &remaining, &amount_remaining,component);
                                                                break;
                                                        case 1 ://Cr-encoding
                                                                dct(CrMatrix,dctresult);
                                                                zzq(dctresult,bitstream,compression,encode);
                                                                Crdcvalue = EncodeDataUnit(bitstream,Crdcvalue,outfile, &remaining, &amount_remaining,component);
                                                                break;
                                                        case 2 ://Cb-encoding
                                                                dct(CbMatrix,dctresult);
                                                                zzq(dctresult,bitstream,compression,encode);
                                                                Cbdcvalue = EncodeDataUnit(bitstream,Cbdcvalue,outfile, &remaining, &amount_remaining,component);
                                                                break;
                                                }
                                        }
                                }
                        }
                        HuffmanEncodeFinishSend(&remaining,&amount_remaining,outfile);
                        printf("\nProcessed %d %dx%d-blocks.",(row-1)*cols+col,MATRIX_SIZE,MATRIX_SIZE);
                        //write JPEG footer
                        writejpegfooter(outfile);
 
                }
                else {
                     printf("\n%s is not a valid BMP-file",argv[1]);
                }
 
          } else { //decode infile to BMP
 
            //    readjpegfile(infile,inputbuffer);
            //    huffmancodec(inputbuffer,bitstream,encode);
              //  zzq(pixelmatrix,bitstream,compression,encode);
            //    DCT(dctmatrix,outputbuffer,encode);
            //    writebmp(outputbuffer);*/
          }
 
        fclose(outfile);
        fclose(infile);
      /*  infile = fopen("test.jpg","rb");
        outfile = fopen("header.h","wb");
        fread(header,389,1,infile);
        for(i=0;i<389;i++)
         fprintf(outfile,"0x%x, ",header[i]);
        fclose(outfile);
        fclose(infile); */
#ifndef __MICROBLAZE		  
        QueryPerformanceCounter(&en);
        printf("\nExecution time: %f seconds",(double)(en.QuadPart-st.QuadPart)/1000000);
#endif		  
        //      free(bmpheader);
  }
  printf("\n\nHit ENTER to close this window.");
  getchar();
  return 0;
}
//---------------------------------------------------------------------------
 
#endif