[cvs] / xvidcore / src / decoder.c Repository:
ViewVC logotype

Diff of /xvidcore/src/decoder.c

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

revision 1.17, Thu May 9 00:15:51 2002 UTC revision 1.69, Sun Mar 27 03:59:41 2005 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  -  Decoder main module  -   *  - Decoder Module -
5   *   *
6   *  This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2002      MinChen <chenm001@163.com>
7   *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending   *               2002-2004 Peter Ross <pross@xvid.org>
  *  to use this software module in hardware or software products are  
  *  advised that its use may infringe existing patents or copyrights, and  
  *  any such use would be at such party's own risk.  The original  
  *  developer of this software module and his/her company, and subsequent  
  *  editors and their companies, will have no liability for use of this  
  *  software or modifications or derivatives thereof.  
8   *   *
9   *  This program is free software; you can redistribute it and/or modify   *  This program is free software; you can redistribute it and/or modify
10   *  it under the terms of the GNU General Public License as published by   *  it under the terms of the GNU General Public License as published by
# Line 26  Line 20 
20   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
21   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22   *   *
  *************************************************************************/  
   
 /**************************************************************************  
  *  
  *  History:  
  *  
  *  08.05.2002  add low_delay support for B_VOP decode  
  *              MinChen <chenm001@163.com>  
  *  05.05.2002  fix some B-frame decode problem  
  *  02.05.2002  add B-frame decode support(have some problem);  
  *              MinChen <chenm001@163.com>  
  *  22.04.2002  add some B-frame decode support;  chenm001 <chenm001@163.com>  
  *  29.03.2002  interlacing fix - compensated block wasn't being used when  
  *              reconstructing blocks, thus artifacts  
  *              interlacing speedup - used transfers to re-interlace  
  *              interlaced decoding should be as fast as progressive now  
  *  26.03.2002  interlacing support - moved transfers outside decode loop  
  *  26.12.2001  decoder_mbinter: dequant/idct moved within if(coded) block  
  *  22.12.2001  lock based interpolation  
  *  01.12.2001  inital version; (c)2001 peter ross <pross@cs.rmit.edu.au>  
  *  
23   *  $Id$   *  $Id$
24   *   *
25   *************************************************************************/   ****************************************************************************/
26    
27    #include <stdio.h>
28  #include <stdlib.h>  #include <stdlib.h>
29  #include <string.h>  #include <string.h>
30    
31    #ifdef BFRAMES_DEC_DEBUG
32            #define BFRAMES_DEC
33    #endif
34    
35  #include "xvid.h"  #include "xvid.h"
36  #include "portab.h"  #include "portab.h"
37    #include "global.h"
38    
39  #include "decoder.h"  #include "decoder.h"
40  #include "bitstream/bitstream.h"  #include "bitstream/bitstream.h"
41  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
42    
43  #include "quant/quant_h263.h"  #include "quant/quant.h"
44  #include "quant/quant_mpeg4.h"  #include "quant/quant_matrix.h"
45  #include "dct/idct.h"  #include "dct/idct.h"
46  #include "dct/fdct.h"  #include "dct/fdct.h"
47  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
48  #include "image/interpolate8x8.h"  #include "image/interpolate8x8.h"
49    #include "image/font.h"
50    #include "image/qpel.h"
51    
52  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
53  #include "prediction/mbprediction.h"  #include "prediction/mbprediction.h"
54  #include "utils/timer.h"  #include "utils/timer.h"
55  #include "utils/emms.h"  #include "utils/emms.h"
56    #include "motion/motion.h"
57    #include "motion/gmc.h"
58    
59  #include "image/image.h"  #include "image/image.h"
60  #include "image/colorspace.h"  #include "image/colorspace.h"
61    #include "image/postprocessing.h"
62  #include "utils/mem_align.h"  #include "utils/mem_align.h"
63    
64  int decoder_create(XVID_DEC_PARAM * param)  static int
65    decoder_resize(DECODER * dec)
66  {  {
67          DECODER * dec;          /* free existing */
68            image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
69            image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
70            image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
71            image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
72            image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
73    
74          dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
         if (dec == NULL)  
         {  
                 return XVID_ERR_MEMORY;  
         }  
         param->handle = dec;  
75    
76          dec->width = param->width;          if (dec->last_mbs)
77          dec->height = param->height;                  xvid_free(dec->last_mbs);
78            if (dec->mbs)
79                    xvid_free(dec->mbs);
80            if (dec->qscale)
81                    xvid_free(dec->qscale);
82    
83            /* realloc */
84          dec->mb_width = (dec->width + 15) / 16;          dec->mb_width = (dec->width + 15) / 16;
85          dec->mb_height = (dec->height + 15) / 16;          dec->mb_height = (dec->height + 15) / 16;
86    
87          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
88          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
89    
90          if (image_create(&dec->cur, dec->edged_width, dec->edged_height))          if (image_create(&dec->cur, dec->edged_width, dec->edged_height)) {
         {  
91                  xvid_free(dec);                  xvid_free(dec);
92                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
93          }          }
94    
95          if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height))          if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {
         {  
96                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
97                  xvid_free(dec);                  xvid_free(dec);
98                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
99          }          }
100          // add by chenm001 <chenm001@163.com>  
101          // for support B-frame to reference last 2 frame          /* Support B-frame to reference last 2 frame */
102          if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height))          if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {
         {  
103                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
104                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
105                  xvid_free(dec);                  xvid_free(dec);
106                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
107          }          }
108          if (image_create(&dec->refn[2], dec->edged_width, dec->edged_height))          if (image_create(&dec->tmp, dec->edged_width, dec->edged_height)) {
         {  
109                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
110                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
111                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
# Line 127  Line 113 
113                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
114          }          }
115    
116          dec->mbs = xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height, CACHE_LINE);          if (image_create(&dec->qtmp, dec->edged_width, dec->edged_height)) {
         if (dec->mbs == NULL)  
         {  
117                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
118                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
119                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
120                  image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);                  image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
121                  xvid_free(dec);                  xvid_free(dec);
122                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
123          }          }
124          // add by chenm001 <chenm001@163.com>  
125          // for skip MB flag          if (image_create(&dec->gmc, dec->edged_width, dec->edged_height)) {
126          dec->last_mbs = xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height, CACHE_LINE);                  image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
127          if (dec->last_mbs == NULL)                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
128          {                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
129                    image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
130                    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
131                    xvid_free(dec);
132                    return XVID_ERR_MEMORY;
133            }
134    
135            dec->mbs =
136                    xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
137                                            CACHE_LINE);
138            if (dec->mbs == NULL) {
139                    image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
140                    image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
141                    image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
142                    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
143                    image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
144                    xvid_free(dec);
145                    return XVID_ERR_MEMORY;
146            }
147            memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
148    
149            /* For skip MB flag */
150            dec->last_mbs =
151                    xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
152                                            CACHE_LINE);
153            if (dec->last_mbs == NULL) {
154                  xvid_free(dec->mbs);                  xvid_free(dec->mbs);
155                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
156                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
157                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
158                  image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);                  image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
159                    image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
160                    xvid_free(dec);
161                    return XVID_ERR_MEMORY;
162            }
163    
164            memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
165    
166            /* nothing happens if that fails */
167            dec->qscale =
168                    xvid_malloc(sizeof(int) * dec->mb_width * dec->mb_height, CACHE_LINE);
169    
170            if (dec->qscale)
171                    memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
172    
173            return 0;
174    }
175    
176    
177    int
178    decoder_create(xvid_dec_create_t * create)
179    {
180            DECODER *dec;
181    
182            if (XVID_VERSION_MAJOR(create->version) != 1)   /* v1.x.x */
183                    return XVID_ERR_VERSION;
184    
185            dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
186            if (dec == NULL) {
187                    return XVID_ERR_MEMORY;
188            }
189    
190            memset(dec, 0, sizeof(DECODER));
191    
192            dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
193            if (dec->mpeg_quant_matrices == NULL) {
194                  xvid_free(dec);                  xvid_free(dec);
195                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
196          }          }
197    
198            create->handle = dec;
199    
200            dec->width = create->width;
201            dec->height = create->height;
202    
203            image_null(&dec->cur);
204            image_null(&dec->refn[0]);
205            image_null(&dec->refn[1]);
206            image_null(&dec->tmp);
207            image_null(&dec->qtmp);
208    
209            /* image based GMC */
210            image_null(&dec->gmc);
211    
212            dec->mbs = NULL;
213            dec->last_mbs = NULL;
214            dec->qscale = NULL;
215    
216          init_timer();          init_timer();
217            init_postproc(&dec->postproc);
218            init_mpeg_matrix(dec->mpeg_quant_matrices);
219    
220          // add by chenm001 <chenm001@163.com>          /* For B-frame support (used to save reference frame's time */
221          // for support B-frame to save reference frame's time          dec->frames = 0;
         dec->frames = -1;  
