[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.24, Wed Jul 3 12:32:50 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:  
  *  
  *  28.06.2002  added basic resync support to iframe/pframe_decode()  
  *      22.06.2002      added primative N_VOP support  
  *                              #define BFRAMES_DEC now enables Minchenm's bframe decoder  
  *  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  static int
65  decoder_create(XVID_DEC_PARAM * param)  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;
         dec->low_delay = 0;  
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);
# Line 111  Line 97 
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);
110                    image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
111                    image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
112                    xvid_free(dec);
113                    return XVID_ERR_MEMORY;
114            }
115    
116            if (image_create(&dec->qtmp, dec->edged_width, dec->edged_height)) {
117                    image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
118                    image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
119                    image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
120                    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
121                    xvid_free(dec);
122                    return XVID_ERR_MEMORY;
123            }
124    
125            if (image_create(&dec->gmc, dec->edged_width, dec->edged_height)) {
126                    image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
127                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
128                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
129                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  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);                  xvid_free(dec);
132                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
133          }          }
# Line 134  Line 139 
139                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
140                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
141                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
142                  image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);                  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);                  xvid_free(dec);
145                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
146          }          }
   
147          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
148    
149          // add by chenm001 <chenm001@163.com>          /* For skip MB flag */
         // for skip MB flag  
150          dec->last_mbs =          dec->last_mbs =
151                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
152                                          CACHE_LINE);                                          CACHE_LINE);
# Line 151  Line 155 
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);                  xvid_free(dec);
161                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
162          }          }
163    
164          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          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);
195                    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    
# Line 174  Line 238 
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
   
 // decode an intra macroblock  
   
 void  
264  decoder_mbintra(DECODER * dec,  decoder_mbintra(DECODER * dec,
265                                  MACROBLOCK * pMB,                                  MACROBLOCK * pMB,
266                                  const uint32_t x_pos,                                  const uint32_t x_pos,
# Line 222  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);
# Line 245  Line 310 
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                          DPRINTF(DPRINTF_COEFF,"block[0] %i", dc_dif);                          DPRINTF(XVID_DEBUG_COEFF,"block[0] %i\n", dc_dif);
320                  } else {                  } 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],                          int direction = dec->alternate_vertical_scan ?
328                                                          start_coeff);                                  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_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);                          dequant_h263_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
341                  } else {                  } else {
342                          dequant4_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);                          dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
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) {
# Line 296  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  #define SIGN(X) (((X)>0)?1:-1)          for (i = 0; i < 6; i++) {
418  #define ABS(X) (((X)>0)?(X):-(X))                  /* Process only coded blocks */
419  static const uint32_t roundtab[16] =                  if (cbp & (1 << (5 - i))) {
         { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };  
420    
421                            /* Clear the block */
422                            memset(&data[0], 0, 64*sizeof(int16_t));
423    
424  // decode an inter macroblock                          /* Decode coeffs and dequantize on the fly */
425                            start_timer();
426                            get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
427                            stop_coding_timer();
428    
429                            /* iDCT */
430                            start_timer();
431                            idct(&data[0]);
432                            stop_idct_timer();
433    
434  void                          /* 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    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,  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();
507                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
508          } else {          if (pMB->mode != MODE_INTER4V) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
                 int sum;  
509    
510                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  uv_dx = mv[0].x;
511                  uv_dx =                  uv_dy = mv[0].y;
512                          (sum ==                  if (dec->quarterpel) {
513                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +                          uv_dx /= 2;
514                                                                    (ABS(sum) / 16) * 2));                          uv_dy /= 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));  
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                            interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,
521                                                                            dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
522                                                                                            mv[0].x, mv[0].y, stride, rounding);
523                    else
524                            interpolate16x16_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos, 16*y_pos,
525                                                                            mv[0].x, mv[0].y, stride, rounding);
526    
527            } else {        /* MODE_INTER4V */
528    
529                    if(dec->quarterpel) {
530                            uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
531                            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                    uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
538                    uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
539    
540                    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,          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos, 16 * y_pos,
555                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);                                                                  mv[0].x, mv[0].y, stride, rounding);
556          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos + 8,                          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos + 8, 16*y_pos,
557                                                    16 * y_pos, pMB->mvs[1].x, pMB->mvs[1].y, stride,                                                                  mv[1].x, mv[1].y, stride, rounding);
558                                                    rounding);                          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos, 16*y_pos + 8,
559          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos,                                                                  mv[2].x, mv[2].y, stride, rounding);
560                                                    16 * y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,                          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos + 8, 16*y_pos + 8,
561                                                    rounding);                                                                  mv[3].x, mv[3].y, stride, rounding);
562          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos + 8,                  }
563                                                    16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,          }
564                                                    rounding);  
565          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,          /* chroma */
566            interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
567                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
568          interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,          interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
569                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
570    
571          stop_comp_timer();          stop_comp_timer();
572    
573          for (i = 0; i < 6; i++) {          if (cbp)
574                  if (cbp & (1 << (5 - i)))       // coded                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
575    }
576    
577    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                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear          const uint32_t stride = dec->edged_width;
588            const uint32_t stride2 = stride / 2;
589    
590                          start_timer();          uint8_t *const pY_Cur=dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
591                          get_inter_block(bs, &block[i * 64]);          uint8_t *const pU_Cur=dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
592                          stop_coding_timer();          uint8_t *const pV_Cur=dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
593    
594                          start_timer();          NEW_GMC_DATA * gmc_data = &dec->new_gmc_data;
595                          if (dec->quant_type == 0) {  
596                                  dequant_inter(&data[i * 64], &block[i * 64], iQuant);          pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
                         } else {  
                                 dequant4_inter(&data[i * 64], &block[i * 64], iQuant);  
                         }  
                         stop_iquant_timer();  
