/[pcsx2_0.9.7]/trunk/pcsx2/IPU/mpeg2lib/Mpeg.cpp
ViewVC logotype

Diff of /trunk/pcsx2/IPU/mpeg2lib/Mpeg.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 31 by william, Tue Sep 7 03:24:11 2010 UTC revision 62 by william, Tue Sep 7 11:08:22 2010 UTC
# Line 33  Line 33 
33  #include "Mpeg.h"  #include "Mpeg.h"
34  #include "Vlc.h"  #include "Vlc.h"
35    
36  int non_linear_quantizer_scale [] =  const int non_linear_quantizer_scale [] =
37  {  {
38          0,  1,  2,  3,  4,  5,  6,      7,          0,  1,  2,  3,  4,  5,  6,      7,
39          8, 10, 12, 14, 16, 18,  20,  22,          8, 10, 12, 14, 16, 18,  20,  22,
# Line 48  int non_linear_quantizer_scale [] = Line 48  int non_linear_quantizer_scale [] =
48          back to the 1st slot when 128bits have been read.          back to the 1st slot when 128bits have been read.
49  */  */
50  extern void ReorderBitstream();  extern void ReorderBitstream();
51    const DCTtab * tab;
52    int mbaCount = 0;
53    
54  int get_macroblock_modes(decoder_t * const decoder)  int get_macroblock_modes()
55  {  {
 #define bit_buf (decoder->bitstream_buf)  
 #define bits (decoder->bitstream_bits)  
 #define bit_ptr (decoder->bitstream_ptr)  
56          int macroblock_modes;          int macroblock_modes;
57          const MBtab * tab;          const MBtab * tab;
58    
59          switch (decoder->coding_type)          switch (decoder.coding_type)
60          {          {
   
61                  case I_TYPE:                  case I_TYPE:
62                          macroblock_modes = UBITS(bit_buf, 2);                          macroblock_modes = UBITS(2);
63    
64                          if (macroblock_modes == 0) return 0;   // error                          if (macroblock_modes == 0) return 0;   // error
65    
66                          tab = MB_I + (macroblock_modes >> 1);                          tab = MB_I + (macroblock_modes >> 1);
67                          DUMPBITS(bit_buf, bits, tab->len);                          DUMPBITS(tab->len);
68                          macroblock_modes = tab->modes;                          macroblock_modes = tab->modes;
69    
70                          if ((!(decoder->frame_pred_frame_dct)) &&                          if ((!(decoder.frame_pred_frame_dct)) &&
71                                  (decoder->picture_structure == FRAME_PICTURE))                                  (decoder.picture_structure == FRAME_PICTURE))
72                          {                          {
73                                  macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;                                  macroblock_modes |= GETBITS(1) * DCT_TYPE_INTERLACED;
                                 DUMPBITS(bit_buf, bits, 1);  
74                          }                          }
75                          return macroblock_modes;                          return macroblock_modes;
76    
77                  case P_TYPE:                  case P_TYPE:
78                          macroblock_modes = UBITS(bit_buf, 6);                          macroblock_modes = UBITS(6);
79    
80                          if (macroblock_modes == 0) return 0;   // error                          if (macroblock_modes == 0) return 0;   // error
81    
82                          tab = MB_P + (macroblock_modes >> 1);                          tab = MB_P + (macroblock_modes >> 1);
83                          DUMPBITS(bit_buf, bits, tab->len);                          DUMPBITS(tab->len);
84                          macroblock_modes = tab->modes;                          macroblock_modes = tab->modes;
85    
86                          if (decoder->picture_structure != FRAME_PICTURE)                          if (decoder.picture_structure != FRAME_PICTURE)
87                          {                          {
88                                  if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)                                  if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
89                                  {                                  {
90                                          macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;                                          macroblock_modes |= GETBITS(2) * MOTION_TYPE_BASE;
                                         DUMPBITS(bit_buf, bits, 2);  
91                                  }                                  }
92    
93                                  return macroblock_modes;                                  return macroblock_modes;
94                          }                          }
95                          else if (decoder->frame_pred_frame_dct)                          else if (decoder.frame_pred_frame_dct)
96                          {                          {
97                                  if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)                                  if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
98                                          macroblock_modes |= MC_FRAME;                                          macroblock_modes |= MC_FRAME;
# Line 107  int get_macroblock_modes(decoder_t * con Line 103  int get_macroblock_modes(decoder_t * con
103                          {                          {
104                                  if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)                                  if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
105                                  {                                  {
106                                          macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;                                          macroblock_modes |= GETBITS(2) * MOTION_TYPE_BASE;
                                         DUMPBITS(bit_buf, bits, 2);  
107                                  }                                  }
108    
109                                  if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))                                  if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
110                                  {                                  {
111                                          macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;                                          macroblock_modes |= GETBITS(1) * DCT_TYPE_INTERLACED;
                                         DUMPBITS(bit_buf, bits, 1);  
112                                  }                                  }
113    
114                                  return macroblock_modes;                                  return macroblock_modes;
115                          }                          }
116    
117                  case B_TYPE:                  case B_TYPE:
118                          macroblock_modes = UBITS(bit_buf, 6);                          macroblock_modes = UBITS(6);
119    
120                          if (macroblock_modes == 0) return 0;   // error                          if (macroblock_modes == 0) return 0;   // error
121    
122                          tab = MB_B + macroblock_modes;                          tab = MB_B + macroblock_modes;
123                          DUMPBITS(bit_buf, bits, tab->len);                          DUMPBITS(tab->len);
124                          macroblock_modes = tab->modes;                          macroblock_modes = tab->modes;
125    
126                          if (decoder->picture_structure != FRAME_PICTURE)                          if (decoder.picture_structure != FRAME_PICTURE)
127                          {                          {
128                                  if (!(macroblock_modes & MACROBLOCK_INTRA))                                  if (!(macroblock_modes & MACROBLOCK_INTRA))
129                                  {                                  {
130                                          macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;                                          macroblock_modes |= GETBITS(2) * MOTION_TYPE_BASE;
                                         DUMPBITS(bit_buf, bits, 2);  
131                                  }                                  }
132    
133                                  return macroblock_modes;                                  return macroblock_modes;
134                          }                          }
135                          else if (decoder->frame_pred_frame_dct)                          else if (decoder.frame_pred_frame_dct)
136                          {                          {
137                                  /* if (! (macroblock_modes & MACROBLOCK_INTRA)) */                                  /* if (! (macroblock_modes & MACROBLOCK_INTRA)) */
138                                  macroblock_modes |= MC_FRAME;                                  macroblock_modes |= MC_FRAME;
# Line 149  int get_macroblock_modes(decoder_t * con Line 142  int get_macroblock_modes(decoder_t * con
142                          {                          {
143                                  if (macroblock_modes & MACROBLOCK_INTRA) goto intra;                                  if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
144    
145                                  macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;                                  macroblock_modes |= GETBITS(2) * MOTION_TYPE_BASE;
                                 DUMPBITS(bit_buf, bits, 2);  
146    
147                                  if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))                                  if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
148                                  {                                  {
149  intra:  intra:
150                                          macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;                                          macroblock_modes |= GETBITS(1) * DCT_TYPE_INTERLACED;
                                         DUMPBITS(bit_buf, bits, 1);  
151                                  }                                  }
152    
153                                  return macroblock_modes;                                  return macroblock_modes;
154                          }                          }
155    
156                  case D_TYPE:                  case D_TYPE:
157                          macroblock_modes = UBITS(bit_buf, 1);                          macroblock_modes = GETBITS(1);
158    
159                          if (macroblock_modes == 0) return 0;   // error                          if (macroblock_modes == 0) return 0;   // error
   
                         DUMPBITS(bit_buf, bits, 1);  
160                          return MACROBLOCK_INTRA;                          return MACROBLOCK_INTRA;
161    
162                  default:                  default:
163                          return 0;                          return 0;
164          }          }
   
 #undef bit_buf  
 #undef bits  
 #undef bit_ptr  
165  }  }
166    
167  static __forceinline int get_quantizer_scale(decoder_t * const decoder)  static __fi int get_quantizer_scale()
168  {  {
169          int quantizer_scale_code;          int quantizer_scale_code;
170    
171          quantizer_scale_code = UBITS(decoder->bitstream_buf, 5);          quantizer_scale_code = GETBITS(5);
         DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, 5);  
172    
173          if (decoder->q_scale_type)          if (decoder.q_scale_type)
174                  return non_linear_quantizer_scale [quantizer_scale_code];                  return non_linear_quantizer_scale [quantizer_scale_code];
175          else          else
176                  return quantizer_scale_code << 1;                  return quantizer_scale_code << 1;
177  }  }
178    
179  static __forceinline int get_coded_block_pattern(decoder_t * const decoder)  static __fi int get_coded_block_pattern()
180  {  {
181          const CBPtab * tab;          const CBPtab * tab;
182            u16 code = UBITS(16);
183    
184          NEEDBITS(decoder->bitstream_buf, decoder->bitstream_bits, decoder->bitstream_ptr);          if (code >= 0x2000)
185                    tab = CBP_7 + (UBITS(7) - 16);
         if (decoder->bitstream_buf >= 0x20000000)  
                 tab = CBP_7 + (UBITS(decoder->bitstream_buf, 7) - 16);  
186          else          else
187                  tab = CBP_9 + UBITS(decoder->bitstream_buf, 9);                  tab = CBP_9 + UBITS(9);
188    
189          DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, tab->len);          DUMPBITS(tab->len);
190          return tab->cbp;          return tab->cbp;
191  }  }
192    
193  static __forceinline int get_luma_dc_dct_diff(decoder_t * const decoder)  int __fi get_motion_delta(const int f_code)
194  {  {
195  #define bit_buf (decoder->bitstream_buf)          int delta;
196  #define bits (decoder->bitstream_bits)          int sign;
197  #define bit_ptr (decoder->bitstream_ptr)          const MVtab * tab;
198            u16 code = UBITS(16);
199    
200            if ((code & 0x8000))
201            {
202                    DUMPBITS(1);
203                    return 0x00010000;
204            }
205            else if ((code & 0xf000) || ((code & 0xfc00) == 0x0c00))
206            {
207                    tab = MV_4 + UBITS(4);
208            }
209            else
210            {
211                    tab = MV_10 + UBITS(10);
212            }
213    
214            delta = tab->delta + 1;
215            DUMPBITS(tab->len);
216    
217            sign = SBITS(1);
218            DUMPBITS(1);
219            return (delta ^ sign) - sign;
220    }
221    
222    int __fi get_dmv()
223    {
224            const DMVtab * tab;
225    
226            tab = DMV_2 + UBITS(2);
227            DUMPBITS(tab->len);
228            return tab->dmv;
229    }
230    
231    int get_macroblock_address_increment()
232    {
233            const MBAtab *mba;
234            
235            u16 code = UBITS(16);
236    
237            if (code >= 4096)
238                    mba = MBA.mba5 + (UBITS(5) - 2);
239            else if (code >= 768)
240                    mba = MBA.mba11 + (UBITS(11) - 24);
241            else switch (UBITS(11))
242                    {
243    
244                            case 8:         /* macroblock_escape */
245                                    DUMPBITS(11);
246                                    return 0x23;
247    
248                            case 15:        /* macroblock_stuffing (MPEG1 only) */
249                                    if (decoder.mpeg1)
250                                    {
251                                            DUMPBITS(11);
252                                            return 0x22;
253                                    }
254    
255                            default:
256                                    return 0;//error
257                    }
258    
259            DUMPBITS(mba->len);
260    
261            return mba->mba + 1;
262    }
263    
264          const DCtab * tab;  static __fi int get_luma_dc_dct_diff()
265    {
266          int size;          int size;
267          int dc_diff;          int dc_diff;
268            u16 code = UBITS(5);
269    
270          if (bit_buf < 0xf8000000)          if (code < 31)
271          {          {
272                  tab = DC_lum_5 + UBITS(bit_buf, 5);                  size = DCtable.lum0[code].size;
273                  size = tab->size;                  DUMPBITS(DCtable.lum0[code].len);
274    
275                  if (size)                  // 5 bits max
                 {  
                         DUMPBITS(bit_buf, bits, tab->len);  
                         bits += size;  
                         dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);  
                         bit_buf <<= size;  
                         return dc_diff;  
                 }  
                 else  
                 {  
                         DUMPBITS(bit_buf, bits, 3);  
                         return 0;  
                 }  
276          }          }
277            else
278            {
279                    code = UBITS(9) - 0x1f0;
280                    size = DCtable.lum1[code].size;
281                    DUMPBITS(DCtable.lum1[code].len);
282    
283                    // 9 bits max
284            }
285            
286            if (size==0)
287                    dc_diff = 0;
288            else
289            {
290                    dc_diff = GETBITS(size);
291    
292          tab = DC_long + (UBITS(bit_buf, 9) - 0x1e0); //0x1e0);                  // 6 for tab0 and 11 for tab1
293                    if ((dc_diff & (1<<(size-1)))==0)
294                      dc_diff-= (1<<size) - 1;
295            }
296    
         size = tab->size;  
         DUMPBITS(bit_buf, bits, tab->len);  
         NEEDBITS(bit_buf, bits, bit_ptr);  
         dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);  
         DUMPBITS(bit_buf, bits, size);  