222          dec->time = dec->time_base = dec->last_time_base = 0;          dec->time = dec->time_base = dec->last_time_base = 0;
223            dec->low_delay = 0;
224            dec->packed_mode = 0;
225            dec->time_inc_resolution = 1; /* until VOL header says otherwise */
226    
227            dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
228    
229          return XVID_ERR_OK;          if (dec->fixed_dimensions)
230                    return decoder_resize(dec);
231            else
232                    return 0;
233  }  }
234    
235    
236  int decoder_destroy(DECODER * dec)  int
237    decoder_destroy(DECODER * dec)
238  {  {
239          xvid_free(dec->last_mbs);          xvid_free(dec->last_mbs);
240          xvid_free(dec->mbs);          xvid_free(dec->mbs);
241            xvid_free(dec->qscale);
242    
243            /* image based GMC */
244            image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
245    
246          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
247          image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);          image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
248          image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);          image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
249            image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
250          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
251            xvid_free(dec->mpeg_quant_matrices);
252          xvid_free(dec);          xvid_free(dec);
253    
254          write_timer();          write_timer();
255          return XVID_ERR_OK;          return 0;
256  }  }
257    
258    static const int32_t dquant_table[4] = {
   
 static const int32_t dquant_table[4] =  
 {  
259          -1, -2, 1, 2          -1, -2, 1, 2
260  };  };
261    
262    /* decode an intra macroblock */
263    static void
264    decoder_mbintra(DECODER * dec,
 // decode an intra macroblock  
   
 void decoder_mbintra(DECODER * dec,  
265                       MACROBLOCK * pMB,                       MACROBLOCK * pMB,
266                       const uint32_t x_pos,                       const uint32_t x_pos,
267                       const uint32_t y_pos,                       const uint32_t y_pos,
# Line 196  Line 269 
269                       const uint32_t cbp,                       const uint32_t cbp,
270                       Bitstream * bs,                       Bitstream * bs,
271                       const uint32_t quant,                       const uint32_t quant,
272                       const uint32_t intra_dc_threshold)                                  const uint32_t intra_dc_threshold,
273                                    const unsigned int bound)
274  {  {
275    
276          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
# Line 213  Line 287 
287          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
288          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
289    
290          memset(block, 0, 6*64*sizeof(int16_t));         // clear          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */
291    
292          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++) {
         {  
293                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
294                  int16_t predictors[8];                  int16_t predictors[8];
295                  int start_coeff;                  int start_coeff;
296    
297                  start_timer();                  start_timer();
298                  predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i*64], iQuant, iDcScaler, predictors);                  predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],
299                  if (!acpred_flag)                                           iQuant, iDcScaler, predictors, bound);
300                  {                  if (!acpred_flag) {
301                          pMB->acpred_directions[i] = 0;                          pMB->acpred_directions[i] = 0;
302                  }                  }
303                  stop_prediction_timer();                  stop_prediction_timer();
304    
305                  if (quant < intra_dc_threshold)                  if (quant < intra_dc_threshold) {
                 {  
306                          int dc_size;                          int dc_size;
307                          int dc_dif;                          int dc_dif;
308    
309                          dc_size = i < 4 ?  get_dc_size_lum(bs) : get_dc_size_chrom(bs);                          dc_size = i < 4 ?  get_dc_size_lum(bs) : get_dc_size_chrom(bs);
310                          dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0 ;                          dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0 ;
311    
312                          if (dc_size > 8)                          if (dc_size > 8) {
313                          {                                  BitstreamSkip(bs, 1);   /* marker */
                                 BitstreamSkip(bs, 1);           // marker  
314                          }                          }
315    
316                          block[i*64 + 0] = dc_dif;                          block[i*64 + 0] = dc_dif;
317                          start_coeff = 1;                          start_coeff = 1;
318                  }  
319                  else                          DPRINTF(XVID_DEBUG_COEFF,"block[0] %i\n", dc_dif);
320                  {                  } else {
321                          start_coeff = 0;                          start_coeff = 0;
322                  }                  }
323    
324                  start_timer();                  start_timer();
325                  if (cbp & (1 << (5-i)))                 // coded                  if (cbp & (1 << (5 - i)))       /* coded */
326                  {                  {
327                          get_intra_block(bs, &block[i*64], pMB->acpred_directions[i], start_coeff);                          int direction = dec->alternate_vertical_scan ?
328                                    2 : pMB->acpred_directions[i];
329    
330                            get_intra_block(bs, &block[i * 64], direction, start_coeff);
331                  }                  }
332                  stop_coding_timer();                  stop_coding_timer();
333    
334                  start_timer();                  start_timer();
335                  add_acdc(pMB, i, &block[i*64], iDcScaler, predictors);                  add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors, dec->bs_version);
336                  stop_prediction_timer();                  stop_prediction_timer();
337    
338                  start_timer();                  start_timer();
339                  if (dec->quant_type == 0)                  if (dec->quant_type == 0) {
340                  {                          dequant_h263_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
341                          dequant_intra(&data[i*64], &block[i*64], iQuant, iDcScaler);                  } else {
342                  }                          dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
                 else  
                 {  
                         dequant4_intra(&data[i*64], &block[i*64], iQuant, iDcScaler);  
343                  }                  }
344                  stop_iquant_timer();                  stop_iquant_timer();
345    
346                  start_timer();                  start_timer();
347                  idct(&data[i*64]);                  idct(&data[i*64]);
348                  stop_idct_timer();                  stop_idct_timer();
349    
350          }          }
351    
352          if (dec->interlacing && pMB->field_dct)          if (dec->interlacing && pMB->field_dct) {
         {  
353                  next_block = stride;                  next_block = stride;
354                  stride *= 2;                  stride *= 2;
355          }          }
# Line 293  Line 364 
364          stop_transfer_timer();          stop_transfer_timer();
365  }  }
366    
367    static void
368    decoder_mb_decode(DECODER * dec,
369                                    const uint32_t cbp,
370                                    Bitstream * bs,
371                                    uint8_t * pY_Cur,
372                                    uint8_t * pU_Cur,
373                                    uint8_t * pV_Cur,
374                                    const MACROBLOCK * pMB)
375    {
376            DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
377    
378            int stride = dec->edged_width;
379            int next_block = stride * 8;
380            int i;
381            const uint32_t iQuant = pMB->quant;
382            const int direction = dec->alternate_vertical_scan ? 2 : 0;
383            typedef void (*get_inter_block_function_t)(
384                            Bitstream * bs,
385                            int16_t * block,
386                            int direction,
387                            const int quant,
388                            const uint16_t *matrix);
389            typedef void (*add_residual_function_t)(
390                            uint8_t *predicted_block,
391                            const int16_t *residual,
392                            int stride);
393    
394            const get_inter_block_function_t get_inter_block = (dec->quant_type == 0)
395                    ? (get_inter_block_function_t)get_inter_block_h263
396                    : (get_inter_block_function_t)get_inter_block_mpeg;
397    
398            uint8_t *dst[6];
399            int strides[6];
400    
401    
402            if (dec->interlacing && pMB->field_dct) {
403                    next_block = stride;
404                    stride *= 2;
405            }
406    
407            dst[0] = pY_Cur;
408            dst[2] = pY_Cur + next_block;
409            dst[1] = dst[0] + 8;
410            dst[3] = dst[2] + 8;
411            dst[4] = pU_Cur;
412            dst[5] = pV_Cur;
413            strides[0] = strides[1] = strides[2] = strides[3] = stride;
414            strides[4] = stride/2;
415            strides[5] = stride/2;
416    
417            for (i = 0; i < 6; i++) {
418                    /* Process only coded blocks */
419                    if (cbp & (1 << (5 - i))) {
420    
421                            /* Clear the block */
422                            memset(&data[0], 0, 64*sizeof(int16_t));
423    
424  #define SIGN(X) (((X)>0)?1:-1)                          /* Decode coeffs and dequantize on the fly */
425  #define ABS(X) (((X)>0)?(X):-(X))                          start_timer();
426  static const uint32_t roundtab[16] =                          get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
427  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };                          stop_coding_timer();
428    
429                            /* iDCT */
430                            start_timer();
431                            idct(&data[0]);
432                            stop_idct_timer();
433    
434  // decode an inter macroblock                          /* Add this residual to the predicted block */
435                            start_timer();
436                            transfer_16to8add(dst[i], &data[0], strides[i]);
437                            stop_transfer_timer();
438                    }
439            }
440    }
441    
442  void decoder_mbinter(DECODER * dec,  static void __inline
443    validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
444    {
445            /* clip a vector to valid range
446               prevents crashes if bitstream is broken
447            */
448            int shift = 5 + dec->quarterpel;
449            int xborder_high = (int)(dec->mb_width - x_pos) << shift;
450            int xborder_low = (-(int)x_pos-1) << shift;
451            int yborder_high = (int)(dec->mb_height - y_pos) << shift;
452            int yborder_low = (-(int)y_pos-1) << shift;
453    
454    #define CHECK_MV(mv) \
455            do { \
456            if ((mv).x > xborder_high) { \
457                    DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
458                    (mv).x = xborder_high; \
459            } else if ((mv).x < xborder_low) { \
460                    DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
461                    (mv).x = xborder_low; \
462            } \
463            if ((mv).y > yborder_high) { \
464                    DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
465                    (mv).y = yborder_high; \
466            } else if ((mv).y < yborder_low) { \
467                    DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
468                    (mv).y = yborder_low; \
469            } \
470            } while (0)
471    
472            CHECK_MV(mv[0]);
473            CHECK_MV(mv[1]);
474            CHECK_MV(mv[2]);
475            CHECK_MV(mv[3]);
476    }
477    
478    /* decode an inter macroblock */
479    static void
480    decoder_mbinter(DECODER * dec,
481                       const MACROBLOCK * pMB,                       const MACROBLOCK * pMB,
482                       const uint32_t x_pos,                       const uint32_t x_pos,
483                       const uint32_t y_pos,                       const uint32_t y_pos,
                      const uint32_t acpred_flag,  
484                       const uint32_t cbp,                       const uint32_t cbp,
485                       Bitstream * bs,                       Bitstream * bs,
486                       const uint32_t quant,                                  const uint32_t rounding,
487                       const uint32_t rounding)                                  const int ref)
488  {  {
   
         DECLARE_ALIGNED_MATRIX(block,6, 64, int16_t, CACHE_LINE);  
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
   
489          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
490          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
         uint32_t next_block = stride * 8;  
491          uint32_t i;          uint32_t i;
492          uint32_t iQuant = pMB->quant;  
493          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
494    
495          int uv_dx, uv_dy;          int uv_dx, uv_dy;
496            VECTOR mv[4];   /* local copy of mvs */
497    
498          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
499          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
500          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
501            for (i = 0; i < 4; i++)
502                    mv[i] = pMB->mvs[i];
503    
504          if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)          validate_vector(mv, x_pos, y_pos, dec);
         {  
                 uv_dx = pMB->mvs[0].x;  
                 uv_dy = pMB->mvs[0].y;  
505    
506                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;          start_timer();
                 uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
         }  
         else  
         {  
                 int sum;  
                 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
                 uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );  
507    
508                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;          if (pMB->mode != MODE_INTER4V) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
509                  uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );  
510                    uv_dx = mv[0].x;
511                    uv_dy = mv[0].y;
512                    if (dec->quarterpel) {
513                            uv_dx /= 2;
514                            uv_dy /= 2;
515          }          }
516                    uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
517                    uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
518    
519          start_timer();                  if (dec->quarterpel)
520          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos,     16*y_pos    , pMB->mvs[0].x, pMB->mvs[0].y, stride,  rounding);                          interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,
521          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos    , pMB->mvs[1].x, pMB->mvs[1].y, stride,  rounding);                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
522          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos,     16*y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,  rounding);                                                                                          mv[0].x, mv[0].y, stride, rounding);
523          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,  rounding);                  else
524          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, rounding);                          interpolate16x16_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos, 16*y_pos,
525          interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, rounding);                                                                          mv[0].x, mv[0].y, stride, rounding);
         stop_comp_timer();  