597    
598                          start_timer();                          start_timer();
                         idct(&data[i * 64]);  
                         stop_idct_timer();  
                 }  
         }  
599    
600          if (dec->interlacing && pMB->field_dct) {  /* this is where the calculations are done */
601                  next_block = stride;  
602                  stride *= 2;          gmc_data->predict_16x16(gmc_data,
603          }                          dec->cur.y + y_pos*16*stride + x_pos*16, dec->refn[0].y,
604                            stride, stride, x_pos, y_pos, rounding);
605    
606            gmc_data->predict_8x8(gmc_data,
607                            dec->cur.u + y_pos*8*stride2 + x_pos*8, dec->refn[0].u,
608                            dec->cur.v + y_pos*8*stride2 + x_pos*8, dec->refn[0].v,
609                            stride2, stride2, x_pos, y_pos, rounding);
610    
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    
         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);  
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  static void
627  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
628                             Bitstream * bs,                             Bitstream * bs,
629                             int quant,                             int quant,
# Line 428  Line 631 
631  {  {
632          uint32_t bound;          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          bound = 0;          bound = 0;
638    
639          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < mb_height; y++) {
640                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < mb_width; x++) {
641                          MACROBLOCK *mb;                          MACROBLOCK *mb;
642                          uint32_t mcbpc;                          uint32_t mcbpc;
643                          uint32_t cbpc;                          uint32_t cbpc;
# Line 445  Line 650 
650    
651                          if (check_resync_marker(bs, 0))                          if (check_resync_marker(bs, 0))
652                          {                          {
653                                  bound = read_video_packet_header(bs, 0, &quant);                                  bound = read_video_packet_header(bs, dec, 0,
654                                  x = bound % dec->mb_width;                                                          &quant, NULL, NULL, &intra_dc_threshold);
655                                  y = bound / dec->mb_width;                                  x = bound % mb_width;
656                                    y = bound / mb_width;
657                          }                          }
658                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
659    
660                          DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));                          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;
# Line 471  Line 677 
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,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
691                                                          intra_dc_threshold, bound);                                                          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  static void
702  get_motion_vector(DECODER * dec,  get_motion_vector(DECODER * dec,
703                                    Bitstream * bs,                                    Bitstream * bs,
704                                    int x,                                    int x,
705                                    int y,                                    int y,
706                                    int k,                                    int k,
707                                    VECTOR * mv,                                  VECTOR * ret_mv,
708                                    int fcode,                                    int fcode,
709                                    const int bound)                                    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;  
         int mv_x, mv_y;  
716    
717          pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);          const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
718            VECTOR mv;
719    
720          mv_x = get_mv(bs, fcode);          mv.x = get_mv(bs, fcode);
721          mv_y = get_mv(bs, fcode);          mv.y = get_mv(bs, fcode);
722    
723          DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv.x, pmv.y);          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);
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;                  mv.x += range;
730          } else if (mv_x > high) {          } else if (mv.x > high) {
731                  mv_x -= range;                  mv.x -= range;
732          }          }
733    
734          if (mv_y < low) {          if (mv.y < low) {
735                  mv_y += range;                  mv.y += range;
736          } else if (mv_y > high) {          } else if (mv.y > high) {
737                  mv_y -= range;                  mv.y -= range;
738          }          }
739    
740          mv->x = mv_x;          ret_mv->x = mv.x;
741          mv->y = mv_y;          ret_mv->y = mv.y;
   