297          return dc_diff;          return dc_diff;
 #undef bit_buf  
 #undef bits  
 #undef bit_ptr  
298  }  }
299    
300  static __forceinline int get_chroma_dc_dct_diff(decoder_t * const decoder)  static __fi int get_chroma_dc_dct_diff()
301  {  {
 #define bit_buf (decoder->bitstream_buf)  
 #define bits (decoder->bitstream_bits)  
 #define bit_ptr (decoder->bitstream_ptr)  
   
         const DCtab * tab;  
302          int size;          int size;
303          int dc_diff;          int dc_diff;
304            u16 code = UBITS(5);
305    
306          if (bit_buf < 0xf8000000)      if (code<31)
307            {
308                    size = DCtable.chrom0[code].size;
309                    DUMPBITS(DCtable.chrom0[code].len);
310            }
311            else
312          {          {
313                  tab = DC_chrom_5 + UBITS(bit_buf, 5);              code = UBITS(10) - 0x3e0;
314                  size = tab->size;              size = DCtable.chrom1[code].size;
315                    DUMPBITS(DCtable.chrom1[code].len);
316            }
317            
318            if (size==0)
319                dc_diff = 0;
320            else
321            {
322                    dc_diff = GETBITS(size);
323    
324                  if (size)                  if ((dc_diff & (1<<(size-1)))==0)
                 {  
                         DUMPBITS(bit_buf, bits, tab->len);  
                         bits += size;  
                         dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);  
                         bit_buf <<= size;  
                         return dc_diff;  
                 }  
                 else  
325                  {                  {
326                          DUMPBITS(bit_buf, bits, 2);                          dc_diff-= (1<<size) - 1;
                         return 0;  
327                  }                  }
328          }          }
329      
         tab = DC_long + (UBITS(bit_buf, 10) - 0x3e0);  
   
         size = tab->size;  
         DUMPBITS(bit_buf, bits, tab->len + 1);  
         NEEDBITS(bit_buf, bits, bit_ptr);  
         dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);  
         DUMPBITS(bit_buf, bits, size);  
330          return dc_diff;          return dc_diff;
 #undef bit_buf  
 #undef bits  
 #undef bit_ptr  