526    
527          for (i = 0; i < 6; i++)          } else {        /* MODE_INTER4V */
         {  
                 if (cbp & (1 << (5-i)))                 // coded  
                 {  
                         memset(&block[i*64], 0, 64 * sizeof(int16_t));          // clear  
528    
529                          start_timer();                  if(dec->quarterpel) {
530                          get_inter_block(bs, &block[i*64]);                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
531                          stop_coding_timer();                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
532                    } else {
533                            uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
534                            uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
535                    }
536    
537                          start_timer();                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
538                          if (dec->quant_type == 0)                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
539                          {  
540                                  dequant_inter(&data[i*64], &block[i*64], iQuant);                  if (dec->quarterpel) {
541                            interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
542                                                                            dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
543                                                                            mv[0].x, mv[0].y, stride, rounding);
544                            interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
545                                                                            dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
546                                                                            mv[1].x, mv[1].y, stride, rounding);
547                            interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
548                                                                            dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
549                                                                            mv[2].x, mv[2].y, stride, rounding);
550                            interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
551                                                                            dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
552                                                                            mv[3].x, mv[3].y, stride, rounding);
553                    } else {
554                            interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos, 16*y_pos,
555                                                                    mv[0].x, mv[0].y, stride, rounding);
556                            interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos + 8, 16*y_pos,
557                                                                    mv[1].x, mv[1].y, stride, rounding);
558                            interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos, 16*y_pos + 8,
559                                                                    mv[2].x, mv[2].y, stride, rounding);
560                            interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos + 8, 16*y_pos + 8,
561                                                                    mv[3].x, mv[3].y, stride, rounding);
562                          }                          }
                         else  
                         {  
                                 dequant4_inter(&data[i*64], &block[i*64], iQuant);  
563                          }                          }
                         stop_iquant_timer();  