742  }  }
743    
744    /* for P_VOP set gmc_warp to NULL */
745  void  static void
746  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
747                             Bitstream * bs,                             Bitstream * bs,
748                             int rounding,                             int rounding,
749                             int quant,                             int quant,
750                             int fcode,                             int fcode,
751                             int intra_dc_threshold)                                  int intra_dc_threshold,
752                                    const WARPPOINTS *const gmc_warp)
753  {  {
   
754          uint32_t x, y;          uint32_t x, y;
755          uint32_t bound;          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();          start_timer();
762          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
763                                     dec->width, dec->height, dec->interlacing);                                                  dec->width, dec->height, dec->bs_version);
764                    dec->is_edged[0] = 1;
765          stop_edges_timer();          stop_edges_timer();
766            }
767    
768            if (gmc_warp) {
769                    /* 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;          bound = 0;
778    
779          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < mb_height; y++) {
780                  for (x = 0; x < dec->mb_width; x++) {                  cp_mb = st_mb = 0;
781                    for (x = 0; x < mb_width; x++) {
782                          MACROBLOCK *mb;                          MACROBLOCK *mb;
783    
784                          // skip stuffing                          /* skip stuffing */
785                          while (BitstreamShowBits(bs, 10) == 1)                          while (BitstreamShowBits(bs, 10) == 1)
786                                  BitstreamSkip(bs, 10);                                  BitstreamSkip(bs, 10);
787    
788                          if (check_resync_marker(bs, fcode - 1))                          if (check_resync_marker(bs, fcode - 1)) {
789                          {                                  bound = read_video_packet_header(bs, dec, fcode - 1,
790                                  bound = read_video_packet_header(bs, fcode - 1, &quant);                                          &quant, &fcode, NULL, &intra_dc_threshold);
791                                  x = bound % dec->mb_width;                                  x = bound % mb_width;
792                                  y = bound / dec->mb_width;                                  y = bound / mb_width;
793                          }                          }
794                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
795    
796                          DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));                          DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
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    
808                                  DPRINTF(DPRINTF_MB, "mode %i", mb->mode);                                  DPRINTF(XVID_DEBUG_MB, "mode %i\n", mb->mode);
809                                  DPRINTF(DPRINTF_MB, "cbpc %i", cbpc);                                  DPRINTF(XVID_DEBUG_MB, "cbpc %i\n", cbpc);
                                 acpred_flag = 0;  
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);
                                 }  
817    
818                                  cbpy = get_cbpy(bs, intra);                                  cbpy = get_cbpy(bs, intra);
819                                  DPRINTF(DPRINTF_MB, "cbpy %i", cbpy);                                  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)];                                          int dquant = dquant_table[BitstreamGetBits(bs, 2)];
825                                          DPRINTF(DPRINTF_MB, "dquant %i", dquant);                                          DPRINTF(XVID_DEBUG_MB, "dquant %i\n", dquant);
826                                          quant += dquant;                                          quant += dquant;
827                                          if (quant > 31) {                                          if (quant > 31) {
828                                                  quant = 31;                                                  quant = 31;
829                                          } else if (quant < 1) {                                          } else if (quant < 1) {
830                                                  quant = 1;                                                  quant = 1;
831                                          }                                          }
832                                          DPRINTF(DPRINTF_MB, "quant %i", quant);                                          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                                            continue;
858    
859                                    } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
860    
861                                          if (dec->interlacing && mb->field_pred) {                                          if (dec->interlacing && mb->field_pred) {
862                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
863                                                                                    fcode, bound);                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1], fcode, bound);
                                                 get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],  
                                                                                   fcode, bound);  
864                                          } else {                                          } else {
865                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
866                                                                                    fcode, bound);                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
                                                 mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =  
                                                         mb->mvs[0].x;  
                                                 mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =  
                                                         mb->mvs[0].y;  
867                                          }                                          }
868                                  } else if (mb->mode ==                                  } else if (mb->mode == MODE_INTER4V ) {
                                                    MODE_INTER4V /* || mb->mode == MODE_INTER4V_Q */ ) {  
869                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
870                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
871                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
872                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
873                                  } 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;
875                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =     0;
                                                 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,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