331  }  }
332    
333  #define SATURATE(val)                                   \  #define SATURATE(val)                                   \
334  do {                                                    \  do {                                                    \
335           if (((u32)(val + 2048) > 4095))        \           if (((u32)(val + 2048) > 4095))        \
336          val = SBITS (val, 1) ^ 2047;                    \          val = (((s32)val) >> 31) ^ 2047;                        \
337  } while (0)  } while (0)
338    
339  static __forceinline void get_intra_block_B14(decoder_t * const decoder)  static __fi bool get_intra_block()
340  {  {
341          int i;          int i;
342          int j;          int j;
343          int val;          int val;
344          const u8 * scan = decoder->scan;          const u8 * scan = decoder.scantype ? mpeg2_scan.alt : mpeg2_scan.norm;
345          const u8 * quant_matrix = decoder->intra_quantizer_matrix;          const u8 (&quant_matrix)[64] = decoder.iq;
346          int quantizer_scale = decoder->quantizer_scale;          int quantizer_scale = decoder.quantizer_scale;
347          int mismatch;          s16 * dest = decoder.DCTblock;
348          const DCTtab * tab;          u16 code;
         u32 bit_buf;  
         u8 * bit_ptr;  
         int bits;  
         s16 * dest;  
   
         dest = decoder->DCTblock;  
         i = 0;  
         mismatch = ~dest[0];  
   
         bit_buf = decoder->bitstream_buf;  
         bits = decoder->bitstream_bits;  
         bit_ptr = decoder->bitstream_ptr;  
349    
350          NEEDBITS(bit_buf, bits, bit_ptr);          /* decode AC coefficients */
351      for (i=1 + ipu_cmd.pos[4]; ; i++)
352          while (1)    {
353          {            switch (ipu_cmd.pos[5])
354                  if (bit_buf >= 0x28000000)            {
355              case 0:
356                    if (!GETWORD())
357                  {                  {
358                          tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);                    ipu_cmd.pos[4] = i - 1;
359                          i += tab->run;                    return false;
                         if (i >= 64) break;     /* end of block */  
   
 normal_code:  
                         j = scan[i];  
                         bit_buf <<= tab->len;  
                         bits += tab->len + 1;  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = (tab->level * quantizer_scale * quant_matrix[i]) >> 4;  
   
                         /* if (bitstream_get (1)) val = -val; */  
                         val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);  
   
                         SATURATE(val);  
                         dest[j] = val;  
                         mismatch ^= val;  
                         bit_buf <<= 1;  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
360                  }                  }
                 else if (bit_buf >= 0x04000000)  
                 {  
                         tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
   
                         /* escape code */  
361    
362                          i += UBITS(bit_buf << 6, 6) - 64;                  code = UBITS(16);
363    
364                          if (i >= 64) break;     /* illegal, check needed to avoid buffer overflow */                  if (code >= 16384 && (!decoder.intra_vlc_format || decoder.mpeg1))
   
                         j = scan[i];  
   
                         DUMPBITS(bit_buf, bits, 12);  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = (SBITS(bit_buf, 12) * quantizer_scale * quant_matrix[i]) / 16;  
   
                         SATURATE(val);  
                         dest[j] = val;  
                         mismatch ^= val;  
                         DUMPBITS(bit_buf, bits, 12);  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
   
                 }  
                 else if (bit_buf >= 0x02000000)  
365                  {                  {
366                          tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);                    tab = &DCT.next[(code >> 12) - 4];
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
367                  }                  }
368                  else if (bit_buf >= 0x00800000)                  else if (code >= 1024)
                 {  
                         tab = DCT_13 + (UBITS(bit_buf, 13) - 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else if (bit_buf >= 0x00200000)  
                 {  
                         tab = DCT_15 + (UBITS(bit_buf, 15) - 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else  
                 {  
                         tab = DCT_16 + UBITS(bit_buf, 16);  
                         bit_buf <<= 16;  
                         GETWORD(&bit_buf, bits + 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
   
                 break;  /* illegal, check needed to avoid buffer overflow */  
         }  
   
         dest[63] ^= mismatch & 1;  
   
         if ((bit_buf >> 30) != 0x2) ipuRegs->ctrl.ECD = 1;  
   
         DUMPBITS(bit_buf, bits, tab->len);      /* dump end of block code */  
   
         decoder->bitstream_buf = bit_buf;  
         decoder->bitstream_bits = bits;  
 }  
   
 static __forceinline void get_intra_block_B15(decoder_t * const decoder)  
 {  
         int i;  
         int j;  
         int val;  
         const u8 * scan = decoder->scan;  
         const u8 * quant_matrix = decoder->intra_quantizer_matrix;  
         int quantizer_scale = decoder->quantizer_scale;  
         int mismatch;  
         const DCTtab * tab;  
         u32 bit_buf;  
         u8 * bit_ptr;  
         int bits;  
         s16 * dest;  
   
         dest = decoder->DCTblock;  
         i = 0;  
         mismatch = ~dest[0];  
   
         bit_buf = decoder->bitstream_buf;  
         bits = decoder->bitstream_bits;  
         bit_ptr = decoder->bitstream_ptr;  
   
         NEEDBITS(bit_buf, bits, bit_ptr);  
   
         while (1)  
         {  
                 if (bit_buf >= 0x04000000)  
369                  {                  {
370                          tab = DCT_B15_8 + (UBITS(bit_buf, 8) - 4);                          if (decoder.intra_vlc_format && !decoder.mpeg1)
                         i += tab->run;  
   
                         if (i < 64)  
371                          {                          {
372  normal_code:                                  tab = &DCT.tab0a[(code >> 8) - 4];
                                 j = scan[i];  
                                 bit_buf <<= tab->len;  
                                 bits += tab->len + 1;  
                                 /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                                 val = (tab->level * quantizer_scale * quant_matrix[i]) >> 4;  
   
                                 /* if (bitstream_get (1)) val = -val; */  
                                 val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);  
   
                                 SATURATE(val);  
                                 dest[j] = val;  
                                 mismatch ^= val;  
   
                                 bit_buf <<= 1;  
                                 NEEDBITS(bit_buf, bits, bit_ptr);  
   
                                 continue;  
373                          }                          }
374                          else                          else
375                          {                          {
376                                  /* end of block. I commented out this code because if we */                                  tab = &DCT.tab0[(code >> 8) - 4];
                                 /* dont exit here we will still exit at the later test :) */  
                                 //if (i >= 128) break;          /* end of block */  
                                 /* escape code */  
   
                                 i += UBITS(bit_buf << 6, 6) - 64;  
   
                                 if (i >= 64)  break;    /* illegal, check against buffer overflow */  
   
                                 j = scan[i];  
                                 DUMPBITS(bit_buf, bits, 12);  
                                 NEEDBITS(bit_buf, bits, bit_ptr);  
   
                                 /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                                 val = (SBITS(bit_buf, 12) * quantizer_scale * quant_matrix[i]) / 16;  
   
                                 SATURATE(val);  
                                 dest[j] = val;  
                                 mismatch ^= val;  
                                 DUMPBITS(bit_buf, bits, 12);  
                                 NEEDBITS(bit_buf, bits, bit_ptr);  
                                 continue;  
377                          }                          }
378                  }                  }
379                  else if (bit_buf >= 0x02000000)                  else if (code >= 512)
380                  {                  {
381                          tab = DCT_B15_10 + (UBITS(bit_buf, 10) - 8);                          if (decoder.intra_vlc_format && !decoder.mpeg1)
382                          i += tab->run;                          {
383                                    tab = &DCT.tab1a[(code >> 6) - 8];
384                          if (i < 64) goto normal_code;                          }
385                  }                          else
386                  else if (bit_buf >= 0x00800000)                          {
387                  {                                  tab = &DCT.tab1[(code >> 6) - 8];
388                          tab = DCT_13 + (UBITS(bit_buf, 13) - 16);                          }
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
389                  }                  }
                 else if (bit_buf >= 0x00200000)  
                 {  
                         tab = DCT_15 + (UBITS(bit_buf, 15) - 16);  
                         i += tab->run;  
390    
391                          if (i < 64) goto normal_code;                  // [TODO] Optimization: Following codes can all be done by a single "expedited" lookup
392                    // that should use a single unrolled DCT table instead of five separate tables used
393                    // here.  Multiple conditional statements are very slow, while modern CPU data caches
394                    // have lots of room to spare.
395    
396                    else if (code >= 256)
397                    {
398                            tab = &DCT.tab2[(code >> 4) - 16];
399                    }
400                    else if (code >= 128)
401                    {    
402                            tab = &DCT.tab3[(code >> 3) - 16];
403                    }
404                    else if (code >= 64)
405                    {    
406                            tab = &DCT.tab4[(code >> 2) - 16];
407                    }
408                    else if (code >= 32)
409                    {    
410                            tab = &DCT.tab5[(code >> 1) - 16];
411                    }
412                    else if (code >= 16)
413                    {    
414                            tab = &DCT.tab6[code - 16];
415                  }                  }
416                  else                  else
417                  {                  {
418                          tab = DCT_16 + UBITS(bit_buf, 16);                    ipu_cmd.pos[4] = 0;
419                          bit_buf <<= 16;                    return true;
                         GETWORD(&bit_buf, bits + 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
420                  }                  }
421    
422                  break;  /* illegal, check needed to avoid buffer overflow */                  DUMPBITS(tab->len);
         }  
   
         dest[63] ^= mismatch & 1;  
423    
424          if ((bit_buf >> 28) != 0x6)                  if (tab->run==64) /* end_of_block */
                 ipuRegs->ctrl.ECD = 1;  
   
         DUMPBITS(bit_buf, bits, tab->len);      /* dump end of block code */  
   
         decoder->bitstream_buf = bit_buf;  
   
         decoder->bitstream_bits = bits;  
 }  
   
 static __forceinline int get_non_intra_block(decoder_t * const decoder)  
 {  
 #define bit_buf (decoder->bitstream_buf)  
 #define bits (decoder->bitstream_bits)  
 #define bit_ptr (decoder->bitstream_ptr)  
         int i;  
         int j;  
         int val;  
         const u8 * scan = decoder->scan;  
         const u8 * quant_matrix = decoder->non_intra_quantizer_matrix;  
         int quantizer_scale = decoder->quantizer_scale;  
         int mismatch;  
         const DCTtab * tab;  
         s16 * dest;  
   
         i = -1;  
         mismatch = -1;  
         dest = decoder->DCTblock;  
         NEEDBITS(bit_buf, bits, bit_ptr);  
   
         if (bit_buf >= 0x28000000)  
         {  
                 tab = DCT_B14DC_5 + (UBITS(bit_buf, 5) - 5);  
                 goto entry_1;  
         }  
         else  
                 goto entry_2;  
   
         while (1)  
         {  
                 if (bit_buf >= 0x28000000)  
425                  {                  {
426                          tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);                          ipu_cmd.pos[4] = 0;
427  entry_1:                          return true;
                         i += tab->run;  
   
                         if (i >= 64) break;     /* end of block */  
 normal_code:  
                         j = scan[i];  
                         bit_buf <<= tab->len;  
                         bits += tab->len + 1;  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = ((2 * tab->level + 1) * quantizer_scale * quant_matrix[i]) >> 5;  
   
                         /* if (bitstream_get (1)) val = -val; */  
                         val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);  
   
                         SATURATE(val);  
                         dest[j] = val;  
                         mismatch ^= val;  
                         bit_buf <<= 1;  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
428                  }                  }
429  entry_2:                  
430                    i+= tab->run == 65 ? GETBITS(6) : tab->run;
431                  if (bit_buf >= 0x04000000)                  if (i >= 64)
432                  {                  {
433                          tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);                          ipu_cmd.pos[4] = 0;
434                          i += tab->run;                          return true;
   
                         if (i < 64) goto normal_code;  
   
                         /* escape code */  
   
                         i += UBITS(bit_buf << 6, 6) - 64;  
   
                         if (i >= 64) break;     /* illegal, check needed to avoid buffer overflow */  
   
                         j = scan[i];  
                         DUMPBITS(bit_buf, bits, 12);  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         val = 2 * (SBITS(bit_buf, 12) + SBITS(bit_buf, 1)) + 1;  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = (val * quantizer_scale * quant_matrix[i]) / 32;  
   
                         SATURATE(val);  
                         dest[j] = val;  
                         mismatch ^= val;  
                         DUMPBITS(bit_buf, bits, 12);  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
435                  }                  }
436                  else if (bit_buf >= 0x02000000)            case 1:
437                    if (!GETWORD())
438                  {                  {
439                          tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);                    ipu_cmd.pos[4] = i - 1;
440                          i += tab->run;                    ipu_cmd.pos[5] = 1;
441                      return false;
                         if (i < 64) goto normal_code;  
442                  }                  }
                 else if (bit_buf >= 0x00800000)  
                 {  
                         tab = DCT_13 + (UBITS(bit_buf, 13) - 16);  
                         i += tab->run;  
443    
444                          if (i < 64) goto normal_code;                  j = scan[i];
445                  }  
446                  else if (bit_buf >= 0x00200000)                  if (tab->run==65) /* escape */
447                  {                  {
448                          tab = DCT_15 + (UBITS(bit_buf, 15) - 16);                    if(!decoder.mpeg1)
449                          i += tab->run;                    {
450                              val = (SBITS(12) * quantizer_scale * quant_matrix[i]) >> 4;
451                              DUMPBITS(12);
452                      }
453                      else
454                      {
455                              val = SBITS(8);
456                              DUMPBITS(8);
457    
458                          if (i < 64) goto normal_code;                            if (!(val & 0x7f))
459                              {
460                                    val = GETBITS(8) + 2 * val;
461                              }
462                            
463                              val = (val * quantizer_scale * quant_matrix[i]) >> 4;
464                              val = (val + ~ (((s32)val) >> 31)) | 1;
465                      }
466                  }                  }
467                  else                  else
468                  {                  {
469                          tab = DCT_16 + UBITS(bit_buf, 16);                    val = (tab->level * quantizer_scale * quant_matrix[i]) >> 4;
470                          bit_buf <<= 16;                    if(decoder.mpeg1)
471                          GETWORD(&bit_buf, bits + 16);                    {
472                          i += tab->run;                          /* oddification */
473                            val = (val - 1) | 1;
474                      }
475    
476                          if (i < 64) goto normal_code;                    /* if (bitstream_get (1)) val = -val; */
477                      val = (val ^ SBITS(1)) - SBITS(1);
478                      DUMPBITS(1);
479                  }                  }
                 break;  /* illegal, check needed to avoid buffer overflow */  
         }  
480    
481          dest[63] ^= mismatch & 1;                  SATURATE(val);
482                    dest[j] = val;
483                    ipu_cmd.pos[5] = 0;
484             }
485      }
486    
487          if ((bit_buf >> 30) != 0x2) ipuRegs->ctrl.ECD = 1;    ipu_cmd.pos[4] = 0;
488      return true;
         DUMPBITS(bit_buf, bits, tab->len);      /* dump end of block code */  
   
         decoder->bitstream_buf = bit_buf;  
         decoder->bitstream_bits = bits;  
         return i;  
   
 #undef bit_buf  
 #undef bits  
 #undef bit_ptr  
489  }  }
490    
491  static __forceinline void get_mpeg1_intra_block(decoder_t * const decoder)  static __fi bool get_non_intra_block(int * last)
492  {  {
493          int i;          int i;
494          int j;          int j;
495          int val;          int val;
496          const u8 * scan = decoder->scan;          const u8 * scan = decoder.scantype ? mpeg2_scan.alt : mpeg2_scan.norm;
497          const u8 * quant_matrix = decoder->intra_quantizer_matrix;          const u8 (&quant_matrix)[64] = decoder.niq;
498          int quantizer_scale = decoder->quantizer_scale;          int quantizer_scale = decoder.quantizer_scale;
499          const DCTtab * tab;          s16 * dest = decoder.DCTblock;
500          u32 bit_buf;          u16 code;
501          int bits;  
502          u8 * bit_ptr;      /* decode AC coefficients */
503          s16 * dest;      for (i= ipu_cmd.pos[4] ; ; i++)
504        {
505          i = 0;                  switch (ipu_cmd.pos[5])
         dest = decoder->DCTblock;  
         bit_buf = decoder->bitstream_buf;  
         bits = decoder->bitstream_bits;  
         bit_ptr = decoder->bitstream_ptr;  
         NEEDBITS(bit_buf, bits, bit_ptr);  
   
         while (1)  
         {  
                 if (bit_buf >= 0x28000000)  
506                  {                  {
507                          tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);                  case 0:
508                          i += tab->run;                          if (!GETWORD())
509                            {
510                          if (i >= 64) break;     /* end of block */                                  ipu_cmd.pos[4] = i;
511                                    return false;
512  normal_code:                          }
                         j = scan[i];  
                         bit_buf <<= tab->len;  
                         bits += tab->len + 1;  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = (tab->level * quantizer_scale * quant_matrix[i]) >> 4;  
   
                         /* oddification */  
                         val = (val - 1) | 1;  
513    
514                          /* if (bitstream_get (1)) val = -val; */                          code = UBITS(16);
                         val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);  
515    
516                          SATURATE(val);                          if (code >= 16384)
517                          dest[j] = val;                          {
518                          bit_buf <<= 1;                                  if (i==0)
519                          NEEDBITS(bit_buf, bits, bit_ptr);                                  {
520                          continue;                                          tab = &DCT.first[(code >> 12) - 4];
521                                    }
522                                    else
523                                    {                      
524                                            tab = &DCT.next[(code >> 12)- 4];
525                                    }
526                            }
527                            else if (code >= 1024)
528                            {
529                                    tab = &DCT.tab0[(code >> 8) - 4];
530                            }
531                            else if (code >= 512)
532                            {              
533                                    tab = &DCT.tab1[(code >> 6) - 8];
534                            }
535    
536                  }                          // [TODO] Optimization: Following codes can all be done by a single "expedited" lookup
537                  else if (bit_buf >= 0x04000000)                          // that should use a single unrolled DCT table instead of five separate tables used
538                  {                          // here.  Multiple conditional statements are very slow, while modern CPU data caches
539                          tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);                          // have lots of room to spare.
540                          i += tab->run;  
541                            else if (code >= 256)
542                            {              
543                                    tab = &DCT.tab2[(code >> 4) - 16];
544                            }
545                            else if (code >= 128)
546                            {              
547                                    tab = &DCT.tab3[(code >> 3) - 16];
548                            }
549                            else if (code >= 64)
550                            {              
551                                    tab = &DCT.tab4[(code >> 2) - 16];
552                            }
553                            else if (code >= 32)
554                            {              
555                                    tab = &DCT.tab5[(code >> 1) - 16];
556                            }
557                            else if (code >= 16)
558                            {              
559                                    tab = &DCT.tab6[code - 16];
560                            }
561                            else
562                            {
563                                    ipu_cmd.pos[4] = 0;
564                                    return true;
565                            }
566    
567                          if (i < 64) goto normal_code;                          DUMPBITS(tab->len);
568    
569                          /* escape code */                          if (tab->run==64) /* end_of_block */
570                            {
571                                    *last = i;
572                                    ipu_cmd.pos[4] = 0;
573                                    return true;
574                            }
575    
576                          i += UBITS(bit_buf << 6, 6) - 64;                          i += (tab->run == 65) ? GETBITS(6) : tab->run;
577                            if (i >= 64)
578                            {
579                                    *last = i;
580                                    ipu_cmd.pos[4] = 0;
581                                    return true;
582                            }
583    
584                          if (i >= 64) break;     /* illegal, check needed to avoid buffer overflow */                  case 1:
585                            if (!GETWORD())
586                            {
587                              ipu_cmd.pos[4] = i;
588                              ipu_cmd.pos[5] = 1;
589                              return false;
590                            }
591    
592                          j = scan[i];                          j = scan[i];
                         DUMPBITS(bit_buf, bits, 12);  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         val = SBITS(bit_buf, 8);  
593    
594                          if (!(val & 0x7f))                          if (tab->run==65) /* escape */
595                          {                          {
596                                  DUMPBITS(bit_buf, bits, 8);                                  if (!decoder.mpeg1)
597                                  val = UBITS(bit_buf, 8) + 2 * val;                                  {
598                          }                                          val = ((2 * (SBITS(12) + SBITS(1)) + 1) * quantizer_scale * quant_matrix[i]) >> 5;
599                                            DUMPBITS(12);
600                                    }
601                                    else
602                                    {
603                                      val = SBITS(8);
604                                      DUMPBITS(8);
605    
606                          /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */                                    if (!(val & 0x7f))
607                          val = (val * quantizer_scale * quant_matrix[i]) >> 4;                                    {
608                                            val = GETBITS(8) + 2 * val;
609                                      }
610    
611                          /* oddification */                                    val = ((2 * (val + (((s32)val) >> 31)) + 1) * quantizer_scale * quant_matrix[i]) / 32;
612                          val = (val + ~SBITS(val, 1)) | 1;                                    val = (val + ~ (((s32)val) >> 31)) | 1;
613                                    }
614                            }
615                            else
616                            {
617                                    val = ((2 * tab->level + 1) * quantizer_scale * quant_matrix[i]) >> 5;
618                                    val = (val ^ SBITS(1)) - SBITS(1);
619                                    DUMPBITS(1);
620                            }
621    
622                          SATURATE(val);                          SATURATE(val);
623                          dest[j] = val;                          dest[j] = val;
624                          DUMPBITS(bit_buf, bits, 8);                          ipu_cmd.pos[5] = 0;
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
625                  }                  }
                 else if (bit_buf >= 0x02000000)  
                 {  
                         tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else if (bit_buf >= 0x00800000)  
                 {  
                         tab = DCT_13 + (UBITS(bit_buf, 13) - 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else if (bit_buf >= 0x00200000)  
                 {  
                         tab = DCT_15 + (UBITS(bit_buf, 15) - 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else  
                 {  
                         tab = DCT_16 + UBITS(bit_buf, 16);  
                         bit_buf <<= 16;  
                         GETWORD(&bit_buf, bits + 16);  
                         i += tab->run;  
  goto normal_code;  
                 }  
   
                 break;  /* illegal, check needed to avoid buffer overflow */  
626          }          }
627    
628          if ((bit_buf >> 30) != 0x2) ipuRegs->ctrl.ECD = 1;          ipu_cmd.pos[4] = 0;
629            return true;
         DUMPBITS(bit_buf, bits, 2);     /* dump end of block code */  
         decoder->bitstream_buf = bit_buf;  
         decoder->bitstream_bits = bits;  
630  }  }
631    
632  static __forceinline int get_mpeg1_non_intra_block(decoder_t * const decoder)  static __fi bool slice_intra_DCT(const int cc, u8 * const dest, const int stride, const bool skip)
633  {  {
634          int i;          if (!skip || ipu_cmd.pos[3])
         int j;  
         int val;  
         const u8 * scan = decoder->scan;  
         const u8 * quant_matrix = decoder->non_intra_quantizer_matrix;  
         int quantizer_scale = decoder->quantizer_scale;  
         const DCTtab * tab;  
         u32 bit_buf;  
         int bits;  
         u8 * bit_ptr;  
         s16 * dest;  
   
         i = -1;  
         dest = decoder->DCTblock;  
   
         bit_buf = decoder->bitstream_buf;  
         bits = decoder->bitstream_bits;  
         bit_ptr = decoder->bitstream_ptr;  
   
         NEEDBITS(bit_buf, bits, bit_ptr);  
   
         if (bit_buf >= 0x28000000)  
         {  
                 tab = DCT_B14DC_5 + (UBITS(bit_buf, 5) - 5);  
                 goto entry_1;  
         }  
         else  
                 goto entry_2;  
   
         while (1)  
635          {          {
636                  if (bit_buf >= 0x28000000)                  ipu_cmd.pos[3] = 0;
637                    if (!GETWORD())
638                  {                  {
639                          tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);                          ipu_cmd.pos[3] = 1;
640  entry_1:                          return false;
                         i += tab->run;  
   
                         if (i >= 64) break;     /* end of block */  
   
 normal_code:  
                         j = scan[i];  
                         bit_buf <<= tab->len;  
                         bits += tab->len + 1;  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = ((2 * tab->level + 1) * quantizer_scale * quant_matrix[i]) >> 5;  
   
                         /* oddification */  
                         val = (val - 1) | 1;  
   
                         /* if (bitstream_get (1)) val = -val; */  
                         val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);  
   
                         SATURATE(val);  
                         dest[j] = val;  
                         bit_buf <<= 1;  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
641                  }                  }
 entry_2:  
                 if (bit_buf >= 0x04000000)  
                 {  
                         tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
   
                         /* escape code */  
   
                         i += UBITS(bit_buf << 6, 6) - 64;  
   
                         if (i >= 64) break;     /* illegal, check needed to avoid buffer overflow */  
   
                         j = scan[i];  
                         DUMPBITS(bit_buf, bits, 12);  
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         val = SBITS(bit_buf, 8);  
   
                         if (!(val & 0x7f))  
                         {  
                                 DUMPBITS(bit_buf, bits, 8);  
                                 val = UBITS(bit_buf, 8) + 2 * val;  
                         }  
   
                         val = 2 * (val + SBITS(val, 1)) + 1;  
   
                         /* JayteeMaster: 10 points! Replaced quant_matrix[j] by quant_matrix[i] as should be */  
                         val = (val * quantizer_scale * quant_matrix[i]) / 32;  
   
                         /* oddification */  
                         val = (val + ~SBITS(val, 1)) | 1;  
642    
643                          SATURATE(val);                  /* Get the intra DC coefficient and inverse quantize it */
644                          dest[j] = val;                  if (cc == 0)
645                          DUMPBITS(bit_buf, bits, 8);                          decoder.dc_dct_pred[0] += get_luma_dc_dct_diff();
                         NEEDBITS(bit_buf, bits, bit_ptr);  
                         continue;  
                 }  
                 else if (bit_buf >= 0x02000000)  
                 {  
                         tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else if (bit_buf >= 0x00800000)  
                 {  
                         tab = DCT_13 + (UBITS(bit_buf, 13) - 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
                 else if (bit_buf >= 0x00200000)  
                 {  
                         tab = DCT_15 + (UBITS(bit_buf, 15) - 16);  
                         i += tab->run;  
   
                         if (i < 64) goto normal_code;  
                 }  
646                  else                  else
647                  {                          decoder.dc_dct_pred[cc] += get_chroma_dc_dct_diff();
                         tab = DCT_16 + UBITS(bit_buf, 16);  
                         bit_buf <<= 16;  
                         GETWORD(&bit_buf, bits + 16);  
                         i += tab->run;  
648    
649                          if (i < 64) goto normal_code;                  decoder.DCTblock[0] = decoder.dc_dct_pred[cc] << (3 - decoder.intra_dc_precision);
                 }  
   
                 break;  /* illegal, check needed to avoid buffer overflow */  
650          }          }
651    
652          if ((bit_buf >> 30) != 0x2) ipuRegs->ctrl.ECD = 1;          if (!get_intra_block())
   
         DUMPBITS(bit_buf, bits, 2);     /* dump end of block code */  
         decoder->bitstream_buf = bit_buf;  
         decoder->bitstream_bits = bits;  
         return i;  
 }  
   
 static void __fastcall slice_intra_DCT(decoder_t * const decoder, const int cc,  
                                        u8 * const dest, const int stride)  
 {  
         NEEDBITS(decoder->bitstream_buf, decoder->bitstream_bits, decoder->bitstream_ptr);  
         /* Get the intra DC coefficient and inverse quantize it */  
   
         if (cc == 0)  
                 decoder->dc_dct_pred[0] += get_luma_dc_dct_diff(decoder);  
         else  
                 decoder->dc_dct_pred[cc] += get_chroma_dc_dct_diff(decoder);  
   
         decoder->DCTblock[0] = decoder->dc_dct_pred[cc] << (3 - decoder->intra_dc_precision);  
   
         if (decoder->mpeg1)  
653          {          {
654                  get_mpeg1_intra_block(decoder);                  return false;
655          }          }
         else if (decoder->intra_vlc_format)  
         {  
                 get_intra_block_B15(decoder);  
         }  
         else  
         {  
                 get_intra_block_B14(decoder);  
         }  
   
         mpeg2_idct_copy(decoder->DCTblock, dest, stride);  
 }  
   
 /* JayteeMaster: changed dest to 16 bit signed */  
 static void __fastcall slice_non_intra_DCT(decoder_t * const decoder,  
         /*u8*/s16 * const dest, const int stride)  
 {  
         int last;  
         memzero(decoder->DCTblock);  
   
         if (decoder->mpeg1)  
                 last = get_mpeg1_non_intra_block(decoder);  
         else  
                 last = get_non_intra_block(decoder);  
656    
657          mpeg2_idct_add(last, decoder->DCTblock, dest, stride);          mpeg2_idct_copy(decoder.DCTblock, dest, stride);
 }  
   
 #if defined(_MSC_VER)  
 #pragma pack(1)  
 #endif  
   
 struct TGA_HEADER  
 {  
         u8  identsize;          // size of ID field that follows 18 u8 header (0 usually)  
         u8  colourmaptype;       // type of colour map 0=none, 1=has palette  
         u8  imagetype;          // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed  
   
         s16 colourmapstart;     // first colour map entry in palette  
         s16 colourmaplength;     // number of colours in palette  
         u8  colourmapbits;       // number of bits per palette entry 15,16,24,32  
   
     s16 xstart;             // image x origin  
     s16 ystart;             // image y origin  
     s16 width;              // image width in pixels  
     s16 height;             // image height in pixels  
     u8  bits;               // image bits per pixel 8,16,24,32  
     u8  descriptor;         // image descriptor bits (vh flip bits)  
   
     // pixel data follows header  
 } __packed;  
   
 #if defined(_MSC_VER)  
 #       pragma pack()  
 #endif  
   
 void SaveTGA(const char* filename, int width, int height, void* pdata)  
 {  
         TGA_HEADER hdr;  
         FILE* f = fopen(filename, "wb");  
   
         if (f == NULL) return;  
   
         assert(sizeof(TGA_HEADER) == 18 && sizeof(hdr) == 18);  
   
         memzero(hdr);  
         hdr.imagetype = 2;  
         hdr.bits = 32;  
         hdr.width = width;  
         hdr.height = height;  
         hdr.descriptor |= 8 | (1 << 5); // 8bit alpha, flip vertical  
         fwrite(&hdr, sizeof(hdr), 1, f);  
         fwrite(pdata, width*height*4, 1, f);  
         fclose(f);  
 }  
   
 static int s_index = 0; //, s_frame = 0;  
658    
659  void SaveRGB32(u8* ptr)          return true;
 {  
         char filename[255];  
         sprintf(filename, "frames/frame%.4d.tga", s_index++);  
         SaveTGA(filename, 16, 16, ptr);  
660  }  }
661    
662  void waitForSCD()  static __fi bool slice_non_intra_DCT(s16 * const dest, const int stride, const bool skip)
663  {  {
664          u8 bit8 = 1;          int last;
   
         while (!getBits8((u8*)&bit8, 0))  
         {  
                 so_resume();  
         }  
665    
666          if (bit8 == 0)          if (!skip)
667          {          {
668                  if (g_BP.BP & 7) g_BP.BP += 8 - (g_BP.BP & 7);                  memzero_sse_a(decoder.DCTblock);
   
                 ipuRegs->ctrl.SCD = 1;  
669          }          }
670    
671          while (!getBits32((u8*)&ipuRegs->top, 0))          if (!get_non_intra_block(&last))
672          {          {
673                  so_resume();                  return false;
674          }          }
675    
676          BigEndian(ipuRegs->top, ipuRegs->top);          mpeg2_idct_add(last, decoder.DCTblock, dest, stride);
677    
678          /*if(ipuRegs->ctrl.SCD)          return true;
         {  
                 switch(ipuRegs->top & 0xFFFFFFF0)  
                 {  
                         case 0x100:  
                         case 0x1A0:  
                                 break;  
                         case 0x1B0:  
                                 ipuRegs->ctrl.SCD = 0;  
                                 if(ipuRegs->top == 0x1b4) ipuRegs->ctrl.ECD = 1;  
                                 //else  
                                 //{  
                                 //      do  
                                 //      {  
                                 //              while(!getBits32((u8*)&ipuRegs->top, 1))  
                                 //              {  
                                 //                      so_resume();  
                                 //              }  
   
                                 //              BigEndian(ipuRegs->top, ipuRegs->top);  
                                 //      }  
                                 //      while((ipuRegs->top & 0xfffffff0) != 0x100);  
                                 //}  
                                 break;  
                         default:  
                                 ipuRegs->ctrl.SCD = 0;  
                                 break;  
                 }  
         }*/  
679  }  }
680    
681  void __forceinline finishmpeg2sliceIDEC(decoder_t* &decoder)  void __fi finishmpeg2sliceIDEC()
682  {  {
683          ipuRegs->ctrl.SCD = 0;          ipuRegs.ctrl.SCD = 0;
684          coded_block_pattern = decoder->coded_block_pattern;          coded_block_pattern = decoder.coded_block_pattern;
685    
686          g_BP.BP += decoder->bitstream_bits - 16;          g_BP.BP += decoder.bitstream_bits - 16;
687    
688          if ((int)g_BP.BP < 0)          if ((int)g_BP.BP < 0)
689          {          {
# Line 1122  void __forceinline finishmpeg2sliceIDEC( Line 695  void __forceinline finishmpeg2sliceIDEC(
695          }          }
696    
697          FillInternalBuffer(&g_BP.BP, 1, 0);          FillInternalBuffer(&g_BP.BP, 1, 0);
   
         waitForSCD();  
698  }  }
699    
700  void mpeg2sliceIDEC(void* pdone)  bool mpeg2sliceIDEC()
701  {  {
702          u32 read;          u16 code;
703            u8 bit8;
704    
705          bool resumed = false;          switch (ipu_cmd.pos[0])
706          decoder_t *decoder = &g_decoder;          {
707            case 0:
708          *(int*)pdone = 0;                  decoder.dc_dct_pred[0] =
709          bitstream_init(decoder);                  decoder.dc_dct_pred[1] =
710                    decoder.dc_dct_pred[2] = 128 << decoder.intra_dc_precision;
711    
712          decoder->dc_dct_pred[0] =                  decoder.mbc = 0;
713          decoder->dc_dct_pred[1] =                  ipuRegs.top = 0;
714          decoder->dc_dct_pred[2] = 128 << decoder->intra_dc_precision;                  ipuRegs.ctrl.ECD = 0;
715    
716          decoder->mbc = 0;          case 1:
717          ipuRegs->ctrl.ECD = 0;                  ipu_cmd.pos[0] = 1;
718                    if (!bitstream_init())
719                    {
720                            return false;
721                    }
722    
723          if (UBITS(decoder->bitstream_buf, 2) == 0)          case 2:
724          {                  ipu_cmd.pos[0] = 2;
                 ipuRegs->ctrl.SCD = 0;  
         }  
         else  
         {  
725                  while (1)                  while (1)
726                  {                  {
727                            macroblock_8& mb8 = decoder.mb8;
728                            macroblock_rgb16& rgb16 = decoder.rgb16;
729                            macroblock_rgb32& rgb32 = decoder.rgb32;
730    
731                          int DCT_offset, DCT_stride;                          int DCT_offset, DCT_stride;
                         int mba_inc;  
732                          const MBAtab * mba;                          const MBAtab * mba;
733    
734                          NEEDBITS(decoder->bitstream_buf, decoder->bitstream_bits, decoder->bitstream_ptr);                          switch (ipu_cmd.pos[1])
                         decoder->macroblock_modes = get_macroblock_modes(decoder);  
   
                         /* maybe integrate MACROBLOCK_QUANT test into get_macroblock_modes ? */  
   
                         if (decoder->macroblock_modes & MACROBLOCK_QUANT) //only IDEC  
                         {  
                                 decoder->quantizer_scale = get_quantizer_scale(decoder);  
                         }  
   
                         if (decoder->macroblock_modes & DCT_TYPE_INTERLACED)  
                         {  
                                 DCT_offset = decoder->stride;  
                                 DCT_stride = decoder->stride * 2;  
                         }  
                         else  
                         {  
                                 DCT_offset = decoder->stride * 8;  
                                 DCT_stride = decoder->stride;  
                         }  
   
                         if (decoder->macroblock_modes & MACROBLOCK_INTRA)  
735                          {                          {
736                                  decoder->coded_block_pattern = 0x3F;//all 6 blocks                          case 0:
737                                  //ipuRegs->ctrl.CBP = 0x3f;                                  decoder.macroblock_modes = get_macroblock_modes();
738    
739                                  memzero(*decoder->mb8);                                  if (decoder.macroblock_modes & MACROBLOCK_QUANT) //only IDEC
740                                  memzero(*decoder->rgb32);                                  {
741                                            decoder.quantizer_scale = get_quantizer_scale();
742                                    }
743    
744                                  slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y, DCT_stride);                                  decoder.coded_block_pattern = 0x3F;//all 6 blocks
745                                  slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y + 8, DCT_stride);                                  memzero_sse_a(mb8);
746                                  slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y + DCT_offset, DCT_stride);                                  memzero_sse_a(rgb32);
                                 slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y + DCT_offset + 8, DCT_stride);  
                                 slice_intra_DCT(decoder, 1, (u8*)decoder->mb8->Cb, decoder->stride >> 1);  
                                 slice_intra_DCT(decoder, 2, (u8*)decoder->mb8->Cr, decoder->stride >> 1);  
747    
748                                  // Send The MacroBlock via DmaIpuFrom                          case 1:
749                                    ipu_cmd.pos[1] = 1;
750    
751                                  if (decoder->ofm == 0)                                  if (decoder.macroblock_modes & DCT_TYPE_INTERLACED)
752                                  {                                  {
753                                          ipu_csc(decoder->mb8, decoder->rgb32, decoder->sgn);                                          DCT_offset = decoder_stride;
754                                            DCT_stride = decoder_stride * 2;
                                         g_nIPU0Data = 64;  
                                         g_pIPU0Pointer = (u8*)decoder->rgb32;  
                                         //if ( s_frame >= 39 ) SaveRGB32(g_pIPU0Pointer);  
755                                  }                                  }
756                                  else                                  else
757                                  {                                  {
758                                          ipu_csc(decoder->mb8, decoder->rgb32, decoder->sgn);                                          DCT_offset = decoder_stride * 8;
759                                          ipu_dither(decoder->rgb32, decoder->rgb16, decoder->dte);                                          DCT_stride = decoder_stride;
760                                    }
761    
762                                          g_nIPU0Data = 32;                                  switch (ipu_cmd.pos[2])
763                                          g_pIPU0Pointer = (u8*)decoder->rgb16;                                  {
764                                          //if ( s_frame >= 39 ) SaveRGB32(g_pIPU0Pointer);                                  case 0:
765                                    case 1:
766                                            if (!slice_intra_DCT(0, (u8*)mb8.Y, DCT_stride, ipu_cmd.pos[2] == 1))
767                                            {
768                                                    ipu_cmd.pos[2] = 1;
769                                                    return false;
770                                            }
771                                    case 2:
772                                            if (!slice_intra_DCT(0, (u8*)mb8.Y + 8, DCT_stride, ipu_cmd.pos[2] == 2))
773                                            {
774                                                    ipu_cmd.pos[2] = 2;
775                                                    return false;
776                                            }
777                                    case 3:
778                                            if (!slice_intra_DCT(0, (u8*)mb8.Y + DCT_offset, DCT_stride, ipu_cmd.pos[2] == 3))
779                                            {
780                                                    ipu_cmd.pos[2] = 3;
781                                                    return false;
782                                            }
783                                    case 4:
784                                            if (!slice_intra_DCT(0, (u8*)mb8.Y + DCT_offset + 8, DCT_stride, ipu_cmd.pos[2] == 4))
785                                            {
786                                                    ipu_cmd.pos[2] = 4;
787                                                    return false;
788                                            }
789                                    case 5:
790                                            if (!slice_intra_DCT(1, (u8*)mb8.Cb, decoder_stride >> 1, ipu_cmd.pos[2] == 5))
791                                            {
792                                                    ipu_cmd.pos[2] = 5;
793                                                    return false;
794                                            }
795                                    case 6:
796                                            if (!slice_intra_DCT(2, (u8*)mb8.Cr, decoder_stride >> 1, ipu_cmd.pos[2] == 6))
797                                            {
798                                                    ipu_cmd.pos[2] = 6;
799                                                    return false;
800                                            }
801                                    }
802    
803                                    // Send The MacroBlock via DmaIpuFrom
804                                    ipu_csc(mb8, rgb32, decoder.sgn);
805    
806                                    if (decoder.ofm == 0)
807                                            decoder.SetOutputTo(rgb32);
808                                    else
809                                    {
810                                            ipu_dither(rgb32, rgb16, decoder.dte);
811                                            decoder.SetOutputTo(rgb16);
812                                  }                                  }
813    
814                                  while (g_nIPU0Data > 0)                          case 2:
815                                    while (decoder.ipu0_data > 0)
816                                  {                                  {
817                                          read = ipu_fifo.out.write((u32*)g_pIPU0Pointer, g_nIPU0Data);                                          uint read = ipu_fifo.out.write((u32*)decoder.GetIpuDataPtr(), decoder.ipu0_data);
818    
819                                          if (read == 0)                                          if (read == 0)
820                                          {                                          {
821                                                  so_resume();                                                  ipu_cmd.pos[1] = 2;
822                                                  resumed = true;                                                  return false;
823                                          }                                          }
824                                          else                                          else
825                                          {                                          {
826                                                  g_pIPU0Pointer += read * 16;                                                  decoder.AdvanceIpuDataBy(read);
                                                 g_nIPU0Data -= read;  
   
827                                          }                                          }
828                                  }                                  }
829    
830                                  decoder->mbc++;                                  decoder.mbc++;
831                          }                                  mbaCount = 0;
832                            case 3:
833                                    while (1)
834                                    {
835                                            if (!GETWORD())
836                                            {
837                                                    ipu_cmd.pos[1] = 3;
838                                                    return false;
839                                            }
840    
841                                            code = UBITS(16);
842                                            if (code >= 0x1000)
843                                            {
844                                                    mba = MBA.mba5 + (UBITS(5) - 2);
845                                                    break;
846                                            }
847                                            else if (code >= 0x0300)
848                                            {
849                                                    mba = MBA.mba11 + (UBITS(11) - 24);
850                                                    break;
851                                            }
852                                            else switch (UBITS(11))
853                                            {
854                                                            case 8:         /* macroblock_escape */
855                                                                    mbaCount += 33;
856                                                                    /* pass through */
857    
858                                                            case 15:        /* macroblock_stuffing (MPEG1 only) */
859                                                                    DUMPBITS(11);
860                                                                    continue;
861    
862                                                            default:        /* end of slice/frame, or error? */
863                                                            {
864                                                                    goto finish_idec;      
865                                                            }
866                                            }
867                                    }
868    
869                          NEEDBITS(decoder->bitstream_buf, decoder->bitstream_bits, decoder->bitstream_ptr);                                  DUMPBITS(mba->len);
870                          mba_inc = 0;                                  mbaCount += mba->mba;
871    
872                          while (1)                                  if (mbaCount)
                         {  
                                 if (decoder->bitstream_buf >= 0x10000000)  
873                                  {                                  {
874                                          mba = MBA_5 + (UBITS(decoder->bitstream_buf, 5) - 2);                                          decoder.dc_dct_pred[0] =
875                                          break;                                          decoder.dc_dct_pred[1] =
876                                            decoder.dc_dct_pred[2] = 128 << decoder.intra_dc_precision;
877    
878                                            decoder.mbc += mbaCount;
879                                  }                                  }
880                                  else if (decoder->bitstream_buf >= 0x03000000)  
881                            case 4:
882                                    if (!GETWORD())
883                                  {                                  {
884                                          mba = MBA_11 + (UBITS(decoder->bitstream_buf, 11) - 24);                                          ipu_cmd.pos[1] = 4;
885                                          break;                                          return false;
886                                  }                                  }
                                 else switch (UBITS(decoder->bitstream_buf, 11))  
                                         {  
887    
888                                                  case 8:         /* macroblock_escape */                                  break;
                                                         mba_inc += 33;  
                                                         /* pass through */  
   
                                                 case 15:        /* macroblock_stuffing (MPEG1 only) */  
                                                         DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, 11);  
                                                         NEEDBITS(decoder->bitstream_buf, decoder->bitstream_bits, decoder->bitstream_ptr);  
                                                         continue;  
   
                                                 default:        /* end of slice/frame, or error? */  
                                                 {  
 #ifdef MPEGHACK  
                                                         if (!resumed) so_resume();  
 #endif  
                                                         finishmpeg2sliceIDEC(decoder);  
   
                                                         *(int*)pdone = 1;  
                                                         so_exit();  
                                                 }  
                                         }  
889                          }                          }
890    
891                          DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, mba->len);                          ipu_cmd.pos[1] = 0;
892                          mba_inc += mba->mba;                          ipu_cmd.pos[2] = 0;
893                    }
894                    
895    finish_idec:
896                    finishmpeg2sliceIDEC();
897    
898                          if (mba_inc)          case 3:
899                          {                  bit8 = 1;
900                                  decoder->dc_dct_pred[0] =                  if (!getBits8((u8*)&bit8, 0))
901                                  decoder->dc_dct_pred[1] =                  {
902                                  decoder->dc_dct_pred[2] = 128 << decoder->intra_dc_precision;                          ipu_cmd.pos[0] = 3;
903                            return false;
904                    }
905    
906                                  do                  if (bit8 == 0)
907                                  {                  {
908                                          decoder->mbc++;                          if (g_BP.BP & 7) g_BP.BP += 8 - (g_BP.BP & 7);
909                                  }  
910                                  while (--mba_inc);                          ipuRegs.ctrl.SCD = 1;
                         }  
911                  }                  }
         }  