564    
565                          start_timer();          /* chroma */
566                          idct(&data[i*64]);          interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
567                          stop_idct_timer();                                                          uv_dx, uv_dy, stride2, rounding);
568                  }          interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
569                                                            uv_dx, uv_dy, stride2, rounding);
570    
571            stop_comp_timer();
572    
573            if (cbp)
574                    decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
575          }          }
576    
577          if (dec->interlacing && pMB->field_dct)  static void
578    decoder_mbgmc(DECODER * dec,
579                                    MACROBLOCK * const pMB,
580                                    const uint32_t x_pos,
581                                    const uint32_t y_pos,
582                                    const uint32_t fcode,
583                                    const uint32_t cbp,
584                                    Bitstream * bs,
585                                    const uint32_t rounding)
586          {          {
587                  next_block = stride;          const uint32_t stride = dec->edged_width;
588                  stride *= 2;          const uint32_t stride2 = stride / 2;
589          }  
590            uint8_t *const pY_Cur=dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
591            uint8_t *const pU_Cur=dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
592            uint8_t *const pV_Cur=dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
593    
594            NEW_GMC_DATA * gmc_data = &dec->new_gmc_data;
595    
596            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
597    
598          start_timer();          start_timer();
599          if (cbp & 32)  
600                  transfer_16to8add(pY_Cur,                  &data[0*64], stride);  /* this is where the calculations are done */
601          if (cbp & 16)  
602                  transfer_16to8add(pY_Cur + 8,              &data[1*64], stride);          gmc_data->predict_16x16(gmc_data,
603          if (cbp & 8)                          dec->cur.y + y_pos*16*stride + x_pos*16, dec->refn[0].y,
604                  transfer_16to8add(pY_Cur + next_block,     &data[2*64], stride);                          stride, stride, x_pos, y_pos, rounding);
605          if (cbp & 4)  
606                  transfer_16to8add(pY_Cur + 8 + next_block, &data[3*64], stride);          gmc_data->predict_8x8(gmc_data,
607          if (cbp & 2)                          dec->cur.u + y_pos*8*stride2 + x_pos*8, dec->refn[0].u,
608                  transfer_16to8add(pU_Cur,                  &data[4*64], stride2);                          dec->cur.v + y_pos*8*stride2 + x_pos*8, dec->refn[0].v,
609          if (cbp & 1)                          stride2, stride2, x_pos, y_pos, rounding);
610                  transfer_16to8add(pV_Cur,                  &data[5*64], stride2);  
611            gmc_data->get_average_mv(gmc_data, &pMB->amv, x_pos, y_pos, dec->quarterpel);
612    
613            pMB->amv.x = gmc_sanitize(pMB->amv.x, dec->quarterpel, fcode);
614            pMB->amv.y = gmc_sanitize(pMB->amv.y, dec->quarterpel, fcode);
615    
616            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
617    
618          stop_transfer_timer();          stop_transfer_timer();
619    
620            if (cbp)
621                    decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
622    
623  }  }
624    
625    
626  void decoder_iframe(DECODER * dec, Bitstream * bs, int quant, int intra_dc_threshold)  static void
627    decoder_iframe(DECODER * dec,
628                                    Bitstream * bs,
629                                    int quant,
630                                    int intra_dc_threshold)
631  {  {
632            uint32_t bound;
633          uint32_t x, y;          uint32_t x, y;
634            const uint32_t mb_width = dec->mb_width;
635            const uint32_t mb_height = dec->mb_height;
636    
637          for (y = 0; y < dec->mb_height; y++)          bound = 0;
         {  
                 for (x = 0; x < dec->mb_width; x++)  
                 {  
                         MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];  
638    
639            for (y = 0; y < mb_height; y++) {
640                    for (x = 0; x < mb_width; x++) {
641                            MACROBLOCK *mb;
642                          uint32_t mcbpc;                          uint32_t mcbpc;
643                          uint32_t cbpc;                          uint32_t cbpc;
644                          uint32_t acpred_flag;                          uint32_t acpred_flag;
645                          uint32_t cbpy;                          uint32_t cbpy;
646                          uint32_t cbp;                          uint32_t cbp;
647    
648                            while (BitstreamShowBits(bs, 9) == 1)
649                                    BitstreamSkip(bs, 9);
650    
651                            if (check_resync_marker(bs, 0))
652                            {
653                                    bound = read_video_packet_header(bs, dec, 0,
654                                                            &quant, NULL, NULL, &intra_dc_threshold);
655                                    x = bound % mb_width;
656                                    y = bound / mb_width;
657                            }
658                            mb = &dec->mbs[y * dec->mb_width + x];
659    
660                            DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
661    
662                          mcbpc = get_mcbpc_intra(bs);                          mcbpc = get_mcbpc_intra(bs);
663                          mb->mode = mcbpc & 7;                          mb->mode = mcbpc & 7;
664                          cbpc = (mcbpc >> 4);                          cbpc = (mcbpc >> 4);
665    
666                          acpred_flag = BitstreamGetBit(bs);                          acpred_flag = BitstreamGetBit(bs);
667    
                         if (mb->mode == MODE_STUFFING)  
                         {  
                                 DEBUG("-- STUFFING ?");  
                                 continue;  
                         }  
   
668                          cbpy = get_cbpy(bs, 1);                          cbpy = get_cbpy(bs, 1);
669                          cbp = (cbpy << 2) | cbpc;                          cbp = (cbpy << 2) | cbpc;
670    
671                          if (mb->mode == MODE_INTRA_Q)                          if (mb->mode == MODE_INTRA_Q) {
                         {  
672                                  quant += dquant_table[BitstreamGetBits(bs,2)];                                  quant += dquant_table[BitstreamGetBits(bs,2)];
673                                  if (quant > 31)                                  if (quant > 31) {
                                 {  
674                                          quant = 31;                                          quant = 31;
675                                  }                                  } else if (quant < 1) {
                                 else if (quant < 1)  
                                 {  
676                                          quant = 1;                                          quant = 1;
677                                  }                                  }
678                          }                          }
679                          mb->quant = quant;                          mb->quant = quant;
680                            mb->mvs[0].x = mb->mvs[0].y =
681                            mb->mvs[1].x = mb->mvs[1].y =
682                            mb->mvs[2].x = mb->mvs[2].y =
683                            mb->mvs[3].x = mb->mvs[3].y =0;
684    
685                          if (dec->interlacing)                          if (dec->interlacing) {
                         {  
686                                  mb->field_dct = BitstreamGetBit(bs);                                  mb->field_dct = BitstreamGetBit(bs);
687                                  DEBUG1("deci: field_dct: ", mb->field_dct);                                  DPRINTF(XVID_DEBUG_MB,"deci: field_dct: %i\n", mb->field_dct);
688                          }                          }
689    
690                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant, intra_dc_threshold);                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
691                                                            intra_dc_threshold, bound);
692    
693                  }                  }
694                    if(dec->out_frm)
695                            output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,mb_width);
696          }          }
697    
698  }  }
699    
700    
701  void get_motion_vector(DECODER *dec, Bitstream *bs, int x, int y, int k, VECTOR * mv, int fcode)  static void
702    get_motion_vector(DECODER * dec,
703                                    Bitstream * bs,
704                                    int x,
705                                    int y,
706                                    int k,
707                                    VECTOR * ret_mv,
708                                    int fcode,
709                                    const int bound)
710  {  {
711    
712          int scale_fac = 1 << (fcode - 1);          const int scale_fac = 1 << (fcode - 1);
713          int high = (32 * scale_fac) - 1;          const int high = (32 * scale_fac) - 1;
714          int low = ((-32) * scale_fac);          const int low = ((-32) * scale_fac);
715          int range = (64 * scale_fac);          const int range = (64 * scale_fac);
   
         VECTOR pmv[4];  
         int32_t psad[4];  
   
         int mv_x, mv_y;  
         int pmv_x, pmv_y;  
   
716    
717          get_pmvdata(dec->mbs, x, y, dec->mb_width, k, pmv, psad);          const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
718            VECTOR mv;
719    
720          pmv_x = pmv[0].x;          mv.x = get_mv(bs, fcode);
721          pmv_y = pmv[0].y;          mv.y = get_mv(bs, fcode);
722    
723          mv_x = get_mv(bs, fcode);          DPRINTF(XVID_DEBUG_MV,"mv_diff (%i,%i) pred (%i,%i) result (%i,%i)\n", mv.x, mv.y, pmv.x, pmv.y, mv.x+pmv.x, mv.y+pmv.y);
         mv_y = get_mv(bs, fcode);  
724    
725          mv_x += pmv_x;          mv.x += pmv.x;
726          mv_y += pmv_y;          mv.y += pmv.y;
727    
728          if (mv_x < low)          if (mv.x < low) {
729          {                  mv.x += range;
730                  mv_x += range;          } else if (mv.x > high) {
731                    mv.x -= range;
732          }          }
733          else if (mv_x > high)  
734          {          if (mv.y < low) {
735                  mv_x -= range;                  mv.y += range;
736            } else if (mv.y > high) {
737                    mv.y -= range;
738          }          }
739    
740          if (mv_y < low)          ret_mv->x = mv.x;
741          {          ret_mv->y = mv.y;
                 mv_y += range;  
742          }          }
743          else if (mv_y > high)  
744    /* for P_VOP set gmc_warp to NULL */
745    static void
746    decoder_pframe(DECODER * dec,
747                                    Bitstream * bs,
748                                    int rounding,
749                                    int quant,
750                                    int fcode,
751                                    int intra_dc_threshold,
752                                    const WARPPOINTS *const gmc_warp)
753          {          {
754                  mv_y -= range;          uint32_t x, y;
755            uint32_t bound;
756            int cp_mb, st_mb;
757            const uint32_t mb_width = dec->mb_width;
758            const uint32_t mb_height = dec->mb_height;
759    
760            if (!dec->is_edged[0]) {
761                    start_timer();
762                    image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
763                                                    dec->width, dec->height, dec->bs_version);
764                    dec->is_edged[0] = 1;
765                    stop_edges_timer();
766          }          }
767    
768          mv->x = mv_x;          if (gmc_warp) {
769          mv->y = mv_y;                  /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
770                    generate_GMCparameters( dec->sprite_warping_points,
771                                    dec->sprite_warping_accuracy, gmc_warp,
772                                    dec->width, dec->height, &dec->new_gmc_data);
773    
774                    /* image warping is done block-based in decoder_mbgmc(), now */
775  }  }
776    
777            bound = 0;
778    
779  void decoder_pframe(DECODER * dec, Bitstream * bs, int rounding, int quant, int fcode, int intra_dc_threshold)          for (y = 0; y < mb_height; y++) {
780  {                  cp_mb = st_mb = 0;
781                    for (x = 0; x < mb_width; x++) {
782                            MACROBLOCK *mb;
783    
784          uint32_t x, y;                          /* skip stuffing */
785                            while (BitstreamShowBits(bs, 10) == 1)
786                                    BitstreamSkip(bs, 10);
787    
788          start_timer();                          if (check_resync_marker(bs, fcode - 1)) {
789          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height, dec->width, dec->height, dec->interlacing);                                  bound = read_video_packet_header(bs, dec, fcode - 1,
790          stop_edges_timer();                                          &quant, &fcode, NULL, &intra_dc_threshold);
791                                    x = bound % mb_width;
792                                    y = bound / mb_width;
793                            }
794                            mb = &dec->mbs[y * dec->mb_width + x];
795    
796          for (y = 0; y < dec->mb_height; y++)                          DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
         {  
                 for (x = 0; x < dec->mb_width; x++)  
                 {  
                         MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];  
797    
798                          //if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs)))                 // not_coded                          if (!(BitstreamGetBit(bs)))     { /* block _is_ coded */
799                          if (!(BitstreamGetBit(bs)))                     // not_coded                                  uint32_t mcbpc, cbpc, cbpy, cbp;
800                          {                                  uint32_t intra, acpred_flag = 0;
801                                  uint32_t mcbpc;                                  int mcsel = 0;          /* mcsel: '0'=local motion, '1'=GMC */
                                 uint32_t cbpc;  
                                 uint32_t acpred_flag;  
                                 uint32_t cbpy;  
                                 uint32_t cbp;  
                                 uint32_t intra;  
802    
803                                    cp_mb++;
804                                  mcbpc = get_mcbpc_inter(bs);                                  mcbpc = get_mcbpc_inter(bs);
805                                  mb->mode = mcbpc & 7;                                  mb->mode = mcbpc & 7;
806                                  cbpc = (mcbpc >> 4);                                  cbpc = (mcbpc >> 4);
807                                  acpred_flag = 0;  
808                                    DPRINTF(XVID_DEBUG_MB, "mode %i\n", mb->mode);
809                                    DPRINTF(XVID_DEBUG_MB, "cbpc %i\n", cbpc);
810    
811                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);
812    
813                                  if (intra)                                  if (gmc_warp && (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q))
814                                  {                                          mcsel = BitstreamGetBit(bs);
815                                    else if (intra)
816                                          acpred_flag = BitstreamGetBit(bs);                                          acpred_flag = BitstreamGetBit(bs);
                                 }  
   
                                 if (mb->mode == MODE_STUFFING)  
                                 {  
                                         DEBUG("-- STUFFING ?");  
                                         continue;  
                                 }  
817    
818                                  cbpy = get_cbpy(bs, intra);                                  cbpy = get_cbpy(bs, intra);
819                                    DPRINTF(XVID_DEBUG_MB, "cbpy %i mcsel %i \n", cbpy,mcsel);
820    
821                                  cbp = (cbpy << 2) | cbpc;                                  cbp = (cbpy << 2) | cbpc;
822    
823                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q)                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {
824                                  {                                          int dquant = dquant_table[BitstreamGetBits(bs, 2)];
825                                          quant += dquant_table[BitstreamGetBits(bs,2)];                                          DPRINTF(XVID_DEBUG_MB, "dquant %i\n", dquant);
826                                          if (quant > 31)                                          quant += dquant;
827                                          {                                          if (quant > 31) {
828                                                  quant = 31;                                                  quant = 31;
829                                          }                                          } else if (quant < 1) {
                                         else if (mb->quant < 1)  
                                         {  
830                                                  quant = 1;                                                  quant = 1;
831                                          }                                          }
832                                            DPRINTF(XVID_DEBUG_MB, "quant %i\n", quant);
833                                  }                                  }
834                                  mb->quant = quant;                                  mb->quant = quant;
835    
836                                  if (dec->interlacing)                                  if (dec->interlacing) {
837                                  {                                          if (cbp || intra) {
838                                          mb->field_dct = BitstreamGetBit(bs);                                          mb->field_dct = BitstreamGetBit(bs);
839                                          DEBUG1("decp: field_dct: ", mb->field_dct);                                                  DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
840                                            }
841    
842                                          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q)                                          if ((mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) && !mcsel) {
                                         {  
843                                                  mb->field_pred = BitstreamGetBit(bs);                                                  mb->field_pred = BitstreamGetBit(bs);
844                                                  DEBUG1("decp: field_pred: ", mb->field_pred);                                                  DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
845    
846                                                  if (mb->field_pred)                                                  if (mb->field_pred) {
                                                 {  
847                                                          mb->field_for_top = BitstreamGetBit(bs);                                                          mb->field_for_top = BitstreamGetBit(bs);
848                                                          DEBUG1("decp: field_for_top: ", mb->field_for_top);                                                          DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
849                                                          mb->field_for_bot = BitstreamGetBit(bs);                                                          mb->field_for_bot = BitstreamGetBit(bs);
850                                                          DEBUG1("decp: field_for_bot: ", mb->field_for_bot);                                                          DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
851                                                  }                                                  }
852                                          }                                          }
853                                  }                                  }
854    
855                                  if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q)                                  if (mcsel) {
856                                  {                                          decoder_mbgmc(dec, mb, x, y, fcode, cbp, bs, rounding);
857                                          if (dec->interlacing && mb->field_pred)                                          continue;
858                                          {  
859                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
860                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1], fcode);  
861                                          }                                          if (dec->interlacing && mb->field_pred) {
862                                          else                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
863                                          {                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1], fcode, bound);
864                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);                                          } else {
865                                                  mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
866                                                  mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
                                         }  
