3 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
4 * Copyright (C) 2003 Peter Gubanov <peter@elecard.net.ru>
5 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
7 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
8 * See http://libmpeg2.sourceforge.net/ for updates.
10 * mpeg2dec is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * mpeg2dec is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * Modified for use with MPlayer, see libmpeg-0.4.1.diff for the exact changes.
25 * detailed changelog at http://svn.mplayerhq.hu/mplayer/trunk/
34 #include "attributes.h"
35 #include "mpeg2_internal.h"
37 extern mpeg2_mc_t mpeg2_mc
;
38 extern void (* mpeg2_idct_copy
) (int16_t * block
, uint8_t * dest
, int stride
);
39 extern void (* mpeg2_idct_add
) (int last
, int16_t * block
,
40 uint8_t * dest
, int stride
);
41 extern void (* mpeg2_cpu_state_save
) (cpu_state_t
* state
);
42 extern void (* mpeg2_cpu_state_restore
) (cpu_state_t
* state
);
46 static inline int get_macroblock_modes (mpeg2_decoder_t
* const decoder
)
48 #define bit_buf (decoder->bitstream_buf)
49 #define bits (decoder->bitstream_bits)
50 #define bit_ptr (decoder->bitstream_ptr)
54 switch (decoder
->coding_type
) {
57 tab
= MB_I
+ UBITS (bit_buf
, 1);
58 DUMPBITS (bit_buf
, bits
, tab
->len
);
59 macroblock_modes
= tab
->modes
;
61 if ((! (decoder
->frame_pred_frame_dct
)) &&
62 (decoder
->picture_structure
== FRAME_PICTURE
)) {
63 macroblock_modes
|= UBITS (bit_buf
, 1) * DCT_TYPE_INTERLACED
;
64 DUMPBITS (bit_buf
, bits
, 1);
67 return macroblock_modes
;
71 tab
= MB_P
+ UBITS (bit_buf
, 5);
72 DUMPBITS (bit_buf
, bits
, tab
->len
);
73 macroblock_modes
= tab
->modes
;
75 if (decoder
->picture_structure
!= FRAME_PICTURE
) {
76 if (macroblock_modes
& MACROBLOCK_MOTION_FORWARD
) {
77 macroblock_modes
|= UBITS (bit_buf
, 2) << MOTION_TYPE_SHIFT
;
78 DUMPBITS (bit_buf
, bits
, 2);
80 return macroblock_modes
| MACROBLOCK_MOTION_FORWARD
;
81 } else if (decoder
->frame_pred_frame_dct
) {
82 if (macroblock_modes
& MACROBLOCK_MOTION_FORWARD
)
83 macroblock_modes
|= MC_FRAME
<< MOTION_TYPE_SHIFT
;
84 return macroblock_modes
| MACROBLOCK_MOTION_FORWARD
;
86 if (macroblock_modes
& MACROBLOCK_MOTION_FORWARD
) {
87 macroblock_modes
|= UBITS (bit_buf
, 2) << MOTION_TYPE_SHIFT
;
88 DUMPBITS (bit_buf
, bits
, 2);
90 if (macroblock_modes
& (MACROBLOCK_INTRA
| MACROBLOCK_PATTERN
)) {
91 macroblock_modes
|= UBITS (bit_buf
, 1) * DCT_TYPE_INTERLACED
;
92 DUMPBITS (bit_buf
, bits
, 1);
94 return macroblock_modes
| MACROBLOCK_MOTION_FORWARD
;
99 tab
= MB_B
+ UBITS (bit_buf
, 6);
100 DUMPBITS (bit_buf
, bits
, tab
->len
);
101 macroblock_modes
= tab
->modes
;
103 if (decoder
->picture_structure
!= FRAME_PICTURE
) {
104 if (! (macroblock_modes
& MACROBLOCK_INTRA
)) {
105 macroblock_modes
|= UBITS (bit_buf
, 2) << MOTION_TYPE_SHIFT
;
106 DUMPBITS (bit_buf
, bits
, 2);
108 return macroblock_modes
;
109 } else if (decoder
->frame_pred_frame_dct
) {
110 /* if (! (macroblock_modes & MACROBLOCK_INTRA)) */
111 macroblock_modes
|= MC_FRAME
<< MOTION_TYPE_SHIFT
;
112 return macroblock_modes
;
114 if (macroblock_modes
& MACROBLOCK_INTRA
)
116 macroblock_modes
|= UBITS (bit_buf
, 2) << MOTION_TYPE_SHIFT
;
117 DUMPBITS (bit_buf
, bits
, 2);
118 if (macroblock_modes
& (MACROBLOCK_INTRA
| MACROBLOCK_PATTERN
)) {
120 macroblock_modes
|= UBITS (bit_buf
, 1) * DCT_TYPE_INTERLACED
;
121 DUMPBITS (bit_buf
, bits
, 1);
123 return macroblock_modes
;
128 DUMPBITS (bit_buf
, bits
, 1);
129 return MACROBLOCK_INTRA
;
139 static inline void get_quantizer_scale (mpeg2_decoder_t
* const decoder
)
141 #define bit_buf (decoder->bitstream_buf)
142 #define bits (decoder->bitstream_bits)
143 #define bit_ptr (decoder->bitstream_ptr)
145 int quantizer_scale_code
;
147 quantizer_scale_code
= UBITS (bit_buf
, 5);
148 DUMPBITS (bit_buf
, bits
, 5);
149 decoder
->quantizer_scale
= decoder
->quantizer_scales
[quantizer_scale_code
];
151 decoder
->quantizer_matrix
[0] =
152 decoder
->quantizer_prescale
[0][quantizer_scale_code
];
153 decoder
->quantizer_matrix
[1] =
154 decoder
->quantizer_prescale
[1][quantizer_scale_code
];
155 decoder
->quantizer_matrix
[2] =
156 decoder
->chroma_quantizer
[0][quantizer_scale_code
];
157 decoder
->quantizer_matrix
[3] =
158 decoder
->chroma_quantizer
[1][quantizer_scale_code
];
164 static inline int get_motion_delta (mpeg2_decoder_t
* const decoder
,
167 #define bit_buf (decoder->bitstream_buf)
168 #define bits (decoder->bitstream_bits)
169 #define bit_ptr (decoder->bitstream_ptr)
175 if (bit_buf
& 0x80000000) {
176 DUMPBITS (bit_buf
, bits
, 1);
178 } else if (bit_buf
>= 0x0c000000) {
180 tab
= MV_4
+ UBITS (bit_buf
, 4);
181 delta
= (tab
->delta
<< f_code
) + 1;
182 bits
+= tab
->len
+ f_code
+ 1;
183 bit_buf
<<= tab
->len
;
185 sign
= SBITS (bit_buf
, 1);
189 delta
+= UBITS (bit_buf
, f_code
);
192 return (delta
^ sign
) - sign
;
196 tab
= MV_10
+ UBITS (bit_buf
, 10);
197 delta
= (tab
->delta
<< f_code
) + 1;
198 bits
+= tab
->len
+ 1;
199 bit_buf
<<= tab
->len
;
201 sign
= SBITS (bit_buf
, 1);
205 NEEDBITS (bit_buf
, bits
, bit_ptr
);
206 delta
+= UBITS (bit_buf
, f_code
);
207 DUMPBITS (bit_buf
, bits
, f_code
);
210 return (delta
^ sign
) - sign
;
218 static inline int bound_motion_vector (const int vector
, const int f_code
)
220 return ((int32_t)vector
<< (27 - f_code
)) >> (27 - f_code
);
223 static inline int get_dmv (mpeg2_decoder_t
* const decoder
)
225 #define bit_buf (decoder->bitstream_buf)
226 #define bits (decoder->bitstream_bits)
227 #define bit_ptr (decoder->bitstream_ptr)
231 tab
= DMV_2
+ UBITS (bit_buf
, 2);
232 DUMPBITS (bit_buf
, bits
, tab
->len
);
239 static inline int get_coded_block_pattern (mpeg2_decoder_t
* const decoder
)
241 #define bit_buf (decoder->bitstream_buf)
242 #define bits (decoder->bitstream_bits)
243 #define bit_ptr (decoder->bitstream_ptr)
247 NEEDBITS (bit_buf
, bits
, bit_ptr
);
249 if (bit_buf
>= 0x20000000) {
251 tab
= CBP_7
+ (UBITS (bit_buf
, 7) - 16);
252 DUMPBITS (bit_buf
, bits
, tab
->len
);
257 tab
= CBP_9
+ UBITS (bit_buf
, 9);
258 DUMPBITS (bit_buf
, bits
, tab
->len
);
267 static inline int get_luma_dc_dct_diff (mpeg2_decoder_t
* const decoder
)
269 #define bit_buf (decoder->bitstream_buf)
270 #define bits (decoder->bitstream_bits)
271 #define bit_ptr (decoder->bitstream_ptr)
276 if (bit_buf
< 0xf8000000) {
277 tab
= DC_lum_5
+ UBITS (bit_buf
, 5);
280 bits
+= tab
->len
+ size
;
281 bit_buf
<<= tab
->len
;
283 UBITS (bit_buf
, size
) - UBITS (SBITS (~bit_buf
, 1), size
);
285 return dc_diff
<< decoder
->intra_dc_precision
;
287 DUMPBITS (bit_buf
, bits
, 3);
291 tab
= DC_long
+ (UBITS (bit_buf
, 9) - 0x1e0);
293 DUMPBITS (bit_buf
, bits
, tab
->len
);
294 NEEDBITS (bit_buf
, bits
, bit_ptr
);
295 dc_diff
= UBITS (bit_buf
, size
) - UBITS (SBITS (~bit_buf
, 1), size
);
296 DUMPBITS (bit_buf
, bits
, size
);
297 return dc_diff
<< decoder
->intra_dc_precision
;
304 static inline int get_chroma_dc_dct_diff (mpeg2_decoder_t
* const decoder
)
306 #define bit_buf (decoder->bitstream_buf)
307 #define bits (decoder->bitstream_bits)
308 #define bit_ptr (decoder->bitstream_ptr)
313 if (bit_buf
< 0xf8000000) {
314 tab
= DC_chrom_5
+ UBITS (bit_buf
, 5);
317 bits
+= tab
->len
+ size
;
318 bit_buf
<<= tab
->len
;
320 UBITS (bit_buf
, size
) - UBITS (SBITS (~bit_buf
, 1), size
);
322 return dc_diff
<< decoder
->intra_dc_precision
;
324 DUMPBITS (bit_buf
, bits
, 2);
328 tab
= DC_long
+ (UBITS (bit_buf
, 10) - 0x3e0);
330 DUMPBITS (bit_buf
, bits
, tab
->len
+ 1);
331 NEEDBITS (bit_buf
, bits
, bit_ptr
);
332 dc_diff
= UBITS (bit_buf
, size
) - UBITS (SBITS (~bit_buf
, 1), size
);
333 DUMPBITS (bit_buf
, bits
, size
);
334 return dc_diff
<< decoder
->intra_dc_precision
;
341 #define SATURATE(val) \
344 if (unlikely (val != (int16_t) val)) \
345 val = (SBITS (val, 1) ^ 2047) << 4; \
348 static void get_intra_block_B14 (mpeg2_decoder_t
* const decoder
,
349 const uint16_t * const quant_matrix
)
354 const uint8_t * const scan
= decoder
->scan
;
359 const uint8_t * bit_ptr
;
360 int16_t * const dest
= decoder
->DCTblock
;
365 bit_buf
= decoder
->bitstream_buf
;
366 bits
= decoder
->bitstream_bits
;
367 bit_ptr
= decoder
->bitstream_ptr
;
369 NEEDBITS (bit_buf
, bits
, bit_ptr
);
372 if (bit_buf
>= 0x28000000) {
374 tab
= DCT_B14AC_5
+ (UBITS (bit_buf
, 5) - 5);
378 break; /* end of block */
382 bit_buf
<<= tab
->len
;
383 bits
+= tab
->len
+ 1;
384 val
= (tab
->level
* quant_matrix
[j
]) >> 4;
386 /* if (bitstream_get (1)) val = -val; */
387 val
= (val
^ SBITS (bit_buf
, 1)) - SBITS (bit_buf
, 1);
394 NEEDBITS (bit_buf
, bits
, bit_ptr
);
398 } else if (bit_buf
>= 0x04000000) {
400 tab
= DCT_B14_8
+ (UBITS (bit_buf
, 8) - 4);
408 i
+= UBITS (bit_buf
<< 6, 6) - 64;
410 break; /* illegal, check needed to avoid buffer overflow */
414 DUMPBITS (bit_buf
, bits
, 12);
415 NEEDBITS (bit_buf
, bits
, bit_ptr
);
416 val
= (SBITS (bit_buf
, 12) * quant_matrix
[j
]) / 16;
422 DUMPBITS (bit_buf
, bits
, 12);
423 NEEDBITS (bit_buf
, bits
, bit_ptr
);
427 } else if (bit_buf
>= 0x02000000) {
428 tab
= DCT_B14_10
+ (UBITS (bit_buf
, 10) - 8);
432 } else if (bit_buf
>= 0x00800000) {
433 tab
= DCT_13
+ (UBITS (bit_buf
, 13) - 16);
437 } else if (bit_buf
>= 0x00200000) {
438 tab
= DCT_15
+ (UBITS (bit_buf
, 15) - 16);
443 tab
= DCT_16
+ UBITS (bit_buf
, 16);
445 GETWORD (bit_buf
, bits
+ 16, bit_ptr
);
450 break; /* illegal, check needed to avoid buffer overflow */
452 dest
[63] ^= mismatch
& 16;
453 DUMPBITS (bit_buf
, bits
, 2); /* dump end of block code */
454 decoder
->bitstream_buf
= bit_buf
;
455 decoder
->bitstream_bits
= bits
;
456 decoder
->bitstream_ptr
= bit_ptr
;
459 static void get_intra_block_B15 (mpeg2_decoder_t
* const decoder
,
460 const uint16_t * const quant_matrix
)
465 const uint8_t * const scan
= decoder
->scan
;
470 const uint8_t * bit_ptr
;
471 int16_t * const dest
= decoder
->DCTblock
;
476 bit_buf
= decoder
->bitstream_buf
;
477 bits
= decoder
->bitstream_bits
;
478 bit_ptr
= decoder
->bitstream_ptr
;
480 NEEDBITS (bit_buf
, bits
, bit_ptr
);
483 if (bit_buf
>= 0x04000000) {
485 tab
= DCT_B15_8
+ (UBITS (bit_buf
, 8) - 4);
492 bit_buf
<<= tab
->len
;
493 bits
+= tab
->len
+ 1;
494 val
= (tab
->level
* quant_matrix
[j
]) >> 4;
496 /* if (bitstream_get (1)) val = -val; */
497 val
= (val
^ SBITS (bit_buf
, 1)) - SBITS (bit_buf
, 1);
504 NEEDBITS (bit_buf
, bits
, bit_ptr
);
510 /* end of block. I commented out this code because if we */
511 /* dont exit here we will still exit at the later test :) */
513 /* if (i >= 128) break; */ /* end of block */
517 i
+= UBITS (bit_buf
<< 6, 6) - 64;
519 break; /* illegal, check against buffer overflow */
523 DUMPBITS (bit_buf
, bits
, 12);
524 NEEDBITS (bit_buf
, bits
, bit_ptr
);
525 val
= (SBITS (bit_buf
, 12) * quant_matrix
[j
]) / 16;
531 DUMPBITS (bit_buf
, bits
, 12);
532 NEEDBITS (bit_buf
, bits
, bit_ptr
);
537 } else if (bit_buf
>= 0x02000000) {
538 tab
= DCT_B15_10
+ (UBITS (bit_buf
, 10) - 8);
542 } else if (bit_buf
>= 0x00800000) {
543 tab
= DCT_13
+ (UBITS (bit_buf
, 13) - 16);
547 } else if (bit_buf
>= 0x00200000) {
548 tab
= DCT_15
+ (UBITS (bit_buf
, 15) - 16);
553 tab
= DCT_16
+ UBITS (bit_buf
, 16);
555 GETWORD (bit_buf
, bits
+ 16, bit_ptr
);
560 break; /* illegal, check needed to avoid buffer overflow */
562 dest
[63] ^= mismatch
& 16;
563 DUMPBITS (bit_buf
, bits
, 4); /* dump end of block code */
564 decoder
->bitstream_buf
= bit_buf
;
565 decoder
->bitstream_bits
= bits
;
566 decoder
->bitstream_ptr
= bit_ptr
;
569 static int get_non_intra_block (mpeg2_decoder_t
* const decoder
,
570 const uint16_t * const quant_matrix
)
575 const uint8_t * const scan
= decoder
->scan
;
580 const uint8_t * bit_ptr
;
581 int16_t * const dest
= decoder
->DCTblock
;
586 bit_buf
= decoder
->bitstream_buf
;
587 bits
= decoder
->bitstream_bits
;
588 bit_ptr
= decoder
->bitstream_ptr
;
590 NEEDBITS (bit_buf
, bits
, bit_ptr
);
591 if (bit_buf
>= 0x28000000) {
592 tab
= DCT_B14DC_5
+ (UBITS (bit_buf
, 5) - 5);
598 if (bit_buf
>= 0x28000000) {
600 tab
= DCT_B14AC_5
+ (UBITS (bit_buf
, 5) - 5);
605 break; /* end of block */
609 bit_buf
<<= tab
->len
;
610 bits
+= tab
->len
+ 1;
611 val
= ((2 * tab
->level
+ 1) * quant_matrix
[j
]) >> 5;
613 /* if (bitstream_get (1)) val = -val; */
614 val
= (val
^ SBITS (bit_buf
, 1)) - SBITS (bit_buf
, 1);
621 NEEDBITS (bit_buf
, bits
, bit_ptr
);
628 if (bit_buf
>= 0x04000000) {
630 tab
= DCT_B14_8
+ (UBITS (bit_buf
, 8) - 4);
638 i
+= UBITS (bit_buf
<< 6, 6) - 64;
640 break; /* illegal, check needed to avoid buffer overflow */
644 DUMPBITS (bit_buf
, bits
, 12);
645 NEEDBITS (bit_buf
, bits
, bit_ptr
);
646 val
= 2 * (SBITS (bit_buf
, 12) + SBITS (bit_buf
, 1)) + 1;
647 val
= (val
* quant_matrix
[j
]) / 32;
653 DUMPBITS (bit_buf
, bits
, 12);
654 NEEDBITS (bit_buf
, bits
, bit_ptr
);
658 } else if (bit_buf
>= 0x02000000) {
659 tab
= DCT_B14_10
+ (UBITS (bit_buf
, 10) - 8);
663 } else if (bit_buf
>= 0x00800000) {
664 tab
= DCT_13
+ (UBITS (bit_buf
, 13) - 16);
668 } else if (bit_buf
>= 0x00200000) {
669 tab
= DCT_15
+ (UBITS (bit_buf
, 15) - 16);
674 tab
= DCT_16
+ UBITS (bit_buf
, 16);
676 GETWORD (bit_buf
, bits
+ 16, bit_ptr
);
681 break; /* illegal, check needed to avoid buffer overflow */
683 dest
[63] ^= mismatch
& 16;
684 DUMPBITS (bit_buf
, bits
, 2); /* dump end of block code */
685 decoder
->bitstream_buf
= bit_buf
;
686 decoder
->bitstream_bits
= bits
;
687 decoder
->bitstream_ptr
= bit_ptr
;
691 static void get_mpeg1_intra_block (mpeg2_decoder_t
* const decoder
)
696 const uint8_t * const scan
= decoder
->scan
;
697 const uint16_t * const quant_matrix
= decoder
->quantizer_matrix
[0];
701 const uint8_t * bit_ptr
;
702 int16_t * const dest
= decoder
->DCTblock
;
706 bit_buf
= decoder
->bitstream_buf
;
707 bits
= decoder
->bitstream_bits
;
708 bit_ptr
= decoder
->bitstream_ptr
;
710 NEEDBITS (bit_buf
, bits
, bit_ptr
);
713 if (bit_buf
>= 0x28000000) {
715 tab
= DCT_B14AC_5
+ (UBITS (bit_buf
, 5) - 5);
719 break; /* end of block */
723 bit_buf
<<= tab
->len
;
724 bits
+= tab
->len
+ 1;
725 val
= (tab
->level
* quant_matrix
[j
]) >> 4;
730 /* if (bitstream_get (1)) val = -val; */
731 val
= (val
^ SBITS (bit_buf
, 1)) - SBITS (bit_buf
, 1);
737 NEEDBITS (bit_buf
, bits
, bit_ptr
);
741 } else if (bit_buf
>= 0x04000000) {
743 tab
= DCT_B14_8
+ (UBITS (bit_buf
, 8) - 4);
751 i
+= UBITS (bit_buf
<< 6, 6) - 64;
753 break; /* illegal, check needed to avoid buffer overflow */
757 DUMPBITS (bit_buf
, bits
, 12);
758 NEEDBITS (bit_buf
, bits
, bit_ptr
);
759 val
= SBITS (bit_buf
, 8);
760 if (! (val
& 0x7f)) {
761 DUMPBITS (bit_buf
, bits
, 8);
762 val
= UBITS (bit_buf
, 8) + 2 * val
;
764 val
= (val
* quant_matrix
[j
]) / 16;
767 val
= (val
+ ~SBITS (val
, 1)) | 1;
772 DUMPBITS (bit_buf
, bits
, 8);
773 NEEDBITS (bit_buf
, bits
, bit_ptr
);
777 } else if (bit_buf
>= 0x02000000) {
778 tab
= DCT_B14_10
+ (UBITS (bit_buf
, 10) - 8);
782 } else if (bit_buf
>= 0x00800000) {
783 tab
= DCT_13
+ (UBITS (bit_buf
, 13) - 16);
787 } else if (bit_buf
>= 0x00200000) {
788 tab
= DCT_15
+ (UBITS (bit_buf
, 15) - 16);
793 tab
= DCT_16
+ UBITS (bit_buf
, 16);
795 GETWORD (bit_buf
, bits
+ 16, bit_ptr
);
800 break; /* illegal, check needed to avoid buffer overflow */
802 DUMPBITS (bit_buf
, bits
, 2); /* dump end of block code */
803 decoder
->bitstream_buf
= bit_buf
;
804 decoder
->bitstream_bits
= bits
;
805 decoder
->bitstream_ptr
= bit_ptr
;
808 static int get_mpeg1_non_intra_block (mpeg2_decoder_t
* const decoder
)
813 const uint8_t * const scan
= decoder
->scan
;
814 const uint16_t * const quant_matrix
= decoder
->quantizer_matrix
[1];
818 const uint8_t * bit_ptr
;
819 int16_t * const dest
= decoder
->DCTblock
;
823 bit_buf
= decoder
->bitstream_buf
;
824 bits
= decoder
->bitstream_bits
;
825 bit_ptr
= decoder
->bitstream_ptr
;
827 NEEDBITS (bit_buf
, bits
, bit_ptr
);
828 if (bit_buf
>= 0x28000000) {
829 tab
= DCT_B14DC_5
+ (UBITS (bit_buf
, 5) - 5);
835 if (bit_buf
>= 0x28000000) {
837 tab
= DCT_B14AC_5
+ (UBITS (bit_buf
, 5) - 5);
842 break; /* end of block */
846 bit_buf
<<= tab
->len
;
847 bits
+= tab
->len
+ 1;
848 val
= ((2 * tab
->level
+ 1) * quant_matrix
[j
]) >> 5;
853 /* if (bitstream_get (1)) val = -val; */
854 val
= (val
^ SBITS (bit_buf
, 1)) - SBITS (bit_buf
, 1);
860 NEEDBITS (bit_buf
, bits
, bit_ptr
);
867 if (bit_buf
>= 0x04000000) {
869 tab
= DCT_B14_8
+ (UBITS (bit_buf
, 8) - 4);
877 i
+= UBITS (bit_buf
<< 6, 6) - 64;
879 break; /* illegal, check needed to avoid buffer overflow */
883 DUMPBITS (bit_buf
, bits
, 12);
884 NEEDBITS (bit_buf
, bits
, bit_ptr
);
885 val
= SBITS (bit_buf
, 8);
886 if (! (val
& 0x7f)) {
887 DUMPBITS (bit_buf
, bits
, 8);
888 val
= UBITS (bit_buf
, 8) + 2 * val
;
890 val
= 2 * (val
+ SBITS (val
, 1)) + 1;
891 val
= (val
* quant_matrix
[j
]) / 32;
894 val
= (val
+ ~SBITS (val
, 1)) | 1;
899 DUMPBITS (bit_buf
, bits
, 8);
900 NEEDBITS (bit_buf
, bits
, bit_ptr
);
904 } else if (bit_buf
>= 0x02000000) {
905 tab
= DCT_B14_10
+ (UBITS (bit_buf
, 10) - 8);
909 } else if (bit_buf
>= 0x00800000) {
910 tab
= DCT_13
+ (UBITS (bit_buf
, 13) - 16);
914 } else if (bit_buf
>= 0x00200000) {
915 tab
= DCT_15
+ (UBITS (bit_buf
, 15) - 16);
920 tab
= DCT_16
+ UBITS (bit_buf
, 16);
922 GETWORD (bit_buf
, bits
+ 16, bit_ptr
);
927 break; /* illegal, check needed to avoid buffer overflow */
929 DUMPBITS (bit_buf
, bits
, 2); /* dump end of block code */
930 decoder
->bitstream_buf
= bit_buf
;
931 decoder
->bitstream_bits
= bits
;
932 decoder
->bitstream_ptr
= bit_ptr
;
936 static inline void slice_intra_DCT (mpeg2_decoder_t
* const decoder
,
938 uint8_t * const dest
, const int stride
)
940 #define bit_buf (decoder->bitstream_buf)
941 #define bits (decoder->bitstream_bits)
942 #define bit_ptr (decoder->bitstream_ptr)
943 NEEDBITS (bit_buf
, bits
, bit_ptr
);
944 /* Get the intra DC coefficient and inverse quantize it */
946 decoder
->DCTblock
[0] =
947 decoder
->dc_dct_pred
[0] += get_luma_dc_dct_diff (decoder
);
949 decoder
->DCTblock
[0] =
950 decoder
->dc_dct_pred
[cc
] += get_chroma_dc_dct_diff (decoder
);
952 if (decoder
->mpeg1
) {
953 if (decoder
->coding_type
!= D_TYPE
)
954 get_mpeg1_intra_block (decoder
);
955 } else if (decoder
->intra_vlc_format
)
956 get_intra_block_B15 (decoder
, decoder
->quantizer_matrix
[cc
? 2 : 0]);
958 get_intra_block_B14 (decoder
, decoder
->quantizer_matrix
[cc
? 2 : 0]);
959 mpeg2_idct_copy (decoder
->DCTblock
, dest
, stride
);
965 static inline void slice_non_intra_DCT (mpeg2_decoder_t
* const decoder
,
967 uint8_t * const dest
, const int stride
)
972 last
= get_mpeg1_non_intra_block (decoder
);
974 last
= get_non_intra_block (decoder
,
975 decoder
->quantizer_matrix
[cc
? 3 : 1]);
976 mpeg2_idct_add (last
, decoder
->DCTblock
, dest
, stride
);
979 #define MOTION_420(table,ref,motion_x,motion_y,size,y) \
980 pos_x = 2 * decoder->offset + motion_x; \
981 pos_y = 2 * decoder->v_offset + motion_y + 2 * y; \
982 if (unlikely (pos_x > decoder->limit_x)) { \
983 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
984 motion_x = pos_x - 2 * decoder->offset; \
986 if (unlikely (pos_y > decoder->limit_y_ ## size)) { \
987 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size; \
988 motion_y = pos_y - 2 * decoder->v_offset - 2 * y; \
990 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
991 table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
992 ref[0] + (pos_x >> 1) + (pos_y >> 1) * decoder->stride, \
993 decoder->stride, size); \
994 motion_x /= 2; motion_y /= 2; \
995 xy_half = ((motion_y & 1) << 1) | (motion_x & 1); \
996 offset = (((decoder->offset + motion_x) >> 1) + \
997 ((((decoder->v_offset + motion_y) >> 1) + y/2) * \
998 decoder->uv_stride)); \
999 table[4+xy_half] (decoder->dest[1] + y/2 * decoder->uv_stride + \
1000 (decoder->offset >> 1), ref[1] + offset, \
1001 decoder->uv_stride, size/2); \
1002 table[4+xy_half] (decoder->dest[2] + y/2 * decoder->uv_stride + \
1003 (decoder->offset >> 1), ref[2] + offset, \
1004 decoder->uv_stride, size/2)
1006 #define MOTION_FIELD_420(table,ref,motion_x,motion_y,dest_field,op,src_field) \
1007 pos_x = 2 * decoder->offset + motion_x; \
1008 pos_y = decoder->v_offset + motion_y; \
1009 if (unlikely (pos_x > decoder->limit_x)) { \
1010 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1011 motion_x = pos_x - 2 * decoder->offset; \
1013 if (unlikely (pos_y > decoder->limit_y)) { \
1014 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y; \
1015 motion_y = pos_y - decoder->v_offset; \
1017 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1018 table[xy_half] (decoder->dest[0] + dest_field * decoder->stride + \
1020 (ref[0] + (pos_x >> 1) + \
1021 ((pos_y op) + src_field) * decoder->stride), \
1022 2 * decoder->stride, 8); \
1023 motion_x /= 2; motion_y /= 2; \
1024 xy_half = ((motion_y & 1) << 1) | (motion_x & 1); \
1025 offset = (((decoder->offset + motion_x) >> 1) + \
1026 (((decoder->v_offset >> 1) + (motion_y op) + src_field) * \
1027 decoder->uv_stride)); \
1028 table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride + \
1029 (decoder->offset >> 1), ref[1] + offset, \
1030 2 * decoder->uv_stride, 4); \
1031 table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride + \
1032 (decoder->offset >> 1), ref[2] + offset, \
1033 2 * decoder->uv_stride, 4)
1035 #define MOTION_DMV_420(table,ref,motion_x,motion_y) \
1036 pos_x = 2 * decoder->offset + motion_x; \
1037 pos_y = decoder->v_offset + motion_y; \
1038 if (unlikely (pos_x > decoder->limit_x)) { \
1039 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1040 motion_x = pos_x - 2 * decoder->offset; \
1042 if (unlikely (pos_y > decoder->limit_y)) { \
1043 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y; \
1044 motion_y = pos_y - decoder->v_offset; \
1046 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1047 offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride; \
1048 table[xy_half] (decoder->dest[0] + decoder->offset, \
1049 ref[0] + offset, 2 * decoder->stride, 8); \
1050 table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset, \
1051 ref[0] + decoder->stride + offset, \
1052 2 * decoder->stride, 8); \
1053 motion_x /= 2; motion_y /= 2; \
1054 xy_half = ((motion_y & 1) << 1) | (motion_x & 1); \
1055 offset = (((decoder->offset + motion_x) >> 1) + \
1056 (((decoder->v_offset >> 1) + (motion_y & ~1)) * \
1057 decoder->uv_stride)); \
1058 table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1), \
1059 ref[1] + offset, 2 * decoder->uv_stride, 4); \
1060 table[4+xy_half] (decoder->dest[1] + decoder->uv_stride + \
1061 (decoder->offset >> 1), \
1062 ref[1] + decoder->uv_stride + offset, \
1063 2 * decoder->uv_stride, 4); \
1064 table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1), \
1065 ref[2] + offset, 2 * decoder->uv_stride, 4); \
1066 table[4+xy_half] (decoder->dest[2] + decoder->uv_stride + \
1067 (decoder->offset >> 1), \
1068 ref[2] + decoder->uv_stride + offset, \
1069 2 * decoder->uv_stride, 4)
1071 #define MOTION_ZERO_420(table,ref) \
1072 table[0] (decoder->dest[0] + decoder->offset, \
1073 (ref[0] + decoder->offset + \
1074 decoder->v_offset * decoder->stride), decoder->stride, 16); \
1075 offset = ((decoder->offset >> 1) + \
1076 (decoder->v_offset >> 1) * decoder->uv_stride); \
1077 table[4] (decoder->dest[1] + (decoder->offset >> 1), \
1078 ref[1] + offset, decoder->uv_stride, 8); \
1079 table[4] (decoder->dest[2] + (decoder->offset >> 1), \
1080 ref[2] + offset, decoder->uv_stride, 8)
1082 #define MOTION_422(table,ref,motion_x,motion_y,size,y) \
1083 pos_x = 2 * decoder->offset + motion_x; \
1084 pos_y = 2 * decoder->v_offset + motion_y + 2 * y; \
1085 if (unlikely (pos_x > decoder->limit_x)) { \
1086 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1087 motion_x = pos_x - 2 * decoder->offset; \
1089 if (unlikely (pos_y > decoder->limit_y_ ## size)) { \
1090 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size; \
1091 motion_y = pos_y - 2 * decoder->v_offset - 2 * y; \
1093 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1094 offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride; \
1095 table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
1096 ref[0] + offset, decoder->stride, size); \
1097 offset = (offset + (motion_x & (motion_x < 0))) >> 1; \
1099 xy_half = ((pos_y & 1) << 1) | (motion_x & 1); \
1100 table[4+xy_half] (decoder->dest[1] + y * decoder->uv_stride + \
1101 (decoder->offset >> 1), ref[1] + offset, \
1102 decoder->uv_stride, size); \
1103 table[4+xy_half] (decoder->dest[2] + y * decoder->uv_stride + \
1104 (decoder->offset >> 1), ref[2] + offset, \
1105 decoder->uv_stride, size)
1107 #define MOTION_FIELD_422(table,ref,motion_x,motion_y,dest_field,op,src_field) \
1108 pos_x = 2 * decoder->offset + motion_x; \
1109 pos_y = decoder->v_offset + motion_y; \
1110 if (unlikely (pos_x > decoder->limit_x)) { \
1111 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1112 motion_x = pos_x - 2 * decoder->offset; \
1114 if (unlikely (pos_y > decoder->limit_y)) { \
1115 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y; \
1116 motion_y = pos_y - decoder->v_offset; \
1118 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1119 offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride; \
1120 table[xy_half] (decoder->dest[0] + dest_field * decoder->stride + \
1121 decoder->offset, ref[0] + offset, \
1122 2 * decoder->stride, 8); \
1123 offset = (offset + (motion_x & (motion_x < 0))) >> 1; \
1125 xy_half = ((pos_y & 1) << 1) | (motion_x & 1); \
1126 table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride + \
1127 (decoder->offset >> 1), ref[1] + offset, \
1128 2 * decoder->uv_stride, 8); \
1129 table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride + \
1130 (decoder->offset >> 1), ref[2] + offset, \
1131 2 * decoder->uv_stride, 8)
1133 #define MOTION_DMV_422(table,ref,motion_x,motion_y) \
1134 pos_x = 2 * decoder->offset + motion_x; \
1135 pos_y = decoder->v_offset + motion_y; \
1136 if (unlikely (pos_x > decoder->limit_x)) { \
1137 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1138 motion_x = pos_x - 2 * decoder->offset; \
1140 if (unlikely (pos_y > decoder->limit_y)) { \
1141 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y; \
1142 motion_y = pos_y - decoder->v_offset; \
1144 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1145 offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride; \
1146 table[xy_half] (decoder->dest[0] + decoder->offset, \
1147 ref[0] + offset, 2 * decoder->stride, 8); \
1148 table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset, \
1149 ref[0] + decoder->stride + offset, \
1150 2 * decoder->stride, 8); \
1151 offset = (offset + (motion_x & (motion_x < 0))) >> 1; \
1153 xy_half = ((pos_y & 1) << 1) | (motion_x & 1); \
1154 table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1), \
1155 ref[1] + offset, 2 * decoder->uv_stride, 8); \
1156 table[4+xy_half] (decoder->dest[1] + decoder->uv_stride + \
1157 (decoder->offset >> 1), \
1158 ref[1] + decoder->uv_stride + offset, \
1159 2 * decoder->uv_stride, 8); \
1160 table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1), \
1161 ref[2] + offset, 2 * decoder->uv_stride, 8); \
1162 table[4+xy_half] (decoder->dest[2] + decoder->uv_stride + \
1163 (decoder->offset >> 1), \
1164 ref[2] + decoder->uv_stride + offset, \
1165 2 * decoder->uv_stride, 8)
1167 #define MOTION_ZERO_422(table,ref) \
1168 offset = decoder->offset + decoder->v_offset * decoder->stride; \
1169 table[0] (decoder->dest[0] + decoder->offset, \
1170 ref[0] + offset, decoder->stride, 16); \
1172 table[4] (decoder->dest[1] + (decoder->offset >> 1), \
1173 ref[1] + offset, decoder->uv_stride, 16); \
1174 table[4] (decoder->dest[2] + (decoder->offset >> 1), \
1175 ref[2] + offset, decoder->uv_stride, 16)
1177 #define MOTION_444(table,ref,motion_x,motion_y,size,y) \
1178 pos_x = 2 * decoder->offset + motion_x; \
1179 pos_y = 2 * decoder->v_offset + motion_y + 2 * y; \
1180 if (unlikely (pos_x > decoder->limit_x)) { \
1181 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1182 motion_x = pos_x - 2 * decoder->offset; \
1184 if (unlikely (pos_y > decoder->limit_y_ ## size)) { \
1185 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size; \
1186 motion_y = pos_y - 2 * decoder->v_offset - 2 * y; \
1188 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1189 offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride; \
1190 table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
1191 ref[0] + offset, decoder->stride, size); \
1192 table[xy_half] (decoder->dest[1] + y * decoder->stride + decoder->offset, \
1193 ref[1] + offset, decoder->stride, size); \
1194 table[xy_half] (decoder->dest[2] + y * decoder->stride + decoder->offset, \
1195 ref[2] + offset, decoder->stride, size)
1197 #define MOTION_FIELD_444(table,ref,motion_x,motion_y,dest_field,op,src_field) \
1198 pos_x = 2 * decoder->offset + motion_x; \
1199 pos_y = decoder->v_offset + motion_y; \
1200 if (unlikely (pos_x > decoder->limit_x)) { \
1201 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1202 motion_x = pos_x - 2 * decoder->offset; \
1204 if (unlikely (pos_y > decoder->limit_y)) { \
1205 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y; \
1206 motion_y = pos_y - decoder->v_offset; \
1208 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1209 offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride; \
1210 table[xy_half] (decoder->dest[0] + dest_field * decoder->stride + \
1211 decoder->offset, ref[0] + offset, \
1212 2 * decoder->stride, 8); \
1213 table[xy_half] (decoder->dest[1] + dest_field * decoder->stride + \
1214 decoder->offset, ref[1] + offset, \
1215 2 * decoder->stride, 8); \
1216 table[xy_half] (decoder->dest[2] + dest_field * decoder->stride + \
1217 decoder->offset, ref[2] + offset, \
1218 2 * decoder->stride, 8)
1220 #define MOTION_DMV_444(table,ref,motion_x,motion_y) \
1221 pos_x = 2 * decoder->offset + motion_x; \
1222 pos_y = decoder->v_offset + motion_y; \
1223 if (unlikely (pos_x > decoder->limit_x)) { \
1224 pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x; \
1225 motion_x = pos_x - 2 * decoder->offset; \
1227 if (unlikely (pos_y > decoder->limit_y)) { \
1228 pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y; \
1229 motion_y = pos_y - decoder->v_offset; \
1231 xy_half = ((pos_y & 1) << 1) | (pos_x & 1); \
1232 offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride; \
1233 table[xy_half] (decoder->dest[0] + decoder->offset, \
1234 ref[0] + offset, 2 * decoder->stride, 8); \
1235 table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset, \
1236 ref[0] + decoder->stride + offset, \
1237 2 * decoder->stride, 8); \
1238 table[xy_half] (decoder->dest[1] + decoder->offset, \
1239 ref[1] + offset, 2 * decoder->stride, 8); \
1240 table[xy_half] (decoder->dest[1] + decoder->stride + decoder->offset, \
1241 ref[1] + decoder->stride + offset, \
1242 2 * decoder->stride, 8); \
1243 table[xy_half] (decoder->dest[2] + decoder->offset, \
1244 ref[2] + offset, 2 * decoder->stride, 8); \
1245 table[xy_half] (decoder->dest[2] + decoder->stride + decoder->offset, \
1246 ref[2] + decoder->stride + offset, \
1247 2 * decoder->stride, 8)
1249 #define MOTION_ZERO_444(table,ref) \
1250 offset = decoder->offset + decoder->v_offset * decoder->stride; \
1251 table[0] (decoder->dest[0] + decoder->offset, \
1252 ref[0] + offset, decoder->stride, 16); \
1253 table[4] (decoder->dest[1] + decoder->offset, \
1254 ref[1] + offset, decoder->stride, 16); \
1255 table[4] (decoder->dest[2] + decoder->offset, \
1256 ref[2] + offset, decoder->stride, 16)
1258 #define bit_buf (decoder->bitstream_buf)
1259 #define bits (decoder->bitstream_bits)
1260 #define bit_ptr (decoder->bitstream_ptr)
1262 static void motion_mp1 (mpeg2_decoder_t
* const decoder
,
1263 motion_t
* const motion
,
1264 mpeg2_mc_fct
* const * const table
)
1266 int motion_x
, motion_y
;
1267 unsigned int pos_x
, pos_y
, xy_half
, offset
;
1269 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1270 motion_x
= (motion
->pmv
[0][0] +
1271 (get_motion_delta (decoder
,
1272 motion
->f_code
[0]) << motion
->f_code
[1]));
1273 motion_x
= bound_motion_vector (motion_x
,
1274 motion
->f_code
[0] + motion
->f_code
[1]);
1275 motion
->pmv
[0][0] = motion_x
;
1277 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1278 motion_y
= (motion
->pmv
[0][1] +
1279 (get_motion_delta (decoder
,
1280 motion
->f_code
[0]) << motion
->f_code
[1]));
1281 motion_y
= bound_motion_vector (motion_y
,
1282 motion
->f_code
[0] + motion
->f_code
[1]);
1283 motion
->pmv
[0][1] = motion_y
;
1285 MOTION_420 (table
, motion
->ref
[0], motion_x
, motion_y
, 16, 0);
1288 #define MOTION_FUNCTIONS(FORMAT,MOTION,MOTION_FIELD,MOTION_DMV,MOTION_ZERO) \
1290 static void motion_fr_frame_##FORMAT (mpeg2_decoder_t * const decoder, \
1291 motion_t * const motion, \
1292 mpeg2_mc_fct * const * const table) \
1294 int motion_x, motion_y; \
1295 unsigned int pos_x, pos_y, xy_half, offset; \
1297 NEEDBITS (bit_buf, bits, bit_ptr); \
1298 motion_x = motion->pmv[0][0] + get_motion_delta (decoder, \
1299 motion->f_code[0]); \
1300 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1301 motion->pmv[1][0] = motion->pmv[0][0] = motion_x; \
1303 NEEDBITS (bit_buf, bits, bit_ptr); \
1304 motion_y = motion->pmv[0][1] + get_motion_delta (decoder, \
1305 motion->f_code[1]); \
1306 motion_y = bound_motion_vector (motion_y, motion->f_code[1]); \
1307 motion->pmv[1][1] = motion->pmv[0][1] = motion_y; \
1309 MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0); \
1312 static void motion_fr_field_##FORMAT (mpeg2_decoder_t * const decoder, \
1313 motion_t * const motion, \
1314 mpeg2_mc_fct * const * const table) \
1316 int motion_x, motion_y, field; \
1317 unsigned int pos_x, pos_y, xy_half, offset; \
1319 NEEDBITS (bit_buf, bits, bit_ptr); \
1320 field = UBITS (bit_buf, 1); \
1321 DUMPBITS (bit_buf, bits, 1); \
1323 motion_x = motion->pmv[0][0] + get_motion_delta (decoder, \
1324 motion->f_code[0]); \
1325 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1326 motion->pmv[0][0] = motion_x; \
1328 NEEDBITS (bit_buf, bits, bit_ptr); \
1329 motion_y = ((motion->pmv[0][1] >> 1) + \
1330 get_motion_delta (decoder, motion->f_code[1])); \
1331 /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */ \
1332 motion->pmv[0][1] = motion_y << 1; \
1334 MOTION_FIELD (table, motion->ref[0], motion_x, motion_y, 0, & ~1, field); \
1336 NEEDBITS (bit_buf, bits, bit_ptr); \
1337 field = UBITS (bit_buf, 1); \
1338 DUMPBITS (bit_buf, bits, 1); \
1340 motion_x = motion->pmv[1][0] + get_motion_delta (decoder, \
1341 motion->f_code[0]); \
1342 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1343 motion->pmv[1][0] = motion_x; \
1345 NEEDBITS (bit_buf, bits, bit_ptr); \
1346 motion_y = ((motion->pmv[1][1] >> 1) + \
1347 get_motion_delta (decoder, motion->f_code[1])); \
1348 /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */ \
1349 motion->pmv[1][1] = motion_y << 1; \
1351 MOTION_FIELD (table, motion->ref[0], motion_x, motion_y, 1, & ~1, field); \
1354 static void motion_fr_dmv_##FORMAT (mpeg2_decoder_t * const decoder, \
1355 motion_t * const motion, \
1356 mpeg2_mc_fct * const * const table) \
1358 int motion_x, motion_y, dmv_x, dmv_y, m, other_x, other_y; \
1359 unsigned int pos_x, pos_y, xy_half, offset; \
1361 NEEDBITS (bit_buf, bits, bit_ptr); \
1362 motion_x = motion->pmv[0][0] + get_motion_delta (decoder, \
1363 motion->f_code[0]); \
1364 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1365 motion->pmv[1][0] = motion->pmv[0][0] = motion_x; \
1366 NEEDBITS (bit_buf, bits, bit_ptr); \
1367 dmv_x = get_dmv (decoder); \
1369 motion_y = ((motion->pmv[0][1] >> 1) + \
1370 get_motion_delta (decoder, motion->f_code[1])); \
1371 /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */ \
1372 motion->pmv[1][1] = motion->pmv[0][1] = motion_y << 1; \
1373 dmv_y = get_dmv (decoder); \
1375 m = decoder->top_field_first ? 1 : 3; \
1376 other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x; \
1377 other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y - 1; \
1378 MOTION_FIELD (mpeg2_mc.put, motion->ref[0], other_x, other_y, 0, | 1, 0); \
1380 m = decoder->top_field_first ? 3 : 1; \
1381 other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x; \
1382 other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y + 1; \
1383 MOTION_FIELD (mpeg2_mc.put, motion->ref[0], other_x, other_y, 1, & ~1, 0);\
1385 MOTION_DMV (mpeg2_mc.avg, motion->ref[0], motion_x, motion_y); \
1388 static void motion_reuse_##FORMAT (mpeg2_decoder_t * const decoder, \
1389 motion_t * const motion, \
1390 mpeg2_mc_fct * const * const table) \
1392 int motion_x, motion_y; \
1393 unsigned int pos_x, pos_y, xy_half, offset; \
1395 motion_x = motion->pmv[0][0]; \
1396 motion_y = motion->pmv[0][1]; \
1398 MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0); \
1401 static void motion_zero_##FORMAT (mpeg2_decoder_t * const decoder, \
1402 motion_t * const motion, \
1403 mpeg2_mc_fct * const * const table) \
1405 unsigned int offset; \
1407 motion->pmv[0][0] = motion->pmv[0][1] = 0; \
1408 motion->pmv[1][0] = motion->pmv[1][1] = 0; \
1410 MOTION_ZERO (table, motion->ref[0]); \
1413 static void motion_fi_field_##FORMAT (mpeg2_decoder_t * const decoder, \
1414 motion_t * const motion, \
1415 mpeg2_mc_fct * const * const table) \
1417 int motion_x, motion_y; \
1418 uint8_t ** ref_field; \
1419 unsigned int pos_x, pos_y, xy_half, offset; \
1421 NEEDBITS (bit_buf, bits, bit_ptr); \
1422 ref_field = motion->ref2[UBITS (bit_buf, 1)]; \
1423 DUMPBITS (bit_buf, bits, 1); \
1425 motion_x = motion->pmv[0][0] + get_motion_delta (decoder, \
1426 motion->f_code[0]); \
1427 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1428 motion->pmv[1][0] = motion->pmv[0][0] = motion_x; \
1430 NEEDBITS (bit_buf, bits, bit_ptr); \
1431 motion_y = motion->pmv[0][1] + get_motion_delta (decoder, \
1432 motion->f_code[1]); \
1433 motion_y = bound_motion_vector (motion_y, motion->f_code[1]); \
1434 motion->pmv[1][1] = motion->pmv[0][1] = motion_y; \
1436 MOTION (table, ref_field, motion_x, motion_y, 16, 0); \
1439 static void motion_fi_16x8_##FORMAT (mpeg2_decoder_t * const decoder, \
1440 motion_t * const motion, \
1441 mpeg2_mc_fct * const * const table) \
1443 int motion_x, motion_y; \
1444 uint8_t ** ref_field; \
1445 unsigned int pos_x, pos_y, xy_half, offset; \
1447 NEEDBITS (bit_buf, bits, bit_ptr); \
1448 ref_field = motion->ref2[UBITS (bit_buf, 1)]; \
1449 DUMPBITS (bit_buf, bits, 1); \
1451 motion_x = motion->pmv[0][0] + get_motion_delta (decoder, \
1452 motion->f_code[0]); \
1453 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1454 motion->pmv[0][0] = motion_x; \
1456 NEEDBITS (bit_buf, bits, bit_ptr); \
1457 motion_y = motion->pmv[0][1] + get_motion_delta (decoder, \
1458 motion->f_code[1]); \
1459 motion_y = bound_motion_vector (motion_y, motion->f_code[1]); \
1460 motion->pmv[0][1] = motion_y; \
1462 MOTION (table, ref_field, motion_x, motion_y, 8, 0); \
1464 NEEDBITS (bit_buf, bits, bit_ptr); \
1465 ref_field = motion->ref2[UBITS (bit_buf, 1)]; \
1466 DUMPBITS (bit_buf, bits, 1); \
1468 motion_x = motion->pmv[1][0] + get_motion_delta (decoder, \
1469 motion->f_code[0]); \
1470 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1471 motion->pmv[1][0] = motion_x; \
1473 NEEDBITS (bit_buf, bits, bit_ptr); \
1474 motion_y = motion->pmv[1][1] + get_motion_delta (decoder, \
1475 motion->f_code[1]); \
1476 motion_y = bound_motion_vector (motion_y, motion->f_code[1]); \
1477 motion->pmv[1][1] = motion_y; \
1479 MOTION (table, ref_field, motion_x, motion_y, 8, 8); \
1482 static void motion_fi_dmv_##FORMAT (mpeg2_decoder_t * const decoder, \
1483 motion_t * const motion, \
1484 mpeg2_mc_fct * const * const table) \
1486 int motion_x, motion_y, other_x, other_y; \
1487 unsigned int pos_x, pos_y, xy_half, offset; \
1489 NEEDBITS (bit_buf, bits, bit_ptr); \
1490 motion_x = motion->pmv[0][0] + get_motion_delta (decoder, \
1491 motion->f_code[0]); \
1492 motion_x = bound_motion_vector (motion_x, motion->f_code[0]); \
1493 motion->pmv[1][0] = motion->pmv[0][0] = motion_x; \
1494 NEEDBITS (bit_buf, bits, bit_ptr); \
1495 other_x = ((motion_x + (motion_x > 0)) >> 1) + get_dmv (decoder); \
1497 motion_y = motion->pmv[0][1] + get_motion_delta (decoder, \
1498 motion->f_code[1]); \
1499 motion_y = bound_motion_vector (motion_y, motion->f_code[1]); \
1500 motion->pmv[1][1] = motion->pmv[0][1] = motion_y; \
1501 other_y = (((motion_y + (motion_y > 0)) >> 1) + get_dmv (decoder) + \
1502 decoder->dmv_offset); \
1504 MOTION (mpeg2_mc.put, motion->ref[0], motion_x, motion_y, 16, 0); \
1505 MOTION (mpeg2_mc.avg, motion->ref[1], other_x, other_y, 16, 0); \
1508 MOTION_FUNCTIONS (420, MOTION_420, MOTION_FIELD_420, MOTION_DMV_420,
1510 MOTION_FUNCTIONS (422, MOTION_422
, MOTION_FIELD_422
, MOTION_DMV_422
,
1512 MOTION_FUNCTIONS (444, MOTION_444
, MOTION_FIELD_444
, MOTION_DMV_444
,
1515 /* like motion_frame, but parsing without actual motion compensation */
1516 static void motion_fr_conceal (mpeg2_decoder_t
* const decoder
)
1520 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1521 tmp
= (decoder
->f_motion
.pmv
[0][0] +
1522 get_motion_delta (decoder
, decoder
->f_motion
.f_code
[0]));
1523 tmp
= bound_motion_vector (tmp
, decoder
->f_motion
.f_code
[0]);
1524 decoder
->f_motion
.pmv
[1][0] = decoder
->f_motion
.pmv
[0][0] = tmp
;
1526 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1527 tmp
= (decoder
->f_motion
.pmv
[0][1] +
1528 get_motion_delta (decoder
, decoder
->f_motion
.f_code
[1]));
1529 tmp
= bound_motion_vector (tmp
, decoder
->f_motion
.f_code
[1]);
1530 decoder
->f_motion
.pmv
[1][1] = decoder
->f_motion
.pmv
[0][1] = tmp
;
1532 DUMPBITS (bit_buf
, bits
, 1); /* remove marker_bit */
1535 static void motion_fi_conceal (mpeg2_decoder_t
* const decoder
)
1539 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1540 DUMPBITS (bit_buf
, bits
, 1); /* remove field_select */
1542 tmp
= (decoder
->f_motion
.pmv
[0][0] +
1543 get_motion_delta (decoder
, decoder
->f_motion
.f_code
[0]));
1544 tmp
= bound_motion_vector (tmp
, decoder
->f_motion
.f_code
[0]);
1545 decoder
->f_motion
.pmv
[1][0] = decoder
->f_motion
.pmv
[0][0] = tmp
;
1547 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1548 tmp
= (decoder
->f_motion
.pmv
[0][1] +
1549 get_motion_delta (decoder
, decoder
->f_motion
.f_code
[1]));
1550 tmp
= bound_motion_vector (tmp
, decoder
->f_motion
.f_code
[1]);
1551 decoder
->f_motion
.pmv
[1][1] = decoder
->f_motion
.pmv
[0][1] = tmp
;
1553 DUMPBITS (bit_buf
, bits
, 1); /* remove marker_bit */
1560 #define MOTION_CALL(routine,direction) \
1562 if ((direction) & MACROBLOCK_MOTION_FORWARD) \
1563 routine (decoder, &(decoder->f_motion), mpeg2_mc.put); \
1564 if ((direction) & MACROBLOCK_MOTION_BACKWARD) \
1565 routine (decoder, &(decoder->b_motion), \
1566 ((direction) & MACROBLOCK_MOTION_FORWARD ? \
1567 mpeg2_mc.avg : mpeg2_mc.put)); \
1570 #define NEXT_MACROBLOCK \
1572 if(decoder->quant_store) { \
1573 if (decoder->picture_structure == TOP_FIELD) \
1574 decoder->quant_store[2*decoder->quant_stride*(decoder->v_offset>>4) \
1575 +(decoder->offset>>4)] = decoder->quantizer_scale; \
1576 else if (decoder->picture_structure == BOTTOM_FIELD) \
1577 decoder->quant_store[2*decoder->quant_stride*(decoder->v_offset>>4) \
1578 + decoder->quant_stride \
1579 +(decoder->offset>>4)] = decoder->quantizer_scale; \
1581 decoder->quant_store[decoder->quant_stride*(decoder->v_offset>>4) \
1582 +(decoder->offset>>4)] = decoder->quantizer_scale; \
1584 decoder->offset += 16; \
1585 if (decoder->offset == decoder->width) { \
1586 do { /* just so we can use the break statement */ \
1587 if (decoder->convert) { \
1588 decoder->convert (decoder->convert_id, decoder->dest, \
1589 decoder->v_offset); \
1590 if (decoder->coding_type == B_TYPE) \
1593 decoder->dest[0] += decoder->slice_stride; \
1594 decoder->dest[1] += decoder->slice_uv_stride; \
1595 decoder->dest[2] += decoder->slice_uv_stride; \
1597 decoder->v_offset += 16; \
1598 if (decoder->v_offset > decoder->limit_y) { \
1599 if (mpeg2_cpu_state_restore) \
1600 mpeg2_cpu_state_restore (&cpu_state); \
1603 decoder->offset = 0; \
1607 static void motion_dummy (mpeg2_decoder_t
* const decoder
,
1608 motion_t
* const motion
,
1609 mpeg2_mc_fct
* const * const table
)
1613 void mpeg2_init_fbuf (mpeg2_decoder_t
* decoder
, uint8_t * current_fbuf
[3],
1614 uint8_t * forward_fbuf
[3], uint8_t * backward_fbuf
[3])
1616 int offset
, stride
, height
, bottom_field
;
1618 stride
= decoder
->stride_frame
;
1619 bottom_field
= (decoder
->picture_structure
== BOTTOM_FIELD
);
1620 offset
= bottom_field
? stride
: 0;
1621 height
= decoder
->height
;
1623 decoder
->picture_dest
[0] = current_fbuf
[0] + offset
;
1624 decoder
->picture_dest
[1] = current_fbuf
[1] + (offset
>> 1);
1625 decoder
->picture_dest
[2] = current_fbuf
[2] + (offset
>> 1);
1627 decoder
->f_motion
.ref
[0][0] = forward_fbuf
[0] + offset
;
1628 decoder
->f_motion
.ref
[0][1] = forward_fbuf
[1] + (offset
>> 1);
1629 decoder
->f_motion
.ref
[0][2] = forward_fbuf
[2] + (offset
>> 1);
1631 decoder
->b_motion
.ref
[0][0] = backward_fbuf
[0] + offset
;
1632 decoder
->b_motion
.ref
[0][1] = backward_fbuf
[1] + (offset
>> 1);
1633 decoder
->b_motion
.ref
[0][2] = backward_fbuf
[2] + (offset
>> 1);
1635 if (decoder
->picture_structure
!= FRAME_PICTURE
) {
1636 decoder
->dmv_offset
= bottom_field
? 1 : -1;
1637 decoder
->f_motion
.ref2
[0] = decoder
->f_motion
.ref
[bottom_field
];
1638 decoder
->f_motion
.ref2
[1] = decoder
->f_motion
.ref
[!bottom_field
];
1639 decoder
->b_motion
.ref2
[0] = decoder
->b_motion
.ref
[bottom_field
];
1640 decoder
->b_motion
.ref2
[1] = decoder
->b_motion
.ref
[!bottom_field
];
1641 offset
= stride
- offset
;
1643 if (decoder
->second_field
&& (decoder
->coding_type
!= B_TYPE
))
1644 forward_fbuf
= current_fbuf
;
1646 decoder
->f_motion
.ref
[1][0] = forward_fbuf
[0] + offset
;
1647 decoder
->f_motion
.ref
[1][1] = forward_fbuf
[1] + (offset
>> 1);
1648 decoder
->f_motion
.ref
[1][2] = forward_fbuf
[2] + (offset
>> 1);
1650 decoder
->b_motion
.ref
[1][0] = backward_fbuf
[0] + offset
;
1651 decoder
->b_motion
.ref
[1][1] = backward_fbuf
[1] + (offset
>> 1);
1652 decoder
->b_motion
.ref
[1][2] = backward_fbuf
[2] + (offset
>> 1);
1658 decoder
->stride
= stride
;
1659 decoder
->uv_stride
= stride
>> 1;
1660 decoder
->slice_stride
= 16 * stride
;
1661 decoder
->slice_uv_stride
=
1662 decoder
->slice_stride
>> (2 - decoder
->chroma_format
);
1663 decoder
->limit_x
= 2 * decoder
->width
- 32;
1664 decoder
->limit_y_16
= 2 * height
- 32;
1665 decoder
->limit_y_8
= 2 * height
- 16;
1666 decoder
->limit_y
= height
- 16;
1668 if (decoder
->mpeg1
) {
1669 decoder
->motion_parser
[0] = motion_zero_420
;
1670 decoder
->motion_parser
[MC_FIELD
] = motion_dummy
;
1671 decoder
->motion_parser
[MC_FRAME
] = motion_mp1
;
1672 decoder
->motion_parser
[MC_DMV
] = motion_dummy
;
1673 decoder
->motion_parser
[4] = motion_reuse_420
;
1674 } else if (decoder
->picture_structure
== FRAME_PICTURE
) {
1675 if (decoder
->chroma_format
== 0) {
1676 decoder
->motion_parser
[0] = motion_zero_420
;
1677 decoder
->motion_parser
[MC_FIELD
] = motion_fr_field_420
;
1678 decoder
->motion_parser
[MC_FRAME
] = motion_fr_frame_420
;
1679 decoder
->motion_parser
[MC_DMV
] = motion_fr_dmv_420
;
1680 decoder
->motion_parser
[4] = motion_reuse_420
;
1681 } else if (decoder
->chroma_format
== 1) {
1682 decoder
->motion_parser
[0] = motion_zero_422
;
1683 decoder
->motion_parser
[MC_FIELD
] = motion_fr_field_422
;
1684 decoder
->motion_parser
[MC_FRAME
] = motion_fr_frame_422
;
1685 decoder
->motion_parser
[MC_DMV
] = motion_fr_dmv_422
;
1686 decoder
->motion_parser
[4] = motion_reuse_422
;
1688 decoder
->motion_parser
[0] = motion_zero_444
;
1689 decoder
->motion_parser
[MC_FIELD
] = motion_fr_field_444
;
1690 decoder
->motion_parser
[MC_FRAME
] = motion_fr_frame_444
;
1691 decoder
->motion_parser
[MC_DMV
] = motion_fr_dmv_444
;
1692 decoder
->motion_parser
[4] = motion_reuse_444
;
1695 if (decoder
->chroma_format
== 0) {
1696 decoder
->motion_parser
[0] = motion_zero_420
;
1697 decoder
->motion_parser
[MC_FIELD
] = motion_fi_field_420
;
1698 decoder
->motion_parser
[MC_16X8
] = motion_fi_16x8_420
;
1699 decoder
->motion_parser
[MC_DMV
] = motion_fi_dmv_420
;
1700 decoder
->motion_parser
[4] = motion_reuse_420
;
1701 } else if (decoder
->chroma_format
== 1) {
1702 decoder
->motion_parser
[0] = motion_zero_422
;
1703 decoder
->motion_parser
[MC_FIELD
] = motion_fi_field_422
;
1704 decoder
->motion_parser
[MC_16X8
] = motion_fi_16x8_422
;
1705 decoder
->motion_parser
[MC_DMV
] = motion_fi_dmv_422
;
1706 decoder
->motion_parser
[4] = motion_reuse_422
;
1708 decoder
->motion_parser
[0] = motion_zero_444
;
1709 decoder
->motion_parser
[MC_FIELD
] = motion_fi_field_444
;
1710 decoder
->motion_parser
[MC_16X8
] = motion_fi_16x8_444
;
1711 decoder
->motion_parser
[MC_DMV
] = motion_fi_dmv_444
;
1712 decoder
->motion_parser
[4] = motion_reuse_444
;
1717 static inline int slice_init (mpeg2_decoder_t
* const decoder
, int code
)
1719 #define bit_buf (decoder->bitstream_buf)
1720 #define bits (decoder->bitstream_bits)
1721 #define bit_ptr (decoder->bitstream_ptr)
1725 decoder
->dc_dct_pred
[0] = decoder
->dc_dct_pred
[1] =
1726 decoder
->dc_dct_pred
[2] = 16384;
1728 decoder
->f_motion
.pmv
[0][0] = decoder
->f_motion
.pmv
[0][1] = 0;
1729 decoder
->f_motion
.pmv
[1][0] = decoder
->f_motion
.pmv
[1][1] = 0;
1730 decoder
->b_motion
.pmv
[0][0] = decoder
->b_motion
.pmv
[0][1] = 0;
1731 decoder
->b_motion
.pmv
[1][0] = decoder
->b_motion
.pmv
[1][1] = 0;
1733 if (decoder
->vertical_position_extension
) {
1734 code
+= UBITS (bit_buf
, 3) << 7;
1735 DUMPBITS (bit_buf
, bits
, 3);
1737 decoder
->v_offset
= (code
- 1) * 16;
1739 if (!(decoder
->convert
) || decoder
->coding_type
!= B_TYPE
)
1740 offset
= (code
- 1) * decoder
->slice_stride
;
1742 decoder
->dest
[0] = decoder
->picture_dest
[0] + offset
;
1743 offset
>>= (2 - decoder
->chroma_format
);
1744 decoder
->dest
[1] = decoder
->picture_dest
[1] + offset
;
1745 decoder
->dest
[2] = decoder
->picture_dest
[2] + offset
;
1747 get_quantizer_scale (decoder
);
1749 /* ignore intra_slice and all the extra data */
1750 while (bit_buf
& 0x80000000) {
1751 DUMPBITS (bit_buf
, bits
, 9);
1752 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1755 /* decode initial macroblock address increment */
1758 if (bit_buf
>= 0x08000000) {
1759 mba
= MBA_5
+ (UBITS (bit_buf
, 6) - 2);
1761 } else if (bit_buf
>= 0x01800000) {
1762 mba
= MBA_11
+ (UBITS (bit_buf
, 12) - 24);
1764 } else switch (UBITS (bit_buf
, 12)) {
1765 case 8: /* macroblock_escape */
1767 DUMPBITS (bit_buf
, bits
, 11);
1768 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1770 case 15: /* macroblock_stuffing (MPEG1 only) */
1772 DUMPBITS (bit_buf
, bits
, 11);
1773 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1775 default: /* error */
1779 DUMPBITS (bit_buf
, bits
, mba
->len
+ 1);
1780 decoder
->offset
= (offset
+ mba
->mba
) << 4;
1782 while (decoder
->offset
- decoder
->width
>= 0) {
1783 decoder
->offset
-= decoder
->width
;
1784 if (!(decoder
->convert
) || decoder
->coding_type
!= B_TYPE
) {
1785 decoder
->dest
[0] += decoder
->slice_stride
;
1786 decoder
->dest
[1] += decoder
->slice_uv_stride
;
1787 decoder
->dest
[2] += decoder
->slice_uv_stride
;
1789 decoder
->v_offset
+= 16;
1791 if (decoder
->v_offset
> decoder
->limit_y
)
1800 void mpeg2_slice (mpeg2_decoder_t
* const decoder
, const int code
,
1801 const uint8_t * const buffer
)
1803 #define bit_buf (decoder->bitstream_buf)
1804 #define bits (decoder->bitstream_bits)
1805 #define bit_ptr (decoder->bitstream_ptr)
1806 cpu_state_t cpu_state
;
1808 bitstream_init (decoder
, buffer
);
1810 if (slice_init (decoder
, code
))
1813 if (mpeg2_cpu_state_save
)
1814 mpeg2_cpu_state_save (&cpu_state
);
1817 int macroblock_modes
;
1821 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1823 macroblock_modes
= get_macroblock_modes (decoder
);
1825 /* maybe integrate MACROBLOCK_QUANT test into get_macroblock_modes ? */
1826 if (macroblock_modes
& MACROBLOCK_QUANT
)
1827 get_quantizer_scale (decoder
);
1829 if (macroblock_modes
& MACROBLOCK_INTRA
) {
1831 int DCT_offset
, DCT_stride
;
1835 if (decoder
->concealment_motion_vectors
) {
1836 if (decoder
->picture_structure
== FRAME_PICTURE
)
1837 motion_fr_conceal (decoder
);
1839 motion_fi_conceal (decoder
);
1841 decoder
->f_motion
.pmv
[0][0] = decoder
->f_motion
.pmv
[0][1] = 0;
1842 decoder
->f_motion
.pmv
[1][0] = decoder
->f_motion
.pmv
[1][1] = 0;
1843 decoder
->b_motion
.pmv
[0][0] = decoder
->b_motion
.pmv
[0][1] = 0;
1844 decoder
->b_motion
.pmv
[1][0] = decoder
->b_motion
.pmv
[1][1] = 0;
1847 if (macroblock_modes
& DCT_TYPE_INTERLACED
) {
1848 DCT_offset
= decoder
->stride
;
1849 DCT_stride
= decoder
->stride
* 2;
1851 DCT_offset
= decoder
->stride
* 8;
1852 DCT_stride
= decoder
->stride
;
1855 offset
= decoder
->offset
;
1856 dest_y
= decoder
->dest
[0] + offset
;
1857 slice_intra_DCT (decoder
, 0, dest_y
, DCT_stride
);
1858 slice_intra_DCT (decoder
, 0, dest_y
+ 8, DCT_stride
);
1859 slice_intra_DCT (decoder
, 0, dest_y
+ DCT_offset
, DCT_stride
);
1860 slice_intra_DCT (decoder
, 0, dest_y
+ DCT_offset
+ 8, DCT_stride
);
1861 if (likely (decoder
->chroma_format
== 0)) {
1862 slice_intra_DCT (decoder
, 1, decoder
->dest
[1] + (offset
>> 1),
1863 decoder
->uv_stride
);
1864 slice_intra_DCT (decoder
, 2, decoder
->dest
[2] + (offset
>> 1),
1865 decoder
->uv_stride
);
1866 if (decoder
->coding_type
== D_TYPE
) {
1867 NEEDBITS (bit_buf
, bits
, bit_ptr
);
1868 DUMPBITS (bit_buf
, bits
, 1);
1870 } else if (likely (decoder
->chroma_format
== 1)) {
1871 uint8_t * dest_u
= decoder
->dest
[1] + (offset
>> 1);
1872 uint8_t * dest_v
= decoder
->dest
[2] + (offset
>> 1);
1875 slice_intra_DCT (decoder
, 1, dest_u
, DCT_stride
);
1876 slice_intra_DCT (decoder
, 2, dest_v
, DCT_stride
);
1877 slice_intra_DCT (decoder
, 1, dest_u
+ DCT_offset
, DCT_stride
);
1878 slice_intra_DCT (decoder
, 2, dest_v
+ DCT_offset
, DCT_stride
);
1880 uint8_t * dest_u
= decoder
->dest
[1] + offset
;
1881 uint8_t * dest_v
= decoder
->dest
[2] + offset
;
1882 slice_intra_DCT (decoder
, 1, dest_u
, DCT_stride
);
1883 slice_intra_DCT (decoder
, 2, dest_v
, DCT_stride
);
1884 slice_intra_DCT (decoder
, 1, dest_u
+ DCT_offset
, DCT_stride
);
1885 slice_intra_DCT (decoder
, 2, dest_v
+ DCT_offset
, DCT_stride
);
1886 slice_intra_DCT (decoder
, 1, dest_u
+ 8, DCT_stride
);
1887 slice_intra_DCT (decoder
, 2, dest_v
+ 8, DCT_stride
);
1888 slice_intra_DCT (decoder
, 1, dest_u
+ DCT_offset
+ 8,
1890 slice_intra_DCT (decoder
, 2, dest_v
+ DCT_offset
+ 8,
1895 motion_parser_t
* parser
;
1898 decoder
->motion_parser
[macroblock_modes
>> MOTION_TYPE_SHIFT
];
1899 MOTION_CALL (parser
, macroblock_modes
);
1901 if (macroblock_modes
& MACROBLOCK_PATTERN
) {
1902 int coded_block_pattern
;
1903 int DCT_offset
, DCT_stride
;
1905 if (macroblock_modes
& DCT_TYPE_INTERLACED
) {
1906 DCT_offset
= decoder
->stride
;
1907 DCT_stride
= decoder
->stride
* 2;
1909 DCT_offset
= decoder
->stride
* 8;
1910 DCT_stride
= decoder
->stride
;
1913 coded_block_pattern
= get_coded_block_pattern (decoder
);
1915 if (likely (decoder
->chroma_format
== 0)) {
1916 int offset
= decoder
->offset
;
1917 uint8_t * dest_y
= decoder
->dest
[0] + offset
;
1918 if (coded_block_pattern
& 1)
1919 slice_non_intra_DCT (decoder
, 0, dest_y
, DCT_stride
);
1920 if (coded_block_pattern
& 2)
1921 slice_non_intra_DCT (decoder
, 0, dest_y
+ 8,
1923 if (coded_block_pattern
& 4)
1924 slice_non_intra_DCT (decoder
, 0, dest_y
+ DCT_offset
,
1926 if (coded_block_pattern
& 8)
1927 slice_non_intra_DCT (decoder
, 0,
1928 dest_y
+ DCT_offset
+ 8,
1930 if (coded_block_pattern
& 16)
1931 slice_non_intra_DCT (decoder
, 1,
1932 decoder
->dest
[1] + (offset
>> 1),
1933 decoder
->uv_stride
);
1934 if (coded_block_pattern
& 32)
1935 slice_non_intra_DCT (decoder
, 2,
1936 decoder
->dest
[2] + (offset
>> 1),
1937 decoder
->uv_stride
);
1938 } else if (likely (decoder
->chroma_format
== 1)) {
1942 coded_block_pattern
|= bit_buf
& (3 << 30);
1943 DUMPBITS (bit_buf
, bits
, 2);
1945 offset
= decoder
->offset
;
1946 dest_y
= decoder
->dest
[0] + offset
;
1947 if (coded_block_pattern
& 1)
1948 slice_non_intra_DCT (decoder
, 0, dest_y
, DCT_stride
);
1949 if (coded_block_pattern
& 2)
1950 slice_non_intra_DCT (decoder
, 0, dest_y
+ 8,
1952 if (coded_block_pattern
& 4)
1953 slice_non_intra_DCT (decoder
, 0, dest_y
+ DCT_offset
,
1955 if (coded_block_pattern
& 8)
1956 slice_non_intra_DCT (decoder
, 0,
1957 dest_y
+ DCT_offset
+ 8,
1961 DCT_offset
= (DCT_offset
+ offset
) >> 1;
1962 if (coded_block_pattern
& 16)
1963 slice_non_intra_DCT (decoder
, 1,
1964 decoder
->dest
[1] + (offset
>> 1),
1966 if (coded_block_pattern
& 32)
1967 slice_non_intra_DCT (decoder
, 2,
1968 decoder
->dest
[2] + (offset
>> 1),
1970 if (coded_block_pattern
& (2 << 30))
1971 slice_non_intra_DCT (decoder
, 1,
1972 decoder
->dest
[1] + DCT_offset
,
1974 if (coded_block_pattern
& (1 << 30))
1975 slice_non_intra_DCT (decoder
, 2,
1976 decoder
->dest
[2] + DCT_offset
,
1980 uint8_t * dest_y
, * dest_u
, * dest_v
;
1982 coded_block_pattern
|= bit_buf
& (63 << 26);
1983 DUMPBITS (bit_buf
, bits
, 6);
1985 offset
= decoder
->offset
;
1986 dest_y
= decoder
->dest
[0] + offset
;
1987 dest_u
= decoder
->dest
[1] + offset
;
1988 dest_v
= decoder
->dest
[2] + offset
;
1990 if (coded_block_pattern
& 1)
1991 slice_non_intra_DCT (decoder
, 0, dest_y
, DCT_stride
);
1992 if (coded_block_pattern
& 2)
1993 slice_non_intra_DCT (decoder
, 0, dest_y
+ 8,
1995 if (coded_block_pattern
& 4)
1996 slice_non_intra_DCT (decoder
, 0, dest_y
+ DCT_offset
,
1998 if (coded_block_pattern
& 8)
1999 slice_non_intra_DCT (decoder
, 0,
2000 dest_y
+ DCT_offset
+ 8,
2003 if (coded_block_pattern
& 16)
2004 slice_non_intra_DCT (decoder
, 1, dest_u
, DCT_stride
);
2005 if (coded_block_pattern
& 32)
2006 slice_non_intra_DCT (decoder
, 2, dest_v
, DCT_stride
);
2007 if (coded_block_pattern
& (32 << 26))
2008 slice_non_intra_DCT (decoder
, 1, dest_u
+ DCT_offset
,
2010 if (coded_block_pattern
& (16 << 26))
2011 slice_non_intra_DCT (decoder
, 2, dest_v
+ DCT_offset
,
2013 if (coded_block_pattern
& (8 << 26))
2014 slice_non_intra_DCT (decoder
, 1, dest_u
+ 8,
2016 if (coded_block_pattern
& (4 << 26))
2017 slice_non_intra_DCT (decoder
, 2, dest_v
+ 8,
2019 if (coded_block_pattern
& (2 << 26))
2020 slice_non_intra_DCT (decoder
, 1,
2021 dest_u
+ DCT_offset
+ 8,
2023 if (coded_block_pattern
& (1 << 26))
2024 slice_non_intra_DCT (decoder
, 2,
2025 dest_v
+ DCT_offset
+ 8,
2030 decoder
->dc_dct_pred
[0] = decoder
->dc_dct_pred
[1] =
2031 decoder
->dc_dct_pred
[2] = 16384;
2036 NEEDBITS (bit_buf
, bits
, bit_ptr
);
2039 if (bit_buf
>= 0x10000000) {
2040 mba
= MBA_5
+ (UBITS (bit_buf
, 5) - 2);
2042 } else if (bit_buf
>= 0x03000000) {
2043 mba
= MBA_11
+ (UBITS (bit_buf
, 11) - 24);
2045 } else switch (UBITS (bit_buf
, 11)) {
2046 case 8: /* macroblock_escape */
2049 case 15: /* macroblock_stuffing (MPEG1 only) */
2050 DUMPBITS (bit_buf
, bits
, 11);
2051 NEEDBITS (bit_buf
, bits
, bit_ptr
);
2053 default: /* end of slice, or error */
2054 if (mpeg2_cpu_state_restore
)
2055 mpeg2_cpu_state_restore (&cpu_state
);
2059 DUMPBITS (bit_buf
, bits
, mba
->len
);
2060 mba_inc
+= mba
->mba
;
2063 decoder
->dc_dct_pred
[0] = decoder
->dc_dct_pred
[1] =
2064 decoder
->dc_dct_pred
[2] = 16384;
2066 if (decoder
->coding_type
== P_TYPE
) {
2068 MOTION_CALL (decoder
->motion_parser
[0],
2069 MACROBLOCK_MOTION_FORWARD
);
2071 } while (--mba_inc
);
2074 MOTION_CALL (decoder
->motion_parser
[4], macroblock_modes
);
2076 } while (--mba_inc
);