912    
913  #ifdef MPEGHACK          case 4:
914          if (!resumed) so_resume();                  if (!getBits32((u8*)&ipuRegs.top, 0))
915  #endif                  {
916                            ipu_cmd.pos[0] = 4;
917                            return false;
918                    }
919    
920          finishmpeg2sliceIDEC(decoder);                  BigEndian(ipuRegs.top, ipuRegs.top);
921                    break;
922            }
923    
924          *(int*)pdone = 1;          return true;
         so_exit();  
925  }  }
926    
927  void mpeg2_slice(void* pdone)  bool mpeg2_slice()
928  {  {
929          int DCT_offset, DCT_stride;          int DCT_offset, DCT_stride;
930          //u8 bit8=0;          u8 bit8;
         //u32 fp = g_BP.FP;  
         u32 bp;  
         decoder_t * decoder = &g_decoder;  
         u32 size = 0;  
   
         *(int*)pdone = 0;  
         ipuRegs->ctrl.ECD = 0;  
   
         memzero(*decoder->mb8);  
         memzero(*decoder->mb16);  
   
         bitstream_init(decoder);  
931    
932          if (decoder->dcr)          macroblock_8& mb8 = decoder.mb8;
933          {          macroblock_16& mb16 = decoder.mb16;
                 decoder->dc_dct_pred[0] =  
                 decoder->dc_dct_pred[1] =  
                 decoder->dc_dct_pred[2] = 128 << decoder->intra_dc_precision;  
         }  
   
         if (decoder->macroblock_modes & DCT_TYPE_INTERLACED)  
         {  
                 DCT_offset = decoder->stride;  
                 DCT_stride = decoder->stride * 2;  
         }  
         else  
         {  
                 DCT_offset = decoder->stride * 8;  
                 DCT_stride = decoder->stride;  
         }  
934    
935          if (decoder->macroblock_modes & MACROBLOCK_INTRA)          switch (ipu_cmd.pos[0])
936          {          {
937                  decoder->coded_block_pattern = 0x3F;//all 6 blocks          case 0:
938                  slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y, DCT_stride);                  if (decoder.dcr)
                 slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y + 8, DCT_stride);  
                 slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y + DCT_offset, DCT_stride);  
                 slice_intra_DCT(decoder, 0, (u8*)decoder->mb8->Y + DCT_offset + 8, DCT_stride);  
                 slice_intra_DCT(decoder, 1, (u8*)decoder->mb8->Cb, decoder->stride >> 1);  
                 slice_intra_DCT(decoder, 2, (u8*)decoder->mb8->Cr, decoder->stride >> 1);  
                 ipu_copy(decoder->mb8, decoder->mb16);  
         }  
         else  
         {  
                 if (decoder->macroblock_modes & MACROBLOCK_PATTERN)  
939                  {                  {
940                          decoder->coded_block_pattern = get_coded_block_pattern(decoder);                          decoder.dc_dct_pred[0] =
941                          /* JayteeMaster: changed from mb8 to mb16 and from u8 to s16 */                          decoder.dc_dct_pred[1] =
942                            decoder.dc_dct_pred[2] = 128 << decoder.intra_dc_precision;
943                          if (decoder->coded_block_pattern & 0x20) slice_non_intra_DCT(decoder, (s16*)decoder->mb16->Y, DCT_stride);                  }
944                          if (decoder->coded_block_pattern & 0x10) slice_non_intra_DCT(decoder, (s16*)decoder->mb16->Y + 8, DCT_stride);                          
945                          if (decoder->coded_block_pattern & 0x08) slice_non_intra_DCT(decoder, (s16*)decoder->mb16->Y + DCT_offset,       DCT_stride);                  ipuRegs.ctrl.ECD = 0;
946                          if (decoder->coded_block_pattern & 0x04) slice_non_intra_DCT(decoder, (s16*)decoder->mb16->Y + DCT_offset + 8, DCT_stride);                  ipuRegs.top = 0;
947                          if (decoder->coded_block_pattern & 0x2)  slice_non_intra_DCT(decoder, (s16*)decoder->mb16->Cb, decoder->stride >> 1);                  memzero_sse_a(mb8);
948                          if (decoder->coded_block_pattern & 0x1)  slice_non_intra_DCT(decoder, (s16*)decoder->mb16->Cr, decoder->stride >> 1);                  memzero_sse_a(mb16);
949            case 1:
950                    if (!bitstream_init())
951                    {
952                            ipu_cmd.pos[0] = 1;
953                            return false;
954                  }                  }
         }  
   
         //Send The MacroBlock via DmaIpuFrom  
   
         size = 0;       // Reset  
         ipuRegs->ctrl.SCD = 0;  
         coded_block_pattern = decoder->coded_block_pattern;  
         bp = g_BP.BP;  
         g_BP.BP += ((int)decoder->bitstream_bits - 16);  
   
         // BP goes from 0 to 128, so negative values mean to read old buffer  
         // so we minus from 128 to get the correct BP  
         if ((int)g_BP.BP < 0)  
         {  
                 g_BP.BP = 128 + (int)g_BP.BP;  
   
                 // After BP is positioned correctly, we need to reload the old buffer  
                 // so that reading may continue properly  
                 ReorderBitstream();  
         }  
   
         FillInternalBuffer(&g_BP.BP, 1, 0);  
   
         decoder->mbc = 1;  
         g_nIPU0Data = 48;  
         g_pIPU0Pointer = (u8*)decoder->mb16;  