867                                  }                                  }
868                                  else if (mb->mode == MODE_INTER4V /* || mb->mode == MODE_INTER4V_Q */)                                  } else if (mb->mode == MODE_INTER4V ) {
869                                  {                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
870                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
871                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
872                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode);                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
873                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode);                                  } else {                /* MODE_INTRA, MODE_INTRA_Q */
                                 }  
                                 else  // MODE_INTRA, MODE_INTRA_Q  
                                 {  
874                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
875                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
876                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant, intra_dc_threshold);                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
877                                                                            intra_dc_threshold, bound);
878                                          continue;                                          continue;
879                                  }                                  }
880    
881                                  decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant, rounding);                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);
882    
883                            } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
884                                    mb->mode = MODE_NOT_CODED_GMC;
885                                    mb->quant = quant;
886                                    decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
887    
888                                    if(dec->out_frm && cp_mb > 0) {
889                                            output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
890                                            cp_mb = 0;
891                          }                          }
892                          else    // not coded                                  st_mb = x+1;
893                          {                          } else {        /* not coded P_VOP macroblock */
                                 //DEBUG2("P-frame MB at (X,Y)=",x,y);  
894                                  mb->mode = MODE_NOT_CODED;                                  mb->mode = MODE_NOT_CODED;
895                                    mb->quant = quant;
896    
897                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
898                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
899    
900                                  // copy macroblock directly from ref to cur                                  decoder_mbinter(dec, mb, x, y, 0, bs,
901                                                                    rounding, 0);
902    
903                                  start_timer();                                  if(dec->out_frm && cp_mb > 0) {
904                                            output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
905                                  transfer8x8_copy(dec->cur.y + (16*y)*dec->edged_width + (16*x),                                          cp_mb = 0;
                                                  dec->refn[0].y + (16*y)*dec->edged_width + (16*x),  
                                                  dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.y + (16*y)*dec->edged_width + (16*x+8),  
                                                  dec->refn[0].y + (16*y)*dec->edged_width + (16*x+8),  
                                                  dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.y + (16*y+8)*dec->edged_width + (16*x),  
                                                  dec->refn[0].y + (16*y+8)*dec->edged_width + (16*x),  
                                                  dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.y + (16*y+8)*dec->edged_width + (16*x+8),  
                                                  dec->refn[0].y + (16*y+8)*dec->edged_width + (16*x+8),  
                                                  dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.u + (8*y)*dec->edged_width/2 + (8*x),  
                                                  dec->refn[0].u + (8*y)*dec->edged_width/2 + (8*x),  
                                                  dec->edged_width/2);  
   
                                 transfer8x8_copy(dec->cur.v + (8*y)*dec->edged_width/2 + (8*x),  
                                                  dec->refn[0].v + (8*y)*dec->edged_width/2 + (8*x),  
                                                  dec->edged_width/2);  
   
                                 stop_transfer_timer();  
                         }  
906                  }                  }
907                                    st_mb = x+1;
908          }          }
909  }  }
910    
911                    if(dec->out_frm && cp_mb > 0)
912                            output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
913            }
914    }
915    
 // add by MinChen <chenm001@163.com>  
 // decode B-frame motion vector  
 void get_b_motion_vector(DECODER *dec, Bitstream *bs, int x, int y, VECTOR * mv, int fcode, const VECTOR pmv)  
 {  
         int scale_fac = 1 << (fcode - 1);  
         int high = (32 * scale_fac) - 1;  
         int low = ((-32) * scale_fac);  
         int range = (64 * scale_fac);  
   
         int mv_x, mv_y;  
         int pmv_x, pmv_y;  
916    
917          pmv_x = pmv.x;  /* decode B-frame motion vector */
918          pmv_y = pmv.y;  static void
919    get_b_motion_vector(Bitstream * bs,
920                                            VECTOR * mv,
921                                            int fcode,
922                                            const VECTOR pmv,
923                                            const DECODER * const dec,
924                                            const int x, const int y)
925    {
926            const int scale_fac = 1 << (fcode - 1);
927            const int high = (32 * scale_fac) - 1;
928            const int low = ((-32) * scale_fac);
929            const int range = (64 * scale_fac);
930    
931          mv_x = get_mv(bs, fcode);          int mv_x = get_mv(bs, fcode);
932          mv_y = get_mv(bs, fcode);          int mv_y = get_mv(bs, fcode);
933    
934          mv_x += pmv_x;          mv_x += pmv.x;
935          mv_y += pmv_y;          mv_y += pmv.y;
936    
937          if (mv_x < low)          if (mv_x < low)
         {  
938                  mv_x += range;                  mv_x += range;
         }  
939          else if (mv_x > high)          else if (mv_x > high)
         {  
940                  mv_x -= range;                  mv_x -= range;
         }  
941    
942          if (mv_y < low)          if (mv_y < low)
         {  
943                  mv_y += range;                  mv_y += range;
         }  
944          else if (mv_y > high)          else if (mv_y > high)
         {  
945                  mv_y -= range;                  mv_y -= range;
         }  
946    
947          mv->x = mv_x;          mv->x = mv_x;
948          mv->y = mv_y;          mv->y = mv_y;
949  }  }
950    
951    /* decode an B-frame direct & interpolate macroblock */
952  // add by MinChen <chenm001@163.com>  static void
953  // decode an B-frame forward & backward inter macroblock  decoder_bf_interpolate_mbinter(DECODER * dec,
954  void decoder_bf_mbinter(DECODER * dec,                                                                  IMAGE forward,
955                       const MACROBLOCK * pMB,                                                                  IMAGE backward,
956                                                                    MACROBLOCK * pMB,
957                       const uint32_t x_pos,                       const uint32_t x_pos,
958                       const uint32_t y_pos,                       const uint32_t y_pos,
                      const uint32_t cbp,  
959                       Bitstream * bs,                       Bitstream * bs,
960                       const uint32_t quant,                                                                  const int direct)
                          const uint8_t ref)  
 {  
   
         DECLARE_ALIGNED_MATRIX(block,6, 64, int16_t, CACHE_LINE);  
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
   
         uint32_t stride = dec->edged_width;  
         uint32_t stride2 = stride / 2;  
         uint32_t next_block = stride * 8;  
         uint32_t i;  
         uint32_t iQuant = pMB->quant;  
         uint8_t *pY_Cur, *pU_Cur, *pV_Cur;  
         int uv_dx, uv_dy;  
   
         pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);  
         pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);  
         pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);  
   
         if (!(pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q))  
         {  
                 uv_dx = pMB->mvs[0].x;  
                 uv_dy = pMB->mvs[0].y;  
   
                 uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;  
                 uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
         }  
         else  
         {  
                 int sum;  
                 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
                 uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );  
   
                 sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;  
                 uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );  
         }  
   
         start_timer();  
         interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos,     16*y_pos    , pMB->mvs[0].x, pMB->mvs[0].y, stride,  0);  
         interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos + 8, 16*y_pos    , pMB->mvs[1].x, pMB->mvs[1].y, stride,  0);  
         interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos,     16*y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,  0);  
         interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos + 8, 16*y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,  0);  
         interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, 0);  
         interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, 0);  
         stop_comp_timer();  
   
         for (i = 0; i < 6; i++)  
         {  
                 if (cbp & (1 << (5-i)))                 // coded  
                 {  
                         memset(&block[i*64], 0, 64 * sizeof(int16_t));          // clear  
   
                         start_timer();  
                         get_inter_block(bs, &block[i*64]);  
                         stop_coding_timer();  
   
                         start_timer();  
                         if (dec->quant_type == 0)  
                         {  
                                 dequant_inter(&data[i*64], &block[i*64], iQuant);  
                         }  
                         else  
961                          {                          {
                                 dequant4_inter(&data[i*64], &block[i*64], iQuant);  
                         }  
                         stop_iquant_timer();  
   
                         start_timer();  
                         idct(&data[i*64]);  
                         stop_idct_timer();  
                 }  
         }  
   
         if (dec->interlacing && pMB->field_dct)  
         {  
                 next_block = stride;  
                 stride *= 2;  
         }  
   
         start_timer();  
         if (cbp & 32)  
                 transfer_16to8add(pY_Cur,                  &data[0*64], stride);  
         if (cbp & 16)  
                 transfer_16to8add(pY_Cur + 8,              &data[1*64], stride);  
         if (cbp & 8)  
                 transfer_16to8add(pY_Cur + next_block,     &data[2*64], stride);  
         if (cbp & 4)  
                 transfer_16to8add(pY_Cur + 8 + next_block, &data[3*64], stride);  
         if (cbp & 2)  
                 transfer_16to8add(pU_Cur,                  &data[4*64], stride2);  
         if (cbp & 1)  
                 transfer_16to8add(pV_Cur,                  &data[5*64], stride2);  
         stop_transfer_timer();  
 }  
   
   
 // add by MinChen <chenm001@163.com>  
 // decode an B-frame direct &  inter macroblock  
 void decoder_bf_interpolate_mbinter(DECODER * dec,  
                          IMAGE forward, IMAGE backward,  
                      const MACROBLOCK * pMB,  
                      const uint32_t x_pos,  
                      const uint32_t y_pos,  
                      const uint32_t cbp,  
                      Bitstream * bs )  
 {  
   
         DECLARE_ALIGNED_MATRIX(block,6, 64, int16_t, CACHE_LINE);  
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
   
962          uint32_t        stride = dec->edged_width;          uint32_t        stride = dec->edged_width;
963          uint32_t        stride2 = stride / 2;          uint32_t        stride2 = stride / 2;
         uint32_t        next_block = stride * 8;  
         uint32_t        iQuant = pMB->quant;  
964          int                     uv_dx, uv_dy;          int                     uv_dx, uv_dy;
965          int                     b_uv_dx, b_uv_dy;          int                     b_uv_dx, b_uv_dy;
         uint32_t        i;  
966          uint8_t         *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t         *pY_Cur, *pU_Cur, *pV_Cur;
967            const uint32_t cbp = pMB->cbp;
968    
969          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
970          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
971          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
972    
973          if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q))          validate_vector(pMB->mvs, x_pos, y_pos, dec);
974          {          validate_vector(pMB->b_mvs, x_pos, y_pos, dec);
975    
976            if (!direct) {
977                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
978                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
   
                 uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;  
                 uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
   
979                  b_uv_dx = pMB->b_mvs[0].x;                  b_uv_dx = pMB->b_mvs[0].x;
980                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
981    
982                  b_uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;                  if (dec->quarterpel) {
983                  b_uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;                          uv_dx /= 2;
984                            uv_dy /= 2;
985                            b_uv_dx /= 2;
986                            b_uv_dy /= 2;
987          }          }
         else  
         {  
                 int sum;  
                 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
                 uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );  
   
                 sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;  
                 uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );  
