OpenCores
URL https://opencores.org/ocsvn/mb-jpeg/mb-jpeg/trunk

Subversion Repositories mb-jpeg

[/] [mb-jpeg/] [tags/] [Step2_2/] [encoder/] [huffman.c] - Blame information for rev 68

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 33 quickwayne 
#pragma argsused
2 
/*
3 
Only encoder
4 
This version works correctly, it is tested with testcase.jpg
5 
The translation into real huffman codes works.
6 
Changed: If huffman wants to send 0xFFxx (FF in one byte) than there must be 0x00 inserted between FF and xx
7 
possible fault in finish send:
8 
-must it be filled up with zeros?          YES
9 
-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.
10 
 still dont know
11 
- 24-11-05 code clean up
12 
- 24-11-05 tables added for color
13 
 
14 
 
15 
 
16 
Block numbers:
17 
Y = 0
18 
cb =1
19 
cr= 2
20 
*/
21 
//---------------------------------------------------------------------------
22 
#pragma hdrstop
23 
#include <stdio.h>
24 
#ifdef __MICROBLAZE
25 
#include "xup2pro.h"
26 
#endif
27 
//===========================================================================
28 
void PrintMatrix(char* pixelmatrix)
29 
{
30 
int i;
31 
//        printf("MATRIX= \n");
32 
//      for (i=0;i<64;i++) printf("%d |",pixelmatrix[i]);
33 
//              printf("\n");
34 
}
35 
//===========================================================================
36 
void FillMatrix( char* pixelmatrix,int select)
37 
{
38 
        int i;
39 
        if (select== 0)
40 
        {
41 
                for (i=0;i<64;i++) pixelmatrix[i]=0;
42 
                 pixelmatrix[0]=6;
43 
                 pixelmatrix[1]=-4;
44 
                 pixelmatrix[2]=15;
45 
                 pixelmatrix[3]=4;
46 
                 pixelmatrix[7]=-1;
47 
                 pixelmatrix[11]=2;
48 
                 pixelmatrix[12]=2;
49 
                 pixelmatrix[20]=-1;
50 
 
51 
        }
52 
        else if (select == 1 )
53 
        {
54 
        for (i=0;i<64;i++) pixelmatrix[i]=0;
55 
                pixelmatrix[0]=36;
56 
                pixelmatrix[1]=-1;
57 
                pixelmatrix[2]=1;
58 
                pixelmatrix[3]=-2;
59 
                pixelmatrix[4]=3;
60 
                pixelmatrix[5]=-5;
61 
                pixelmatrix[6]=0;
62 
                pixelmatrix[7]=7;
63 
                pixelmatrix[8]=4;
64 
                pixelmatrix[9]=-10;
65 
                pixelmatrix[12]=8;
66 
                pixelmatrix[13]=-16;
67 
                pixelmatrix[14]=17;
68 
                pixelmatrix[33]=30;
69 
                pixelmatrix[34]=-63;
70 
                pixelmatrix[35]=-32;
71 
                pixelmatrix[36]=50;
72 
                pixelmatrix[40]=-100;
73 
                pixelmatrix[41]=121;
74 
                pixelmatrix[42]=100;
75 
                pixelmatrix[47]=-3;
76 
                pixelmatrix[48]=-2;
77 
                pixelmatrix[49]=-7;
78 
                pixelmatrix[50]=-15;
79 
                pixelmatrix[51]=3;
80 
                pixelmatrix[52]=7;
81 
        }
82 
}
83 
//===========================================================================
84 
void ConvertDCMagnitudeC(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
85 
{
86 
        switch (magnitude) {
87 
                case 0x00 : *out=0x0000; *lenght=2; break;
88 
                case 0x01 : *out=0x0001; *lenght=2; break;
89 
                case 0x02 : *out=0x0002; *lenght=2; break;
90 
                case 0x03 : *out=0x0006; *lenght=3; break;
91 
                case 0x04 : *out=0x000e; *lenght=4; break;
92 
                case 0x05 : *out=0x001e; *lenght=5; break;
93 
                case 0x06 : *out=0x003e; *lenght=6; break;
94 
                case 0x07 : *out=0x007e; *lenght=7; break;
95 
                case 0x08 : *out=0x00fe; *lenght=8; break;
96 
                case 0x09 : *out=0x01fe; *lenght=9; break;
97 
                case 0x0a : *out=0x03fe; *lenght=10; break;
98 
                case 0x0b : *out=0x07fe; *lenght=11; break;
99 
        }
100 
}
101 
//===========================================================================
102 
void ConvertACMagnitudeC(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
103 
{
104 
        switch (magnitude) {
105 
case 0x00 :  *lenght=0x02; *out=0x0000; break; //1010
106 
case 0x01 :  *lenght=0x02; *out=0x0001; break; //00
107 
case 0x02 :  *lenght=0x03; *out=0x0004; break; //01
108 
case 0x03 :  *lenght=0x04; *out=0x000a; break; //100
109 
case 0x04 :  *lenght=0x05; *out=0x0018; break; //1011
110 
case 0x05 :  *lenght=0x05; *out=0x0019; break; //11010
111 
case 0x06 :  *lenght=0x06; *out=0x0038; break; //1111000
112 
case 0x07 :  *lenght=0x07; *out=0x0078; break; //11111000
113 
case 0x08 :  *lenght=0x09; *out=0x01f4; break; //1111110110
114 
case 0x09 :  *lenght=0x0a; *out=0x03f6; break; //1111111110000010
115 
case 0x0A :  *lenght=0x0c; *out=0x0ff4; break; //1111111110000011
116 
case 0x11 :  *lenght=0x04; *out=0x000b; break; //1100
117 
case 0x12 :  *lenght=0x06; *out=0x0039; break; //11011
118 
case 0x13 :  *lenght=0x08; *out=0x00f6; break; //1111001
119 
case 0x14 :  *lenght=0x09; *out=0x01f5; break; //111110110
120 
case 0x15 :  *lenght=0x0b; *out=0x07f6; break; //11111110110
121 
case 0x16 :  *lenght=0x0c; *out=0x0ff5; break; //1111111110000100
122 
case 0x17 :  *lenght=0x10; *out=0xff88; break; //1111111110000101
123 
case 0x18 :  *lenght=0x10; *out=0xff89; break; //1111111110000110
124 
case 0x19 :  *lenght=0x10; *out=0xff8a; break; //1111111110000111
125 
case 0x1A :  *lenght=0x10; *out=0xff8b; break; //1111111110001000
126 
case 0x21 :  *lenght=0x05; *out=0x001a; break; //11100
127 
case 0x22 :  *lenght=0x08; *out=0x00f7; break; //11111001
128 
case 0x23 :  *lenght=0x0a; *out=0x03f7; break; //1111110111
129 
case 0x24 :  *lenght=0x0c; *out=0x0ff6; break; //111111110100
130 
case 0x25 :  *lenght=0x0f; *out=0x7fc2; break; //1111111110001001
131 
case 0x26 :  *lenght=0x10; *out=0xff8c; break; //1111111110001010
132 
case 0x27 :  *lenght=0x10; *out=0xff8d; break; //1111111110001011
133 
case 0x28 :  *lenght=0x10; *out=0xff8e; break; //1111111110001100
134 
case 0x29 :  *lenght=0x10; *out=0xff8f; break; //1111111110001101
135 
case 0x2A :  *lenght=0x10; *out=0xff90; break; //1111111110001110
136 
case 0x31 :  *lenght=0x05; *out=0x001b; break; //111010
137 
case 0x32 :  *lenght=0x08; *out=0x00f8; break; //111110111
138 
case 0x33 :  *lenght=0x0a; *out=0x03f8; break; //111111110101
139 
case 0x34 :  *lenght=0x0c; *out=0x0ff7; break; //1111111110001111
140 
case 0x35 :  *lenght=0x10; *out=0xff91; break; //1111111110010000
141 
case 0x36 :  *lenght=0x10; *out=0xff92; break; //1111111110010001
142 
case 0x37 :  *lenght=0x10; *out=0xff93; break; //1111111110010010
143 
case 0x38 :  *lenght=0x10; *out=0xff94; break; //1111111110010011
144 
case 0x39 :  *lenght=0x10; *out=0xff95; break; //1111111110010100
145 
case 0x3A :  *lenght=0x10; *out=0xff96; break; //1111111110010101
146 
case 0x41 :  *lenght=0x06; *out=0x003a; break; //111011
147 
case 0x42 :  *lenght=0x09; *out=0x01f6; break; //1111111000
148 
case 0x43 :  *lenght=0x10; *out=0xff97; break; //1111111110010110
149 
case 0x44 :  *lenght=0x10; *out=0xff98; break; //1111111110010111
150 
case 0x45 :  *lenght=0x10; *out=0xff99; break; //1111111110011000
151 
case 0x46 :  *lenght=0x10; *out=0xff9a; break; //1111111110011001
152 
case 0x47 :  *lenght=0x10; *out=0xff9b; break; //1111111110011010
153 
case 0x48 :  *lenght=0x10; *out=0xff9c; break; //1111111110011011
154 
case 0x49 :  *lenght=0x10; *out=0xff9d; break; //1111111110011100
155 
case 0x4A :  *lenght=0x10; *out=0xff9e; break; //1111111110011101
156 
case 0x51 :  *lenght=0x06; *out=0x003b; break; //1111010
157 
case 0x52 :  *lenght=0x0a; *out=0x03f9; break; //11111110111
158 
case 0x53 :  *lenght=0x10; *out=0xff9f; break; //1111111110011110
159 
case 0x54 :  *lenght=0x10; *out=0xffa0; break; //1111111110011111
160 
case 0x55 :  *lenght=0x10; *out=0xffa1; break; //1111111110100000
161 
case 0x56 :  *lenght=0x10; *out=0xFFA2; break; //1111111110100001
162 
case 0x57 :  *lenght=0x10; *out=0xFFA3; break; //1111111110100010
163 
case 0x58 :  *lenght=0x10; *out=0xFFA4; break; //1111111110100011
164 
case 0x59 :  *lenght=0x10; *out=0xFFA5; break; //1111111110100100
165 
case 0x5A :  *lenght=0x10; *out=0xFFA6; break; //1111111110100101
166 
case 0x61 :  *lenght=0x07; *out=0x0079; break; //1111011
167 
case 0x62 :  *lenght=0x0b; *out=0x07f7; break; //111111110110
168 
case 0x63 :  *lenght=0x10; *out=0xffa7; break; //1111111110100110
169 
case 0x64 :  *lenght=0x10; *out=0xffa8; break; //1111111110100111
170 
case 0x65 :  *lenght=0x10; *out=0xffa9; break; //1111111110101000
171 
case 0x66 :  *lenght=0x10; *out=0xffaa; break; //1111111110101001
172 
case 0x67 :  *lenght=0x10; *out=0xffab; break; //1111111110101010
173 
case 0x68 :  *lenght=0x10; *out=0xFFAc; break; //1111111110101011
174 
case 0x69 :  *lenght=0x10; *out=0xFFAf; break; //1111111110101100
175 
case 0x6A :  *lenght=0x10; *out=0xFFAe; break; //1111111110101101
176 
case 0x71 :  *lenght=0x07; *out=0x007a; break; //11111010
177 
case 0x72 :  *lenght=0x0b; *out=0x07f8; break; //111111110111
178 
case 0x73 :  *lenght=0x10; *out=0xffaf; break; //1111111110101110
179 
case 0x74 :  *lenght=0x10; *out=0xffb0; break; //1111111110101111
180 
case 0x75 :  *lenght=0x10; *out=0xFFB1; break; //1111111110110000
181 
case 0x76 :  *lenght=0x10; *out=0xFFB2; break; //111111110110001
182 
case 0x77 :  *lenght=0x10; *out=0xFFB3; break; //111111110110010
183 
case 0x78 :  *lenght=0x10; *out=0xFFB4; break; //111111110110011
184 
case 0x79 :  *lenght=0x10; *out=0xFFB5; break; //1111111110110100
185 
case 0x7A :  *lenght=0x10; *out=0xFFB6; break; //1111111110110101
186 
case 0x81 :  *lenght=0x08; *out=0x00f9; break; //111111000
187 
case 0x82 :  *lenght=0x10; *out=0xffb7; break; //111111111000000
188 
case 0x83 :  *lenght=0x10; *out=0xFFB8; break; //1111111110110110
189 
case 0x84 :  *lenght=0x10; *out=0xFFB9; break; //1111111110110111
190 
case 0x85 :  *lenght=0x10; *out=0xFFBa; break; //1111111110111000
191 
case 0x86 :  *lenght=0x10; *out=0xFFBb; break; //1111111110111001
192 
case 0x87 :  *lenght=0x10; *out=0xFFBc; break; //1111111110111010
193 
case 0x88 :  *lenght=0x10; *out=0xFFBd; break; //1111111110111011
194 
case 0x89 :  *lenght=0x10; *out=0xFFBe; break; //1111111110111100
195 
case 0x8A :  *lenght=0x10; *out=0xFFBf; break; //1111111110111101
196 
case 0x91 :  *lenght=0x09; *out=0x01f7; break; //111111001
197 
case 0x92 :  *lenght=0x10; *out=0xffc0; break; //1111111110111110
198 
case 0x93 :  *lenght=0x10; *out=0xffc1; break; //1111111110111111
199 
case 0x94 :  *lenght=0x10; *out=0xFFC2; break; //1111111111000000
200 
case 0x95 :  *lenght=0x10; *out=0xFFC3; break; //1111111111000001
201 
case 0x96 :  *lenght=0x10; *out=0xFFC4; break; //1111111111000010
202 
case 0x97 :  *lenght=0x10; *out=0xFFC5; break; //1111111111000011
203 
case 0x98 :  *lenght=0x10; *out=0xFFC6; break; //1111111111000100
204 
case 0x99 :  *lenght=0x10; *out=0xFFC7; break; //1111111111000101
205 
case 0x9A :  *lenght=0x10; *out=0xFFC8; break; //1111111111000110
206 
case 0xA1 :  *lenght=0x09; *out=0x01f8; break; //111111010
207 
case 0xA2 :  *lenght=0x10; *out=0xffc9; break; //1111111111000111
208 
case 0xA3 :  *lenght=0x10; *out=0xFFCa; break; //1111111111001000
209 
case 0xA4 :  *lenght=0x10; *out=0xFFCb; break; //1111111111001001
210 
case 0xA5 :  *lenght=0x10; *out=0xFFCc; break; //1111111111001010
211 
case 0xA6 :  *lenght=0x10; *out=0xFFCd; break; //1111111111001011
212 
case 0xA7 :  *lenght=0x10; *out=0xFFCe; break; //1111111111001100
213 
case 0xA8 :  *lenght=0x10; *out=0xFFCf; break; //1111111111001101
214 
case 0xA9 :  *lenght=0x10; *out=0xFFd0; break; //1111111111001110
215 
case 0xAA :  *lenght=0x10; *out=0xFFd1; break; //1111111111001111
216 
case 0xB1 :  *lenght=0x09; *out=0x01f9; break; //1111111001
217 
case 0xB2 :  *lenght=0x10; *out=0xFFD2; break; //1111111111010000
218 
case 0xB3 :  *lenght=0x10; *out=0xFFD3; break; //1111111111010001
219 
case 0xB4 :  *lenght=0x10; *out=0xFFD4; break; //1111111111010010
220 
case 0xB5 :  *lenght=0x10; *out=0xFFD5; break; //1111111111010011
221 
case 0xB6 :  *lenght=0x10; *out=0xFFD6; break; //1111111111010100
222 
case 0xB7 :  *lenght=0x10; *out=0xFFD7; break; //1111111111010101
223 
case 0xB8 :  *lenght=0x10; *out=0xFFD8; break; //1111111111010110
224 
case 0xB9 :  *lenght=0x10; *out=0xFFD9; break; //1111111111010111
225 
case 0xBA :  *lenght=0x10; *out=0xFFDa; break; //1111111111011000
226 
case 0xC1 :  *lenght=0x09; *out=0x01fa; break; //1111111010
227 
case 0xC2 :  *lenght=0x10; *out=0xFFDb; break; //1111111111011001
228 
case 0xC3 :  *lenght=0x10; *out=0xFFDc; break; //1111111111011010
229 
case 0xC4 :  *lenght=0x10; *out=0xFFDd; break; //1111111111011011
230 
case 0xC5 :  *lenght=0x10; *out=0xFFDe; break; //1111111111011100
231 
case 0xC6 :  *lenght=0x10; *out=0xFFDf; break; //1111111111011101
232 
case 0xC7 :  *lenght=0x10; *out=0xFFe0; break; //1111111111011110
233 
case 0xC8 :  *lenght=0x10; *out=0xFFe1; break; //1111111111011111
234 
case 0xC9 :  *lenght=0x10; *out=0xFFe2; break; //1111111111100000
235 
case 0xCA :  *lenght=0x10; *out=0xFFe3; break; //1111111111100001
236 
case 0xD1 :  *lenght=0x0b; *out=0x07f9; break; //11111111000
237 
case 0xD2 :  *lenght=0x10; *out=0xFFE4; break; //1111111111100010
238 
case 0xD3 :  *lenght=0x10; *out=0xFFE5; break; //1111111111100011
239 
case 0xD4 :  *lenght=0x10; *out=0xFFE6; break; //1111111111100100
240 
case 0xD5 :  *lenght=0x10; *out=0xFFE7; break; //1111111111100101
241 
case 0xD6 :  *lenght=0x10; *out=0xFFE8; break; //1111111111100110
242 
case 0xD7 :  *lenght=0x10; *out=0xFFE9; break; //1111111111100111
243 
case 0xD8 :  *lenght=0x10; *out=0xFFEa; break; //1111111111101000
244 
case 0xD9 :  *lenght=0x10; *out=0xFFEb; break; //1111111111101001
245 
case 0xDA :  *lenght=0x10; *out=0xFFEc; break; //1111111111101010
246 
case 0xE1 :  *lenght=0x0e; *out=0x3fe0; break; //1111111111101011
247 
case 0xE2 :  *lenght=0x10; *out=0xffed; break; //1111111111101100
248 
case 0xE3 :  *lenght=0x10; *out=0xFFEe; break; //1111111111101101
249 
case 0xE4 :  *lenght=0x10; *out=0xFFEf; break; //1111111111101110
250 
case 0xE5 :  *lenght=0x10; *out=0xFFf0; break; //1111111111101111
251 
case 0xE6 :  *lenght=0x10; *out=0xFFF1; break; //1111111111110000
252 
case 0xE7 :  *lenght=0x10; *out=0xFFF2; break; //1111111111110001
253 
case 0xE8 :  *lenght=0x10; *out=0xFFF3; break; //1111111111110010
254 
case 0xE9 :  *lenght=0x10; *out=0xFFF4; break; //1111111111110011
255 
case 0xEA :  *lenght=0x10; *out=0xFFF5; break; //1111111111110100
256 
case 0xF0 :  *lenght=0x0a; *out=0x03fa; break; //11111111001
257 
case 0xF1 :  *lenght=0x0f; *out=0x7fc3; break; //1111111111110101
258 
case 0xF2 :  *lenght=0x10; *out=0xFFF6; break; //1111111111110110
259 
case 0xF3 :  *lenght=0x10; *out=0xFFF7; break; //1111111111110111
260 
case 0xF4 :  *lenght=0x10; *out=0xFFF8; break; //1111111111111000
261 
case 0xF5 :  *lenght=0x10; *out=0xFFF9; break; //1111111111111001
262 
case 0xF6 :  *lenght=0x10; *out=0xFFFA; break; //1111111111111010
263 
case 0xF7 :  *lenght=0x10; *out=0xFFFB; break; //1111111111111011
264 
case 0xF8 :  *lenght=0x10; *out=0xFFFC; break; //1111111111111100
265 
case 0xF9 :  *lenght=0x10; *out=0xFFFD; break; //1111111111111101
266 
case 0xFA :  *lenght=0x10; *out=0xFFFE; break; //1111111111111110
267 
#ifndef __MICROBLAZE
268 
default : printf("WAARDE STAAT NIET IN TABEL!!!!!!!!!!!!!!!!!!!!\n");break;
269 
#endif
270 
        }
271 
  //      printf("magnitude= %x out= %x lenght= %d \n",magnitude,*out,*lenght);
272 
        return;
273 
}
274 
//===========================================================================
275 
void ConvertDCMagnitudeY(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
276 
{
277 
        switch (magnitude) {
278 
                case 0x00 : *out=0x0000; *lenght=2; break;
279 
                case 0x01 : *out=0x0002; *lenght=3; break;
280 
                case 0x02 : *out=0x0003; *lenght=3; break;
281 
                case 0x03 : *out=0x0004; *lenght=3; break;
282 
                case 0x04 : *out=0x0005; *lenght=3; break;
283 
                case 0x05 : *out=0x0006; *lenght=3; break;
284 
                case 0x06 : *out=0x000e; *lenght=4; break;
285 
                case 0x07 : *out=0x001e; *lenght=5; break;
286 
                case 0x08 : *out=0x003e; *lenght=6; break;
287 
                case 0x09 : *out=0x007e; *lenght=7; break;
288 
                case 0x0a : *out=0x00fe; *lenght=8; break;
289 
                case 0x0b : *out=0x01fe; *lenght=9; break;
290 
        }
291 
}
292 
//===========================================================================
293 
void ConvertACMagnitudeY(unsigned char magnitude,unsigned short int *out, unsigned short int *lenght)
294 
{
295 
        switch (magnitude) {
296 
case 0x00 :  *lenght=4;  *out=0xFFFA; break; //1010
297 
case 0x01 :  *lenght=2;  *out=0xFFF0; break; //00
298 
case 0x02 :  *lenght=2;  *out=0xFFF1; break; //01
299 
case 0x03 :  *lenght=3;  *out=0xFFF4; break; //100
300 
case 0x04 :  *lenght=4;  *out=0xFFFB; break; //1011
301 
case 0x05 :  *lenght=5;  *out=0xFFFA; break; //11010
302 
case 0x06 :  *lenght=7;  *out=0xFFF8; break; //1111000
303 
case 0x07 :  *lenght=8;  *out=0xFFF8; break; //11111000
304 
case 0x08 :  *lenght=10; *out=0xFFF6; break; //1111110110
305 
case 0x09 :  *lenght=16; *out=0xFF82; break; //1111111110000010
306 
case 0x0A :  *lenght=16; *out=0xFF83; break; //1111111110000011
307 
case 0x11 :  *lenght=4;  *out=0xFFFC; break; //1100
308 
case 0x12 :  *lenght=5;  *out=0xFFFB; break; //11011
309 
case 0x13 :  *lenght=7;  *out=0xFFF9; break; //1111001
310 
case 0x14 :  *lenght=9;  *out=0xFFF6; break; //111110110
311 
case 0x15 :  *lenght=11; *out=0xFFF6; break; //11111110110
312 
case 0x16 :  *lenght=16; *out=0xFF84; break; //1111111110000100
313 
case 0x17 :  *lenght=16; *out=0xFF85; break; //1111111110000101
314 
case 0x18 :  *lenght=16; *out=0xFF86; break; //1111111110000110
315 
case 0x19 :  *lenght=16; *out=0xFF87; break; //1111111110000111
316 
case 0x1A :  *lenght=16; *out=0xFF88; break; //1111111110001000
317 
case 0x21 :  *lenght=5;  *out=0xFFFC; break; //11100
318 
case 0x22 :  *lenght=8;  *out=0xFFF9; break; //11111001
319 
case 0x23 :  *lenght=10; *out=0xFFF7; break; //1111110111
320 
case 0x24 :  *lenght=12; *out=0xFFF4; break; //111111110100
321 
case 0x25 :  *lenght=16; *out=0xFF89; break; //1111111110001001
322 
case 0x26 :  *lenght=16; *out=0xFF8A; break; //1111111110001010
323 
case 0x27 :  *lenght=16; *out=0xFF8B; break; //1111111110001011
324 
case 0x28 :  *lenght=16; *out=0xFF8C; break; //1111111110001100
325 
case 0x29 :  *lenght=16; *out=0xFF8D; break; //1111111110001101
326 
case 0x2A :  *lenght=16; *out=0xFF8E; break; //1111111110001110
327 
case 0x31 :  *lenght=6;  *out=0xFFFA; break; //111010
328 
case 0x32 :  *lenght=9;  *out=0xFFF7; break; //111110111
329 
case 0x33 :  *lenght=12; *out=0xFFF5; break; //111111110101
330 
case 0x34 :  *lenght=16; *out=0xFF8F; break; //1111111110001111
331 
case 0x35 :  *lenght=16; *out=0xFF90; break; //1111111110010000
332 
case 0x36 :  *lenght=16; *out=0xFF91; break; //1111111110010001
333 
case 0x37 :  *lenght=16; *out=0xFF92; break; //1111111110010010
334 
case 0x38 :  *lenght=16; *out=0xFF93; break; //1111111110010011
335 
case 0x39 :  *lenght=16; *out=0xFF94; break; //1111111110010100
336 
case 0x3A :  *lenght=16; *out=0xFF95; break; //1111111110010101
337 
case 0x41 :  *lenght=6;  *out=0xFFFB; break; //111011
338 
case 0x42 :  *lenght=10; *out=0xFFF8; break; //1111111000
339 
case 0x43 :  *lenght=16; *out=0xFF96; break; //1111111110010110
340 
case 0x44 :  *lenght=16; *out=0xFF97; break; //1111111110010111
341 
case 0x45 :  *lenght=16; *out=0xFF98; break; //1111111110011000
342 
case 0x46 :  *lenght=16; *out=0xFF99; break; //1111111110011001
343 
case 0x47 :  *lenght=16; *out=0xFF9A; break; //1111111110011010
344 
case 0x48 :  *lenght=16; *out=0xFF9B; break; //1111111110011011
345 
case 0x49 :  *lenght=16; *out=0xFF9C; break; //1111111110011100
346 
case 0x4A :  *lenght=16; *out=0xFF9D; break; //1111111110011101
347 
case 0x51 :  *lenght=7;  *out=0xFFFA; break; //1111010
348 
case 0x52 :  *lenght=11; *out=0xFFF7; break; //11111110111
349 
case 0x53 :  *lenght=16; *out=0xFF9E; break; //1111111110011110
350 
case 0x54 :  *lenght=16; *out=0xFF9F; break; //1111111110011111
351 
case 0x55 :  *lenght=16; *out=0xFFA0; break; //1111111110100000
352 
case 0x56 :  *lenght=16; *out=0xFFA1; break; //1111111110100001
353 
case 0x57 :  *lenght=16; *out=0xFFA2; break; //1111111110100010
354 
case 0x58 :  *lenght=16; *out=0xFFA3; break; //1111111110100011
355 
case 0x59 :  *lenght=16; *out=0xFFA4; break; //1111111110100100
356 
case 0x5A :  *lenght=16; *out=0xFFA5; break; //1111111110100101
357 
case 0x61 :  *lenght=7;  *out=0xFFFB; break; //1111011
358 
case 0x62 :  *lenght=12; *out=0xFFF6; break; //111111110110
359 
case 0x63 :  *lenght=16; *out=0xFFA6; break; //1111111110100110
360 
case 0x64 :  *lenght=16; *out=0xFFA7; break; //1111111110100111
361 
case 0x65 :  *lenght=16; *out=0xFFA8; break; //1111111110101000
362 
case 0x66 :  *lenght=16; *out=0xFFA9; break; //1111111110101001
363 
case 0x67 :  *lenght=16; *out=0xFFAA; break; //1111111110101010
364 
case 0x68 :  *lenght=16; *out=0xFFAB; break; //1111111110101011
365 
case 0x69 :  *lenght=16; *out=0xFFAC; break; //1111111110101100
366 
case 0x6A :  *lenght=16; *out=0xFFAD; break; //1111111110101101
367 
case 0x71 :  *lenght=8;  *out=0xFFFA; break; //11111010
368 
case 0x72 :  *lenght=12; *out=0xFFF7; break; //111111110111
369 
case 0x73 :  *lenght=16; *out=0xFFAE; break; //1111111110101110
370 
case 0x74 :  *lenght=16; *out=0xFFAF; break; //1111111110101111
371 
case 0x75 :  *lenght=16; *out=0xFFB0; break; //1111111110110000
372 
case 0x76 :  *lenght=16; *out=0xFFB1; break; //111111110110001
373 
case 0x77 :  *lenght=16; *out=0xFFB2; break; //111111110110010
374 
case 0x78 :  *lenght=16; *out=0xFFB3; break; //111111110110011
375 
case 0x79 :  *lenght=16; *out=0xFFB4; break; //1111111110110100
376 
case 0x7A :  *lenght=16; *out=0xFFB5; break; //1111111110110101
377 
case 0x81 :  *lenght=9;  *out=0xFFF8; break; //111111000
378 
case 0x82 :  *lenght=15; *out=0xFFC0; break; //111111111000000
379 
case 0x83 :  *lenght=16; *out=0xFFB6; break; //1111111110110110
380 
case 0x84 :  *lenght=16; *out=0xFFB7; break; //1111111110110111
381 
case 0x85 :  *lenght=16; *out=0xFFB8; break; //1111111110111000
382 
case 0x86 :  *lenght=16; *out=0xFFB9; break; //1111111110111001
383 
case 0x87 :  *lenght=16; *out=0xFFBA; break; //1111111110111010
384 
case 0x88 :  *lenght=16; *out=0xFFBB; break; //1111111110111011
385 
case 0x89 :  *lenght=16; *out=0xFFBC; break; //1111111110111100
386 
case 0x8A :  *lenght=16; *out=0xFFBD; break; //1111111110111101
387 
case 0x91 :  *lenght=9;  *out=0xFFF9; break; //111111001
388 
case 0x92 :  *lenght=16; *out=0xFFBE; break; //1111111110111110
389 
case 0x93 :  *lenght=16; *out=0xFFBF; break; //1111111110111111
390 
case 0x94 :  *lenght=16; *out=0xFFC0; break; //1111111111000000
391 
case 0x95 :  *lenght=16; *out=0xFFC1; break; //1111111111000001
392 
case 0x96 :  *lenght=16; *out=0xFFC2; break; //1111111111000010
393 
case 0x97 :  *lenght=16; *out=0xFFC3; break; //1111111111000011
394 
case 0x98 :  *lenght=16; *out=0xFFC4; break; //1111111111000100
395 
case 0x99 :  *lenght=16; *out=0xFFC5; break; //1111111111000101
396 
case 0x9A :  *lenght=16; *out=0xFFC6; break; //1111111111000110
397 
case 0xA1 :  *lenght=9;  *out=0xFFFA; break; //111111010
398 
case 0xA2 :  *lenght=16; *out=0xFFC7; break; //1111111111000111
399 
case 0xA3 :  *lenght=16; *out=0xFFC8; break; //1111111111001000
400 
case 0xA4 :  *lenght=16; *out=0xFFC9; break; //1111111111001001
401 
case 0xA5 :  *lenght=16; *out=0xFFCA; break; //1111111111001010
402 
case 0xA6 :  *lenght=16; *out=0xFFCB; break; //1111111111001011
403 
case 0xA7 :  *lenght=16; *out=0xFFCC; break; //1111111111001100
404 
case 0xA8 :  *lenght=16; *out=0xFFCD; break; //1111111111001101
405 
case 0xA9 :  *lenght=16; *out=0xFFCE; break; //1111111111001110
406 
case 0xAA :  *lenght=16; *out=0xFFCF; break; //1111111111001111
407 
case 0xB1 :  *lenght=10; *out=0xFFF9; break; //1111111001
408 
case 0xB2 :  *lenght=16; *out=0xFFD0; break; //1111111111010000
409 
case 0xB3 :  *lenght=16; *out=0xFFD1; break; //1111111111010001
410 
case 0xB4 :  *lenght=16; *out=0xFFD2; break; //1111111111010010
411 
case 0xB5 :  *lenght=16; *out=0xFFD3; break; //1111111111010011
412 
case 0xB6 :  *lenght=16; *out=0xFFD4; break; //1111111111010100
413 
case 0xB7 :  *lenght=16; *out=0xFFD5; break; //1111111111010101
414 
case 0xB8 :  *lenght=16; *out=0xFFD6; break; //1111111111010110
415 
case 0xB9 :  *lenght=16; *out=0xFFD7; break; //1111111111010111
416 
case 0xBA :  *lenght=16; *out=0xFFD8; break; //1111111111011000
417 
case 0xC1 :  *lenght=10; *out=0xFFFA; break; //1111111010
418 
case 0xC2 :  *lenght=16; *out=0xFFD9; break; //1111111111011001
419 
case 0xC3 :  *lenght=16; *out=0xFFDA; break; //1111111111011010
420 
case 0xC4 :  *lenght=16; *out=0xFFDB; break; //1111111111011011
421 
case 0xC5 :  *lenght=16; *out=0xFFDC; break; //1111111111011100
422 
case 0xC6 :  *lenght=16; *out=0xFFDD; break; //1111111111011101
423 
case 0xC7 :  *lenght=16; *out=0xFFDE; break; //1111111111011110
424 
case 0xC8 :  *lenght=16; *out=0xFFDF; break; //1111111111011111
425 
case 0xC9 :  *lenght=16; *out=0xFFE0; break; //1111111111100000
426 
case 0xCA :  *lenght=16; *out=0xFFE1; break; //1111111111100001
427 
case 0xD1 :  *lenght=11; *out=0xFFF8; break; //11111111000
428 
case 0xD2 :  *lenght=16; *out=0xFFE2; break; //1111111111100010
429 
case 0xD3 :  *lenght=16; *out=0xFFE3; break; //1111111111100011
430 
case 0xD4 :  *lenght=16; *out=0xFFE4; break; //1111111111100100
431 
case 0xD5 :  *lenght=16; *out=0xFFE5; break; //1111111111100101
432 
case 0xD6 :  *lenght=16; *out=0xFFE6; break; //1111111111100110
433 
case 0xD7 :  *lenght=16; *out=0xFFE7; break; //1111111111100111
434 
case 0xD8 :  *lenght=16; *out=0xFFE8; break; //1111111111101000
435 
case 0xD9 :  *lenght=16; *out=0xFFE9; break; //1111111111101001
436 
case 0xDA :  *lenght=16; *out=0xFFEA; break; //1111111111101010
437 
case 0xE1 :  *lenght=16; *out=0xFFEB; break; //1111111111101011
438 
case 0xE2 :  *lenght=16; *out=0xFFEC; break; //1111111111101100
439 
case 0xE3 :  *lenght=16; *out=0xFFED; break; //1111111111101101
440 
case 0xE4 :  *lenght=16; *out=0xFFEE; break; //1111111111101110
441 
case 0xE5 :  *lenght=16; *out=0xFFEF; break; //1111111111101111
442 
case 0xE6 :  *lenght=16; *out=0xFFF0; break; //1111111111110000
443 
case 0xE7 :  *lenght=16; *out=0xFFF1; break; //1111111111110001
444 
case 0xE8 :  *lenght=16; *out=0xFFF2; break; //1111111111110010
445 
case 0xE9 :  *lenght=16; *out=0xFFF3; break; //1111111111110011
446 
case 0xEA :  *lenght=16; *out=0xFFF4; break; //1111111111110100
447 
case 0xF0 :  *lenght=11; *out=0xFFF9; break; //11111111001
448 
case 0xF1 :  *lenght=16; *out=0xFFF5; break; //1111111111110101
449 
case 0xF2 :  *lenght=16; *out=0xFFF6; break; //1111111111110110
450 
case 0xF3 :  *lenght=16; *out=0xFFF7; break; //1111111111110111
451 
case 0xF4 :  *lenght=16; *out=0xFFF8; break; //1111111111111000
452 
case 0xF5 :  *lenght=16; *out=0xFFF9; break; //1111111111111001
453 
case 0xF6 :  *lenght=16; *out=0xFFFA; break; //1111111111111010
454 
case 0xF7 :  *lenght=16; *out=0xFFFB; break; //1111111111111011
455 
case 0xF8 :  *lenght=16; *out=0xFFFC; break; //1111111111111100
456 
case 0xF9 :  *lenght=16; *out=0xFFFD; break; //1111111111111101
457 
case 0xFA :  *lenght=16; *out=0xFFFE; break; //1111111111111110
458 
#ifndef __MICROBLAZE
459 
default : printf("WAARDE STAAT NIET IN TABEL!!!!!!!!!!!!!!!!!!!!\n");break;
460 
#endif
461 
        }
462 
  //      printf("magnitude= %x out= %x lenght= %d \n",magnitude,*out,*lenght);
463 
        return;
464 
}
465 
//===========================================================================
466 
char Extend (char additional, unsigned char magnitude)
467 
{
468 
        int vt= 1 << (magnitude-1);
469 
        if ( additional < vt ) return (additional + (-1 << magnitude) + 1);
470 
        else return additional;
471 
}
472 
//===========================================================================
473 
void ReverseExtend (char value, unsigned char *magnitude, unsigned char *bits)
474 
{
475 
 //     printf("reverseextend value= %d\n",*magnitude);
476 
        if (value >=0)
477 
        {
478 
                *bits=value;
479 
        }
480 
        else
481 
        {
482 
                value=-value;
483 
                *bits=~value;
484 
        }
485 
        *magnitude=0;
486 
        while (value !=0)
487 
        {
488 
                value>>=1;
489 
                ++*magnitude;
490 
        }
491 
 //     printf("reverseextend magnitude= %d bits= %d",magnitude,bits);
492 
        return;
493 
}
494 
 
495 
static int __count3=0;
496 
 
497 
//===========================================================================
498 
void WriteRawBits16(unsigned char amount_bits, unsigned int bits, unsigned int *remaining,unsigned char *amount_remaining, FILE* file)     //*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
499 
// this function collects bits to send
500 
// 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
501 
// if more than 16 bits are collected, 16 bits are send and the remaining bits are stored again
502 
{
503 
        unsigned short int send;
504 
        unsigned int mask;
505 
        unsigned char send2;
506 
        int count;
507 
 
508 
 #ifdef __MICROBLAZE
509 
       if (__count3<16) {
510 
        xil_printf("%x %x, ", amount_bits, bits);
511 
        __count3++;
512 
        if ((__count3&0x07)==0) xil_printf("\r\n");
513 
        }
514 
#else
515 
       if (__count3<16) {
516 
        printf(" %x %x, ", amount_bits, bits);
517 
        __count3++;
518 
        if ((__count3&0x07)==0) printf("\r\n");
519 
        }
520 
#endif
521 
 
522 
 
523 
        mask=0x00;  //init mask
524 
        *remaining=(*remaining<<amount_bits);                                   //shift to make place for the new bits
525 
        for (count=amount_bits; count>0; count--) mask=(mask<<1)|0x01;          //create mask for adding bit
526 
        *remaining=*remaining | (bits&mask);                                    //add bits
527 
        *amount_remaining=*amount_remaining + amount_bits;                      //change *amount_remaining to the correct new value
528 
        if (*amount_remaining >= 16)                                            //are there more than 16 bits in buffer, send 16 bits
529 
        {
530 
 
531 
#ifndef __MICROBLAZE
532 
if (*amount_remaining >= 32 ) printf("ERROR, more bits to send %d",*amount_remaining);
533 
#endif
534 
 
535 
                send=*remaining>>(*amount_remaining-16);                        //this value can be send/stored (in art this can be dony by selecting bits)
536 
                send2=(send & 0xFF00) >>8;
537 
#ifdef __MICROBLAZE
538 
               sysace_fwrite(&send2,1,1,file);
539 
#else
540 
                fwrite(&send2,1,1,file);
541 
#endif
542 
                if (send2==0xFF)
543 
                {
544 
                        send2=0x00;
545 
#ifdef __MICROBLAZE
546 
                        sysace_fwrite(&send2,1,1,file);
547 
#else
548 
                        fwrite(&send2,1,1,file);
549 
#endif
550 
                }
551 
                send2=send & 0xFF;
552 
#ifdef __MICROBLAZE
553 
               sysace_fwrite(&send2,1,1,file);
554 
#else
555 
                fwrite(&send2,1,1,file);
556 
#endif
557 
                if (send2==0xFF)
558 
                {
559 
                        send2=0x00;
560 
#ifdef __MICROBLAZE
561 
                       sysace_fwrite(&send2,1,1,file);
562 
#else
563 
                       fwrite(&send2,1,1,file);
564 
#endif
565 
                }
566 
                *amount_remaining=*amount_remaining-16;                         //descrease by 16 because these are send
567 
        }
568 
        return;
569 
}
570 
//===========================================================================
571 
void HuffmanEncodeFinishSend(unsigned int *remaining,unsigned char *amount_remaining, FILE* file)
572 
// There are still some bits left to send at the end of the 8x8 matrix (or maybe the file),
573 
// the remaining bits are filled up with ones and send
574 
// possible fault: -must it be filled up with ones?
575 
{
576 
        unsigned short int send;
577 
        unsigned int mask;
578 
        int  count;
579 
        mask=0x00;                                                              //init mask
580 
        if (*amount_remaining >= 8)                                           //  //2 bytes to send, send first byte
581 
        {
582 
                send=*remaining>>(*amount_remaining-8);                         //shift so that first byte is ready to send
583 
#ifdef __MICROBLAZE
584 
                sysace_fwrite(&send,1,1,file);
585 
#else
586 
                fwrite(&send,1,1,file);
587 
#endif
588 
                if (send==0xFF)                                                 //is this still needed????
589 
                {
590 
                        send=0x00;
591 
#ifdef __MICROBLAZE
592 
                        sysace_fwrite(&send,1,1,file);
593 
#else
594 
                        fwrite(&send,1,1,file);
595 
 #endif
596 
               }
597 
                *amount_remaining=*amount_remaining -8;                         // lower the value to the amount of bits that still needs to be send
598 
        }
599 
        if (*amount_remaining >= 0)                                             //there is a last byte to send
600 
        {
601 
                send=*remaining<<(8-*amount_remaining);                         //shift the last bits to send to the front of the byte
602 
                mask=0x00;                                                      //init mask
603 
                for (count=(8-*amount_remaining); count>0; count--) mask=(mask<<1)|0x01; //create mask to fill byte up with ones
604 
                send=send | mask;                                               //add the ones to the byte
605 
#ifdef __MICROBLAZE
606 
                sysace_fwrite(&send,1,1,file);
607 
#else
608 
                fwrite(&send,1,1,file);
609 
#endif
610 
                *amount_remaining=0x00;                                         //is this needed?
611 
        }
612 
        return;
613 
}
614 
//===========================================================================
615 
void HuffmanEncodeUsingDCTable(unsigned char magnitude,unsigned int *remaining,unsigned char *amount_remaining, FILE* file)
616 
// Translate magnitude into needed data (from table) and send it
617 
{
618 
        unsigned char send;
619 
        unsigned short int huffmancode, huffmanlengt;
620 
        ConvertDCMagnitudeY(magnitude, &huffmancode, &huffmanlengt);
621 
        WriteRawBits16(huffmanlengt,huffmancode,remaining,amount_remaining, file);
622 
        //printf("Write DC magnitude= %2x \n",magnitude);
623 
        //WriteRawBits16(0x08,magnitude,remaining,amount_remaining, file);
624 
        return;
625 
}
626 
//===========================================================================
627 
void HuffmanEncodeUsingACTable(unsigned char mag,unsigned int *remaining,unsigned char *amount_remaining, FILE* file)
628 
// Translate magnitude into needed data (from table) and send it
629 
{
630 
        unsigned char send;
631 
        unsigned short int huffmancode, huffmanlengt;
632 
        ConvertACMagnitudeY(mag, &huffmancode, &huffmanlengt);
633 
        WriteRawBits16(huffmanlengt,huffmancode,remaining,amount_remaining, file);
634 
        return;
635 
}
636 
//===========================================================================
637 
char EncodeDataUnit(char dataunit[64], char last_dc_value, FILE* file, unsigned int *remaining, unsigned char *amount_remaining, unsigned int color)
638 
{
639 
        char difference;
640 
        unsigned char magnitude,zerorun,ii,ert;
641 
        unsigned int bits;
642 
        unsigned char bits_char;
643 
                                         //init
644 
  //    PrintMatrix(dataunit) ;
645 
        difference = dataunit[0] - last_dc_value;
646 
        last_dc_value=dataunit[0];
647 
        ReverseExtend(difference, &magnitude,&bits_char);
648 
        bits=bits_char;
649 
        HuffmanEncodeUsingDCTable(magnitude,remaining,amount_remaining, file);
650 
        WriteRawBits16(magnitude,bits,remaining,amount_remaining, file);
651 
        zerorun=0;
652 
        ii=1;
653 
        while ( ii < 64 )
654 
        {
655 
                if (dataunit[ii] != 0 )
656 
                {
657 
                        while ( zerorun >= 16 )
658 
                        {
659 
                                HuffmanEncodeUsingACTable(0xF0,remaining,amount_remaining,file);
660 
                                zerorun=zerorun-16;
661 
                            //    printf("16 zeros:  %d\n",zerorun);
662 
                        }
663 
                        ReverseExtend(dataunit[ii],&magnitude,&bits_char);
664 
                        bits=bits_char;
665 
                        ert= ((int)zerorun *16);                                     //ERROR !!!!!!!!!!!
666 
                        ert=ert + magnitude;
667 
                        HuffmanEncodeUsingACTable(ert,remaining,amount_remaining,file);
668 
                        WriteRawBits16(magnitude,bits,remaining,amount_remaining, file);
669 
                        zerorun=0;
670 
                }
671 
                else zerorun=zerorun+1;
672 
                ii++;
673 
        }
674 
        if ( zerorun != 0 )
675 
        {
676 
                HuffmanEncodeUsingACTable(0x00,remaining,amount_remaining,file);
677 
//                printf("NUL DE REST IS NUL\n");
678 
        }
679 
 //       HuffmanEncodeFinishSend(remaining,amount_remaining,file);
680 
        return last_dc_value;
681 
}
682 
 
683 
#if 0
684 
//===========================================================================
685 
void DecodeDataUnit(char *coefficients[64], char last_dc_value, char value)
686 
{
687 
        char ii;
688 
        char lowbits,highbits,extrabits;
689 
        //decode DC
690 
 
691 
 
692 
        //decode AC
693 
        //set coefficients to 0
694 
        for (ii=0;ii<64;ii++) *coefficients[ii]=0x00;     //for the next optimu\ization step: don't write 0 before beginning, these value are overwritten. Only write 0 is you know tha value is 0, now you only write each value once, not twice is the value ain't 0.
695 
        while (ii<64)
696 
        {
697 
//                value= DecodeUsingACTable();
698 
                lowbits = value && 0x0F;
699 
                highbits = (value && 0xF0 ) >>4;
700 
 
701 
                if (lowbits != 0x00)
702 
                {
703 
//                        extrabits = ReadRawBits(lowbits);
704 
                        ii=ii+highbits;
705 
                        *coefficients[ii]=Extend(extrabits,lowbits);
706 
                        ii++;
707 
                }
708 
                else
709 
                {
710 
                        if (highbits==0xF) ii=ii+16; //run of 16 zeros
711 
                        else if (highbits == 0x0) ii=64; //the rest are zeros
712 
                }
713 
        }
714 
}
715 
//===========================================================================
716 
#endif
717 
 
718 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.