877                                                                          intra_dc_threshold, bound);                                                                          intra_dc_threshold, bound);
878                                          continue;                                          continue;
879                                  }                                  }
880    
881                                  decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);
882                                                                  rounding);  
883                          } else                          // not coded                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
884                          {                                  mb->mode = MODE_NOT_CODED_GMC;
885                                  //DEBUG2("P-frame MB at (X,Y)=",x,y);                                  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                                    st_mb = x+1;
893                            } else {        /* not coded P_VOP macroblock */
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);
                                 start_timer();  
   
                                 transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +  
                                                                  (16 * x),  
                                                                  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);  
902    
903                                  stop_transfer_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                                            cp_mb = 0;
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    
916    
917  // add by MinChen <chenm001@163.com>  /* decode B-frame motion vector */
918  // decode B-frame motion vector  static void
919  void  get_b_motion_vector(Bitstream * bs,
 get_b_motion_vector(DECODER * dec,  
                                         Bitstream * bs,  
                                         int x,  
                                         int y,  
920                                          VECTOR * mv,                                          VECTOR * mv,
921                                          int fcode,                                          int fcode,
922                                          const VECTOR pmv)                                          const VECTOR pmv,
923  {                                          const DECODER * const dec,
924          int scale_fac = 1 << (fcode - 1);                                          const int x, const int y)
925          int high = (32 * scale_fac) - 1;  {
926          int low = ((-32) * scale_fac);          const int scale_fac = 1 << (fcode - 1);
927          int range = (64 * scale_fac);          const int high = (32 * scale_fac) - 1;
928            const int low = ((-32) * scale_fac);
929            const int range = (64 * scale_fac);
930    
931          int mv_x, mv_y;          int mv_x = get_mv(bs, fcode);
932          int pmv_x, pmv_y;          int mv_y = get_mv(bs, fcode);
933    
934          pmv_x = pmv.x;          mv_x += pmv.x;
935          pmv_y = pmv.y;          mv_y += pmv.y;
   
         mv_x = get_mv(bs, fcode);  
         mv_y = get_mv(bs, fcode);  
   
         mv_x += pmv_x;  
         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
 // decode an B-frame forward & backward inter macroblock  
 void  
 decoder_bf_mbinter(DECODER * dec,  
                                    const MACROBLOCK * pMB,  
                                    const uint32_t x_pos,  
                                    const uint32_t y_pos,  
                                    const uint32_t cbp,  
                                    Bitstream * bs,  
                                    const uint32_t quant,  
                                    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 {  
                                 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  
953  decoder_bf_interpolate_mbinter(DECODER * dec,  decoder_bf_interpolate_mbinter(DECODER * dec,
954                                                             IMAGE forward,                                                             IMAGE forward,
955                                                             IMAGE backward,                                                             IMAGE backward,
956                                                             const MACROBLOCK * pMB,                                                                  MACROBLOCK * pMB,
957                                                             const uint32_t x_pos,                                                             const uint32_t x_pos,
958                                                             const uint32_t y_pos,                                                             const uint32_t y_pos,
959                                                             const uint32_t cbp,                                                                  Bitstream * bs,
960                                                             Bitstream * bs)                                                                  const int direct)
961  {  {
   
         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                    }
988    
989                    uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
990                    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          } else {          } else {
995                  int sum;                  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                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  if (dec->quarterpel) {
1001                  uv_dx =                          uv_dx /= 2;
1002                          (sum ==                          uv_dy /= 2;
1003                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +                          b_uv_dx /= 2;
1004                                                                    (ABS(sum) / 16) * 2));                          b_uv_dy /= 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));  
   
                 sum =  
                         pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x +  
                         pMB->b_mvs[3].x;  
                 b_uv_dx =  
                         (sum ==  
                          0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +  
                                                                   (ABS(sum) / 16) * 2));  
   
                 sum =  
                         pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y +  
                         pMB->b_mvs[3].y;  
                 b_uv_dy =  
                         (sum ==  
                          0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +  
                                                                   (ABS(sum) / 16) * 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    
1013          start_timer();          start_timer();
1014            if(dec->quarterpel) {
1015                    if(!direct) {
1016                            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                                                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1019                    } else {
1020                            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            } else {
1034          interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,          interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,
1035                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1036          interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,          interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1037                                                    pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);                                                    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,          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);                                                    pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1040          interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8,                  interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos + 8,
1041                                                    16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,                                                          pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1042                                                    0);          }
1043    
1044          interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,          interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1045                                                    uv_dy, stride2, 0);                                                    uv_dy, stride2, 0);
1046          interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,          interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1047                                                    uv_dy, stride2, 0);                                                    uv_dy, stride2, 0);
1048    
1049    
1050          interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos, 16 * y_pos,          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);                                                    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();  
   
                         start_timer();  
                         if (dec->quant_type == 0) {  
                                 dequant_inter(&data[i * 64], &block[i * 64], iQuant);  
1055                          } else {                          } else {
1056                                  dequant4_inter(&data[i * 64], &block[i * 64], iQuant);                          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                          stop_iquant_timer();                                          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                          start_timer();                                          dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1061                          idct(&data[i * 64]);                                          pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1062                          stop_idct_timer();                          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                  next_block = stride;                          b_uv_dx, b_uv_dy, stride2, 0);
1082                  stride *= 2;          interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1083          }                          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
 int32_t __inline  