988    
989                  sum = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
990                  b_uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
991                    b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];
992                    b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
993    
994                  sum = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;          } else {
995                  b_uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
996                    uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
997                    b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
998                    b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;
999    
1000                    if (dec->quarterpel) {
1001                            uv_dx /= 2;
1002                            uv_dy /= 2;
1003                            b_uv_dx /= 2;
1004                            b_uv_dy /= 2;
1005                    }
1006    
1007                    uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
1008                    uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
1009                    b_uv_dx = (b_uv_dx >> 3) + roundtab_76[b_uv_dx & 0xf];
1010                    b_uv_dy = (b_uv_dy >> 3) + roundtab_76[b_uv_dy & 0xf];
1011          }          }
1012    
   
         start_timer();  
         interpolate8x8_switch(dec->cur.y, forward.y, 16*x_pos,     16*y_pos    , pMB->mvs[0].x, pMB->mvs[0].y, stride,  0);  
         interpolate8x8_switch(dec->cur.y, forward.y, 16*x_pos + 8, 16*y_pos    , pMB->mvs[1].x, pMB->mvs[1].y, stride,  0);  
         interpolate8x8_switch(dec->cur.y, forward.y, 16*x_pos,     16*y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,  0);  
         interpolate8x8_switch(dec->cur.y, forward.y, 16*x_pos + 8, 16*y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,  0);  
         interpolate8x8_switch(dec->cur.u, forward.u, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, 0);  
         interpolate8x8_switch(dec->cur.v, forward.v, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, 0);  
   
   
         interpolate8x8_switch(dec->refn[2].y, backward.y, 16*x_pos,     16*y_pos    , pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride,  0);  
         interpolate8x8_switch(dec->refn[2].y, backward.y, 16*x_pos + 8, 16*y_pos    , pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride,  0);  
         interpolate8x8_switch(dec->refn[2].y, backward.y, 16*x_pos,     16*y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride,  0);  
         interpolate8x8_switch(dec->refn[2].y, backward.y, 16*x_pos + 8, 16*y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride,  0);  
         interpolate8x8_switch(dec->refn[2].u, backward.u, 8*x_pos,      8*y_pos,      b_uv_dx,         b_uv_dy,         stride2, 0);  
         interpolate8x8_switch(dec->refn[2].v, backward.v, 8*x_pos,      8*y_pos,      b_uv_dx,         b_uv_dy,         stride2, 0);  
   
         interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16*x_pos,     16*y_pos    , stride);  
         interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16*x_pos + 8, 16*y_pos    , stride);  
         interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16*x_pos,     16*y_pos + 8, stride);  
         interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16*x_pos + 8, 16*y_pos + 8, stride);  
         interpolate8x8_c(dec->cur.u, dec->refn[2].u, 8*x_pos,      8*y_pos,      stride2);  
         interpolate8x8_c(dec->cur.v, dec->refn[2].v, 8*x_pos,      8*y_pos,      stride2);  
   
         stop_comp_timer();  
   
         for (i = 0; i < 6; i++)  
         {  
                 if (cbp & (1 << (5-i)))                 // coded  
                 {  
                         memset(&block[i*64], 0, 64 * sizeof(int16_t));          // clear  
   
                         start_timer();  
                         get_inter_block(bs, &block[i*64]);  
                         stop_coding_timer();  
   
1013                          start_timer();                          start_timer();
1014                          if (dec->quant_type == 0)          if(dec->quarterpel) {
1015                          {                  if(!direct) {
1016                                  dequant_inter(&data[i*64], &block[i*64], iQuant);                          interpolate16x16_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1017                          }                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1018                          else                                                                                  pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1019                          {                  } else {
1020                                  dequant4_inter(&data[i*64], &block[i*64], iQuant);                          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1021                                                                                    dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1022                                                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1023                            interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1024                                                                                    dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1025                                                                                    pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1026                            interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1027                                                                                    dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1028                                                                                    pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1029                            interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1030                                                                                    dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1031                                                                                    pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1032                          }                          }
1033                          stop_iquant_timer();          } else {
1034                    interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,
1035                          start_timer();                                                          pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1036                          idct(&data[i*64]);                  interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1037                          stop_idct_timer();                                                          pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1038                    interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos + 8,
1039                                                            pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1040                    interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos + 8,
1041                                                            pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1042            }
1043    
1044            interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1045                                                    uv_dy, stride2, 0);
1046            interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1047                                                    uv_dy, stride2, 0);
1048    
1049    
1050            if(dec->quarterpel) {
1051                    if(!direct) {
1052                            interpolate16x16_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1053                                            dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1054                                            pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1055                    } else {
1056                            interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1057                                            dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1058                                            pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1059                            interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1060                                            dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1061                                            pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1062                            interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1063                                            dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1064                                            pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1065                            interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1066                                            dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1067                                            pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1068                  }                  }
1069            } else {
1070                    interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos, 16 * y_pos,
1071                                    pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1072                    interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1073                                    16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1074                    interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos,
1075                                    16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1076                    interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1077                                    16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1078          }          }
1079    
1080          if (dec->interlacing && pMB->field_dct)          interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1081          {                          b_uv_dx, b_uv_dy, stride2, 0);
1082                  next_block = stride;          interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1083                  stride *= 2;                          b_uv_dx, b_uv_dy, stride2, 0);
         }  
1084    
1085          start_timer();          stop_comp_timer();
         if (cbp & 32)  
                 transfer_16to8add(pY_Cur,                  &data[0*64], stride);  
         if (cbp & 16)  
                 transfer_16to8add(pY_Cur + 8,              &data[1*64], stride);  
         if (cbp & 8)  
                 transfer_16to8add(pY_Cur + next_block,     &data[2*64], stride);  
         if (cbp & 4)  
                 transfer_16to8add(pY_Cur + 8 + next_block, &data[3*64], stride);  
         if (cbp & 2)  
                 transfer_16to8add(pU_Cur,                  &data[4*64], stride2);  
         if (cbp & 1)  
                 transfer_16to8add(pV_Cur,                  &data[5*64], stride2);  
         stop_transfer_timer();  
 }  