955    
956          while (g_nIPU0Data > 0)          case 2:
957          {                  ipu_cmd.pos[0] = 2;
                 size = ipu_fifo.out.write((u32*)g_pIPU0Pointer, g_nIPU0Data);  
958    
959                  if (size == 0)                  if (decoder.macroblock_modes & DCT_TYPE_INTERLACED)
960                  {                  {
961                          so_resume();                          DCT_offset = decoder_stride;
962                            DCT_stride = decoder_stride * 2;
963                  }                  }
964                  else                  else
965                  {                  {
966                          g_pIPU0Pointer += size * 16;                          DCT_offset = decoder_stride * 8;
967                          g_nIPU0Data -= size;                          DCT_stride = decoder_stride;
968                  }                  }
         }  
         waitForSCD();  
   
         decoder->bitstream_bits = 0;  
         *(int*)pdone = 1;  
         so_exit();  
 }  
   
 int __forceinline get_motion_delta(decoder_t * const decoder,  
                                    const int f_code)  
 {  
 #define bit_buf (decoder->bitstream_buf)  
 #define bits (decoder->bitstream_bits)  
 #define bit_ptr (decoder->bitstream_ptr)  
   
         int delta;  
         int sign;  
         const MVtab * tab;  
   
         if ((bit_buf & 0x80000000))  
         {  
                 DUMPBITS(bit_buf, bits, 1);  
                 return 0x00010000;  
         }  
         else if ((bit_buf & 0xf0000000) || ((bit_buf & 0xfc000000) == 0x0c000000))  
         {  
   
                 tab = MV_4 + UBITS(bit_buf, 4);  
                 delta = (tab->delta << f_code) + 1;  
                 bits += tab->len + f_code + 1;  
                 bit_buf <<= tab->len;  
   
                 sign = SBITS(bit_buf, 1);  
                 bit_buf <<= 1;  
   
                 if (f_code) delta += UBITS(bit_buf, f_code);  
969    
970                  bit_buf <<= f_code;                  if (decoder.macroblock_modes & MACROBLOCK_INTRA)
971                    {
972                  return (delta ^ sign) - sign;                          switch(ipu_cmd.pos[1])
973                            {
974          }                          case 0:
975          else                                  decoder.coded_block_pattern = 0x3F;
976          {                          case 1:
977                  tab = MV_10 + UBITS(bit_buf, 10);                                  if (!slice_intra_DCT(0, (u8*)mb8.Y, DCT_stride, ipu_cmd.pos[1] == 1))
978                  delta = (tab->delta << f_code) + 1;                                  {
979                  bits += tab->len + 1;                                          ipu_cmd.pos[1] = 1;
980                  bit_buf <<= tab->len;                                          return false;
981                                    }
982                  sign = SBITS(bit_buf, 1);                          case 2:
983                  bit_buf <<= 1;                                  if (!slice_intra_DCT(0, (u8*)mb8.Y + 8, DCT_stride, ipu_cmd.pos[1] == 2))
984                                    {
985                                            ipu_cmd.pos[1] = 2;
986                                            return false;
987                                    }
988                            case 3:
989                                    if (!slice_intra_DCT(0, (u8*)mb8.Y + DCT_offset, DCT_stride, ipu_cmd.pos[1] == 3))
990                                    {
991                                            ipu_cmd.pos[1] = 3;
992                                            return false;
993                                    }
994                            case 4:
995                                    if (!slice_intra_DCT(0, (u8*)mb8.Y + DCT_offset + 8, DCT_stride, ipu_cmd.pos[1] == 4))
996                                    {
997                                            ipu_cmd.pos[1] = 4;
998                                            return false;
999                                    }
1000                            case 5:
1001                                    if (!slice_intra_DCT(1, (u8*)mb8.Cb, decoder_stride >> 1, ipu_cmd.pos[1] == 5))
1002                                    {
1003                                            ipu_cmd.pos[1] = 5;
1004                                            return false;
1005                                    }
1006                            case 6:
1007                                    if (!slice_intra_DCT(2, (u8*)mb8.Cr, decoder_stride >> 1, ipu_cmd.pos[1] == 6))
1008                                    {
1009                                            ipu_cmd.pos[1] = 6;
1010                                            return false;
1011                                    }
1012                                    break;
1013                            }
1014    
1015                  if (f_code)                          ipu_copy(mb8, mb16);
1016                    }
1017                    else
1018                  {                  {
1019                          NEEDBITS(bit_buf, bits, bit_ptr);                          if (decoder.macroblock_modes & MACROBLOCK_PATTERN)
1020                          delta += UBITS(bit_buf, f_code);                          {
1021                          DUMPBITS(bit_buf, bits, f_code);                                  switch(ipu_cmd.pos[1])
1022                                    {
1023                                    case 0:
1024                                            decoder.coded_block_pattern = get_coded_block_pattern();  // max 9bits
1025                                    case 1:
1026                                            if (decoder.coded_block_pattern & 0x20)
1027                                            {
1028                                                    if (!slice_non_intra_DCT((s16*)mb16.Y, DCT_stride, ipu_cmd.pos[1] == 1))
1029                                                    {
1030                                                            ipu_cmd.pos[1] = 1;
1031                                                            return false;
1032                                                    }
1033                                            }
1034                                    case 2:
1035                                            if (decoder.coded_block_pattern & 0x10)
1036                                            {
1037                                                    if (!slice_non_intra_DCT((s16*)mb16.Y + 8, DCT_stride, ipu_cmd.pos[1] == 2))
1038                                                    {
1039                                                            ipu_cmd.pos[1] = 2;
1040                                                            return false;
1041                                                    }
1042                                            }
1043                                    case 3:
1044                                            if (decoder.coded_block_pattern & 0x08)
1045                                            {
1046                                                    if (!slice_non_intra_DCT((s16*)mb16.Y + DCT_offset, DCT_stride, ipu_cmd.pos[1] == 3))
1047                                                    {
1048                                                            ipu_cmd.pos[1] = 3;
1049                                                            return false;
1050                                                    }
1051                                            }
1052                                    case 4:
1053                                            if (decoder.coded_block_pattern & 0x04)
1054                                            {
1055                                                    if (!slice_non_intra_DCT((s16*)mb16.Y + DCT_offset + 8, DCT_stride, ipu_cmd.pos[1] == 4))
1056                                                    {
1057                                                            ipu_cmd.pos[1] = 4;
1058                                                            return false;
1059                                                    }
1060                                            }
1061                                    case 5:
1062                                            if (decoder.coded_block_pattern & 0x2)
1063                                            {
1064                                                    if (!slice_non_intra_DCT((s16*)mb16.Cb, decoder_stride >> 1, ipu_cmd.pos[1] == 5))
1065                                                    {
1066                                                            ipu_cmd.pos[1] = 5;
1067                                                            return false;
1068                                                    }
1069                                            }
1070                                    case 6:
1071                                            if (decoder.coded_block_pattern & 0x1)
1072                                            {
1073                                                    if (!slice_non_intra_DCT((s16*)mb16.Cr, decoder_stride >> 1, ipu_cmd.pos[1] == 6))
1074                                                    {
1075                                                            ipu_cmd.pos[1] = 6;
1076                                                            return false;
1077                                                    }
1078                                            }
1079                                            break;
1080                                    }
1081                            }
1082                  }                  }
1083    
1084                  return (delta ^ sign) - sign;                  // Send The MacroBlock via DmaIpuFrom
1085                    ipuRegs.ctrl.SCD = 0;
1086          }                  coded_block_pattern = decoder.coded_block_pattern;
1087                    g_BP.BP += (int)decoder.bitstream_bits - 16;
1088    
1089  #undef bit_buf                  // BP goes from 0 to 128, so negative values mean to read old buffer
1090  #undef bits                  // so we minus from 128 to get the correct BP
1091  #undef bit_ptr                  if ((int)g_BP.BP < 0)
1092  }                  {
1093                            g_BP.BP = 128 + (int)g_BP.BP;
1094    
1095  int __forceinline get_dmv(decoder_t * const decoder)                          // After BP is positioned correctly, we need to reload the old buffer
1096  {                          // so that reading may continue properly
1097  #define bit_buf (decoder->bitstream_buf)                          ReorderBitstream();
1098  #define bits (decoder->bitstream_bits)                  }
 #define bit_ptr (decoder->bitstream_ptr)  
1099    
1100          const DMVtab * tab;                  decoder.mbc = 1;
1101                    decoder.SetOutputTo(mb16);
1102    
1103          tab = DMV_2 + UBITS(bit_buf, 2);          case 3:
1104          DUMPBITS(bit_buf, bits, tab->len);                  while (decoder.ipu0_data > 0)
1105          return tab->dmv;                  {
1106  #undef bit_buf                          uint size = ipu_fifo.out.write((u32*)decoder.GetIpuDataPtr(), decoder.ipu0_data);
 #undef bits  
 #undef bit_ptr  
 }  
1107    
1108  int get_macroblock_address_increment(decoder_t * const decoder)                          if (size == 0)
1109  {                          {
1110          const MBAtab *mba;                                  ipu_cmd.pos[0] = 3;
1111                                    return false;
1112                            }
1113                            else
1114                            {
1115                                    decoder.AdvanceIpuDataBy(size);
1116                            }
1117                    }
1118    
1119          if (decoder->bitstream_buf >= 0x10000000)          case 4:
1120                  mba = MBA_5 + (UBITS(decoder->bitstream_buf, 5) - 2);                  bit8 = 1;
1121          else if (decoder->bitstream_buf >= 0x03000000)                  if (!getBits8((u8*)&bit8, 0))
                 mba = MBA_11 + (UBITS(decoder->bitstream_buf, 11) - 24);  
         else switch (UBITS(decoder->bitstream_buf, 11))  
1122                  {                  {
1123                            ipu_cmd.pos[0] = 4;
1124                            return false;
1125                    }
1126    
1127                          case 8:         /* macroblock_escape */                  if (bit8 == 0)
1128                                  DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, 11);                  {
1129                                  return 0x23;                          if (g_BP.BP & 7) g_BP.BP += 8 - (g_BP.BP & 7);
1130    
1131                          case 15:        /* macroblock_stuffing (MPEG1 only) */                          ipuRegs.ctrl.SCD = 1;
1132                                  if (decoder->mpeg1)                  }
                                 {  
                                         DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, 11);  
                                         return 0x22;  
                                 }  
1133    
1134                          default:          case 5:
1135                                  return 0;//error                  if (!getBits32((u8*)&ipuRegs.top, 0))
1136                    {
1137                            ipu_cmd.pos[0] = 5;
1138                            return false;
1139                  }                  }
1140    
1141          DUMPBITS(decoder->bitstream_buf, decoder->bitstream_bits, mba->len);                  BigEndian(ipuRegs.top, ipuRegs.top);
1142                    decoder.bitstream_bits = 0;
1143                    break;
1144            }
1145    
1146          return mba->mba + 1;          return true;
1147  }  }

Legend:
Removed from v.31  
changed lines
  Added in v.62

  ViewVC Help
Powered by ViewVC 1.1.22