|
Message
From: cvs at opencores.org<cvs@o...>
Date: Fri Jul 28 15:46:53 CEST 2006
Subject: [cvs-checkins] MODIFIED: mb-jpeg ...
Date: 00/06/07 28:15:46 Added: mb-jpeg/bmp2jpg_mb bmp2jpg_mb.c ColorConversion.c dct.c
huffman.c zzq.c dct.h ejpgl.h huffman.h io.h mb.h
weights.h zzq.h
Log:
Code ported for both platforms, i386 on PC and microblaze on xup2pro
Revision Changes Path
1.1 mb-jpeg/bmp2jpg_mb/bmp2jpg_mb.c
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/bmp2jpg_mb.c?rev=1.1&content-type=text/x-cvsweb-markup
Index: bmp2jpg_mb.c
===================================================================
#include <stdio.h>
#include <stdlib.h>
#include "mb.h"
#include "zzq.h"
#include "io.h"
#include "huffman.h"
#include "dct.h"
#ifndef __MICROBLAZE
#error This code is for Micrblaze processor only
#endif
char* bmpimage;
int bmpsize;
INFOHEADER _bmpheader;
INFOHEADER *bmpheader;
JPEGHEADER _jpegheader;
JPEGHEADER *jpegheader;
SYSACE_FILE *infile;
SYSACE_FILE *outfile;
unsigned char qtable[64] = {16, 8, 8, 16, 12, 8, 16, 16, 16, 16, 16, 16, 16, 16,
16, 32, 32, 16, 16, 16, 16, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 128, 128, 128, 128, 128, 64, 64,
128, 128, 128, 128, 128, 64, 128, 128, 128};
unsigned char huffmancount[4][16] = {{0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, //standard DC table count
{0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,0x00,0x00,0x01,0x7D}, //standard AC table count
{0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, //standard DC table count
{0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,0x00,0x00,0x01,0x7D}}; //standard AC table count
unsigned char huffDCvalues[12] ={0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b};// {0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E};
unsigned char huffACvalues[162] = {0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71,
0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82,
0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64,
0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA};
signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3];
signed char pmatrix2[MATRIX_SIZE][MATRIX_SIZE]; //YUV domain pixels
unsigned char buffer[MATRIX_SIZE*3];
int ejpgl_error(int errno, void* remark);
void get_MB(int mb_row, int mb_col, signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3]) {
unsigned int row, col;
int offset;
for(row = 0;row < MATRIX_SIZE; row++) {
offset = bmpsize-3*bmpheader->width*(row + 1 + mb_row*MATRIX_SIZE)+MATRIX_SIZE*3*mb_col;
memcpy(buffer, bmpimage + offset, MATRIX_SIZE*3);
for(col = 0; col < MATRIX_SIZE*3; col++) {
pixelmatrix[row][col] = buffer[col]- 128;
}
}
}
void put_char(unsigned c) {
sysace_fwrite(&c, 1, 1, outfile);
}
int main()
{
SYSACE_FILE* outfile2;
int i;
unsigned int col, cols, row, rows;
int compression;
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) { // see if the BMP file is correctly read into memory
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;
if ((outfile = sysace_fopen("image01.jpg", "w")) == NULL) {
ejpgl_error(eOPENOUTPUT_FILE, 0);
}
writejpegheader(outfile,bmpheader);
dct_init_start();
zzq_encode_init_start(compression);
vlc_init_start();
for (row = 0; row < rows; row++) {
for (col = 0; col < cols; col++) {
get_MB(row, col, pixelmatrix);
// dct->zz/q->vlc dct call zz/q call vlc
RGB2Y_matrix(pixelmatrix, pmatrix2);
dct(pmatrix2, 0);
RGB2Cr_matrix(pixelmatrix, pmatrix2);
dct(pmatrix2, 1);
RGB2Cb_matrix(pixelmatrix, pmatrix2);
dct(pmatrix2, 2);
}
}
HuffmanEncodeFinishSend();
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);
}
int getbmpheader(FILE * file, INFOHEADER *header)
{
memcpy(header, bmpimage+14, sizeof(INFOHEADER));
#if defined(__MICROBLAZE) // for Big Endian processors
header->size = htonl(header->size);
header->width = htonl(header->width);
header->height = htonl(header->height);
header->planes = hton(header->planes);
header->bits = hton(header->bits);
header->compression = htonl(header->compression);
header->imagesize = htonl(header->imagesize);
header->xresolution = htonl(header->xresolution);
header->yresolution= htonl(header->yresolution);
header->ncolours= htonl(header->ncolours);
header->importantcolours= htonl(header->importantcolours);
#endif
return 1;
}
void writejpegheader(FILE * file, INFOHEADER *header)
{
JPEGHEADER *jpegheader;
unsigned int headersize, huffmantablesize, previoussize;
unsigned char QTcount, i, j, components, id, huffmantablecount;
unsigned short length, headerlength;
//Number of Quatization Tables
QTcount = 2;
headerlength = 12; //12 bytes are needed for the markers
huffmantablecount = 4; //2 AC and 2 DC tables
huffmantablesize = 0;
jpegheader = &_jpegheader;//(JPEGHEADER *)malloc(550);
jpegheader->SOIMarker[0] = 0xff;
jpegheader->SOIMarker[1] = 0xd8;
//APP0 segment
jpegheader->app0.APP0Marker[0] = 0xff;
jpegheader->app0.APP0Marker[1] = 0xe0;
headerlength += 16; //APP0 marker is always 16 bytes long
jpegheader->app0.Length[0] = 0x00;
jpegheader->app0.Length[1] = 0x10;
jpegheader->app0.Identifier[0] = 0x4a;
jpegheader->app0.Identifier[1] = 0x46;
jpegheader->app0.Identifier[2] = 0x49;
jpegheader->app0.Identifier[3] = 0x46;
jpegheader->app0.Identifier[4] = 0x00;
jpegheader->app0.Version[0] = 0x01;
jpegheader->app0.Version[1] = 0x00;
jpegheader->app0.Units = 0x00;
jpegheader->app0.XDensity[0] = 0x00;
jpegheader->app0.XDensity[1] = 0x01;
jpegheader->app0.YDensity[0] = 0x00;
jpegheader->app0.YDensity[1] = 0x01;
jpegheader->app0.ThumbWidth = 0x00;
jpegheader->app0.ThumbHeight = 0x00;
//Quantization Table Segment
jpegheader->qt.QTMarker[0] = 0xff;
jpegheader->qt.QTMarker[1] = 0xdb;
length = (QTcount<<6) + QTcount + 2;
headerlength += length;
jpegheader->qt.Length[0] = (length & 0xff00)>>8;
jpegheader->qt.Length[1] = length & 0xff;
// jpegheader->qt.QTInfo = 0x00; // index = 0, precision = 0
//write Quantization table to header
i = 0;
/* jpegheader->qt.QTInfo[0] = 0;
for(i=0;i<64;i++) {
jpegheader->qt.QTInfo[i+1] = qtable[i];
}
jpegheader->qt.QTInfo[65] = 1;
for(i=0;i<64;i++) {
jpegheader->qt.QTInfo[i+66] = qtable[i];
} */
for (id=0; id<QTcount; id++) {
jpegheader->qt.QTInfo[(id<<6)+id] = id;
for(i=0;i<64;i++) {
jpegheader->qt.QTInfo[i+1+id+(id<<6)] = qtable[i];
}
}
//Start of Frame segment
jpegheader->sof0.SOF0Marker[0] = 0xff;
jpegheader->sof0.SOF0Marker[1] = 0xc0;
if(header->bits == 8) {
components = 0x01;
}
else {
components = 0x03;
}
length = 8 + 3*components;
headerlength += length;
jpegheader->sof0.Length[0] = (length & 0xff00) >> 8;
jpegheader->sof0.Length[1] = length & 0xff;
jpegheader->sof0.DataPrecision = 0x08;
jpegheader->sof0.ImageHeight[0] = (header->height & 0xff00) >> 8;
jpegheader->sof0.ImageHeight[1] = header->height & 0xff;
jpegheader->sof0.ImageWidth[0] = (header->width & 0xff00) >> 8;
jpegheader->sof0.ImageWidth[1] = header->width & 0xff;
jpegheader->sof0.Components = components;
for (i=0; i < components; i++) {
jpegheader->sof0.ComponentInfo[i][0] = i+1; //color component
jpegheader->sof0.ComponentInfo[i][1] = 0x11; //no sampling has been done
jpegheader->sof0.ComponentInfo[i][2] = (i==0)? 0x00 : 0x01; //quantization table ID
}
//Start of Huffman Table Segment
jpegheader->ht.HTMarker[0] = 0xff;
jpegheader->ht.HTMarker[1] = 0xc4;
//Set dummy HT segment length
length = 0;//tablecount*17;
jpegheader->ht.Length[0] = (length & 0xff00) >> 8;
jpegheader->ht.Length[1] = length & 0xff;
previoussize = 0;
for (id=0; id < huffmantablecount; id++) {
huffmantablesize = 0;
switch (id) {
case 0 : jpegheader->ht.HuffmanInfo[previoussize] = 0x00;
break;
case 1 : jpegheader->ht.HuffmanInfo[previoussize] = 0x10;
break;
case 2 : jpegheader->ht.HuffmanInfo[previoussize] = 0x01;
break;
case 3 : jpegheader->ht.HuffmanInfo[previoussize] = 0x11;
break;
}
for (i=1; i <= 16; i++) {
jpegheader->ht.HuffmanInfo[i+previoussize] = huffmancount[id][i-1];
huffmantablesize += huffmancount[id][i-1];
}
for (i=0; i < huffmantablesize; i++) {
jpegheader->ht.HuffmanInfo[i+previoussize+17] = (id%2 == 1)? huffACvalues[i] : huffDCvalues[i];
}
previoussize += huffmantablesize + 17;
}
//Set real HT segment length
length = 2+previoussize;
headerlength += length;
jpegheader->ht.Length[0] = (length & 0xff00) >> 8;
jpegheader->ht.Length[1] = length & 0xff;
//Reset marker segment
/* jpegheader->dri.DRIMarker[0] = 0xff;
jpegheader->dri.DRIMarker[1] = 0xdd;
jpegheader->dri.Length[0] = 0x00;
jpegheader->dri.Length[1] = 0x04;
jpegheader->dri.RestartInteral[0] = 0x00; //no restart markers
jpegheader->dri.RestartInteral[1] = 0x00; //no restart markers
headerlength += 6; //length of DRI segment
*/
//Start of Scan Header Segment
jpegheader->sos.SOSMarker[0] = 0xff;
jpegheader->sos.SOSMarker[1] = 0xda;
length = 6 + (components<<1);
headerlength += length;
jpegheader->sos.Length[0] = (length & 0xff00) >> 8;
jpegheader->sos.Length[1] = length & 0xff;
jpegheader->sos.ComponentCount = components; //number of color components in the image
jpegheader->sos.Component[0][0] = 0x01; //Y component
jpegheader->sos.Component[0][1] = 0x00; //indexes of huffman tables for Y-component
if (components == 0x03) {
jpegheader->sos.Component[1][0] = 0x02; //the CB component
jpegheader->sos.Component[1][1] = 0x11; //indexes of huffman tables for CB-component
jpegheader->sos.Component[2][0] = 0x03; //The CR component
jpegheader->sos.Component[2][1] = 0x11; //indexes of huffman tables for CR-component
}
//following bytes are ignored since progressive scan is not to be implemented
jpegheader->sos.Ignore[0] = 0x00;
jpegheader->sos.Ignore[1] = 0x3f;
jpegheader->sos.Ignore[2] = 0x00;
sysace_fwrite(jpegheader, 1, headerlength, file);
xil_printf("jpeg header size %x\r\n", headerlength);
}
void writejpegfooter(FILE * file)
{
unsigned char footer[2];
footer[0] = 0xff;
footer[1] = 0xd9;
// fseek(file,0,SEEK_END);
sysace_fwrite(footer,sizeof(footer),1,file);
}
1.1 mb-jpeg/bmp2jpg_mb/ColorConversion.c
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/ColorConversion.c?rev=1.1&content-type=text/x-cvsweb-markup
Index: ColorConversion.c
===================================================================
#include <stdio.h>
#include "io.h"
#if 0
/*USED VALUES OF ROY's CODE THIS MIGHT LEAD TO PROBLEMS*/
signed char RGB2Y (int r, int g, int b) {
return ((66*r + 129*g + 25*b + 128)>>8)+128;
}
/*USED VALUES OF ROY's CODE THIS MIGHT LEAD TO PROBLEMS*/
signed char RGB2Cr (int r, int g, int b) {
return ((-38*r - 74*g + 112*b + 128)>>8)+128;
}
/*USED VALUES OF ROY's CODE THIS MIGHT LEAD TO PROBLEMS*/
signed char RGB2Cb (int r, int g, int b) {
return ((112*r - 94*g - 18*b + 128)>>8)+128;
}
void RGB2YCrCb(signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],signed char YMatrix[MATRIX_SIZE][MATRIX_SIZE],signed char CrMatrix[MATRIX_SIZE][MATRIX_SIZE],signed char CbMatrix[MATRIX_SIZE][MATRIX_SIZE])
{
unsigned int row, col;
for(row = 0;row < MATRIX_SIZE; row++) {
for(col = 0; col < MATRIX_SIZE; col++) {
YMatrix[row][col] = RGB2Y(pixelmatrix[row][col*3+2],pixelmatrix[row][col*3+1],pixelmatrix[row][col*3]) - 128;
CrMatrix[row][col] = RGB2Cr(pixelmatrix[row][col*3+2],pixelmatrix[row][col*3+1],pixelmatrix[row][col*3]) - 128;
CbMatrix[row][col] = RGB2Cb(pixelmatrix[row][col*3+2],pixelmatrix[row][col*3+1],pixelmatrix[row][col*3]) - 128;
}
}
}
#endif
#define RGB2Y(r, g, b) (((66*r + 129*g + 25*b + 128)>>8)+128)
#define RGB2Cr(r, g, b) (((-38*r - 74*g + 112*b + 128)>>8)+128)
#define RGB2Cb(r, g, b) (((112*r - 94*g - 18*b + 128)>>8)+128)
void RGB2Y_matrix(signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],signed char YUVMatrix[MATRIX_SIZE][MATRIX_SIZE])
{
unsigned int row, col;
for(row = 0;row < MATRIX_SIZE; row++) {
for(col = 0; col < MATRIX_SIZE; col++) {
YUVMatrix[row][col] = RGB2Y(pixelmatrix[row][col*3+2],pixelmatrix[row][col*3+1],pixelmatrix[row][col*3]) - 128;
}
}
}
void RGB2Cr_matrix(signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],signed char YUVMatrix[MATRIX_SIZE][MATRIX_SIZE])
{
unsigned int row, col;
for(row = 0;row < MATRIX_SIZE; row++) {
for(col = 0; col < MATRIX_SIZE; col++) {
YUVMatrix[row][col] = RGB2Cr(pixelmatrix[row][col*3+2],pixelmatrix[row][col*3+1],pixelmatrix[row][col*3]) - 128;
}
}
}
void RGB2Cb_matrix(signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],signed char YUVMatrix[MATRIX_SIZE][MATRIX_SIZE])
{
unsigned int row, col;
for(row = 0;row < MATRIX_SIZE; row++) {
for(col = 0; col < MATRIX_SIZE; col++) {
YUVMatrix[row][col] = RGB2Cb(pixelmatrix[row][col*3+2],pixelmatrix[row][col*3+1],pixelmatrix[row][col*3]) - 128;
}
}
}
1.1 mb-jpeg/bmp2jpg_mb/dct.c
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/dct.c?rev=1.1&content-type=text/x-cvsweb-markup
Index: dct.c
===================================================================
#include <stdio.h>
#include "dct.h"
#include "weights.h"
#include "ejpgl.h"
signed short dctresult[MATRIX_SIZE][MATRIX_SIZE];
#ifdef MULTITASK
/******************************************/
/*
/* DCT task
/* for multitask RTOS implementation or
/* multiprocessor implementation
/*
/******************************************/
void dct_task(void* dct_cfg) {
struct dct_cfg_block* cb;
cb = (struct dct_cfg_block*)dct_cfg;
for (;;) {
semTake();
dct(cb->input, cb->output);
semGive();
}
}
#endif
int dct_init_start() {
return 0;
}
/*
Function Name: dct
Operation: Find the 8x8 DCT of an array using separable DCT
First, finds 1-d DCT along rows, storing the result in inter[][]
Then, 1-d DCT along columns of inter[][] is found
Input: pixels is the 8x8 input array
Output: dct is the 8x8 output array
*/
void dct(signed char pixels[8][8], int color)
{
FILE * file;
int inr, inc; /* rows and columns of input image */
int intr, intc; /* rows and columns of intermediate image */
int outr, outc; /* rows and columns of dct */
int f_val; /* cumulative sum */
int inter[8][8]; /* stores intermediate result */
int i,j,k;
k=0;
// file = fopen("weights.h","w+");
// fprintf(file,"double weights1[512] = {");
/* find 1-d dct along rows */
for (intr=0; intr<8; intr++)
for (intc=0; intc<8; intc++) {
for (i=0,f_val=0; i<8; i++) {
f_val += (pixels[intr][i]* weights[k]);//cos((double)(2*i+1)*(double)intc*PI/16);
k++;
// fprintf(file, "\n%.0f,",cos((double)(2*i+1)*(double)intc*PI/16)*16384);
}
if (intc!=0)
inter[intr][intc] = f_val>>15;
else
inter[intr][intc] = (11585*(f_val>>14))>>15;
}
// fprintf(file,"\n};");
// fclose(file);
k=0;
/* find 1-d dct along columns */
for (outc=0; outc<8; outc++)
for (outr=0; outr<8; outr++) {
for (i=0,f_val=0; i<8; i++) {
f_val += (inter[i][outc] *weights[k]);
k++;
}
if (outr!=0)
dctresult[outr][outc] = f_val>>15;
else
dctresult[outr][outc] = (11585*(f_val>>14)>>15);
}
zzq_encode(dctresult, color);
}
/*****************************************************************
UNCOMMENT THIS SECTION TO TEST 2D DCT
*****************************************************************/
/*
main()
{
unsigned char inputmatrix[8][8];
unsigned char outputmatrix[8][8];
unsigned int i,j;
printf("Input Matrix (8*8) :-\n");
for (i=0; i<8; i++){
printf("\n");
for (j=0;j<8;j++){
inputmatrix[i][j] = i*8+j;
printf("%4d",inputmatrix[i][j]);
}
}
dct(inputmatrix,outputmatrix);
printf("\n\nOutput Matrix (8*8) :-\n");
for (i=0; i<8; i++){
printf("\n");
for (j=0;j<8;j++){
printf("%4d",outputmatrix[i][j]);
}
}
printf("\n");
}
*/
1.1 mb-jpeg/bmp2jpg_mb/huffman.c
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/huffman.c?rev=1.1&content-type=text/x-cvsweb-markup
Index: huffman.c
===================================================================
#pragma argsused
/*
Only encoder
This version works correctly, it is tested with testcase.jpg
The translation into real huffman codes works.
Changed: If huffman wants to send 0xFFxx (FF in one byte) than there must be 0x00 inserted between FF and xx
possible fault in finish send:
-must it be filled up with zeros? YES
-must it be filled up to one bye? or 2 byte? --> in this code there is filled up to 2 bytes, but I (joris) thinks this must be filled up to 1 byte.
still dont know
- 24-11-05 code clean up
- 24-11-05 tables added for color
Block numbers:
Y = 0
cb =1
cr= 2
*/
//---------------------------------------------------------------------------
#include <stdio.h>
static unsigned int vlc_remaining;
static unsigned char vlc_amount_remaining;
static unsigned char dcvalue[4]; // 3 is enough
int vlc_init_start() {
vlc_remaining=0x00;
vlc_amount_remaining=0x00;
memset(dcvalue, 0, 4);
return 0;
}
#define vlc_output_byte(c) put_char(c)
#ifdef __MULTI_TASK
void vlc_task() {
}
#endif
#ifdef __MULTI_PROCESSOR
int main() {
for (;;) {
}
}
#endif
void ConvertDCMagnitudeC(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
{
switch (magnitude) {
case 0x00 : *out=0x0000; *lenght=2; break;
case 0x01 : *out=0x0001; *lenght=2; break;
case 0x02 : *out=0x0002; *lenght=2; break;
case 0x03 : *out=0x0006; *lenght=3; break;
case 0x04 : *out=0x000e; *lenght=4; break;
case 0x05 : *out=0x001e; *lenght=5; break;
case 0x06 : *out=0x003e; *lenght=6; break;
case 0x07 : *out=0x007e; *lenght=7; break;
case 0x08 : *out=0x00fe; *lenght=8; break;
case 0x09 : *out=0x01fe; *lenght=9; break;
case 0x0a : *out=0x03fe; *lenght=10; break;
case 0x0b : *out=0x07fe; *lenght=11; break;
}
}
//===========================================================================
void ConvertACMagnitudeC(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
{
switch (magnitude) {
case 0x00 : *lenght=0x02; *out=0x0000; break; //1010
case 0x01 : *lenght=0x02; *out=0x0001; break; //00
case 0x02 : *lenght=0x03; *out=0x0004; break; //01
case 0x03 : *lenght=0x04; *out=0x000a; break; //100
case 0x04 : *lenght=0x05; *out=0x0018; break; //1011
case 0x05 : *lenght=0x05; *out=0x0019; break; //11010
case 0x06 : *lenght=0x06; *out=0x0038; break; //1111000
case 0x07 : *lenght=0x07; *out=0x0078; break; //11111000
case 0x08 : *lenght=0x09; *out=0x01f4; break; //1111110110
case 0x09 : *lenght=0x0a; *out=0x03f6; break; //1111111110000010
case 0x0A : *lenght=0x0c; *out=0x0ff4; break; //1111111110000011
case 0x11 : *lenght=0x04; *out=0x000b; break; //1100
case 0x12 : *lenght=0x06; *out=0x0039; break; //11011
case 0x13 : *lenght=0x08; *out=0x00f6; break; //1111001
case 0x14 : *lenght=0x09; *out=0x01f5; break; //111110110
case 0x15 : *lenght=0x0b; *out=0x07f6; break; //11111110110
case 0x16 : *lenght=0x0c; *out=0x0ff5; break; //1111111110000100
case 0x17 : *lenght=0x10; *out=0xff88; break; //1111111110000101
case 0x18 : *lenght=0x10; *out=0xff89; break; //1111111110000110
case 0x19 : *lenght=0x10; *out=0xff8a; break; //1111111110000111
case 0x1A : *lenght=0x10; *out=0xff8b; break; //1111111110001000
case 0x21 : *lenght=0x05; *out=0x001a; break; //11100
case 0x22 : *lenght=0x08; *out=0x00f7; break; //11111001
case 0x23 : *lenght=0x0a; *out=0x03f7; break; //1111110111
case 0x24 : *lenght=0x0c; *out=0x0ff6; break; //111111110100
case 0x25 : *lenght=0x0f; *out=0x7fc2; break; //1111111110001001
case 0x26 : *lenght=0x10; *out=0xff8c; break; //1111111110001010
case 0x27 : *lenght=0x10; *out=0xff8d; break; //1111111110001011
case 0x28 : *lenght=0x10; *out=0xff8e; break; //1111111110001100
case 0x29 : *lenght=0x10; *out=0xff8f; break; //1111111110001101
case 0x2A : *lenght=0x10; *out=0xff90; break; //1111111110001110
case 0x31 : *lenght=0x05; *out=0x001b; break; //111010
case 0x32 : *lenght=0x08; *out=0x00f8; break; //111110111
case 0x33 : *lenght=0x0a; *out=0x03f8; break; //111111110101
case 0x34 : *lenght=0x0c; *out=0x0ff7; break; //1111111110001111
case 0x35 : *lenght=0x10; *out=0xff91; break; //1111111110010000
case 0x36 : *lenght=0x10; *out=0xff92; break; //1111111110010001
case 0x37 : *lenght=0x10; *out=0xff93; break; //1111111110010010
case 0x38 : *lenght=0x10; *out=0xff94; break; //1111111110010011
case 0x39 : *lenght=0x10; *out=0xff95; break; //1111111110010100
case 0x3A : *lenght=0x10; *out=0xff96; break; //1111111110010101
case 0x41 : *lenght=0x06; *out=0x003a; break; //111011
case 0x42 : *lenght=0x09; *out=0x01f6; break; //1111111000
case 0x43 : *lenght=0x10; *out=0xff97; break; //1111111110010110
case 0x44 : *lenght=0x10; *out=0xff98; break; //1111111110010111
case 0x45 : *lenght=0x10; *out=0xff99; break; //1111111110011000
case 0x46 : *lenght=0x10; *out=0xff9a; break; //1111111110011001
case 0x47 : *lenght=0x10; *out=0xff9b; break; //1111111110011010
case 0x48 : *lenght=0x10; *out=0xff9c; break; //1111111110011011
case 0x49 : *lenght=0x10; *out=0xff9d; break; //1111111110011100
case 0x4A : *lenght=0x10; *out=0xff9e; break; //1111111110011101
case 0x51 : *lenght=0x06; *out=0x003b; break; //1111010
case 0x52 : *lenght=0x0a; *out=0x03f9; break; //11111110111
case 0x53 : *lenght=0x10; *out=0xff9f; break; //1111111110011110
case 0x54 : *lenght=0x10; *out=0xffa0; break; //1111111110011111
case 0x55 : *lenght=0x10; *out=0xffa1; break; //1111111110100000
case 0x56 : *lenght=0x10; *out=0xFFA2; break; //1111111110100001
case 0x57 : *lenght=0x10; *out=0xFFA3; break; //1111111110100010
case 0x58 : *lenght=0x10; *out=0xFFA4; break; //1111111110100011
case 0x59 : *lenght=0x10; *out=0xFFA5; break; //1111111110100100
case 0x5A : *lenght=0x10; *out=0xFFA6; break; //1111111110100101
case 0x61 : *lenght=0x07; *out=0x0079; break; //1111011
case 0x62 : *lenght=0x0b; *out=0x07f7; break; //111111110110
case 0x63 : *lenght=0x10; *out=0xffa7; break; //1111111110100110
case 0x64 : *lenght=0x10; *out=0xffa8; break; //1111111110100111
case 0x65 : *lenght=0x10; *out=0xffa9; break; //1111111110101000
case 0x66 : *lenght=0x10; *out=0xffaa; break; //1111111110101001
case 0x67 : *lenght=0x10; *out=0xffab; break; //1111111110101010
case 0x68 : *lenght=0x10; *out=0xFFAc; break; //1111111110101011
case 0x69 : *lenght=0x10; *out=0xFFAf; break; //1111111110101100
case 0x6A : *lenght=0x10; *out=0xFFAe; break; //1111111110101101
case 0x71 : *lenght=0x07; *out=0x007a; break; //11111010
case 0x72 : *lenght=0x0b; *out=0x07f8; break; //111111110111
case 0x73 : *lenght=0x10; *out=0xffaf; break; //1111111110101110
case 0x74 : *lenght=0x10; *out=0xffb0; break; //1111111110101111
case 0x75 : *lenght=0x10; *out=0xFFB1; break; //1111111110110000
case 0x76 : *lenght=0x10; *out=0xFFB2; break; //111111110110001
case 0x77 : *lenght=0x10; *out=0xFFB3; break; //111111110110010
case 0x78 : *lenght=0x10; *out=0xFFB4; break; //111111110110011
case 0x79 : *lenght=0x10; *out=0xFFB5; break; //1111111110110100
case 0x7A : *lenght=0x10; *out=0xFFB6; break; //1111111110110101
case 0x81 : *lenght=0x08; *out=0x00f9; break; //111111000
case 0x82 : *lenght=0x10; *out=0xffb7; break; //111111111000000
case 0x83 : *lenght=0x10; *out=0xFFB8; break; //1111111110110110
case 0x84 : *lenght=0x10; *out=0xFFB9; break; //1111111110110111
case 0x85 : *lenght=0x10; *out=0xFFBa; break; //1111111110111000
case 0x86 : *lenght=0x10; *out=0xFFBb; break; //1111111110111001
case 0x87 : *lenght=0x10; *out=0xFFBc; break; //1111111110111010
case 0x88 : *lenght=0x10; *out=0xFFBd; break; //1111111110111011
case 0x89 : *lenght=0x10; *out=0xFFBe; break; //1111111110111100
case 0x8A : *lenght=0x10; *out=0xFFBf; break; //1111111110111101
case 0x91 : *lenght=0x09; *out=0x01f7; break; //111111001
case 0x92 : *lenght=0x10; *out=0xffc0; break; //1111111110111110
case 0x93 : *lenght=0x10; *out=0xffc1; break; //1111111110111111
case 0x94 : *lenght=0x10; *out=0xFFC2; break; //1111111111000000
case 0x95 : *lenght=0x10; *out=0xFFC3; break; //1111111111000001
case 0x96 : *lenght=0x10; *out=0xFFC4; break; //1111111111000010
case 0x97 : *lenght=0x10; *out=0xFFC5; break; //1111111111000011
case 0x98 : *lenght=0x10; *out=0xFFC6; break; //1111111111000100
case 0x99 : *lenght=0x10; *out=0xFFC7; break; //1111111111000101
case 0x9A : *lenght=0x10; *out=0xFFC8; break; //1111111111000110
case 0xA1 : *lenght=0x09; *out=0x01f8; break; //111111010
case 0xA2 : *lenght=0x10; *out=0xffc9; break; //1111111111000111
case 0xA3 : *lenght=0x10; *out=0xFFCa; break; //1111111111001000
case 0xA4 : *lenght=0x10; *out=0xFFCb; break; //1111111111001001
case 0xA5 : *lenght=0x10; *out=0xFFCc; break; //1111111111001010
case 0xA6 : *lenght=0x10; *out=0xFFCd; break; //1111111111001011
case 0xA7 : *lenght=0x10; *out=0xFFCe; break; //1111111111001100
case 0xA8 : *lenght=0x10; *out=0xFFCf; break; //1111111111001101
case 0xA9 : *lenght=0x10; *out=0xFFd0; break; //1111111111001110
case 0xAA : *lenght=0x10; *out=0xFFd1; break; //1111111111001111
case 0xB1 : *lenght=0x09; *out=0x01f9; break; //1111111001
case 0xB2 : *lenght=0x10; *out=0xFFD2; break; //1111111111010000
case 0xB3 : *lenght=0x10; *out=0xFFD3; break; //1111111111010001
case 0xB4 : *lenght=0x10; *out=0xFFD4; break; //1111111111010010
case 0xB5 : *lenght=0x10; *out=0xFFD5; break; //1111111111010011
case 0xB6 : *lenght=0x10; *out=0xFFD6; break; //1111111111010100
case 0xB7 : *lenght=0x10; *out=0xFFD7; break; //1111111111010101
case 0xB8 : *lenght=0x10; *out=0xFFD8; break; //1111111111010110
case 0xB9 : *lenght=0x10; *out=0xFFD9; break; //1111111111010111
case 0xBA : *lenght=0x10; *out=0xFFDa; break; //1111111111011000
case 0xC1 : *lenght=0x09; *out=0x01fa; break; //1111111010
case 0xC2 : *lenght=0x10; *out=0xFFDb; break; //1111111111011001
case 0xC3 : *lenght=0x10; *out=0xFFDc; break; //1111111111011010
case 0xC4 : *lenght=0x10; *out=0xFFDd; break; //1111111111011011
case 0xC5 : *lenght=0x10; *out=0xFFDe; break; //1111111111011100
case 0xC6 : *lenght=0x10; *out=0xFFDf; break; //1111111111011101
case 0xC7 : *lenght=0x10; *out=0xFFe0; break; //1111111111011110
case 0xC8 : *lenght=0x10; *out=0xFFe1; break; //1111111111011111
case 0xC9 : *lenght=0x10; *out=0xFFe2; break; //1111111111100000
case 0xCA : *lenght=0x10; *out=0xFFe3; break; //1111111111100001
case 0xD1 : *lenght=0x0b; *out=0x07f9; break; //11111111000
case 0xD2 : *lenght=0x10; *out=0xFFE4; break; //1111111111100010
case 0xD3 : *lenght=0x10; *out=0xFFE5; break; //1111111111100011
case 0xD4 : *lenght=0x10; *out=0xFFE6; break; //1111111111100100
case 0xD5 : *lenght=0x10; *out=0xFFE7; break; //1111111111100101
case 0xD6 : *lenght=0x10; *out=0xFFE8; break; //1111111111100110
case 0xD7 : *lenght=0x10; *out=0xFFE9; break; //1111111111100111
case 0xD8 : *lenght=0x10; *out=0xFFEa; break; //1111111111101000
case 0xD9 : *lenght=0x10; *out=0xFFEb; break; //1111111111101001
case 0xDA : *lenght=0x10; *out=0xFFEc; break; //1111111111101010
case 0xE1 : *lenght=0x0e; *out=0x3fe0; break; //1111111111101011
case 0xE2 : *lenght=0x10; *out=0xffed; break; //1111111111101100
case 0xE3 : *lenght=0x10; *out=0xFFEe; break; //1111111111101101
case 0xE4 : *lenght=0x10; *out=0xFFEf; break; //1111111111101110
case 0xE5 : *lenght=0x10; *out=0xFFf0; break; //1111111111101111
case 0xE6 : *lenght=0x10; *out=0xFFF1; break; //1111111111110000
case 0xE7 : *lenght=0x10; *out=0xFFF2; break; //1111111111110001
case 0xE8 : *lenght=0x10; *out=0xFFF3; break; //1111111111110010
case 0xE9 : *lenght=0x10; *out=0xFFF4; break; //1111111111110011
case 0xEA : *lenght=0x10; *out=0xFFF5; break; //1111111111110100
case 0xF0 : *lenght=0x0a; *out=0x03fa; break; //11111111001
case 0xF1 : *lenght=0x0f; *out=0x7fc3; break; //1111111111110101
case 0xF2 : *lenght=0x10; *out=0xFFF6; break; //1111111111110110
case 0xF3 : *lenght=0x10; *out=0xFFF7; break; //1111111111110111
case 0xF4 : *lenght=0x10; *out=0xFFF8; break; //1111111111111000
case 0xF5 : *lenght=0x10; *out=0xFFF9; break; //1111111111111001
case 0xF6 : *lenght=0x10; *out=0xFFFA; break; //1111111111111010
case 0xF7 : *lenght=0x10; *out=0xFFFB; break; //1111111111111011
case 0xF8 : *lenght=0x10; *out=0xFFFC; break; //1111111111111100
case 0xF9 : *lenght=0x10; *out=0xFFFD; break; //1111111111111101
case 0xFA : *lenght=0x10; *out=0xFFFE; break; //1111111111111110
#ifndef __MICROBLAZE
default : printf("WAARDE STAAT NIET IN TABEL!!!!!!!!!!!!!!!!!!!!\n");break;
#endif
}
// printf("magnitude= %x out= %x lenght= %d \n",magnitude,*out,*lenght);
return;
}
//===========================================================================
void ConvertDCMagnitudeY(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
{
switch (magnitude) {
case 0x00 : *out=0x0000; *lenght=2; break;
case 0x01 : *out=0x0002; *lenght=3; break;
case 0x02 : *out=0x0003; *lenght=3; break;
case 0x03 : *out=0x0004; *lenght=3; break;
case 0x04 : *out=0x0005; *lenght=3; break;
case 0x05 : *out=0x0006; *lenght=3; break;
case 0x06 : *out=0x000e; *lenght=4; break;
case 0x07 : *out=0x001e; *lenght=5; break;
case 0x08 : *out=0x003e; *lenght=6; break;
case 0x09 : *out=0x007e; *lenght=7; break;
case 0x0a : *out=0x00fe; *lenght=8; break;
case 0x0b : *out=0x01fe; *lenght=9; break;
}
}
//===========================================================================
void ConvertACMagnitudeY(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
{
switch (magnitude) {
case 0x00 : *lenght=4; *out=0xFFFA; break; //1010
case 0x01 : *lenght=2; *out=0xFFF0; break; //00
case 0x02 : *lenght=2; *out=0xFFF1; break; //01
case 0x03 : *lenght=3; *out=0xFFF4; break; //100
case 0x04 : *lenght=4; *out=0xFFFB; break; //1011
case 0x05 : *lenght=5; *out=0xFFFA; break; //11010
case 0x06 : *lenght=7; *out=0xFFF8; break; //1111000
case 0x07 : *lenght=8; *out=0xFFF8; break; //11111000
case 0x08 : *lenght=10; *out=0xFFF6; break; //1111110110
case 0x09 : *lenght=16; *out=0xFF82; break; //1111111110000010
case 0x0A : *lenght=16; *out=0xFF83; break; //1111111110000011
case 0x11 : *lenght=4; *out=0xFFFC; break; //1100
case 0x12 : *lenght=5; *out=0xFFFB; break; //11011
case 0x13 : *lenght=7; *out=0xFFF9; break; //1111001
case 0x14 : *lenght=9; *out=0xFFF6; break; //111110110
case 0x15 : *lenght=11; *out=0xFFF6; break; //11111110110
case 0x16 : *lenght=16; *out=0xFF84; break; //1111111110000100
case 0x17 : *lenght=16; *out=0xFF85; break; //1111111110000101
case 0x18 : *lenght=16; *out=0xFF86; break; //1111111110000110
case 0x19 : *lenght=16; *out=0xFF87; break; //1111111110000111
case 0x1A : *lenght=16; *out=0xFF88; break; //1111111110001000
case 0x21 : *lenght=5; *out=0xFFFC; break; //11100
case 0x22 : *lenght=8; *out=0xFFF9; break; //11111001
case 0x23 : *lenght=10; *out=0xFFF7; break; //1111110111
case 0x24 : *lenght=12; *out=0xFFF4; break; //111111110100
case 0x25 : *lenght=16; *out=0xFF89; break; //1111111110001001
case 0x26 : *lenght=16; *out=0xFF8A; break; //1111111110001010
case 0x27 : *lenght=16; *out=0xFF8B; break; //1111111110001011
case 0x28 : *lenght=16; *out=0xFF8C; break; //1111111110001100
case 0x29 : *lenght=16; *out=0xFF8D; break; //1111111110001101
case 0x2A : *lenght=16; *out=0xFF8E; break; //1111111110001110
case 0x31 : *lenght=6; *out=0xFFFA; break; //111010
case 0x32 : *lenght=9; *out=0xFFF7; break; //111110111
case 0x33 : *lenght=12; *out=0xFFF5; break; //111111110101
case 0x34 : *lenght=16; *out=0xFF8F; break; //1111111110001111
case 0x35 : *lenght=16; *out=0xFF90; break; //1111111110010000
case 0x36 : *lenght=16; *out=0xFF91; break; //1111111110010001
case 0x37 : *lenght=16; *out=0xFF92; break; //1111111110010010
case 0x38 : *lenght=16; *out=0xFF93; break; //1111111110010011
case 0x39 : *lenght=16; *out=0xFF94; break; //1111111110010100
case 0x3A : *lenght=16; *out=0xFF95; break; //1111111110010101
case 0x41 : *lenght=6; *out=0xFFFB; break; //111011
case 0x42 : *lenght=10; *out=0xFFF8; break; //1111111000
case 0x43 : *lenght=16; *out=0xFF96; break; //1111111110010110
case 0x44 : *lenght=16; *out=0xFF97; break; //1111111110010111
case 0x45 : *lenght=16; *out=0xFF98; break; //1111111110011000
case 0x46 : *lenght=16; *out=0xFF99; break; //1111111110011001
case 0x47 : *lenght=16; *out=0xFF9A; break; //1111111110011010
case 0x48 : *lenght=16; *out=0xFF9B; break; //1111111110011011
case 0x49 : *lenght=16; *out=0xFF9C; break; //1111111110011100
case 0x4A : *lenght=16; *out=0xFF9D; break; //1111111110011101
case 0x51 : *lenght=7; *out=0xFFFA; break; //1111010
case 0x52 : *lenght=11; *out=0xFFF7; break; //11111110111
case 0x53 : *lenght=16; *out=0xFF9E; break; //1111111110011110
case 0x54 : *lenght=16; *out=0xFF9F; break; //1111111110011111
case 0x55 : *lenght=16; *out=0xFFA0; break; //1111111110100000
case 0x56 : *lenght=16; *out=0xFFA1; break; //1111111110100001
case 0x57 : *lenght=16; *out=0xFFA2; break; //1111111110100010
case 0x58 : *lenght=16; *out=0xFFA3; break; //1111111110100011
case 0x59 : *lenght=16; *out=0xFFA4; break; //1111111110100100
case 0x5A : *lenght=16; *out=0xFFA5; break; //1111111110100101
case 0x61 : *lenght=7; *out=0xFFFB; break; //1111011
case 0x62 : *lenght=12; *out=0xFFF6; break; //111111110110
case 0x63 : *lenght=16; *out=0xFFA6; break; //1111111110100110
case 0x64 : *lenght=16; *out=0xFFA7; break; //1111111110100111
case 0x65 : *lenght=16; *out=0xFFA8; break; //1111111110101000
case 0x66 : *lenght=16; *out=0xFFA9; break; //1111111110101001
case 0x67 : *lenght=16; *out=0xFFAA; break; //1111111110101010
case 0x68 : *lenght=16; *out=0xFFAB; break; //1111111110101011
case 0x69 : *lenght=16; *out=0xFFAC; break; //1111111110101100
case 0x6A : *lenght=16; *out=0xFFAD; break; //1111111110101101
case 0x71 : *lenght=8; *out=0xFFFA; break; //11111010
case 0x72 : *lenght=12; *out=0xFFF7; break; //111111110111
case 0x73 : *lenght=16; *out=0xFFAE; break; //1111111110101110
case 0x74 : *lenght=16; *out=0xFFAF; break; //1111111110101111
case 0x75 : *lenght=16; *out=0xFFB0; break; //1111111110110000
case 0x76 : *lenght=16; *out=0xFFB1; break; //111111110110001
case 0x77 : *lenght=16; *out=0xFFB2; break; //111111110110010
case 0x78 : *lenght=16; *out=0xFFB3; break; //111111110110011
case 0x79 : *lenght=16; *out=0xFFB4; break; //1111111110110100
case 0x7A : *lenght=16; *out=0xFFB5; break; //1111111110110101
case 0x81 : *lenght=9; *out=0xFFF8; break; //111111000
case 0x82 : *lenght=15; *out=0xFFC0; break; //111111111000000
case 0x83 : *lenght=16; *out=0xFFB6; break; //1111111110110110
case 0x84 : *lenght=16; *out=0xFFB7; break; //1111111110110111
case 0x85 : *lenght=16; *out=0xFFB8; break; //1111111110111000
case 0x86 : *lenght=16; *out=0xFFB9; break; //1111111110111001
case 0x87 : *lenght=16; *out=0xFFBA; break; //1111111110111010
case 0x88 : *lenght=16; *out=0xFFBB; break; //1111111110111011
case 0x89 : *lenght=16; *out=0xFFBC; break; //1111111110111100
case 0x8A : *lenght=16; *out=0xFFBD; break; //1111111110111101
case 0x91 : *lenght=9; *out=0xFFF9; break; //111111001
case 0x92 : *lenght=16; *out=0xFFBE; break; //1111111110111110
case 0x93 : *lenght=16; *out=0xFFBF; break; //1111111110111111
case 0x94 : *lenght=16; *out=0xFFC0; break; //1111111111000000
case 0x95 : *lenght=16; *out=0xFFC1; break; //1111111111000001
case 0x96 : *lenght=16; *out=0xFFC2; break; //1111111111000010
case 0x97 : *lenght=16; *out=0xFFC3; break; //1111111111000011
case 0x98 : *lenght=16; *out=0xFFC4; break; //1111111111000100
case 0x99 : *lenght=16; *out=0xFFC5; break; //1111111111000101
case 0x9A : *lenght=16; *out=0xFFC6; break; //1111111111000110
case 0xA1 : *lenght=9; *out=0xFFFA; break; //111111010
case 0xA2 : *lenght=16; *out=0xFFC7; break; //1111111111000111
case 0xA3 : *lenght=16; *out=0xFFC8; break; //1111111111001000
case 0xA4 : *lenght=16; *out=0xFFC9; break; //1111111111001001
case 0xA5 : *lenght=16; *out=0xFFCA; break; //1111111111001010
case 0xA6 : *lenght=16; *out=0xFFCB; break; //1111111111001011
case 0xA7 : *lenght=16; *out=0xFFCC; break; //1111111111001100
case 0xA8 : *lenght=16; *out=0xFFCD; break; //1111111111001101
case 0xA9 : *lenght=16; *out=0xFFCE; break; //1111111111001110
case 0xAA : *lenght=16; *out=0xFFCF; break; //1111111111001111
case 0xB1 : *lenght=10; *out=0xFFF9; break; //1111111001
case 0xB2 : *lenght=16; *out=0xFFD0; break; //1111111111010000
case 0xB3 : *lenght=16; *out=0xFFD1; break; //1111111111010001
case 0xB4 : *lenght=16; *out=0xFFD2; break; //1111111111010010
case 0xB5 : *lenght=16; *out=0xFFD3; break; //1111111111010011
case 0xB6 : *lenght=16; *out=0xFFD4; break; //1111111111010100
case 0xB7 : *lenght=16; *out=0xFFD5; break; //1111111111010101
case 0xB8 : *lenght=16; *out=0xFFD6; break; //1111111111010110
case 0xB9 : *lenght=16; *out=0xFFD7; break; //1111111111010111
case 0xBA : *lenght=16; *out=0xFFD8; break; //1111111111011000
case 0xC1 : *lenght=10; *out=0xFFFA; break; //1111111010
case 0xC2 : *lenght=16; *out=0xFFD9; break; //1111111111011001
case 0xC3 : *lenght=16; *out=0xFFDA; break; //1111111111011010
case 0xC4 : *lenght=16; *out=0xFFDB; break; //1111111111011011
case 0xC5 : *lenght=16; *out=0xFFDC; break; //1111111111011100
case 0xC6 : *lenght=16; *out=0xFFDD; break; //1111111111011101
case 0xC7 : *lenght=16; *out=0xFFDE; break; //1111111111011110
case 0xC8 : *lenght=16; *out=0xFFDF; break; //1111111111011111
case 0xC9 : *lenght=16; *out=0xFFE0; break; //1111111111100000
case 0xCA : *lenght=16; *out=0xFFE1; break; //1111111111100001
case 0xD1 : *lenght=11; *out=0xFFF8; break; //11111111000
case 0xD2 : *lenght=16; *out=0xFFE2; break; //1111111111100010
case 0xD3 : *lenght=16; *out=0xFFE3; break; //1111111111100011
case 0xD4 : *lenght=16; *out=0xFFE4; break; //1111111111100100
case 0xD5 : *lenght=16; *out=0xFFE5; break; //1111111111100101
case 0xD6 : *lenght=16; *out=0xFFE6; break; //1111111111100110
case 0xD7 : *lenght=16; *out=0xFFE7; break; //1111111111100111
case 0xD8 : *lenght=16; *out=0xFFE8; break; //1111111111101000
case 0xD9 : *lenght=16; *out=0xFFE9; break; //1111111111101001
case 0xDA : *lenght=16; *out=0xFFEA; break; //1111111111101010
case 0xE1 : *lenght=16; *out=0xFFEB; break; //1111111111101011
case 0xE2 : *lenght=16; *out=0xFFEC; break; //1111111111101100
case 0xE3 : *lenght=16; *out=0xFFED; break; //1111111111101101
case 0xE4 : *lenght=16; *out=0xFFEE; break; //1111111111101110
case 0xE5 : *lenght=16; *out=0xFFEF; break; //1111111111101111
case 0xE6 : *lenght=16; *out=0xFFF0; break; //1111111111110000
case 0xE7 : *lenght=16; *out=0xFFF1; break; //1111111111110001
case 0xE8 : *lenght=16; *out=0xFFF2; break; //1111111111110010
case 0xE9 : *lenght=16; *out=0xFFF3; break; //1111111111110011
case 0xEA : *lenght=16; *out=0xFFF4; break; //1111111111110100
case 0xF0 : *lenght=11; *out=0xFFF9; break; //11111111001
case 0xF1 : *lenght=16; *out=0xFFF5; break; //1111111111110101
case 0xF2 : *lenght=16; *out=0xFFF6; break; //1111111111110110
case 0xF3 : *lenght=16; *out=0xFFF7; break; //1111111111110111
case 0xF4 : *lenght=16; *out=0xFFF8; break; //1111111111111000
case 0xF5 : *lenght=16; *out=0xFFF9; break; //1111111111111001
case 0xF6 : *lenght=16; *out=0xFFFA; break; //1111111111111010
case 0xF7 : *lenght=16; *out=0xFFFB; break; //1111111111111011
case 0xF8 : *lenght=16; *out=0xFFFC; break; //1111111111111100
case 0xF9 : *lenght=16; *out=0xFFFD; break; //1111111111111101
case 0xFA : *lenght=16; *out=0xFFFE; break; //1111111111111110
#ifndef __MICROBLAZE
default : printf("WAARDE STAAT NIET IN TABEL!!!!!!!!!!!!!!!!!!!!\n");break;
#endif
}
// printf("magnitude= %x out= %x lenght= %d \n",magnitude,*out,*lenght);
return;
}
//===========================================================================
char Extend (char additional, unsigned char magnitude)
{
int vt= 1 << (magnitude-1);
if ( additional < vt ) return (additional + (-1 << magnitude) + 1);
else return additional;
}
//===========================================================================
void ReverseExtend (char value, unsigned char *magnitude, unsigned char *bits)
{
// printf("reverseextend value= %d\n",*magnitude);
if (value >=0)
{
*bits=value;
}
else
{
value=-value;
*bits=~value;
}
*magnitude=0;
while (value !=0)
{
value>>=1;
++*magnitude;
}
// printf("reverseextend magnitude= %d bits= %d",magnitude,bits);
return;
}
//===========================================================================
void WriteRawBits16(unsigned char amount_bits, unsigned int bits) //*remaining needs bo be more than 8 bits because 8 bits could be added and ther ecould already be up ot 7 bits in *remaining
// this function collects bits to send
// if there less than 16 bits collected, nothing is send and these bits are stored in *remaining. In *amount_remaining there is stated how much bits are stored in *remaining
// if more than 16 bits are collected, 16 bits are send and the remaining bits are stored again
{
unsigned short int send;
unsigned int mask;
unsigned char send2;
int count;
mask=0x00; //init mask
vlc_remaining=(vlc_remaining<<amount_bits); //shift to make place for the new bits
for (count=amount_bits; count>0; count--) mask=(mask<<1)|0x01; //create mask for adding bit
vlc_remaining=vlc_remaining | (bits&mask); //add bits
vlc_amount_remaining=vlc_amount_remaining + amount_bits; //change *amount_remaining to the correct new value
if (vlc_amount_remaining >= 16) //are there more than 16 bits in buffer, send 16 bits
{
#ifndef __MICROBLAZE
if (vlc_amount_remaining >= 32 ) printf("ERROR, more bits to send %d",vlc_amount_remaining);
#endif
send=vlc_remaining>>(vlc_amount_remaining-16); //this value can be send/stored (in art this can be dony by selecting bits)
send2=(send & 0xFF00) >>8;
vlc_output_byte(send2);
// fwrite(&send2,1,1,file);
if (send2==0xFF)
{
send2=0x00;
vlc_output_byte(send2);
// fwrite(&send2,1,1,file);
}
send2=send & 0xFF;
vlc_output_byte(send2);
// fwrite(&send2,1,1,file);
if (send2==0xFF)
{
send2=0x00;
vlc_output_byte(send2);
// fwrite(&send2,1,1,file);
}
vlc_amount_remaining=vlc_amount_remaining-16; //descrease by 16 because these are send
}
return;
}
//===========================================================================
void HuffmanEncodeFinishSend()
// There are still some bits left to send at the end of the 8x8 matrix (or maybe the file),
// the remaining bits are filled up with ones and send
// possible fault: -must it be filled up with ones?
{
unsigned short int send;
unsigned int mask;
int count;
mask=0x00; //init mask
if (vlc_amount_remaining >= 8) //2 bytes to send, send first byte
{
send=vlc_remaining>>(vlc_amount_remaining-8); //shift so that first byte is ready to send
vlc_output_byte(send);
// fwrite(&send,1,1,file);
if (send==0xFF) //is this still needed????
{
send=0x00;
vlc_output_byte(send);
// fwrite(&send,1,1,file);
}
vlc_amount_remaining=vlc_amount_remaining -8; // lower the value to the amount of bits that still needs to be send
}
if (vlc_amount_remaining >= 0) //there is a last byte to send
{
send=vlc_remaining<<(8-vlc_amount_remaining); //shift the last bits to send to the front of the byte
mask=0x00; //init mask
for (count=(8-vlc_amount_remaining); count>0; count--) mask=(mask<<1)|0x01; //create mask to fill byte up with ones
send=send | mask; //add the ones to the byte
vlc_output_byte(send);
// fwrite(&send,1,1,file);
vlc_amount_remaining=0x00; //is this needed?
}
return;
}
//===========================================================================
void HuffmanEncodeUsingDCTable(unsigned char magnitude)
// Translate magnitude into needed data (from table) and send it
{
unsigned char send;
unsigned short int huffmancode, huffmanlengt;
ConvertDCMagnitudeY(magnitude, &huffmancode, &huffmanlengt);
WriteRawBits16(huffmanlengt,huffmancode);
//printf("Write DC magnitude= %2x \n",magnitude);
//WriteRawBits16(0x08,magnitude,remaining,amount_remaining, file);
return;
}
//===========================================================================
void HuffmanEncodeUsingACTable(unsigned char mag)
// Translate magnitude into needed data (from table) and send it
{
unsigned char send;
unsigned short int huffmancode, huffmanlengt;
ConvertACMagnitudeY(mag, &huffmancode, &huffmanlengt);
WriteRawBits16(huffmanlengt,huffmancode);
return;
}
//===========================================================================
char EncodeDataUnit(char dataunit[64], unsigned int color)
{
char difference;
unsigned char magnitude,zerorun,ii,ert;
unsigned int bits;
char last_dc_value;
//init
// PrintMatrix(dataunit) ;
last_dc_value = dcvalue[color];
difference = dataunit[0] - last_dc_value;
last_dc_value=dataunit[0];
ReverseExtend(difference, &magnitude,&bits);
HuffmanEncodeUsingDCTable(magnitude);
WriteRawBits16(magnitude,bits);
zerorun=0;
ii=1;
while ( ii < 64 )
{
if (dataunit[ii] != 0 )
{
while ( zerorun >= 16 )
{
HuffmanEncodeUsingACTable(0xF0);
zerorun=zerorun-16;
// printf("16 zeros: %d\n",zerorun);
}
ReverseExtend(dataunit[ii],&magnitude,&bits);
ert= ((int)zerorun *16); //ERROR !!!!!!!!!!!
ert=ert + magnitude;
HuffmanEncodeUsingACTable(ert);
WriteRawBits16(magnitude,bits);
zerorun=0;
}
else zerorun=zerorun+1;
ii++;
}
if ( zerorun != 0 )
{
HuffmanEncodeUsingACTable(0x00);
// printf("NUL DE REST IS NUL\n");
}
// HuffmanEncodeFinishSend(remaining,amount_remaining,file);
dcvalue[color] = last_dc_value;
return 0;
}
1.1 mb-jpeg/bmp2jpg_mb/zzq.c
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/zzq.c?rev=1.1&content-type=text/x-cvsweb-markup
Index: zzq.c
===================================================================
//---------------------------------------------------------------------------
#include <stdio.h>
#include "zzq.h"
unsigned char quantization_table[MATRIX_SIZE][MATRIX_SIZE] ={
{4, 3, 3, 4, 4, 5, 6, 6},
{3, 3, 4, 4, 5, 6, 6, 6},
{4, 4, 4, 4, 5, 6, 6, 6},
{4, 4, 4, 5, 6, 6, 6, 6},
{4, 4, 5, 6, 6, 7, 7, 6},
{4, 5, 6, 6, 6, 7, 7, 6},
{6, 6, 6, 6, 7, 7, 7, 7},
{6, 6, 6, 7, 7, 7, 7, 7}
};
signed char bitstream[NUMBER_OF_PIXELS] ;
int zzq_encode_init_start(int compression) {
return 0;
}
void zzq_encode(signed short pixelmatrix[MATRIX_SIZE][MATRIX_SIZE], int color)
{
int i, x, y, jumped, deltax, deltay;
x = y = deltax = deltay = jumped = 0;
for(i=0;i<NUMBER_OF_PIXELS;i++)
{
if(pixelmatrix[y][x]>0)
bitstream[i] = (pixelmatrix[y][x]>>quantization_table[y][x]);
else
bitstream[i] = -((-pixelmatrix[y][x])>>quantization_table[y][x]);
if((y == 0) || (y == MATRIX_SIZE-1)) { //on top or bottom side of matrix
if(!jumped) { //first jump to element on the right
x++;
jumped = 1;
} else { //modify direction
if(i<(NUMBER_OF_PIXELS>>1)) {
deltax = -1;
deltay = 1;
} else {
deltax = 1;
deltay = -1;
}
x += deltax;
y += deltay;
jumped = 0;
}
} else if ((x == 0) || (x == MATRIX_SIZE-1)) { //on left or right side of matrix
if(!jumped) { //jump to element below
y++;
jumped = 1;
} else { //modify direction
if(i<(NUMBER_OF_PIXELS>>1)) {
deltax = 1;
deltay = -1;
} else {
deltax = -1;
deltay = 1;
}
x += deltax;
y += deltay;
jumped = 0;
}
}
else {//not on the edges of the matrix
x += deltax;
y += deltay;
}
}
EncodeDataUnit(bitstream, color);
}
//---------------------------------------------------------------------------
1.1 mb-jpeg/bmp2jpg_mb/dct.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/dct.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: dct.h
===================================================================
#include <stdio.h>
/*
Function Name: dct
Operation: Find the 8x8 DCT of an array using separable DCT
First, finds 1-d DCT along rows, storing the result in inter[][]
Then, 1-d DCT along columns of inter[][] is found
Input: pixels is the 8x8 input array
Output: dct is the 8x8 output array
*/
void dct(signed char pixels[8][8], int color);
1.1 mb-jpeg/bmp2jpg_mb/ejpgl.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/ejpgl.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: ejpgl.h
===================================================================
#ifndef _EJPGL_H
#define _EJPGL_H
#define MATRIX_SIZE 8
#ifndef htonl
#define htonl(x) ((((x)&0xff000000)>>24) | (((x)&0x00ff0000)>>8) | (((x)&0x0000ff00)<<8) | (((x)&0x000000ff)<<24))
#endif
#ifndef hton
#define hton(x) ((((x) & 0xff00)>>8) | (((x) &0x00ff)<<8))
#endif
int idct8x8(int* fblock, char* sblock);
#endif
1.1 mb-jpeg/bmp2jpg_mb/huffman.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/huffman.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: huffman.h
===================================================================
#ifndef _HUFFMAN_H
#define _HUFFMAN_H 1
int vlc_init();
char EncodeDataUnit(char dataunit[NUMBER_OF_PIXELS], unsigned int component);
void HuffmanEncodeFinishSend();
#else
#error "ERROR file huffman.h multiple times included"
#endif /* --- _HUFFMAN_H --- */
1.1 mb-jpeg/bmp2jpg_mb/io.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/io.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: io.h
===================================================================
#ifndef _IO_H
#define _IO_H 1
#define MATRIX_SIZE 8
typedef struct {
unsigned int size; /* Header size in bytes */
int width,height; /* Width and height of image */
unsigned short int planes; /* Number of colour planes */
unsigned short int bits; /* Bits per pixel */
unsigned int compression; /* Compression type */
unsigned int imagesize; /* Image size in bytes */
int xresolution,yresolution; /* Pixels per meter */
unsigned int ncolours; /* Number of colours */
unsigned int importantcolours; /* Important colours */
unsigned char palette[1024]; /* Storage for palette */
} INFOHEADER;
typedef struct {
int restofheader; //TODO
INFOHEADER info; /* Information header */
} BMPHEADER;
typedef struct {
unsigned int row; /* Width and height of image */
unsigned int col; /* Width and height of image */
} BLOCKINFO;
typedef struct {
unsigned char QTMarker[2];
unsigned char Length[2];
unsigned char QTInfo[130]; //bit 0..3: number of QT (0..3, otherwise error)
// bit 4..7: precision of QT, 0 = 8 bit, otherwise 16 bit
// unsigned char ValuesQT[]; //max 192 values. 64*(precision+1) bytes
} QTINFO;
typedef struct {
unsigned char HTMarker[2];
unsigned char Length[2];
unsigned char HuffmanInfo[416]; //Array containing ALL huffman information
//For each color component holds:
//First byte is used as info byte, followed by 16 bytes with values used
//for counting the different huffman codes, finally the corresponding
//huffman codes will follow. This sequence can repeat it self for
//different Huffman tables, both DC or AC tables.
//The structure of the information byte is as follows:
//bit 0..3 : number of HT (0..3, otherwise error)
//bit 4 : type of HT, 0 = DC table, 1 = AC table
//bit 5..7 : not used, must be 0 (Used for progressive scan JPEG)
} HTINFO;
typedef struct {
unsigned char APP0Marker[2];
unsigned char Length[2];
unsigned char Identifier[5];
unsigned char Version[2];
unsigned char Units;
unsigned char XDensity[2];
unsigned char YDensity[2];
unsigned char ThumbWidth;
unsigned char ThumbHeight;
} APP0INFO;
typedef struct {
unsigned char SOF0Marker[2];
unsigned char Length[2];
unsigned char DataPrecision; //This is in bits/sample, usually 8 (12 and 16 not supported by most software).
unsigned char ImageHeight[2];
unsigned char ImageWidth[2];
unsigned char Components; //Usually 1 = grey scaled, 3 = color YcbCr or YIQ 4 = color CMYK
unsigned char ComponentInfo[3][3]; //Read each component data of 3 bytes. It contains,
//(component Id(1byte)(1 = Y, 2 = Cb, 3 = Cr, 4 = I, 5 = Q),
//sampling factors (1byte) (bit 0-3 vertical., 4-7 horizontal.),
//quantization table number (1 byte)).
} SOF0INFO;
typedef struct {
unsigned char SOSMarker[2];
unsigned char Length[2]; //This must be equal to 6+2*(number of components in scan).
unsigned char ComponentCount; //This must be >= 1 and <=4 (otherwise error), usually 1 or 3
unsigned char Component[3][2]; // For each component, read 2 bytes. It contains,
//1 byte Component Id (1=Y, 2=Cb, 3=Cr, 4=I, 5=Q),
//1 byte Huffman table to use :
//bit 0..3 : AC table (0..3)
//bit 4..7 : DC table (0..3)
unsigned char Ignore[3]; //We have to skip 3 bytes
} SOSINFO;
typedef struct {
unsigned char DRIMarker[2];
unsigned char Length[2];
unsigned char RestartInteral[2]; // Interval of the restart markers
} DRIINFO;
typedef struct {
unsigned char SOIMarker[2]; //Start of image marker
APP0INFO app0;
QTINFO qt;
SOF0INFO sof0;
HTINFO ht;
// DRIINFO dri;
SOSINFO sos;
} JPEGHEADER;
/*
* Read BMP header and return it in header, for now only the width and height
* are returned, since the other values are of no use.
*/
int getbmpheader(FILE * file, INFOHEADER *header);
int getjpegheader(FILE * file, JPEGHEADER *header);
void writebmpheader(FILE * file, BMPHEADER *header);
void writejpegheader(FILE * file, INFOHEADER *header);
void writejpegfooter(FILE * file);
/*
* Read BMP to retrieve 8*8 block starting at horizontal position mcol*8, and
* vertical position mrow*8 in the image. This block is returned in pixelmatrix.
*
*/
void readbmpfile(FILE * file, signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3], unsigned int mrow, unsigned int mcol, INFOHEADER * header);
void RGB2YCrCb(signed char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE*3],signed char YMatrix[MATRIX_SIZE][MATRIX_SIZE],signed char CrMatrix[MATRIX_SIZE][MATRIX_SIZE],signed char CbMatrix[MATRIX_SIZE][MATRIX_SIZE]);
void readjpegfile(FILE * file, unsigned char bitstream[]);
void writebmpfile(FILE * file, unsigned char pixelmatrix[MATRIX_SIZE][MATRIX_SIZE], unsigned int mrow, unsigned int mcol, unsigned int width);
void writejpegfile(FILE * file, unsigned char bitstream[]);
#else
#error "ERROR file io.h multiple times included"
#endif /* --- _IO_H --- */
1.1 mb-jpeg/bmp2jpg_mb/mb.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/mb.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: mb.h
===================================================================
#ifndef _XUP2PRO_H
#define _XUP2PRO_H
// Microblaze related declaration
#include <xparameters.h>
#include <sysace_stdio.h>
#include "xio.h"
#define __XUPV2P
// XUP2P board related declaration
#ifdef __XUPV2P
#define JPG_ADDRESS 0x70000000
#define JPG_MAXSIZE 0x10000
#define BMP_ADDRESS 0x70010000
#define BMP_MAXSIZE 0x10000
#else
#define JPG_MAXSIZE 0x400000
#define BMP_MAXSIZE 0x1c00000
#endif
// JPEG decoder related declaration
extern unsigned char* jpgimage;
extern char* bmpimage;
extern unsigned long jpgsize;
extern int bmpsize;
// function declaration
#define eOPENINPUT_FILE 1
#define eOPENOUTPUT_FILE 2
#define eINVALID_BMP 3
#define eLARGE_INPUTFILE 4
#ifndef htonl
#define htonl(x) ((((x)&0xff000000)>>24) | (((x)&0x00ff0000)>>8) | (((x)&0x0000ff00)<<8) | (((x)&0x000000ff)<<24))
#endif
#ifndef hton
#define hton(x) ((((x) & 0xff00)>>8) | (((x) &0x00ff)<<8))
#endif
#endif
1.1 mb-jpeg/bmp2jpg_mb/weights.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/weights.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: weights.h
===================================================================
signed int weights[512] = {
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16384,
16069,
13623,
9102,
3196,
-3196,
-9102,
-13623,
-16069,
15137,
6270,
-6270,
-15137,
-15137,
-6270,
6270,
15137,
13623,
-3196,
-16069,
-9103,
9102,
16069,
3196,
-13623,
11585,
-11585,
-11585,
11585,
11585,
-11585,
-11585,
11585,
9102,
-16069,
3196,
13623,
-13623,
-3197,
16069,
-9102,
6270,
-15137,
15137,
-6270,
-6270,
15137,
-15137,
6270,
3196,
-9103,
13623,
-16069,
16069,
-13623,
9102,
-3196
};
1.1 mb-jpeg/bmp2jpg_mb/zzq.h
http://www.opencores.org/cvsweb.shtml/mb-jpeg/bmp2jpg_mb/zzq.h?rev=1.1&content-type=text/x-cvsweb-markup
Index: zzq.h
===================================================================
#ifndef _ZZQ_H
#define _ZZQ_H 1
#define MATRIX_SIZE 8
#define NUMBER_OF_PIXELS MATRIX_SIZE*MATRIX_SIZE
/*
* ZigZag order the pixelmatrix and quantify its values, if endode == 0 the
* inverse operation will be caried out.
*/
void zzq_encode(signed short pixelmatrix[MATRIX_SIZE][MATRIX_SIZE], int color);
#else
#error "ERROR file zzq.h multiple times included"
#endif /* --- _ZZQ_H --- */
|
 |
Browse