1086    
1087            if (cbp)
1088                    decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1089    }
1090    
1091  // add by MinChen <chenm001@163.com>  /* for decode B-frame dbquant */
1092  // for decode B-frame dbquant  static __inline int32_t
1093  int32_t __inline get_dbquant(Bitstream * bs)  get_dbquant(Bitstream * bs)
1094  {  {
1095          if (!BitstreamGetBit(bs))               // '0'          if (!BitstreamGetBit(bs))               /*  '0' */
1096                  return(0);                  return(0);
1097          else if (!BitstreamGetBit(bs))  // '10'          else if (!BitstreamGetBit(bs))  /* '10' */
1098                  return(-2);                  return(-2);
1099          else          else                                                    /* '11' */
1100                  return(2);                                      // '11'                  return (2);
1101  }  }
1102    
1103  // add by MinChen <chenm001@163.com>  /*
1104  // for decode B-frame mb_type   * decode B-frame mb_type
1105  // bit   ret_value   * bit          ret_value
1106  // 1        0   * 1            0
1107  // 01       1   * 01           1
1108  // 001      2   * 001          2
1109  // 0001     3   * 0001         3
1110  int32_t __inline get_mbtype(Bitstream * bs)   */
1111    static int32_t __inline
1112    get_mbtype(Bitstream * bs)
1113  {  {
1114          int32_t mb_type;          int32_t mb_type;
         for(mb_type=0;mb_type<=3;mb_type++){  
                 if  (BitstreamGetBit(bs))  
                         break;  
         }  
1115    
1116          if (mb_type<=3)          for (mb_type = 0; mb_type <= 3; mb_type++)
1117                    if (BitstreamGetBit(bs))
1118                  return(mb_type);                  return(mb_type);
1119          else  
1120                  return(-1);          return -1;
1121  }  }
1122    
1123  void decoder_bframe(DECODER * dec, Bitstream * bs, int quant, int fcode_forward, int fcode_backward)  static void
1124    decoder_bframe(DECODER * dec,
1125                                    Bitstream * bs,
1126                                    int quant,
1127                                    int fcode_forward,
1128                                    int fcode_backward)
1129  {  {
   
1130          uint32_t        x, y;          uint32_t        x, y;
1131          VECTOR          mv, zeromv;          VECTOR mv;
1132            const VECTOR zeromv = {0,0};
1133            int i;
1134    
1135            if (!dec->is_edged[0]) {
1136          start_timer();          start_timer();
1137          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height, dec->width, dec->height, dec->interlacing);                  image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1138          //image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height, dec->width, dec->height, dec->interlacing);                                                  dec->width, dec->height, dec->bs_version);
1139                    dec->is_edged[0] = 1;
1140          stop_edges_timer();          stop_edges_timer();
1141            }
1142    
1143            if (!dec->is_edged[1]) {
1144                    start_timer();
1145                    image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1146                                                    dec->width, dec->height, dec->bs_version);
1147                    dec->is_edged[1] = 1;
1148                    stop_edges_timer();
1149            }
1150    
1151          for (y = 0; y < dec->mb_height; y++)          for (y = 0; y < dec->mb_height; y++) {
1152          {                  /* Initialize Pred Motion Vector */
1153                  // Initialize Pred Motion Vector                  dec->p_fmv = dec->p_bmv = zeromv;
1154                  dec->p_fmv.x = dec->p_fmv.y = dec->p_bmv.x = dec->p_bmv.y = 0;                  for (x = 0; x < dec->mb_width; x++) {
                 for (x = 0; x < dec->mb_width; x++)  
                 {  
1155                          MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];                          MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];
1156                          MACROBLOCK * last_mb = &dec->last_mbs[y*dec->mb_width + x];                          MACROBLOCK * last_mb = &dec->last_mbs[y*dec->mb_width + x];
1157                            const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
1158                            uint32_t intra_dc_threshold; /* fake variable */
1159    
1160                            if (check_resync_marker(bs, fcode_max  - 1)) {
1161                                    int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,
1162                                                                                                             &fcode_forward, &fcode_backward, &intra_dc_threshold);
1163                                    x = bound % dec->mb_width;
1164                                    y = bound / dec->mb_width;
1165                                    /* reset predicted macroblocks */
1166                                    dec->p_fmv = dec->p_bmv = zeromv;
1167                            }
1168    
1169                            mv =
1170                            mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1171                            mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1172                            mb->quant = quant;
1173    
1174                          mb->mvs[0].x=mb->mvs[0].y=zeromv.x = zeromv.y = mv.x = mv.y = 0;                          /*
1175                             * skip if the co-located P_VOP macroblock is not coded
1176                             * if not codec in co-located S_VOP macroblock is _not_
1177                             * automatically skipped
1178                             */
1179    
                         // the last P_VOP is skip macroblock ?  
1180                          if (last_mb->mode == MODE_NOT_CODED){                          if (last_mb->mode == MODE_NOT_CODED){
                                 //DEBUG2("Skip MB in B-frame at (X,Y)=!",x,y);  
                                 mb->mb_type = MODE_FORWARD;  
1181                                  mb->cbp = 0;                                  mb->cbp = 0;
1182                                  mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;                                  mb->mode = MODE_FORWARD;
1183                                  mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);
                                 mb->quant = 8;  
   
                                 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);  
1184                                  continue;                                  continue;
1185                          }                          }
1186    
1187                          //t=BitstreamShowBits(bs,32);                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */
   
                         if (!BitstreamGetBit(bs)){      // modb=='0'  
1188                                  const uint8_t modb2=BitstreamGetBit(bs);                                  const uint8_t modb2=BitstreamGetBit(bs);
1189    
1190                                  mb->mb_type = get_mbtype(bs);                                  mb->mode = get_mbtype(bs);
1191    
1192                                  if (!modb2){    // modb=='00'                                  if (!modb2)             /* modb=='00' */
1193                                          mb->cbp = BitstreamGetBits(bs,6);                                          mb->cbp = BitstreamGetBits(bs,6);
1194                                  } else {                                  else
1195                                          mb->cbp = 0;                                          mb->cbp = 0;
                                 }  
                                 if (mb->mb_type && mb->cbp){  
                                         quant += get_dbquant(bs);  
1196    
1197                                    if (mb->mode && mb->cbp) {
1198                                            quant += get_dbquant(bs);
1199                                          if (quant > 31)                                          if (quant > 31)
                                         {  
1200                                                  quant = 31;                                                  quant = 31;
1201                                          }                                          else if (quant < 1)
                                         else if (mb->quant < 1)  
                                         {  
1202                                                  quant = 1;                                                  quant = 1;
1203                                          }                                          }
                                 } else {  
                                         quant = 8;  
                                 }  
1204                                  mb->quant = quant;                                  mb->quant = quant;
1205    
1206                                    if (dec->interlacing) {
1207                                            if (mb->cbp) {
1208                                                    mb->field_dct = BitstreamGetBit(bs);
1209                                                    DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1210                                            }
1211    
1212                                            if (mb->mode) {
1213                                                    mb->field_pred = BitstreamGetBit(bs);
1214                                                    DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1215    
1216                                                    if (mb->field_pred) {
1217                                                            mb->field_for_top = BitstreamGetBit(bs);
1218                                                            DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1219                                                            mb->field_for_bot = BitstreamGetBit(bs);
1220                                                            DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1221                                                    }
1222                                            }
1223                                    }
1224    
1225                          } else {                          } else {
1226                                  mb->mb_type = MODE_DIRECT_NONE_MV;                                  mb->mode = MODE_DIRECT_NONE_MV;
1227                                  mb->cbp = 0;                                  mb->cbp = 0;
1228                          }                          }
1229    
1230                          mb->mode = MODE_INTER;                          switch (mb->mode) {
                         //DEBUG1("Switch bm_type=",mb->mb_type);  
   
                         switch(mb->mb_type)  
                         {  
1231                          case MODE_DIRECT:                          case MODE_DIRECT:
1232                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], 1, zeromv);                                  get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);
1233    
1234                          case MODE_DIRECT_NONE_MV:                          case MODE_DIRECT_NONE_MV:
                                 {       // Because this file is a C file not C++ so I use '{' to define var  
                                         const int64_t   TRB=dec->time_pp-dec->time_bp,  
                                                                         TRD=dec->time_pp;  
                                         int i;  
1235                                          for(i=0;i<4;i++){                                          for(i=0;i<4;i++){
1236                                                  mb->mvs[i].x    = (int32_t)((TRB * last_mb->mvs[i].x)/TRD+mb->mvs[0].x);                                          mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1237                                                  mb->b_mvs[i].x  = (int32_t)((mb->mvs[0].x==0)?((TRB-TRD)*last_mb->mvs[i].x)/TRD:mb->mvs[i].x-last_mb->mvs[i].x);                                          mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1238                                                  mb->mvs[i].y    = (int32_t)((TRB * last_mb->mvs[i].y)/TRD+mb->mvs[0].y);  
1239                                                  mb->b_mvs[i].y  = (int32_t)((mb->mvs[0].y==0)?((TRB-TRD)*last_mb->mvs[i].y)/TRD:mb->mvs[i].y-last_mb->mvs[i].y);                                          mb->b_mvs[i].x = (mv.x)
1240                                          }                                                  ?  mb->mvs[i].x - last_mb->mvs[i].x
1241                                          //DEBUG("B-frame Direct!\n");                                                  : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1242                                            mb->b_mvs[i].y = (mv.y)
1243                                                    ? mb->mvs[i].y - last_mb->mvs[i].y
1244                                                    : last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
1245                                  }                                  }
1246                                  mb->mode = MODE_INTER4V;  
1247                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0], mb, x, y, mb->cbp, bs);                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1248                                                                                                    mb, x, y, bs, 1);
1249                                  break;                                  break;
1250    
1251                          case MODE_INTERPOLATE:                          case MODE_INTERPOLATE:
1252                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward, dec->p_fmv);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1253                                  dec->p_fmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                 dec->p_fmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;  
   
                                 get_b_motion_vector(dec, bs, x, y, &mb->b_mvs[0], fcode_backward, dec->p_bmv);  
                                 dec->p_bmv.x = mb->b_mvs[1].x = mb->b_mvs[2].x = mb->b_mvs[3].x = mb->b_mvs[0].x;  
                                 dec->p_bmv.y = mb->b_mvs[1].y = mb->b_mvs[2].y = mb->b_mvs[3].y = mb->b_mvs[0].y;  
1254    
1255                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0], mb, x, y, mb->cbp, bs);                                  get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1256                                  //DEBUG("B-frame Bidir!\n");                                  dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] = mb->b_mvs[0];
1257    
1258                                    decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1259                                                                                            mb, x, y, bs, 0);
1260                                  break;                                  break;
1261    
1262                          case MODE_BACKWARD:                          case MODE_BACKWARD:
1263                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_backward, dec->p_bmv);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1264                                  dec->p_bmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                 dec->p_bmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;  
1265    
1266                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 0);                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0);
                                 //DEBUG("B-frame Backward!\n");  
1267                                  break;                                  break;
1268    
1269                          case MODE_FORWARD:                          case MODE_FORWARD:
1270                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward, dec->p_fmv);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1271                                  dec->p_fmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                 dec->p_fmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;  
1272    
1273                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);
                                 //DEBUG("B-frame Forward!\n");  
1274                                  break;                                  break;
1275    
1276                          default:                          default:
1277                                  DEBUG1("Not support B-frame mb_type =",mb->mb_type);                                  DPRINTF(XVID_DEBUG_ERROR,"Not supported B-frame mb_type = %i\n", mb->mode);
1278                          }                          }
1279                    } /* End of for */
                 }       // end of FOR  