1093  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   */
1111    static int32_t __inline
1112  get_mbtype(Bitstream * bs)  get_mbtype(Bitstream * bs)
1113  {  {
1114          int32_t mb_type;          int32_t mb_type;
1115    
1116          for (mb_type = 0; mb_type <= 3; mb_type++) {          for (mb_type = 0; mb_type <= 3; mb_type++)
1117                  if (BitstreamGetBit(bs))                  if (BitstreamGetBit(bs))
                         break;  
         }  
   
         if (mb_type <= 3)  
1118                  return (mb_type);                  return (mb_type);
1119          else  
1120                  return (-1);          return -1;
1121  }  }
1122    
1123  void  static void
1124  decoder_bframe(DECODER * dec,  decoder_bframe(DECODER * dec,
1125                             Bitstream * bs,                             Bitstream * bs,
1126                             int quant,                             int quant,
1127                             int fcode_forward,                             int fcode_forward,
1128                             int fcode_backward)                             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,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1138                                     dec->width, dec->height, dec->interlacing);                                                  dec->width, dec->height, dec->bs_version);
1139          //image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height, dec->width, dec->height, dec->interlacing);                  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                  /* Initialize Pred Motion Vector */
1153                  dec->p_fmv.x = dec->p_fmv.y = dec->p_bmv.x = dec->p_bmv.y = 0;                  dec->p_fmv = dec->p_bmv = zeromv;
1154                  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                          mb->mvs[0].x = mb->mvs[0].y = zeromv.x = zeromv.y = mv.x = mv.y =                          if (check_resync_marker(bs, fcode_max  - 1)) {
1161                                  0;                                  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                            /*
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                          }                          }
                         //t=BitstreamShowBits(bs,32);  
1186    
1187                          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 (quant > 31) {                                  if (mb->mode && mb->cbp) {
1198                                            quant += get_dbquant(bs);
1199                                            if (quant > 31)
1200                                                  quant = 31;                                                  quant = 31;
1201                                          } else if (quant < 1) {                                          else if (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 =                                          mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1237                                                          (int32_t) ((TRB * last_mb->mvs[i].x) / TRD +                                          mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1238                                                                             mb->mvs[0].x);  
1239                                                  mb->b_mvs[i].x =                                          mb->b_mvs[i].x = (mv.x)
1240                                                          (int32_t) ((mb->mvs[0].x ==                                                  ?  mb->mvs[i].x - last_mb->mvs[i].x
1241                                                                                  0) ? ((TRB -                                                  : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1242                                                                                             TRD) * last_mb->mvs[i].x) /                                          mb->b_mvs[i].y = (mv.y)
1243                                                                             TRD : mb->mvs[i].x - last_mb->mvs[i].x);                                                  ? mb->mvs[i].y - last_mb->mvs[i].y
1244                                                  mb->mvs[i].y =                                                  : last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
                                                         (int32_t) ((TRB * last_mb->mvs[i].y) / TRD +  
                                                                            mb->mvs[0].y);  
                                                 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);  
                                         }  
                                         //DEBUG("B-frame Direct!\n");  
1245                                  }                                  }
1246                                  mb->mode = MODE_INTER4V;  
1247                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1248                                                                                             mb, x, y, mb->cbp, bs);                                                                                                  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,                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1253                                                                          dec->p_fmv);                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1254                                  dec->p_fmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =  
1255                                          mb->mvs[0].x;                                  get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1256                                  dec->p_fmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =                                  dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] = mb->b_mvs[0];
                                         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;  
1257    
1258                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1259                                                                                             mb, x, y, mb->cbp, bs);                                                                                          mb, x, y, bs, 0);
                                 //DEBUG("B-frame Bidir!\n");  
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,                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1264                                                                          dec->p_bmv);                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                 dec->p_bmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =  
                                         mb->mvs[0].x;  
                                 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,                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1271                                                                          dec->p_fmv);                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                 dec->p_fmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =  
                                         mb->mvs[0].x;  
                                 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  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1285  mb_swap(MACROBLOCK ** mb1,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1286                  MACROBLOCK ** mb2)                                          int coding_type, int quant)
1287  {  {
1288          MACROBLOCK *temp = *mb1;          const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1289    
1290            if (dec->cartoon_mode)
1291                    frame->general &= ~XVID_FILMEFFECT;
1292    
1293          *mb1 = *mb2;          if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1294          *mb2 = temp;                  && 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            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  int
1324  decoder_decode(DECODER * dec,  decoder_decode(DECODER * dec,
1325                             XVID_DEC_FRAME * frame)                                  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            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                    emms();
1362                    stop_global_timer();
1363                    return ret;
1364            }
1365    
1366          BitstreamInit(&bs, frame->bitstream, frame->length);          BitstreamInit(&bs, frame->bitstream, frame->length);
1367    
1368          // add by chenm001 <chenm001@163.com>          /* XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's */
1369          // for support B-frame to reference last 2 frame          if(dec->low_delay_default && frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1370          dec->frames++;          {
1371          vop_type =                  image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1372                  BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode_forward,                                           (uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1373                                                           &fcode_backward, &intra_dc_threshold);                  if (stats) stats->type = XVID_TYPE_NOTHING;
1374                    emms();
1375                    return 1;       /* one byte consumed */
1376            }
1377    
1378          dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  // init pred vector to 0          success = 0;
1379            output = 0;
1380            seen_something = 0;
1381    
1382          switch (vop_type) {  repeat:
1383          case P_VOP:  
1384                  decoder_pframe(dec, &bs, rounding, quant, fcode_forward,          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1385                                             intra_dc_threshold);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1386  #ifdef BFRAMES_DEC  
1387                  DEBUG1("P_VOP  Time=", dec->time);          DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%"
1388    #if defined(_MSC_VER)
1389        "I64"
1390    #else
1391        "ll"
1392  #endif  #endif
1393                  break;      "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);
 #ifdef BFRAMES_DEC  
                 DEBUG1("I_VOP  Time=", dec->time);  
 #endif  
1442                  break;                  break;
1443                    case P_VOP :
1444          case B_VOP:                          decoder_pframe(dec, &bs, rounding, quant,
1445  #ifdef BFRAMES_DEC                                                  fcode_forward, intra_dc_threshold, NULL);
                 if (dec->time_pp > dec->time_bp) {  
                         DEBUG1("B_VOP  Time=", dec->time);  
                         decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);  
                 } else {  
                         DEBUG("broken B-frame!");  
                 }  
 #else  
                 image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);  
 #endif  
