Mercurial > libavcodec.hg
comparison vc1.c @ 3527:3187e7ffe52d libavcodec
Use functions from DSPContext in vc1.c
author | kostya |
---|---|
date | Sun, 30 Jul 2006 03:47:26 +0000 |
parents | 7407a264d243 |
children | 79ad5cd43686 |
comparison
equal
deleted
inserted
replaced
3526:7dc8e4a12105 | 3527:3187e7ffe52d |
---|---|
713 else v->altpq = v->pq + pqdiff + 1; | 713 else v->altpq = v->pq + pqdiff + 1; |
714 } | 714 } |
715 } | 715 } |
716 } | 716 } |
717 return 0; | 717 return 0; |
718 } | |
719 | |
720 | |
721 /** Do inverse transform | |
722 */ | |
723 static void vc1_inv_trans(DCTELEM block[64], int M, int N) | |
724 { | |
725 int i; | |
726 register int t1,t2,t3,t4,t5,t6,t7,t8; | |
727 DCTELEM *src, *dst; | |
728 | |
729 src = block; | |
730 dst = block; | |
731 if(M==4){ | |
732 for(i = 0; i < N; i++){ | |
733 t1 = 17 * (src[0] + src[2]); | |
734 t2 = 17 * (src[0] - src[2]); | |
735 t3 = 22 * src[1]; | |
736 t4 = 22 * src[3]; | |
737 t5 = 10 * src[1]; | |
738 t6 = 10 * src[3]; | |
739 | |
740 dst[0] = (t1 + t3 + t6 + 4) >> 3; | |
741 dst[1] = (t2 - t4 + t5 + 4) >> 3; | |
742 dst[2] = (t2 + t4 - t5 + 4) >> 3; | |
743 dst[3] = (t1 - t3 - t6 + 4) >> 3; | |
744 | |
745 src += 8; | |
746 dst += 8; | |
747 } | |
748 }else{ | |
749 for(i = 0; i < N; i++){ | |
750 t1 = 12 * (src[0] + src[4]); | |
751 t2 = 12 * (src[0] - src[4]); | |
752 t3 = 16 * src[2] + 6 * src[6]; | |
753 t4 = 6 * src[2] - 16 * src[6]; | |
754 | |
755 t5 = t1 + t3; | |
756 t6 = t2 + t4; | |
757 t7 = t2 - t4; | |
758 t8 = t1 - t3; | |
759 | |
760 t1 = 16 * src[1] + 15 * src[3] + 9 * src[5] + 4 * src[7]; | |
761 t2 = 15 * src[1] - 4 * src[3] - 16 * src[5] - 9 * src[7]; | |
762 t3 = 9 * src[1] - 16 * src[3] + 4 * src[5] + 15 * src[7]; | |
763 t4 = 4 * src[1] - 9 * src[3] + 15 * src[5] - 16 * src[7]; | |
764 | |
765 dst[0] = (t5 + t1 + 4) >> 3; | |
766 dst[1] = (t6 + t2 + 4) >> 3; | |
767 dst[2] = (t7 + t3 + 4) >> 3; | |
768 dst[3] = (t8 + t4 + 4) >> 3; | |
769 dst[4] = (t8 - t4 + 4) >> 3; | |
770 dst[5] = (t7 - t3 + 4) >> 3; | |
771 dst[6] = (t6 - t2 + 4) >> 3; | |
772 dst[7] = (t5 - t1 + 4) >> 3; | |
773 | |
774 src += 8; | |
775 dst += 8; | |
776 } | |
777 } | |
778 | |
779 src = block; | |
780 dst = block; | |
781 if(N==4){ | |
782 for(i = 0; i < M; i++){ | |
783 t1 = 17 * (src[ 0] + src[16]); | |
784 t2 = 17 * (src[ 0] - src[16]); | |
785 t3 = 22 * src[ 8]; | |
786 t4 = 22 * src[24]; | |
787 t5 = 10 * src[ 8]; | |
788 t6 = 10 * src[24]; | |
789 | |
790 dst[ 0] = (t1 + t3 + t6 + 64) >> 7; | |
791 dst[ 8] = (t2 - t4 + t5 + 64) >> 7; | |
792 dst[16] = (t2 + t4 - t5 + 64) >> 7; | |
793 dst[24] = (t1 - t3 - t6 + 64) >> 7; | |
794 | |
795 src ++; | |
796 dst ++; | |
797 } | |
798 }else{ | |
799 for(i = 0; i < M; i++){ | |
800 t1 = 12 * (src[ 0] + src[32]); | |
801 t2 = 12 * (src[ 0] - src[32]); | |
802 t3 = 16 * src[16] + 6 * src[48]; | |
803 t4 = 6 * src[16] - 16 * src[48]; | |
804 | |
805 t5 = t1 + t3; | |
806 t6 = t2 + t4; | |
807 t7 = t2 - t4; | |
808 t8 = t1 - t3; | |
809 | |
810 t1 = 16 * src[ 8] + 15 * src[24] + 9 * src[40] + 4 * src[56]; | |
811 t2 = 15 * src[ 8] - 4 * src[24] - 16 * src[40] - 9 * src[56]; | |
812 t3 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56]; | |
813 t4 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56]; | |
814 | |
815 dst[ 0] = (t5 + t1 + 64) >> 7; | |
816 dst[ 8] = (t6 + t2 + 64) >> 7; | |
817 dst[16] = (t7 + t3 + 64) >> 7; | |
818 dst[24] = (t8 + t4 + 64) >> 7; | |
819 dst[32] = (t8 - t4 + 64 + 1) >> 7; | |
820 dst[40] = (t7 - t3 + 64 + 1) >> 7; | |
821 dst[48] = (t6 - t2 + 64 + 1) >> 7; | |
822 dst[56] = (t5 - t1 + 64 + 1) >> 7; | |
823 | |
824 src++; | |
825 dst++; | |
826 } | |
827 } | |
828 } | |
829 | |
830 /** Apply overlap transform to vertical edge | |
831 * @todo optimize | |
832 * @todo move to DSPContext | |
833 */ | |
834 static void vc1_v_overlap(uint8_t* src, int stride, int rnd) | |
835 { | |
836 int i; | |
837 int a, b, c, d; | |
838 for(i = 0; i < 8; i++) { | |
839 a = src[-2*stride]; | |
840 b = src[-stride]; | |
841 c = src[0]; | |
842 d = src[stride]; | |
843 | |
844 src[-2*stride] = clip_uint8((7*a + d + 4 - rnd) >> 3); | |
845 src[-stride] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3); | |
846 src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3); | |
847 src[stride] = clip_uint8((a + 7*d + 3 + rnd) >> 3); | |
848 src++; | |
849 } | |
850 } | |
851 | |
852 /** Apply overlap transform to horizontal edge | |
853 * @todo optimize | |
854 * @todo move to DSPContext | |
855 */ | |
856 static void vc1_h_overlap(uint8_t* src, int stride, int rnd) | |
857 { | |
858 int i; | |
859 int a, b, c, d; | |
860 for(i = 0; i < 8; i++) { | |
861 a = src[-2]; | |
862 b = src[-1]; | |
863 c = src[0]; | |
864 d = src[1]; | |
865 | |
866 src[-2] = clip_uint8((7*a + d + 4 - rnd) >> 3); | |
867 src[-1] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3); | |
868 src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3); | |
869 src[1] = clip_uint8((a + 7*d + 3 + rnd) >> 3); | |
870 src += stride; | |
871 } | |
872 } | 718 } |
873 | 719 |
874 /** Put block onto picture | 720 /** Put block onto picture |
875 * @todo move to DSPContext | 721 * @todo move to DSPContext |
876 */ | 722 */ |
2479 idx = vc1_simple_progressive_8x8_zz[i++]; | 2325 idx = vc1_simple_progressive_8x8_zz[i++]; |
2480 block[idx] = value * scale; | 2326 block[idx] = value * scale; |
2481 if(!v->pquantizer) | 2327 if(!v->pquantizer) |
2482 block[idx] += (block[idx] < 0) ? -mquant : mquant; | 2328 block[idx] += (block[idx] < 0) ? -mquant : mquant; |
2483 } | 2329 } |
2484 vc1_inv_trans(block, 8, 8); | 2330 s->dsp.vc1_inv_trans_8x8(block); |
2485 break; | 2331 break; |
2486 case TT_4X4: | 2332 case TT_4X4: |
2487 for(j = 0; j < 4; j++) { | 2333 for(j = 0; j < 4; j++) { |
2488 last = subblkpat & (1 << (3 - j)); | 2334 last = subblkpat & (1 << (3 - j)); |
2489 i = 0; | 2335 i = 0; |
2497 block[idx + off] = value * scale; | 2343 block[idx + off] = value * scale; |
2498 if(!v->pquantizer) | 2344 if(!v->pquantizer) |
2499 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant; | 2345 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant; |
2500 } | 2346 } |
2501 if(!(subblkpat & (1 << (3 - j)))) | 2347 if(!(subblkpat & (1 << (3 - j)))) |
2502 vc1_inv_trans(block + off, 4, 4); | 2348 s->dsp.vc1_inv_trans_4x4(block, j); |
2503 } | 2349 } |
2504 break; | 2350 break; |
2505 case TT_8X4: | 2351 case TT_8X4: |
2506 for(j = 0; j < 2; j++) { | 2352 for(j = 0; j < 2; j++) { |
2507 last = subblkpat & (1 << (1 - j)); | 2353 last = subblkpat & (1 << (1 - j)); |
2516 block[idx + off] = value * scale; | 2362 block[idx + off] = value * scale; |
2517 if(!v->pquantizer) | 2363 if(!v->pquantizer) |
2518 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant; | 2364 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant; |
2519 } | 2365 } |
2520 if(!(subblkpat & (1 << (1 - j)))) | 2366 if(!(subblkpat & (1 << (1 - j)))) |
2521 vc1_inv_trans(block + off, 8, 4); | 2367 s->dsp.vc1_inv_trans_8x4(block, j); |
2522 } | 2368 } |
2523 break; | 2369 break; |
2524 case TT_4X8: | 2370 case TT_4X8: |
2525 for(j = 0; j < 2; j++) { | 2371 for(j = 0; j < 2; j++) { |
2526 last = subblkpat & (1 << (1 - j)); | 2372 last = subblkpat & (1 << (1 - j)); |
2535 block[idx + off] = value * scale; | 2381 block[idx + off] = value * scale; |
2536 if(!v->pquantizer) | 2382 if(!v->pquantizer) |
2537 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant; | 2383 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant; |
2538 } | 2384 } |
2539 if(!(subblkpat & (1 << (1 - j)))) | 2385 if(!(subblkpat & (1 << (1 - j)))) |
2540 vc1_inv_trans(block + off, 4, 8); | 2386 s->dsp.vc1_inv_trans_4x8(block, j); |
2541 } | 2387 } |
2542 break; | 2388 break; |
2543 } | 2389 } |
2544 return 0; | 2390 return 0; |
2545 } | 2391 } |
2632 if(i == 1 || i == 3 || s->mb_x) | 2478 if(i == 1 || i == 3 || s->mb_x) |
2633 v->c_avail = v->mb_type[0][s->block_index[i] - 1]; | 2479 v->c_avail = v->mb_type[0][s->block_index[i] - 1]; |
2634 | 2480 |
2635 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset); | 2481 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset); |
2636 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; | 2482 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; |
2637 vc1_inv_trans(s->block[i], 8, 8); | 2483 s->dsp.vc1_inv_trans_8x8(s->block[i]); |
2638 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1; | 2484 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1; |
2639 for(j = 0; j < 64; j++) s->block[i][j] += 128; | 2485 for(j = 0; j < 64; j++) s->block[i][j] += 128; |
2640 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2)); | 2486 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2)); |
2641 /* TODO: proper loop filtering */ | 2487 /* TODO: proper loop filtering */ |
2642 if(v->pq >= 9 && v->overlap) { | 2488 if(v->pq >= 9 && v->overlap) { |
2643 if(v->a_avail) | 2489 if(v->a_avail) |
2644 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1)); | 2490 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1)); |
2645 if(v->c_avail) | 2491 if(v->c_avail) |
2646 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1)); | 2492 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1)); |
2647 } | 2493 } |
2648 } else if(val) { | 2494 } else if(val) { |
2649 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block); | 2495 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block); |
2650 if(!v->ttmbf && ttmb < 8) ttmb = -1; | 2496 if(!v->ttmbf && ttmb < 8) ttmb = -1; |
2651 first_block = 0; | 2497 first_block = 0; |
2736 if(i == 1 || i == 3 || s->mb_x) | 2582 if(i == 1 || i == 3 || s->mb_x) |
2737 v->c_avail = v->mb_type[0][s->block_index[i] - 1]; | 2583 v->c_avail = v->mb_type[0][s->block_index[i] - 1]; |
2738 | 2584 |
2739 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset); | 2585 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset); |
2740 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; | 2586 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; |
2741 vc1_inv_trans(s->block[i], 8, 8); | 2587 s->dsp.vc1_inv_trans_8x8(s->block[i]); |
2742 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1; | 2588 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1; |
2743 for(j = 0; j < 64; j++) s->block[i][j] += 128; | 2589 for(j = 0; j < 64; j++) s->block[i][j] += 128; |
2744 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize); | 2590 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize); |
2745 /* TODO: proper loop filtering */ | 2591 /* TODO: proper loop filtering */ |
2746 if(v->pq >= 9 && v->overlap) { | 2592 if(v->pq >= 9 && v->overlap) { |
2747 if(v->a_avail) | 2593 if(v->a_avail) |
2748 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1)); | 2594 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1)); |
2749 if(v->c_avail) | 2595 if(v->c_avail) |
2750 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1)); | 2596 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1)); |
2751 } | 2597 } |
2752 } else if(is_coded[i]) { | 2598 } else if(is_coded[i]) { |
2753 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block); | 2599 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block); |
2754 if(!v->ttmbf && ttmb < 8) ttmb = -1; | 2600 if(!v->ttmbf && ttmb < 8) ttmb = -1; |
2755 first_block = 0; | 2601 first_block = 0; |
2902 if(i == 1 || i == 3 || s->mb_x) | 2748 if(i == 1 || i == 3 || s->mb_x) |
2903 v->c_avail = v->mb_type[0][s->block_index[i] - 1]; | 2749 v->c_avail = v->mb_type[0][s->block_index[i] - 1]; |
2904 | 2750 |
2905 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset); | 2751 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset); |
2906 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; | 2752 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; |
2907 vc1_inv_trans(s->block[i], 8, 8); | 2753 s->dsp.vc1_inv_trans_8x8(s->block[i]); |
2908 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1; | 2754 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1; |
2909 for(j = 0; j < 64; j++) s->block[i][j] += 128; | 2755 for(j = 0; j < 64; j++) s->block[i][j] += 128; |
2910 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2)); | 2756 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2)); |
2911 /* TODO: proper loop filtering */ | 2757 /* TODO: proper loop filtering */ |
2912 if(v->pq >= 9 && v->overlap) { | 2758 if(v->pq >= 9 && v->overlap) { |
2913 if(v->a_avail) | 2759 if(v->a_avail) |
2914 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1)); | 2760 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1)); |
2915 if(v->c_avail) | 2761 if(v->c_avail) |
2916 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1)); | 2762 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1)); |
2917 } | 2763 } |
2918 } else if(val) { | 2764 } else if(val) { |
2919 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block); | 2765 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block); |
2920 if(!v->ttmbf && ttmb < 8) ttmb = -1; | 2766 if(!v->ttmbf && ttmb < 8) ttmb = -1; |
2921 first_block = 0; | 2767 first_block = 0; |
2992 } | 2838 } |
2993 cbp |= val << (5 - k); | 2839 cbp |= val << (5 - k); |
2994 | 2840 |
2995 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2); | 2841 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2); |
2996 | 2842 |
2997 vc1_inv_trans(s->block[k], 8, 8); | 2843 s->dsp.vc1_inv_trans_8x8(s->block[k]); |
2998 if(v->pq >= 9 && v->overlap) { | 2844 if(v->pq >= 9 && v->overlap) { |
2999 for(j = 0; j < 64; j++) s->block[k][j] += 128; | 2845 for(j = 0; j < 64; j++) s->block[k][j] += 128; |
3000 } | 2846 } |
3001 } | 2847 } |
3002 | 2848 |
3003 vc1_put_block(v, s->block); | 2849 vc1_put_block(v, s->block); |
3004 if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */ | 2850 if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */ |
3005 if(!s->first_slice_line) { | 2851 if(!s->first_slice_line) { |
3006 vc1_v_overlap(s->dest[0], s->linesize, 0); | 2852 s->dsp.vc1_v_overlap(s->dest[0], s->linesize, 0); |
3007 vc1_v_overlap(s->dest[0] + 8, s->linesize, 0); | 2853 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize, 0); |
3008 if(!(s->flags & CODEC_FLAG_GRAY)) { | 2854 if(!(s->flags & CODEC_FLAG_GRAY)) { |
3009 vc1_v_overlap(s->dest[1], s->uvlinesize, s->mb_y&1); | 2855 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize, s->mb_y&1); |
3010 vc1_v_overlap(s->dest[2], s->uvlinesize, s->mb_y&1); | 2856 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize, s->mb_y&1); |
3011 } | 2857 } |
3012 } | 2858 } |
3013 vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1); | 2859 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1); |
3014 vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1); | 2860 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1); |
3015 if(s->mb_x) { | 2861 if(s->mb_x) { |
3016 vc1_h_overlap(s->dest[0], s->linesize, 0); | 2862 s->dsp.vc1_h_overlap(s->dest[0], s->linesize, 0); |
3017 vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0); | 2863 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0); |
3018 if(!(s->flags & CODEC_FLAG_GRAY)) { | 2864 if(!(s->flags & CODEC_FLAG_GRAY)) { |
3019 vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1); | 2865 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1); |
3020 vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1); | 2866 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1); |
3021 } | 2867 } |
3022 } | 2868 } |
3023 vc1_h_overlap(s->dest[0] + 8, s->linesize, 1); | 2869 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize, 1); |
3024 vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1); | 2870 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1); |
3025 } | 2871 } |
3026 | 2872 |
3027 if(get_bits_count(&s->gb) > v->bits) { | 2873 if(get_bits_count(&s->gb) > v->bits) { |
3028 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits); | 2874 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits); |
3029 return; | 2875 return; |