1 /* ����ͷ�ļ� */
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include "stdefine.h"
6 #include "bitstr.h"
7 #include "huffman.h"
8 #include "quant.h"
9 #include "zigzag.h"
10 #include "dct.h"
11 #include "bmp.h"
12 #include "color.h"
13 #include "jfif.h"
14
15 // Ԥ���뿪��
16 #define DEBUG_JFIF 0
17
18 // �ڲ����Ͷ���
19 typedef struct {
20 // width & height
21 int width;
22 int height;
23
24 // quantization table
25 int *pqtab[16];
26
27 // huffman codec ac
28 HUFCODEC *phcac[16];
29
30 // huffman codec dc
31 HUFCODEC *phcdc[16];
32
33 // components
34 int comp_num;
35 struct {
36 int id;
37 int samp_factor_v;
38 int samp_factor_h;
39 int qtab_idx;
40 int htab_idx_ac;
41 int htab_idx_dc;
42 } comp_info[4];
43
44 int datalen;
45 BYTE *databuf;
46 } JFIF;
47
48 /* �ڲ�����ʵ�� */
49 #if DEBUG_JFIF
jfif_dump(JFIF * jfif)50 static void jfif_dump(JFIF *jfif)
51 {
52 int i, j;
53
54 printf("++ jfif dump ++\n");
55 printf("width : %d\n", jfif->width );
56 printf("height: %d\n", jfif->height);
57 printf("\n");
58
59 for (i=0; i<16; i++) {
60 if (!jfif->pqtab[i]) continue;
61 printf("qtab%d\n", i);
62 for (j=0; j<64; j++) {
63 printf("%3d,%c", jfif->pqtab[i][j], j%8 == 7 ? '\n' : ' ');
64 }
65 printf("\n");
66 }
67
68 for (i=0; i<16; i++) {
69 int size = 16;
70 if (!jfif->phcac[i]) continue;
71 printf("htabac%d\n", i);
72 for (j=0; j<16; j++) {
73 size += jfif->phcac[i]->huftab[j];
74 }
75 for (j=0; j<size; j++) {
76 printf("%3d,%c", jfif->phcac[i]->huftab[j], j%16 == 15 ? '\n' : ' ');
77 }
78 printf("\n\n");
79 }
80
81 for (i=0; i<16; i++) {
82 int size = 16;
83 if (!jfif->phcdc[i]) continue;
84 printf("htabdc%d\n", i);
85 for (j=0; j<16; j++) {
86 size += jfif->phcdc[i]->huftab[j];
87 }
88 for (j=0; j<size; j++) {
89 printf("%3d,%c", jfif->phcdc[i]->huftab[j], j%16 == 15 ? '\n' : ' ');
90 }
91 printf("\n\n");
92 }
93
94 printf("comp_num : %d\n", jfif->comp_num);
95 for (i=0; i<jfif->comp_num; i++) {
96 printf("id:%d samp_factor_v:%d samp_factor_h:%d qtab_idx:%d htab_idx_ac:%d htab_idx_dc:%d\n",
97 jfif->comp_info[i].id,
98 jfif->comp_info[i].samp_factor_v,
99 jfif->comp_info[i].samp_factor_h,
100 jfif->comp_info[i].qtab_idx,
101 jfif->comp_info[i].htab_idx_ac,
102 jfif->comp_info[i].htab_idx_dc);
103 }
104 printf("\n");
105
106 printf("datalen : %d\n", jfif->datalen);
107 printf("-- jfif dump --\n");
108 }
109
dump_du(int * du)110 static void dump_du(int *du)
111 {
112 int i;
113 for (i=0; i<64; i++) {
114 printf("%3d%c", du[i], i % 8 == 7 ? '\n' : ' ');
115 }
116 printf("\n");
117 }
118 #endif
119
ALIGN(int x,int y)120 static int ALIGN(int x, int y) {
121 // y must be a power of 2.
122 return (x + y - 1) & ~(y - 1);
123 }
124
category_encode(int * code,int * size)125 static void category_encode(int *code, int *size)
126 {
127 unsigned absc = abs(*code);
128 unsigned mask = (1 << 15);
129 int i = 15;
130 if (absc == 0) { *size = 0; return; }
131 while (i && !(absc & mask)) { mask >>= 1; i--; }
132 *size = i + 1;
133 if (*code < 0) *code = (1 << *size) - absc - 1;
134 }
135
category_decode(int code,int size)136 static int category_decode(int code, int size)
137 {
138 return code >= (1 << (size - 1)) ? code : code - (1 << size) + 1;
139 }
140
141 /* ����ʵ�� */
jfif_load(char * file)142 void* jfif_load(char *file)
143 {
144 JFIF *jfif = NULL;
145 FILE *fp = NULL;
146 int header = 0;
147 int type = 0;
148 WORD size = 0;
149 BYTE *buf = NULL;
150 BYTE *end = NULL;
151 BYTE *dqt, *dht;
152 int ret =-1;
153 long offset = 0;
154 int i;
155
156 jfif = calloc(1, sizeof(JFIF));
157 buf = calloc(1, 0x10000);
158 end = buf + 0x10000;
159 if (!jfif || !buf) goto done;
160
161 fp = fopen(file, "rb");
162 if (!fp) goto done;
163
164 while (1) {
165 do { header = fgetc(fp); } while (header != EOF && header != 0xff); // get header
166 do { type = fgetc(fp); } while (type != EOF && type == 0xff); // get type
167 if (header == EOF || type == EOF) {
168 printf("file eof !\n");
169 break;
170 }
171
172 if ((type == 0xd8) || (type == 0xd9) || (type == 0x01) || (type >= 0xd0 && type <= 0xd7)) {
173 size = 0;
174 } else {
175 size = fgetc(fp) << 8;
176 size |= fgetc(fp) << 0;
177 size -= 2;
178 }
179
180 size = fread(buf, 1, size, fp);
181 switch (type) {
182 case 0xc0: // SOF0
183 jfif->width = (buf[3] << 8) | (buf[4] << 0);
184 jfif->height = (buf[1] << 8) | (buf[2] << 0);
185 jfif->comp_num = buf[5] < 4 ? buf[5] : 4;
186 for (i=0; i<jfif->comp_num; i++) {
187 jfif->comp_info[i].id = buf[6 + i * 3];
188 jfif->comp_info[i].samp_factor_v = (buf[7 + i * 3] >> 0) & 0x0f;
189 jfif->comp_info[i].samp_factor_h = (buf[7 + i * 3] >> 4) & 0x0f;
190 jfif->comp_info[i].qtab_idx = buf[8 + i * 3] & 0x0f;
191 }
192 break;
193
194 case 0xda: // SOS
195 jfif->comp_num = buf[0] < 4 ? buf[0] : 4;
196 for (i=0; i<jfif->comp_num; i++) {
197 jfif->comp_info[i].id = buf[1 + i * 2];
198 jfif->comp_info[i].htab_idx_ac = (buf[2 + i * 2] >> 0) & 0x0f;
199 jfif->comp_info[i].htab_idx_dc = (buf[2 + i * 2] >> 4) & 0x0f;
200 }
201 offset = ftell(fp);
202 ret = 0;
203 goto read_data;
204
205 case 0xdb: // DQT
206 dqt = buf;
207 while (size > 0 && dqt < end) {
208 int idx = dqt[0] & 0x0f;
209 int f16 = dqt[0] & 0xf0;
210 if (!jfif->pqtab[idx]) jfif->pqtab[idx] = malloc(64 * sizeof(int));
211 if (!jfif->pqtab[idx]) break;
212 if (dqt + 1 + 64 + (f16 ? 64 : 0) < end) {
213 for (i=0; i<64; i++) {
214 jfif->pqtab[idx][ZIGZAG[i]] = f16 ? ((dqt[1 + i * 2] << 8) | (dqt[2 + i * 2] << 0)) : dqt[1 + i];
215 }
216 }
217 dqt += 1 + 64 + (f16 ? 64 : 0);
218 size-= 1 + 64 + (f16 ? 64 : 0);
219 }
220 break;
221
222 case 0xc4: // DHT
223 dht = buf;
224 while (size > 0 && dht + 17 < end) {
225 int idx = dht[0] & 0x0f;
226 int fac = dht[0] & 0xf0;
227 int len = 0;
228 for (i=1; i<1+16; i++) len += dht[i];
229 if (len > end - dht - 17) len = end - dht - 17;
230 if (len > 256) len = 256;
231 if (fac) {
232 if (!jfif->phcac[idx]) jfif->phcac[idx] = calloc(1, sizeof(HUFCODEC));
233 if (jfif->phcac[idx]) memcpy(jfif->phcac[idx]->huftab, &dht[1], 16 + len);
234 } else {
235 if (!jfif->phcdc[idx]) jfif->phcdc[idx] = calloc(1, sizeof(HUFCODEC));
236 if (jfif->phcdc[idx]) memcpy(jfif->phcdc[idx]->huftab, &dht[1], 16 + len);
237 }
238 dht += 17 + len;
239 size-= 17 + len;
240 }
241 break;
242 }
243 }
244
245 read_data:
246 fseek(fp, 0, SEEK_END);
247 jfif->datalen = ftell(fp) - offset;
248 jfif->databuf = malloc(jfif->datalen);
249 if (jfif->databuf) {
250 fseek(fp, offset, SEEK_SET);
251 fread(jfif->databuf, 1, jfif->datalen, fp);
252 }
253
254 done:
255 if (buf) free (buf);
256 if (fp) fclose(fp );
257 if (ret == -1) {
258 jfif_free(jfif);
259 jfif = NULL;
260 }
261 return jfif;
262 }
263
jfif_save(void * ctxt,char * file)264 int jfif_save(void *ctxt, char *file)
265 {
266 JFIF *jfif = (JFIF*)ctxt;
267 FILE *fp = NULL;
268 int len = 0;
269 int i, j;
270 int ret = -1;
271
272 fp = fopen(file, "wb");
273 if (!fp) goto done;
274
275 // output SOI
276 fputc(0xff, fp);
277 fputc(0xd8, fp);
278
279 // output DQT
280 for (i=0; i<16; i++) {
281 if (!jfif->pqtab[i]) continue;
282 len = 2 + 1 + 64;
283 fputc(0xff, fp);
284 fputc(0xdb, fp);
285 fputc(len >> 8, fp);
286 fputc(len >> 0, fp);
287 fputc(i, fp);
288 for (j=0; j<64; j++) {
289 fputc(jfif->pqtab[i][ZIGZAG[j]], fp);
290 }
291 }
292
293 // output SOF0
294 len = 2 + 1 + 2 + 2 + 1 + 3 * jfif->comp_num;
295 fputc(0xff, fp);
296 fputc(0xc0, fp);
297 fputc(len >> 8, fp);
298 fputc(len >> 0, fp);
299 fputc(8, fp); // precision 8bit
300 fputc(jfif->height >> 8, fp); // height
301 fputc(jfif->height >> 0, fp); // height
302 fputc(jfif->width >> 8, fp); // width
303 fputc(jfif->width >> 0, fp); // width
304 fputc(jfif->comp_num, fp);
305 for (i=0; i<jfif->comp_num; i++) {
306 fputc(jfif->comp_info[i].id, fp);
307 fputc((jfif->comp_info[i].samp_factor_v << 0)|(jfif->comp_info[i].samp_factor_h << 4), fp);
308 fputc(jfif->comp_info[i].qtab_idx, fp);
309 }
310
311 // output DHT AC
312 for (i=0; i<16; i++) {
313 if (!jfif->phcac[i]) continue;
314 fputc(0xff, fp);
315 fputc(0xc4, fp);
316 len = 2 + 1 + 16;
317 for (j=0; j<16; j++) len += jfif->phcac[i]->huftab[j];
318 fputc(len >> 8, fp);
319 fputc(len >> 0, fp);
320 fputc(i + 0x10, fp);
321 fwrite(jfif->phcac[i]->huftab, len - 3, 1, fp);
322 }
323
324 // output DHT DC
325 for (i=0; i<16; i++) {
326 if (!jfif->phcdc[i]) continue;
327 fputc(0xff, fp);
328 fputc(0xc4, fp);
329 len = 2 + 1 + 16;
330 for (j=0; j<16; j++) len += jfif->phcdc[i]->huftab[j];
331 fputc(len >> 8, fp);
332 fputc(len >> 0, fp);
333 fputc(i + 0x00, fp);
334 fwrite(jfif->phcdc[i]->huftab, len - 3, 1, fp);
335 }
336
337 // output SOS
338 len = 2 + 1 + 2 * jfif->comp_num + 3;
339 fputc(0xff, fp);
340 fputc(0xda, fp);
341 fputc(len >> 8, fp);
342 fputc(len >> 0, fp);
343 fputc(jfif->comp_num, fp);
344 for (i=0; i<jfif->comp_num; i++) {
345 fputc(jfif->comp_info[i].id, fp);
346 fputc((jfif->comp_info[i].htab_idx_ac << 0)|(jfif->comp_info[i].htab_idx_dc << 4), fp);
347 }
348 fputc(0x00, fp);
349 fputc(0x00, fp);
350 fputc(0x00, fp);
351
352 // output data
353 if (jfif->databuf) {
354 fwrite(jfif->databuf, jfif->datalen, 1, fp);
355 }
356 ret = 0;
357
358 done:
359 if (fp) fclose(fp);
360 return ret;
361 }
362
jfif_free(void * ctxt)363 void jfif_free(void *ctxt)
364 {
365 JFIF *jfif = (JFIF*)ctxt;
366 int i;
367 if (!jfif) return;
368 for (i=0; i<16; i++) {
369 if (jfif->pqtab[i]) free(jfif->pqtab[i]);
370 if (jfif->phcac[i]) free(jfif->phcac[i]);
371 if (jfif->phcdc[i]) free(jfif->phcdc[i]);
372 }
373 if (jfif->databuf) free(jfif->databuf);
374 free(jfif);
375 }
376
jfif_decode(void * ctxt,BMP * pb)377 int jfif_decode(void *ctxt, BMP *pb)
378 {
379 JFIF *jfif = (JFIF*)ctxt;
380 void *bs = NULL;
381 int *ftab[16]= {0};
382 int dc[4] = {0};
383 int mcuw, mcuh, mcuc, mcur, mcui, jw, jh;
384 int i, j, c, h, v, x, y;
385 int sfh_max = 0;
386 int sfv_max = 0;
387 int yuv_stride[3] = {0};
388 int yuv_height[3] = {0};
389 int *yuv_datbuf[3] = {0};
390 int *idst, *isrc;
391 int *ysrc, *usrc, *vsrc;
392 BYTE *bdst;
393 int ret = -1;
394
395 if (!ctxt || !pb) {
396 printf("invalid input params !\n");
397 return -1;
398 }
399
400 // init dct module
401 init_dct_module();
402
403 //++ init ftab
404 for (i=0; i<16; i++) {
405 if (jfif->pqtab[i]) {
406 ftab[i] = malloc(64 * sizeof(int));
407 if (ftab[i]) {
408 init_idct_ftab(ftab[i], jfif->pqtab[i]);
409 } else {
410 goto done;
411 }
412 }
413 }
414 //-- init ftab
415
416 //++ calculate mcu info
417 for (c=0; c<jfif->comp_num; c++) {
418 if (sfh_max < jfif->comp_info[c].samp_factor_h) {
419 sfh_max = jfif->comp_info[c].samp_factor_h;
420 }
421 if (sfv_max < jfif->comp_info[c].samp_factor_v) {
422 sfv_max = jfif->comp_info[c].samp_factor_v;
423 }
424 }
425 mcuw = sfh_max * 8;
426 mcuh = sfv_max * 8;
427 jw = ALIGN(jfif->width, mcuw);
428 jh = ALIGN(jfif->height, mcuh);
429 mcuc = jw / mcuw;
430 mcur = jh / mcuh;
431 //-- calculate mcu info
432
433 // create yuv buffer for decoding
434 yuv_stride[0] = jw;
435 yuv_stride[1] = jw * jfif->comp_info[1].samp_factor_h / sfh_max;
436 yuv_stride[2] = jw * jfif->comp_info[2].samp_factor_h / sfh_max;
437 yuv_height[0] = jh;
438 yuv_height[1] = jh * jfif->comp_info[1].samp_factor_v / sfv_max;
439 yuv_height[2] = jh * jfif->comp_info[2].samp_factor_v / sfv_max;
440 yuv_datbuf[0] = malloc(yuv_stride[0] * yuv_height[0] * sizeof(int));
441 yuv_datbuf[1] = malloc(yuv_stride[1] * yuv_height[1] * sizeof(int));
442 yuv_datbuf[2] = malloc(yuv_stride[2] * yuv_height[2] * sizeof(int));
443 if (!yuv_datbuf[0] || !yuv_datbuf[1] || !yuv_datbuf[2]) {
444 goto done;
445 }
446
447 // open bit stream
448 bs = bitstr_open(jfif->databuf, "mem", jfif->datalen);
449 if (!bs) {
450 printf("failed to open bitstr for jfif_decode !");
451 return -1;
452 }
453
454 // init huffman codec
455 for (i=0; i<16; i++) {
456 if (jfif->phcac[i]) {
457 jfif->phcac[i]->input = bs;
458 huffman_decode_init(jfif->phcac[i]);
459 }
460 if (jfif->phcdc[i]) {
461 jfif->phcdc[i]->input = bs;
462 huffman_decode_init(jfif->phcdc[i]);
463 }
464 }
465
466 for (mcui=0; mcui<mcuc*mcur; mcui++) {
467 for (c=0; c<jfif->comp_num; c++) {
468 for (v=0; v<jfif->comp_info[c].samp_factor_v; v++) {
469 for (h=0; h<jfif->comp_info[c].samp_factor_h; h++) {
470 HUFCODEC *hcac = jfif->phcac[jfif->comp_info[c].htab_idx_ac];
471 HUFCODEC *hcdc = jfif->phcdc[jfif->comp_info[c].htab_idx_dc];
472 int fidx = jfif->comp_info[c].qtab_idx;
473 int size, znum, code;
474 int du[64] = {0};
475
476 //+ decode dc
477 size = huffman_decode_step(hcdc) & 0xf;
478 if (size) {
479 code = bitstr_get_bits(bs, size);
480 code = category_decode(code, size);
481 }
482 else {
483 code = 0;
484 }
485 dc[c] += code;
486 du[0] = dc[c];
487 //- decode dc
488
489 //+ decode ac
490 for (i=1; i<64;) {
491 code = huffman_decode_step(hcac);
492 if (code <= 0) break;
493 size = (code >> 0) & 0xf;
494 znum = (code >> 4) & 0xf;
495 i += znum;
496 code = bitstr_get_bits(bs, size);
497 code = category_decode(code, size);
498 if (i < 64) du[i++] = code;
499 }
500 //- decode ac
501
502 // de-zigzag
503 zigzag_decode(du);
504
505 // idct
506 idct2d8x8(du, ftab[fidx]);
507
508 // copy du to yuv buffer
509 x = ((mcui % mcuc) * mcuw + h * 8) * jfif->comp_info[c].samp_factor_h / sfh_max;
510 y = ((mcui / mcuc) * mcuh + v * 8) * jfif->comp_info[c].samp_factor_v / sfv_max;
511 idst = yuv_datbuf[c] + y * yuv_stride[c] + x;
512 isrc = du;
513 for (i=0; i<8; i++) {
514 memcpy(idst, isrc, 8 * sizeof(int));
515 idst += yuv_stride[c];
516 isrc += 8;
517 }
518 }
519 }
520 }
521 }
522
523 // close huffman codec
524 for (i=0; i<16; i++) {
525 if (jfif->phcac[i]) huffman_decode_done(jfif->phcac[i]);
526 if (jfif->phcdc[i]) huffman_decode_done(jfif->phcdc[i]);
527 }
528
529 // close bit stream
530 bitstr_close(bs);
531
532 // create bitmap, and convert yuv to rgb
533 bmp_create(pb, jfif->width, jfif->height);
534 bdst = (BYTE*)pb->pdata;
535 ysrc = yuv_datbuf[0];
536 for (i=0; i<jfif->height; i++) {
537 int uy = i * jfif->comp_info[1].samp_factor_v / sfv_max;
538 int vy = i * jfif->comp_info[2].samp_factor_v / sfv_max;
539 for (j=0; j<jfif->width; j++) {
540 int ux = j * jfif->comp_info[1].samp_factor_h / sfh_max;
541 int vx = j * jfif->comp_info[2].samp_factor_h / sfh_max;
542 usrc = yuv_datbuf[2] + uy * yuv_stride[2] + ux;
543 vsrc = yuv_datbuf[1] + vy * yuv_stride[1] + vx;
544 yuv_to_rgb(*ysrc, *vsrc, *usrc, bdst + 2, bdst + 1, bdst + 0);
545 bdst += 3;
546 ysrc += 1;
547 }
548 bdst -= jfif->width * 3;
549 bdst += pb->stride;
550 ysrc -= jfif->width * 1;
551 ysrc += yuv_stride[0];
552 }
553
554 // success
555 ret = 0;
556
557 done:
558 if (yuv_datbuf[0]) free(yuv_datbuf[0]);
559 if (yuv_datbuf[1]) free(yuv_datbuf[1]);
560 if (yuv_datbuf[2]) free(yuv_datbuf[2]);
561 //++ free ftab
562 for (i=0; i<16; i++) {
563 if (ftab[i]) {
564 free(ftab[i]);
565 }
566 }
567 //-- free ftab
568 return ret;
569 }
570
571 #define DU_TYPE_LUMIN 0
572 #define DU_TYPE_CHROM 1
573
574 typedef struct {
575 unsigned runlen : 4;
576 unsigned codesize : 4;
577 unsigned codedata : 16;
578 } RLEITEM;
579
jfif_encode_du(JFIF * jfif,int type,int du[64],int * dc)580 static void jfif_encode_du(JFIF *jfif, int type, int du[64], int *dc)
581 {
582 HUFCODEC *hfcac = jfif->phcac[type];
583 HUFCODEC *hfcdc = jfif->phcdc[type];
584 int *pqtab = jfif->pqtab[type];
585 void *bs = hfcac->output;
586 int diff, code, size;
587 RLEITEM rlelist[63];
588 int i, j, n, eob;
589
590 // fdct
591 fdct2d8x8(du, NULL);
592
593 // quant
594 quant_encode(du, pqtab);
595
596 // zigzag
597 zigzag_encode(du);
598
599 // dc
600 diff = du[0] - *dc;
601 *dc = du[0];
602
603 // category encode for dc
604 code = diff;
605 category_encode(&code, &size);
606
607 // huffman encode for dc
608 huffman_encode_step(hfcdc, size);
609 bitstr_put_bits(bs, code, size);
610
611 // rle encode for ac
612 for (i=1, j=0, n=0, eob=0; i<64 && j<63; i++) {
613 if (du[i] == 0 && n < 15) {
614 n++;
615 } else {
616 code = du[i]; size = 0;
617 category_encode(&code, &size);
618 rlelist[j].runlen = n;
619 rlelist[j].codesize = size;
620 rlelist[j].codedata = code;
621 n = 0;
622 j++;
623 if (size != 0) eob = j;
624 }
625 }
626
627 // set eob
628 if (du[63] == 0) {
629 rlelist[eob].runlen = 0;
630 rlelist[eob].codesize = 0;
631 rlelist[eob].codedata = 0;
632 j = eob + 1;
633 }
634
635 // huffman encode for ac
636 for (i=0; i<j; i++) {
637 huffman_encode_step(hfcac, (rlelist[i].runlen << 4) | (rlelist[i].codesize << 0));
638 bitstr_put_bits(bs, rlelist[i].codedata, rlelist[i].codesize);
639 }
640 }
641
jfif_encode(BMP * pb)642 void* jfif_encode(BMP *pb)
643 {
644 JFIF *jfif = NULL;
645 void *bs = NULL;
646 int jw, jh;
647 int *yuv_datbuf[3] = {0};
648 int *ydst, *udst, *vdst;
649 int *isrc, *idst;
650 BYTE *bsrc;
651 int du[64]= {0};
652 int dc[4]= {0};
653 int i, j, m, n;
654 int failed = 1;
655
656 // check input params
657 if (!pb) {
658 printf("invalid input params !\n");
659 return NULL;
660 }
661
662 // allocate jfif context
663 jfif = calloc(1, sizeof(JFIF));
664 if (!jfif) return NULL;
665
666 // init dct module
667 init_dct_module();
668
669 // init jfif context
670 jfif->width = pb->width;
671 jfif->height = pb->height;
672 jfif->pqtab[0] = malloc(64*sizeof(int));
673 jfif->pqtab[1] = malloc(64*sizeof(int));
674 jfif->phcac[0] = calloc(1, sizeof(HUFCODEC));
675 jfif->phcac[1] = calloc(1, sizeof(HUFCODEC));
676 jfif->phcdc[0] = calloc(1, sizeof(HUFCODEC));
677 jfif->phcdc[1] = calloc(1, sizeof(HUFCODEC));
678 jfif->datalen = jfif->width * jfif->height * 2;
679 jfif->databuf = malloc(jfif->datalen);
680 if (!jfif->pqtab[0] || !jfif->pqtab[1]
681 || !jfif->phcac[0] || !jfif->phcac[1]
682 || !jfif->phcdc[0] || !jfif->phcdc[1]
683 || !jfif->databuf) {
684 goto done;
685 }
686
687 // init qtab
688 memcpy(jfif->pqtab[0], STD_QUANT_TAB_LUMIN, 64*sizeof(int));
689 memcpy(jfif->pqtab[1], STD_QUANT_TAB_CHROM, 64*sizeof(int));
690
691 // open bit stream
692 bs = bitstr_open(jfif->databuf, "mem", jfif->datalen);
693 if (!bs) {
694 printf("failed to open bitstr for jfif_decode !");
695 goto done;
696 }
697
698 // init huffman codec
699 memcpy(jfif->phcac[0]->huftab, STD_HUFTAB_LUMIN_AC, MAX_HUFFMAN_CODE_LEN + 256);
700 memcpy(jfif->phcac[1]->huftab, STD_HUFTAB_CHROM_AC, MAX_HUFFMAN_CODE_LEN + 256);
701 memcpy(jfif->phcdc[0]->huftab, STD_HUFTAB_LUMIN_DC, MAX_HUFFMAN_CODE_LEN + 256);
702 memcpy(jfif->phcdc[1]->huftab, STD_HUFTAB_CHROM_DC, MAX_HUFFMAN_CODE_LEN + 256);
703 jfif->phcac[0]->output = bs; huffman_encode_init(jfif->phcac[0], 1);
704 jfif->phcac[1]->output = bs; huffman_encode_init(jfif->phcac[1], 1);
705 jfif->phcdc[0]->output = bs; huffman_encode_init(jfif->phcdc[0], 1);
706 jfif->phcdc[1]->output = bs; huffman_encode_init(jfif->phcdc[1], 1);
707
708 // init comp_num & comp_info
709 jfif->comp_num = 3;
710 jfif->comp_info[0].id = 1;
711 jfif->comp_info[0].samp_factor_v = 2;
712 jfif->comp_info[0].samp_factor_h = 2;
713 jfif->comp_info[0].qtab_idx = 0;
714 jfif->comp_info[0].htab_idx_ac = 0;
715 jfif->comp_info[0].htab_idx_dc = 0;
716 jfif->comp_info[1].id = 2;
717 jfif->comp_info[1].samp_factor_v = 1;
718 jfif->comp_info[1].samp_factor_h = 1;
719 jfif->comp_info[1].qtab_idx = 1;
720 jfif->comp_info[1].htab_idx_ac = 1;
721 jfif->comp_info[1].htab_idx_dc = 1;
722 jfif->comp_info[2].id = 3;
723 jfif->comp_info[2].samp_factor_v = 1;
724 jfif->comp_info[2].samp_factor_h = 1;
725 jfif->comp_info[2].qtab_idx = 1;
726 jfif->comp_info[2].htab_idx_ac = 1;
727 jfif->comp_info[2].htab_idx_dc = 1;
728
729 // init jw & jw, init yuv data buffer
730 jw = ALIGN(pb->width, 16);
731 jh = ALIGN(pb->height, 16);
732 yuv_datbuf[0] = calloc(1, jw * jh / 1 * sizeof(int));
733 yuv_datbuf[1] = calloc(1, jw * jh / 4 * sizeof(int));
734 yuv_datbuf[2] = calloc(1, jw * jh / 4 * sizeof(int));
735 if (!yuv_datbuf[0] || !yuv_datbuf[1] || !yuv_datbuf[2]) {
736 goto done;
737 }
738
739 // convert rgb to yuv
740 bsrc = pb->pdata;
741 ydst = yuv_datbuf[0];
742 udst = yuv_datbuf[1];
743 vdst = yuv_datbuf[2];
744 for (i=0; i<pb->height; i++) {
745 for (j=0; j<pb->width; j++) {
746 rgb_to_yuv(bsrc[2], bsrc[1], bsrc[0], ydst, udst, vdst);
747 bsrc += 3;
748 ydst += 1;
749 if (j & 1) {
750 udst += 1;
751 vdst += 1;
752 }
753 }
754 bsrc -= pb->width * 3; bsrc += pb->stride;
755 ydst -= pb->width * 1; ydst += jw;
756 udst -= pb->width / 2;
757 vdst -= pb->width / 2;
758 if (i & 1) {
759 udst += jw / 2;
760 vdst += jw / 2;
761 }
762 }
763
764 for (m=0; m<jh/16; m++) {
765 for (n=0; n<jw/16; n++) {
766 //++ encode mcu, yuv 4:2:0
767 //+ y du0
768 isrc = yuv_datbuf[0] + (m * 16 + 0) * jw + n * 16 + 0;
769 idst = du;
770 for (i=0; i<8; i++) {
771 memcpy(idst, isrc, 8 * sizeof(int));
772 isrc += jw; idst += 8;
773 }
774 jfif_encode_du(jfif, DU_TYPE_LUMIN, du, &(dc[0]));
775 //- y du0
776
777 //+ y du1
778 isrc = yuv_datbuf[0] + (m * 16 + 0) * jw + n * 16 + 8;
779 idst = du;
780 for (i=0; i<8; i++) {
781 memcpy(idst, isrc, 8 * sizeof(int));
782 isrc += jw; idst += 8;
783 }
784 jfif_encode_du(jfif, DU_TYPE_LUMIN, du, &(dc[0]));
785 //- y du1
786
787 //+ y du2
788 isrc = yuv_datbuf[0] + (m * 16 + 8) * jw + n * 16 + 0;
789 idst = du;
790 for (i=0; i<8; i++) {
791 memcpy(idst, isrc, 8 * sizeof(int));
792 isrc += jw; idst += 8;
793 }
794 jfif_encode_du(jfif, DU_TYPE_LUMIN, du, &(dc[0]));
795 //- y du2
796
797 //+ y du3
798 isrc = yuv_datbuf[0] + (m * 16 + 8) * jw + n * 16 + 8;
799 idst = du;
800 for (i=0; i<8; i++) {
801 memcpy(idst, isrc, 8 * sizeof(int));
802 isrc += jw; idst += 8;
803 }
804 jfif_encode_du(jfif, DU_TYPE_LUMIN, du, &(dc[0]));
805 //- y du3
806
807 //+ u du
808 isrc = yuv_datbuf[1] + m * 8 * (jw/2) + n * 8;
809 idst = du;
810 for (i=0; i<8; i++) {
811 memcpy(idst, isrc, 8 * sizeof(int));
812 isrc += jw/2; idst += 8;
813 }
814 jfif_encode_du(jfif, DU_TYPE_CHROM, du, &(dc[1]));
815 //- u du
816
817 //+ v du
818 isrc = yuv_datbuf[2] + m * 8 * (jw/2) + n * 8;
819 idst = du;
820 for (i=0; i<8; i++) {
821 memcpy(idst, isrc, 8 * sizeof(int));
822 isrc += jw/2; idst += 8;
823 }
824 jfif_encode_du(jfif, DU_TYPE_CHROM, du, &(dc[2]));
825 //- v du
826 //-- encode mcu, yuv 4:2:0
827 }
828 }
829 failed = 0;
830
831 done:
832 // free yuv data buffer
833 if (yuv_datbuf[0]) free(yuv_datbuf[0]);
834 if (yuv_datbuf[1]) free(yuv_datbuf[1]);
835 if (yuv_datbuf[2]) free(yuv_datbuf[2]);
836
837 // close huffman codec
838 huffman_encode_done(jfif->phcac[0]);
839 huffman_encode_done(jfif->phcac[1]);
840 huffman_encode_done(jfif->phcdc[0]);
841 huffman_encode_done(jfif->phcdc[1]);
842 jfif->datalen = bitstr_tell(bs);
843
844 // close bit stream
845 bitstr_close(bs);
846
847 // if failed free context
848 if (failed) {
849 jfif_free(jfif);
850 jfif = NULL;
851 }
852
853 // return context
854 return jfif;
855 }
856
857
858
859
860
861
862
863