1446                  break;                  break;
1447                    case S_VOP :
1448          case N_VOP:                             // vop not coded                          decoder_pframe(dec, &bs, rounding, quant,
1449                  // when low_delay==0, N_VOP's should interpolate between the past and future frames                                                  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);                  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    
 #ifdef BFRAMES_DEC  
         // test if no B_VOP  
1483          if (dec->low_delay) {          if (dec->low_delay) {
1484  #endif                          DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1485                  image_output(&dec->cur, dec->width, dec->height, dec->edged_width,                          dec->low_delay = 0;
                                          frame->image, frame->stride, frame->colorspace);  
 #ifdef BFRAMES_DEC  
         } else {  
                 if (dec->frames >= 1) {  
                         start_timer();  
                         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);  
1486                          }                          }
1487                          stop_conv_timer();  
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 {
1500                            decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1501                            decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1502                  }                  }
1503    
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  #endif
1511    
1512          if (vop_type == I_VOP || vop_type == P_VOP) {          /* low_delay_default mode: repeat in packed_mode */
1513                  image_swap(&dec->refn[0], &dec->refn[1]);          if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {
1514                  image_swap(&dec->cur, &dec->refn[0]);                  success = 1;
1515                  // swap MACROBLOCK                  goto repeat;
1516                  if (dec->low_delay && vop_type == P_VOP)          }
1517                          mb_swap(&dec->mbs, &dec->last_mbs);  
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                    }
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.24  
changed lines
  Added in v.1.69

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