1280          }          }
1281  }  }
1282    
1283  // swap two MACROBLOCK array  /* perform post processing if necessary, and output the image */
1284  void mb_swap(MACROBLOCK **mb1, MACROBLOCK **mb2)  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1285                                            xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1286                                            int coding_type, int quant)
1287  {  {
1288          MACROBLOCK *temp=*mb1;          const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1289          *mb1=*mb2;  
1290          *mb2=temp;          if (dec->cartoon_mode)
1291                    frame->general &= ~XVID_FILMEFFECT;
1292    
1293            if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1294                    && mbs != NULL) /* post process */
1295            {
1296                    /* note: image is stored to tmp */
1297                    image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1298                    image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1299                                               mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1300                                               frame->general, brightness, dec->frames, (coding_type == B_VOP));
1301                    img = &dec->tmp;
1302  }  }
1303    
1304  int decoder_decode(DECODER * dec, XVID_DEC_FRAME * frame)          image_output(img, dec->width, dec->height,
1305                                     dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,
1306                                     frame->output.csp, dec->interlacing);
1307    
1308            if (stats) {
1309                    stats->type = coding2type(coding_type);
1310                    stats->data.vop.time_base = (int)dec->time_base;
1311                    stats->data.vop.time_increment = 0;     /* XXX: todo */
1312                    stats->data.vop.qscale_stride = dec->mb_width;
1313                    stats->data.vop.qscale = dec->qscale;
1314                    if (stats->data.vop.qscale != NULL && mbs != NULL) {
1315                            int i;
1316                            for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1317                                    stats->data.vop.qscale[i] = mbs[i].quant;
1318                    } else
1319                            stats->data.vop.qscale = NULL;
1320            }
1321    }
1322    
1323    int
1324    decoder_decode(DECODER * dec,
1325                                    xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
1326  {  {
1327    
1328          Bitstream bs;          Bitstream bs;
1329          uint32_t rounding;          uint32_t rounding;
1330          uint32_t quant;          uint32_t quant = 2;
1331          uint32_t fcode_forward;          uint32_t fcode_forward;
1332          uint32_t fcode_backward;          uint32_t fcode_backward;
1333          uint32_t intra_dc_threshold;          uint32_t intra_dc_threshold;
1334          uint32_t vop_type;          WARPPOINTS gmc_warp;
1335            int coding_type;
1336            int success, output, seen_something;
1337    
1338            if (XVID_VERSION_MAJOR(frame->version) != 1 || (stats && XVID_VERSION_MAJOR(stats->version) != 1))      /* v1.x.x */
1339                    return XVID_ERR_VERSION;
1340    
1341          start_global_timer();          start_global_timer();
1342    
1343          BitstreamInit(&bs, frame->bitstream, frame->length);          dec->low_delay_default = (frame->general & XVID_LOWDELAY);
1344            if ((frame->general & XVID_DISCONTINUITY))
1345                    dec->frames = 0;
1346            dec->out_frm = (frame->output.csp == XVID_CSP_SLICE) ? &frame->output : NULL;
1347    
1348            if (frame->length < 0) {        /* decoder flush */
1349                    int ret;
1350                    /* if not decoding "low_delay/packed", and this isn't low_delay and
1351                            we have a reference frame, then outout the reference frame */
1352                    if (!(dec->low_delay_default && dec->packed_mode) && !dec->low_delay && dec->frames>0) {
1353                            decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1354                            dec->frames = 0;
1355                            ret = 0;
1356                    } else {
1357                            if (stats) stats->type = XVID_TYPE_NOTHING;
1358                            ret = XVID_ERR_END;
1359                    }
1360    
1361          // add by chenm001 <chenm001@163.com>                  emms();
1362          // for support B-frame to reference last 2 frame                  stop_global_timer();
1363          dec->frames ++;                  return ret;
1364          vop_type=BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold);          }
1365    
1366          dec->p_bmv.x=dec->p_bmv.y=dec->p_fmv.y=dec->p_fmv.y=0;          // init pred vector to 0          BitstreamInit(&bs, frame->bitstream, frame->length);
1367          switch (vop_type)  
1368            /* XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's */
1369            if(dec->low_delay_default && frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1370          {          {
1371          case P_VOP :                  image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1372                  decoder_pframe(dec, &bs, rounding, quant, fcode_forward, intra_dc_threshold);                                           (uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1373                  DEBUG1("P_VOP  Time=",dec->time);                  if (stats) stats->type = XVID_TYPE_NOTHING;
1374                  break;                  emms();
1375                    return 1;       /* one byte consumed */
1376            }
1377    
1378            success = 0;
1379            output = 0;
1380            seen_something = 0;
1381    
1382    repeat:
1383    
1384            coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1385                            &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1386    
1387            DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%"
1388    #if defined(_MSC_VER)
1389        "I64"
1390    #else
1391        "ll"
1392    #endif
1393        "i,  time_pp=%i,  time_bp=%i\n",
1394                                                            coding_type,    dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1395    
1396            if (coding_type == -1) { /* nothing */
1397                    if (success) goto done;
1398                    if (stats) stats->type = XVID_TYPE_NOTHING;
1399                    emms();
1400                    return BitstreamPos(&bs)/8;
1401            }
1402    
1403            if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */
1404    
1405                    if (coding_type == -3)
1406                            decoder_resize(dec);
1407    
1408                    if (stats) {
1409                            stats->type = XVID_TYPE_VOL;
1410                            stats->data.vol.general = 0;
1411                            /*XXX: if (dec->interlacing)
1412                                    stats->data.vol.general |= ++INTERLACING; */
1413                            stats->data.vol.width = dec->width;
1414                            stats->data.vol.height = dec->height;
1415                            stats->data.vol.par = dec->aspect_ratio;
1416                            stats->data.vol.par_width = dec->par_width;
1417                            stats->data.vol.par_height = dec->par_height;
1418                            emms();
1419                            return BitstreamPos(&bs)/8;     /* number of bytes consumed */
1420                    }
1421                    goto repeat;
1422            }
1423    
1424            if(dec->frames == 0 && coding_type != I_VOP) {
1425                    /* 1st frame is not an i-vop */
1426                    goto repeat;
1427            }
1428    
1429            dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1430    
1431            /* packed_mode: special-N_VOP treament */
1432            if (dec->packed_mode && coding_type == N_VOP) {
1433                    if (dec->low_delay_default && dec->frames > 0) {
1434                            decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1435                            output = 1;
1436                    }
1437                    /* ignore otherwise */
1438            } else if (coding_type != B_VOP) {
1439                    switch(coding_type) {
1440          case I_VOP :          case I_VOP :
1441                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);
                 DEBUG1("I_VOP  Time=",dec->time);  
1442                  break;                  break;
1443                    case P_VOP :
1444          case B_VOP :                          decoder_pframe(dec, &bs, rounding, quant,
1445                  if (dec->time_pp > dec->time_bp){                                                  fcode_forward, intra_dc_threshold, NULL);
                         DEBUG1("B_VOP  Time=",dec->time);  
                         decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);  
                 } else {  
                         DEBUG("broken B-frame!");  
                 }  
1446                  break;                  break;
1447                    case S_VOP :
1448          case N_VOP :    // vop not coded                          decoder_pframe(dec, &bs, rounding, quant,
1449                                                    fcode_forward, intra_dc_threshold, &gmc_warp);
1450                            break;
1451                    case N_VOP :
1452                            /* XXX: not_coded vops are not used for forward prediction */
1453                            /* we should not swap(last_mbs,mbs) */
1454                            image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1455                            SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs); /* it will be swapped back */
1456                  break;                  break;
1457                    }
1458    
1459          default :                  /* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1460                  return XVID_ERR_FAIL;                  if (!(dec->low_delay_default && dec->packed_mode)) {
1461                            if (dec->low_delay) {
1462                                    decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1463                                    output = 1;
1464                            } else if (dec->frames > 0)     { /* is the reference frame valid? */
1465                                    /* output the reference frame */
1466                                    decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1467                                    output = 1;
1468                            }
1469          }          }
1470    
1471          frame->length = BitstreamPos(&bs) / 8;                  image_swap(&dec->refn[0], &dec->refn[1]);
1472                    dec->is_edged[1] = dec->is_edged[0];
1473                    image_swap(&dec->cur, &dec->refn[0]);
1474                    dec->is_edged[0] = 0;
1475                    SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
1476                    dec->last_coding_type = coding_type;
1477    
1478                    dec->frames++;
1479                    seen_something = 1;
1480    
1481            } else {        /* B_VOP */
1482    
         // test if no B_VOP  
1483          if (dec->low_delay){          if (dec->low_delay){
1484              image_output(&dec->cur, dec->width, dec->height, dec->edged_width,                          DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1485                                       frame->image, frame->stride, frame->colorspace);                          dec->low_delay = 0;
1486                    }
1487    
1488                    if (dec->frames < 2) {
1489                            /* attemping to decode a bvop without atleast 2 reference frames */
1490                            image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1491                                                    "broken b-frame, mising ref frames");
1492                            if (stats) stats->type = XVID_TYPE_NOTHING;
1493                    } else if (dec->time_pp <= dec->time_bp) {
1494                            /* this occurs when dx50_bvop_compatibility==0 sequences are
1495                            decoded in vfw. */
1496                            image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1497                                                    "broken b-frame, tpp=%i tbp=%i", dec->time_pp, dec->time_bp);
1498                            if (stats) stats->type = XVID_TYPE_NOTHING;
1499          } else {          } else {
1500                  if (dec->frames >= 1){                          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1501                          start_timer();                          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
                         if ((vop_type == I_VOP || vop_type == P_VOP))  
                         {  
                                 image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,  
                                                  frame->image, frame->stride, frame->colorspace);  
                         } else if (vop_type == B_VOP) {  
                                 image_output(&dec->cur, dec->width, dec->height, dec->edged_width,  
                                                  frame->image, frame->stride, frame->colorspace);  
1502                          }                          }
1503                          stop_conv_timer();  
1504                    output = 1;
1505                    dec->frames++;
1506                  }                  }
1507    
1508    #if 0 /* Avoids to read to much data because of 32bit reads in our BS functions */
1509             BitstreamByteAlign(&bs);
1510    #endif
1511    
1512            /* low_delay_default mode: repeat in packed_mode */
1513            if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {
1514                    success = 1;
1515                    goto repeat;
1516            }
1517    
1518    done :
1519    
1520      /* if we reach here without outputing anything _and_
1521         the calling application has specified low_delay_default,
1522         we *must* output something.
1523         this always occurs on the first call to decode() call
1524         when bframes are present in the bitstream. it may also
1525         occur if no vops  were seen in the bitstream
1526    
1527         if packed_mode is enabled, then we output the recently
1528         decoded frame (the very first ivop). otherwise we have
1529         nothing to display, and therefore output a black screen.
1530      */
1531      if (dec->low_delay_default && output == 0) {
1532        if (dec->packed_mode && seen_something) {
1533                            decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1534        } else {
1535                            image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);
1536                            decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1537                            if (stats) stats->type = XVID_TYPE_NOTHING;
1538          }          }
         if (vop_type==I_VOP || vop_type==P_VOP){  
                 image_swap(&dec->refn[0], &dec->refn[1]);  
                 image_swap(&dec->cur, &dec->refn[0]);  
                 // swap MACROBLOCK  
                 if (dec->low_delay && vop_type==P_VOP)  
                         mb_swap(&dec->mbs, &dec->last_mbs);  
1539          }          }
1540    
1541          emms();          emms();
   
1542          stop_global_timer();          stop_global_timer();
1543    
1544          return XVID_ERR_OK;          return (BitstreamPos(&bs) + 7) / 8;     /* number of bytes consumed */
1545  }  }

Legend:
Removed from v.1.17  
changed lines
  Added in v.1.69

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4