Mercurial > libavcodec.hg
comparison mjpegdec.c @ 8287:7a1d037482c4 libavcodec
fix progressive jpeg:
support refinement passes
remove intermediate clipping
remove redundant idct
author | lorenm |
---|---|
date | Wed, 10 Dec 2008 21:26:00 +0000 |
parents | 7729da3e4866 |
children | 800444234375 |
comparison
equal
deleted
inserted
replaced
8286:e06b2b848b74 | 8287:7a1d037482c4 |
---|---|
349 av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len); | 349 av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len); |
350 } | 350 } |
351 | 351 |
352 /* totally blank picture as progressive JPEG will only add details to it */ | 352 /* totally blank picture as progressive JPEG will only add details to it */ |
353 if(s->progressive){ | 353 if(s->progressive){ |
354 memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height); | 354 int bw = (width + s->h_max*8-1) / (s->h_max*8); |
355 memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1])); | 355 int bh = (height + s->v_max*8-1) / (s->v_max*8); |
356 memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2])); | 356 for(i=0; i<s->nb_components; i++) { |
357 int size = bw * bh * s->h_count[i] * s->v_count[i]; | |
358 av_freep(&s->blocks[i]); | |
359 av_freep(&s->last_nnz[i]); | |
360 s->blocks[i] = av_malloc(size * sizeof(**s->blocks)); | |
361 s->last_nnz[i] = av_mallocz(size * sizeof(**s->last_nnz)); | |
362 s->block_stride[i] = bw * s->h_count[i]; | |
363 } | |
364 memset(s->coefs_finished, 0, sizeof(s->coefs_finished)); | |
357 } | 365 } |
358 return 0; | 366 return 0; |
359 } | 367 } |
360 | 368 |
361 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) | 369 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) |
430 CLOSE_READER(re, &s->gb)} | 438 CLOSE_READER(re, &s->gb)} |
431 | 439 |
432 return 0; | 440 return 0; |
433 } | 441 } |
434 | 442 |
435 /* decode block and dequantize - progressive JPEG version */ | 443 static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block, int component, |
436 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, | 444 int dc_index, int16_t *quant_matrix, int Al) |
437 int component, int dc_index, int ac_index, int16_t *quant_matrix, | 445 { |
438 int ss, int se, int Ah, int Al, int *EOBRUN) | 446 int val; |
439 { | 447 memset(block, 0, 64*sizeof(DCTELEM)); |
440 int code, i, j, level, val, run; | 448 val = mjpeg_decode_dc(s, dc_index); |
441 | 449 if (val == 0xffff) { |
442 /* DC coef */ | 450 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); |
443 if(!ss){ | 451 return -1; |
444 val = mjpeg_decode_dc(s, dc_index); | 452 } |
445 if (val == 0xffff) { | 453 val = (val * quant_matrix[0] << Al) + s->last_dc[component]; |
446 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); | |
447 return -1; | |
448 } | |
449 val = (val * quant_matrix[0] << Al) + s->last_dc[component]; | |
450 }else | |
451 val = 0; | |
452 s->last_dc[component] = val; | 454 s->last_dc[component] = val; |
453 block[0] = val; | 455 block[0] = val; |
454 if(!se) return 0; | 456 return 0; |
455 /* AC coefs */ | 457 } |
458 | |
459 /* decode block and dequantize - progressive JPEG version */ | |
460 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, | |
461 int ac_index, int16_t *quant_matrix, | |
462 int ss, int se, int Al, int *EOBRUN) | |
463 { | |
464 int code, i, j, level, val, run; | |
465 | |
456 if(*EOBRUN){ | 466 if(*EOBRUN){ |
457 (*EOBRUN)--; | 467 (*EOBRUN)--; |
458 return 0; | 468 return 0; |
459 } | 469 } |
460 {OPEN_READER(re, &s->gb) | 470 {OPEN_READER(re, &s->gb) |
503 break; | 513 break; |
504 } | 514 } |
505 } | 515 } |
506 } | 516 } |
507 CLOSE_READER(re, &s->gb)} | 517 CLOSE_READER(re, &s->gb)} |
508 | 518 if(i > *last_nnz) |
509 return 0; | 519 *last_nnz = i; |
510 } | 520 return 0; |
521 } | |
522 | |
523 #define REFINE_BIT(j) {\ | |
524 UPDATE_CACHE(re, &s->gb);\ | |
525 sign = block[j]>>15;\ | |
526 block[j] += SHOW_UBITS(re, &s->gb, 1) * ((quant_matrix[j]^sign)-sign) << Al;\ | |
527 LAST_SKIP_BITS(re, &s->gb, 1);\ | |
528 } | |
529 | |
530 #define ZERO_RUN \ | |
531 for(;;i++) {\ | |
532 if(i > last) {\ | |
533 i += run;\ | |
534 if(i > se) {\ | |
535 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);\ | |
536 return -1;\ | |
537 }\ | |
538 break;\ | |
539 }\ | |
540 j = s->scantable.permutated[i];\ | |
541 if(block[j])\ | |
542 REFINE_BIT(j)\ | |
543 else if(run-- == 0)\ | |
544 break;\ | |
545 } | |
546 | |
547 /* decode block and dequantize - progressive JPEG refinement pass */ | |
548 static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, | |
549 int ac_index, int16_t *quant_matrix, | |
550 int ss, int se, int Al, int *EOBRUN) | |
551 { | |
552 int code, i=ss, j, sign, val, run; | |
553 int last = FFMIN(se, *last_nnz); | |
554 | |
555 OPEN_READER(re, &s->gb); | |
556 if(*EOBRUN) | |
557 (*EOBRUN)--; | |
558 else { | |
559 for(;;i++) { | |
560 UPDATE_CACHE(re, &s->gb); | |
561 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
562 /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */ | |
563 code -= 16; | |
564 if(code & 0xF) { | |
565 run = ((unsigned) code) >> 4; | |
566 UPDATE_CACHE(re, &s->gb); | |
567 val = SHOW_UBITS(re, &s->gb, 1); | |
568 LAST_SKIP_BITS(re, &s->gb, 1); | |
569 ZERO_RUN; | |
570 j = s->scantable.permutated[i]; | |
571 val--; | |
572 block[j] = ((quant_matrix[j]^val)-val) << Al; | |
573 if(i == se) { | |
574 if(i > *last_nnz) | |
575 *last_nnz = i; | |
576 CLOSE_READER(re, &s->gb) | |
577 return 0; | |
578 } | |
579 }else{ | |
580 run = ((unsigned) code) >> 4; | |
581 if(run == 0xF){ | |
582 ZERO_RUN; | |
583 }else{ | |
584 val = run; | |
585 run = (1 << run); | |
586 if(val) { | |
587 UPDATE_CACHE(re, &s->gb); | |
588 run += SHOW_UBITS(re, &s->gb, val); | |
589 LAST_SKIP_BITS(re, &s->gb, val); | |
590 } | |
591 *EOBRUN = run - 1; | |
592 break; | |
593 } | |
594 } | |
595 } | |
596 | |
597 if(i > *last_nnz) | |
598 *last_nnz = i; | |
599 } | |
600 | |
601 for(;i<=last;i++) { | |
602 j = s->scantable.permutated[i]; | |
603 if(block[j]) | |
604 REFINE_BIT(j) | |
605 } | |
606 CLOSE_READER(re, &s->gb); | |
607 | |
608 return 0; | |
609 } | |
610 #undef REFINE_BIT | |
611 #undef ZERO_RUN | |
511 | 612 |
512 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | 613 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ |
513 int i, mb_x, mb_y; | 614 int i, mb_x, mb_y; |
514 uint16_t buffer[32768][4]; | 615 uint16_t buffer[32768][4]; |
515 int left[3], top[3], topleft[3]; | 616 int left[3], top[3], topleft[3]; |
658 } | 759 } |
659 } | 760 } |
660 return 0; | 761 return 0; |
661 } | 762 } |
662 | 763 |
663 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){ | 764 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al){ |
664 int i, mb_x, mb_y; | 765 int i, mb_x, mb_y; |
665 int EOBRUN = 0; | |
666 uint8_t* data[MAX_COMPONENTS]; | 766 uint8_t* data[MAX_COMPONENTS]; |
667 int linesize[MAX_COMPONENTS]; | 767 int linesize[MAX_COMPONENTS]; |
668 | |
669 if(Ah) return 0; /* TODO decode refinement planes too */ | |
670 | 768 |
671 for(i=0; i < nb_components; i++) { | 769 for(i=0; i < nb_components; i++) { |
672 int c = s->comp_index[i]; | 770 int c = s->comp_index[i]; |
673 data[c] = s->picture.data[c]; | 771 data[c] = s->picture.data[c]; |
674 linesize[c]=s->linesize[c]; | 772 linesize[c]=s->linesize[c]; |
773 s->coefs_finished[c] |= 1; | |
675 if(s->avctx->codec->id==CODEC_ID_AMV) { | 774 if(s->avctx->codec->id==CODEC_ID_AMV) { |
676 //picture should be flipped upside-down for this codec | 775 //picture should be flipped upside-down for this codec |
677 assert(!(s->avctx->flags & CODEC_FLAG_EMU_EDGE)); | 776 assert(!(s->avctx->flags & CODEC_FLAG_EMU_EDGE)); |
678 data[c] += (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 )); | 777 data[c] += (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 )); |
679 linesize[c] *= -1; | 778 linesize[c] *= -1; |
693 h = s->h_scount[i]; | 792 h = s->h_scount[i]; |
694 v = s->v_scount[i]; | 793 v = s->v_scount[i]; |
695 x = 0; | 794 x = 0; |
696 y = 0; | 795 y = 0; |
697 for(j=0;j<n;j++) { | 796 for(j=0;j<n;j++) { |
698 memset(s->block, 0, sizeof(s->block)); | |
699 if (!s->progressive && decode_block(s, s->block, i, | |
700 s->dc_index[i], s->ac_index[i], | |
701 s->quant_matrixes[ s->quant_index[c] ]) < 0) { | |
702 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
703 return -1; | |
704 } | |
705 if (s->progressive && decode_block_progressive(s, s->block, i, | |
706 s->dc_index[i], s->ac_index[i], | |
707 s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) { | |
708 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
709 return -1; | |
710 } | |
711 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x); | |
712 ptr = data[c] + | 797 ptr = data[c] + |
713 (((linesize[c] * (v * mb_y + y) * 8) + | 798 (((linesize[c] * (v * mb_y + y) * 8) + |
714 (h * mb_x + x) * 8) >> s->avctx->lowres); | 799 (h * mb_x + x) * 8) >> s->avctx->lowres); |
715 if (s->interlaced && s->bottom_field) | 800 if(s->interlaced && s->bottom_field) |
716 ptr += linesize[c] >> 1; | 801 ptr += linesize[c] >> 1; |
802 if(!s->progressive) { | |
803 memset(s->block, 0, sizeof(s->block)); | |
804 if(decode_block(s, s->block, i, | |
805 s->dc_index[i], s->ac_index[i], | |
806 s->quant_matrixes[ s->quant_index[c] ]) < 0) { | |
807 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
808 return -1; | |
809 } | |
810 s->dsp.idct_put(ptr, linesize[c], s->block); | |
811 } else { | |
812 int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x); | |
813 DCTELEM *block = s->blocks[c][block_idx]; | |
814 if(Ah) | |
815 block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al; | |
816 else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) { | |
817 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
818 return -1; | |
819 } | |
820 } | |
821 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x); | |
717 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8); | 822 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8); |
718 if(!s->progressive) | |
719 s->dsp.idct_put(ptr, linesize[c], s->block); | |
720 else | |
721 s->dsp.idct_add(ptr, linesize[c], s->block); | |
722 if (++x == h) { | 823 if (++x == h) { |
723 x = 0; | 824 x = 0; |
724 y++; | 825 y++; |
725 } | 826 } |
726 } | 827 } |
730 !--s->restart_count) { | 831 !--s->restart_count) { |
731 align_get_bits(&s->gb); | 832 align_get_bits(&s->gb); |
732 skip_bits(&s->gb, 16); /* skip RSTn */ | 833 skip_bits(&s->gb, 16); /* skip RSTn */ |
733 for (i=0; i<nb_components; i++) /* reset dc */ | 834 for (i=0; i<nb_components; i++) /* reset dc */ |
734 s->last_dc[i] = 1024; | 835 s->last_dc[i] = 1024; |
836 } | |
837 } | |
838 } | |
839 return 0; | |
840 } | |
841 | |
842 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al){ | |
843 int mb_x, mb_y; | |
844 int EOBRUN = 0; | |
845 int c = s->comp_index[0]; | |
846 uint8_t* data = s->picture.data[c]; | |
847 int linesize = s->linesize[c]; | |
848 int last_scan = 0; | |
849 int16_t *quant_matrix = s->quant_matrixes[ s->quant_index[c] ]; | |
850 | |
851 if(!Al) { | |
852 s->coefs_finished[c] |= (1LL<<(se+1))-(1LL<<ss); | |
853 last_scan = !~s->coefs_finished[c]; | |
854 } | |
855 | |
856 if(s->interlaced && s->bottom_field) | |
857 data += linesize >> 1; | |
858 | |
859 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
860 uint8_t *ptr = data + (mb_y*linesize*8 >> s->avctx->lowres); | |
861 int block_idx = mb_y * s->block_stride[c]; | |
862 DCTELEM (*block)[64] = &s->blocks[c][block_idx]; | |
863 uint8_t *last_nnz = &s->last_nnz[c][block_idx]; | |
864 for(mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) { | |
865 int ret; | |
866 if(Ah) | |
867 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0], | |
868 quant_matrix, ss, se, Al, &EOBRUN); | |
869 else | |
870 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0], | |
871 quant_matrix, ss, se, Al, &EOBRUN); | |
872 if(ret < 0) { | |
873 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
874 return -1; | |
875 } | |
876 if(last_scan) { | |
877 s->dsp.idct_put(ptr, linesize, *block); | |
878 ptr += 8 >> s->avctx->lowres; | |
735 } | 879 } |
736 } | 880 } |
737 } | 881 } |
738 return 0; | 882 return 0; |
739 } | 883 } |
847 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) | 991 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) |
848 return -1; | 992 return -1; |
849 } | 993 } |
850 } | 994 } |
851 }else{ | 995 }else{ |
852 if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0) | 996 if(s->progressive && predictor) { |
853 return -1; | 997 if(mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, point_transform) < 0) |
998 return -1; | |
999 } else { | |
1000 if(mjpeg_decode_scan(s, nb_components, prev_shift, point_transform) < 0) | |
1001 return -1; | |
1002 } | |
854 } | 1003 } |
855 emms_c(); | 1004 emms_c(); |
856 return 0; | 1005 return 0; |
857 out_of_range: | 1006 out_of_range: |
858 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); | 1007 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); |
1352 | 1501 |
1353 for(i=0;i<2;i++) { | 1502 for(i=0;i<2;i++) { |
1354 for(j=0;j<4;j++) | 1503 for(j=0;j<4;j++) |
1355 free_vlc(&s->vlcs[i][j]); | 1504 free_vlc(&s->vlcs[i][j]); |
1356 } | 1505 } |
1506 for(i=0; i<MAX_COMPONENTS; i++) { | |
1507 av_freep(&s->blocks[i]); | |
1508 av_freep(&s->last_nnz[i]); | |
1509 } | |
1357 return 0; | 1510 return 0; |
1358 } | 1511 } |
1359 | 1512 |
1360 AVCodec mjpeg_decoder = { | 1513 AVCodec mjpeg_decoder = { |
1361 "mjpeg", | 1514 "mjpeg", |