[svn] / branches / release-1_3-branch / xvidcore / src / decoder.c Repository:
ViewVC logotype

Diff of /branches/release-1_3-branch/xvidcore/src/decoder.c

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

trunk/xvidcore/src/decoder.c revision 605, Sat Oct 19 12:20:33 2002 UTC branches/release-1_3-branch/xvidcore/src/decoder.c revision 2180, Tue Nov 12 14:48:35 2019 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   *  Copyright(C) 2002 MinChen <chenm001@163.com>   *  Copyright(C) 2002 MinChen <chenm001@163.com>
7   *               2002 Peter Ross <pross@xvid.org>   *               2002-2010 Peter Ross <pross@xvid.org>
  *  
  *  This program is an implementation of a part of one or more MPEG-4  
  *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending  
  *  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 29  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   *   *
23   *************************************************************************/   * $Id$
   
 /**************************************************************************  
  *  
  *  History:  
  *  
  *  15.07.2002  fix a bug in B-frame decode at DIRECT mode  
   
  *  10.07.2002  added BFRAMES_DEC_DEBUG support  
  *              Fix a little bug for low_delay flage  
  *              MinChen <chenm001@163.com>  
  *  28.06.2002  added basic resync support to iframe/pframe_decode()  
  *  22.06.2002  added primative N_VOP support  
  *                              #define BFRAMES_DEC now enables Minchen'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@xvid.org>  
  *  
  *  $Id: decoder.c,v 1.42 2002-10-19 12:20:33 edgomez Exp $  
24   *   *
25   *************************************************************************/   ****************************************************************************/
26    
27    #include <stdio.h>
28  #include <stdlib.h>  #include <stdlib.h>
29  #include <string.h>  #include <string.h>
30    
# Line 71  Line 34 
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  #define DIV2ROUND(n)  (((n)>>1)|((n)&1))
65  decoder_create(XVID_DEC_PARAM * param)  #define DIV2(n)       ((n)>>1)
66    #define DIVUVMOV(n) (((n) >> 1) + roundtab_79[(n) & 0x3]) //
67    
68    static int
69    decoder_resize(DECODER * dec)
70  {  {
71          DECODER *dec;          /* free existing */
72            image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
73            image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
74            image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
75            image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
76            image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
77    
78          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;  
79    
80          dec->width = param->width;    image_null(&dec->cur);
81          dec->height = param->height;    image_null(&dec->refn[0]);
82      image_null(&dec->refn[1]);
83      image_null(&dec->tmp);
84      image_null(&dec->qtmp);
85      image_null(&dec->gmc);
86    
87    
88      xvid_free(dec->last_mbs);
89      xvid_free(dec->mbs);
90      xvid_free(dec->qscale);
91      dec->last_mbs = NULL;
92      dec->mbs = NULL;
93      dec->qscale = NULL;
94    
95            /* realloc */
96          dec->mb_width = (dec->width + 15) / 16;          dec->mb_width = (dec->width + 15) / 16;
97          dec->mb_height = (dec->height + 15) / 16;          dec->mb_height = (dec->height + 15) / 16;
98    
99          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
100          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
         dec->low_delay = 0;  
   
         if (image_create(&dec->cur, dec->edged_width, dec->edged_height)) {  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
101    
102          if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {          if (   image_create(&dec->cur, dec->edged_width, dec->edged_height)
103                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);              || image_create(&dec->refn[0], dec->edged_width, dec->edged_height)
104                  xvid_free(dec);              || image_create(&dec->refn[1], dec->edged_width, dec->edged_height)         /* Support B-frame to reference last 2 frame */
105                  return XVID_ERR_MEMORY;              || image_create(&dec->tmp, dec->edged_width, dec->edged_height)
106          }              || image_create(&dec->qtmp, dec->edged_width, dec->edged_height)
107          // add by chenm001 <chenm001@163.com>        || image_create(&dec->gmc, dec->edged_width, dec->edged_height) )
108          // for support B-frame to reference last 2 frame      goto memory_error;
         if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
         if (image_create(&dec->refn[2], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
109    
110          dec->mbs =          dec->mbs =
111                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
112                                          CACHE_LINE);                                          CACHE_LINE);
113          if (dec->mbs == NULL) {          if (dec->mbs == NULL)
114                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);            goto memory_error;
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
115          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
116    
117          // add by chenm001 <chenm001@163.com>          /* For skip MB flag */
         // for skip MB flag  
118          dec->last_mbs =          dec->last_mbs =
119                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120                                          CACHE_LINE);                                          CACHE_LINE);
121          if (dec->last_mbs == NULL) {          if (dec->last_mbs == NULL)
122              goto memory_error;
123            memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124    
125            /* nothing happens if that fails */
126            dec->qscale =
127                    xvid_malloc(sizeof(int) * dec->mb_width * dec->mb_height, CACHE_LINE);
128    
129            if (dec->qscale)
130                    memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131    
132            return 0;
133    
134    memory_error:
135            /* Most structures were deallocated / nullifieded, so it should be safe */
136            /* decoder_destroy(dec) minus the write_timer */
137                  xvid_free(dec->mbs);                  xvid_free(dec->mbs);
138                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141                  image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143    
144                  xvid_free(dec);                  xvid_free(dec);
145                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
146          }          }
147    
148          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);  
149    int
150    decoder_create(xvid_dec_create_t * create)
151    {
152      int ret = 0;
153      DECODER *dec;
154    
155      if (XVID_VERSION_MAJOR(create->version) != 1) /* v1.x.x */
156        return XVID_ERR_VERSION;
157    
158      dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
159      if (dec == NULL) {
160        return XVID_ERR_MEMORY;
161      }
162    
163      memset(dec, 0, sizeof(DECODER));
164    
165      dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
166      if (dec->mpeg_quant_matrices == NULL) {
167        xvid_free(dec);
168        return XVID_ERR_MEMORY;
169      }
170    
171      create->handle = dec;
172    
173      dec->width = MAX(0, create->width);
174      dec->height = MAX(0, create->height);
175    
176      dec->num_threads = MAX(0, create->num_threads);
177    
178      image_null(&dec->cur);
179      image_null(&dec->refn[0]);
180      image_null(&dec->refn[1]);
181      image_null(&dec->tmp);
182      image_null(&dec->qtmp);
183    
184      /* image based GMC */
185      image_null(&dec->gmc);
186    
187      dec->mbs = NULL;
188      dec->last_mbs = NULL;
189      dec->qscale = NULL;
190    
191          init_timer();          init_timer();
192      init_postproc(&dec->postproc);
193      init_mpeg_matrix(dec->mpeg_quant_matrices);
194    
195          // add by chenm001 <chenm001@163.com>    /* For B-frame support (used to save reference frame's time */
196          // for support B-frame to save reference frame's time    dec->frames = 0;
         dec->frames = -1;  
197          dec->time = dec->time_base = dec->last_time_base = 0;          dec->time = dec->time_base = dec->last_time_base = 0;
198      dec->low_delay = 0;
199      dec->packed_mode = 0;
200      dec->time_inc_resolution = 1; /* until VOL header says otherwise */
201      dec->ver_id = 1;
202    
203      if (create->fourcc == ((int)('X')|((int)('V')<<8)|
204                             ((int)('I')<<16)|((int)('D')<<24))) { /* XVID */
205        dec->bs_version = 0; /* Initially assume oldest xvid version */
206      }
207      else {
208            dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
209      }
210    
211          return XVID_ERR_OK;    dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
212    
213      ret = decoder_resize(dec);
214      if (ret == XVID_ERR_MEMORY) create->handle = NULL;
215    
216      return ret;
217  }  }
218    
219    
# Line 186  Line 222 
222  {  {
223          xvid_free(dec->last_mbs);          xvid_free(dec->last_mbs);
224          xvid_free(dec->mbs);          xvid_free(dec->mbs);
225      xvid_free(dec->qscale);
226    
227      /* image based GMC */
228      image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
229    
230          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
231          image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);          image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
232          image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
233      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
234          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
235      xvid_free(dec->mpeg_quant_matrices);
236          xvid_free(dec);          xvid_free(dec);
237    
238          write_timer();          write_timer();
239          return XVID_ERR_OK;    return 0;
240  }  }
241    
   
   
242  static const int32_t dquant_table[4] = {  static const int32_t dquant_table[4] = {
243          -1, -2, 1, 2          -1, -2, 1, 2
244  };  };
245    
246    /* decode an intra macroblock */
247    static void
   
 // decode an intra macroblock  
   
 void  
248  decoder_mbintra(DECODER * dec,  decoder_mbintra(DECODER * dec,
249                                  MACROBLOCK * pMB,                                  MACROBLOCK * pMB,
250                                  const uint32_t x_pos,                                  const uint32_t x_pos,
# Line 227  Line 264 
264          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
265          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
266          uint32_t i;          uint32_t i;
267          uint32_t iQuant = pMB->quant;    uint32_t iQuant = MAX(1, pMB->quant);
268          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
269    
270          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
271          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
272          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
273    
274          memset(block, 0, 6 * 64 * sizeof(int16_t));     // clear    memset(block, 0, 6 * 64 * sizeof(int16_t)); /* clear */
275    
276          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
277                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
# Line 257  Line 294 
294                          dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0;                          dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0;
295    
296                          if (dc_size > 8) {                          if (dc_size > 8) {
297                                  BitstreamSkip(bs, 1);   // marker          BitstreamSkip(bs, 1); /* marker */
298                          }                          }
299    
300                          block[i * 64 + 0] = dc_dif;                          block[i * 64 + 0] = dc_dif;
301                          start_coeff = 1;                          start_coeff = 1;
302    
303                          DPRINTF(DPRINTF_COEFF,"block[0] %i", dc_dif);        DPRINTF(XVID_DEBUG_COEFF,"block[0] %i\n", dc_dif);
304                  } else {                  } else {
305                          start_coeff = 0;                          start_coeff = 0;
306                  }                  }
307    
308                  start_timer();                  start_timer();
309                  if (cbp & (1 << (5 - i)))       // coded      if (cbp & (1 << (5 - i))) /* coded */
310                  {                  {
311                          get_intra_block(bs, &block[i * 64], pMB->acpred_directions[i],        int direction = dec->alternate_vertical_scan ?
312                                                          start_coeff);          2 : pMB->acpred_directions[i];
313    
314          get_intra_block(bs, &block[i * 64], direction, start_coeff);
315                  }                  }
316                  stop_coding_timer();                  stop_coding_timer();
317    
318                  start_timer();                  start_timer();
319                  add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors);      add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors, dec->bs_version);
320                  stop_prediction_timer();                  stop_prediction_timer();
321    
322                  start_timer();                  start_timer();
323                  if (dec->quant_type == 0) {                  if (dec->quant_type == 0) {
324                          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);
325                  } else {                  } else {
326                          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);
327                  }                  }
328                  stop_iquant_timer();                  stop_iquant_timer();
329    
330                  start_timer();                  start_timer();
331                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
332                  stop_idct_timer();                  stop_idct_timer();
333    
334          }          }
335    
336          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
# Line 308  Line 348 
348          stop_transfer_timer();          stop_transfer_timer();
349  }  }
350    
351    static void
352    decoder_mb_decode(DECODER * dec,
353            const uint32_t cbp,
354            Bitstream * bs,
355            uint8_t * pY_Cur,
356            uint8_t * pU_Cur,
357            uint8_t * pV_Cur,
358            const MACROBLOCK * pMB)
359    {
360      DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
361    
362      int stride = dec->edged_width;
363      int i;
364      const uint32_t iQuant = MAX(1, pMB->quant);
365      const int direction = dec->alternate_vertical_scan ? 2 : 0;
366      typedef void (*get_inter_block_function_t)(
367          Bitstream * bs,
368          int16_t * block,
369          int direction,
370          const int quant,
371          const uint16_t *matrix);
372      typedef void (*add_residual_function_t)(
373          uint8_t *predicted_block,
374          const int16_t *residual,
375          int stride);
376    
377      const get_inter_block_function_t get_inter_block = (dec->quant_type == 0)
378        ? (get_inter_block_function_t)get_inter_block_h263
379        : (get_inter_block_function_t)get_inter_block_mpeg;
380    
381      uint8_t *dst[6];
382      int strides[6];
383    
384    
385      if (dec->interlacing && pMB->field_dct) {
386        dst[0] = pY_Cur;
387        dst[1] = pY_Cur + 8;
388        dst[2] = pY_Cur + stride;
389        dst[3] = dst[2] + 8;
390        dst[4] = pU_Cur;
391        dst[5] = pV_Cur;
392        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
393        strides[4] = stride/2;
394        strides[5] = stride/2;
395      } else {
396        dst[0] = pY_Cur;
397        dst[1] = pY_Cur + 8;
398        dst[2] = pY_Cur + 8*stride;
399        dst[3] = dst[2] + 8;
400        dst[4] = pU_Cur;
401        dst[5] = pV_Cur;
402        strides[0] = strides[1] = strides[2] = strides[3] = stride;
403        strides[4] = stride/2;
404        strides[5] = stride/2;
405      }
406    
407      for (i = 0; i < 6; i++) {
408        /* Process only coded blocks */
409        if (cbp & (1 << (5 - i))) {
410    
411          /* Clear the block */
412          memset(&data[0], 0, 64*sizeof(int16_t));
413    
414          /* Decode coeffs and dequantize on the fly */
415          start_timer();
416          get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
417          stop_coding_timer();
418    
419  #define SIGN(X) (((X)>0)?1:-1)        /* iDCT */
420  #define ABS(X) (((X)>0)?(X):-(X))        start_timer();
421  static const uint32_t roundtab[16] =        idct((short * const)&data[0]);
422          { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };        stop_idct_timer();
423    
424          /* Add this residual to the predicted block */
425          start_timer();
426          transfer_16to8add(dst[i], &data[0], strides[i]);
427          stop_transfer_timer();
428        }
429      }
430    }
431    
432  // decode an inter macroblock  static void __inline
433    validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
434    {
435      /* clip a vector to valid range
436         prevents crashes if bitstream is broken
437      */
438      int shift = 5 + dec->quarterpel;
439      int xborder_high = (int)(dec->mb_width - x_pos) << shift;
440      int xborder_low = (-(int)x_pos-1) << shift;
441      int yborder_high = (int)(dec->mb_height - y_pos) << shift;
442      int yborder_low = (-(int)y_pos-1) << shift;
443    
444    #define CHECK_MV(mv) \
445      do { \
446      if ((mv).x > xborder_high) { \
447        DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
448        (mv).x = xborder_high; \
449      } else if ((mv).x < xborder_low) { \
450        DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
451        (mv).x = xborder_low; \
452      } \
453      if ((mv).y > yborder_high) { \
454        DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
455        (mv).y = yborder_high; \
456      } else if ((mv).y < yborder_low) { \
457        DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
458        (mv).y = yborder_low; \
459      } \
460      } while (0)
461    
462      CHECK_MV(mv[0]);
463      CHECK_MV(mv[1]);
464      CHECK_MV(mv[2]);
465      CHECK_MV(mv[3]);
466    }
467    
468    /* Up to this version, chroma rounding was wrong with qpel.
469     * So we try to be backward compatible to avoid artifacts */
470    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
471    
472  void  /* decode an inter macroblock */
473    static void
474  decoder_mbinter(DECODER * dec,  decoder_mbinter(DECODER * dec,
475                                  const MACROBLOCK * pMB,                                  const MACROBLOCK * pMB,
476                                  const uint32_t x_pos,                                  const uint32_t x_pos,
477                                  const uint32_t y_pos,                                  const uint32_t y_pos,
                                 const uint32_t acpred_flag,  
478                                  const uint32_t cbp,                                  const uint32_t cbp,
479                                  Bitstream * bs,                                  Bitstream * bs,
480                                  const uint32_t quant,          const uint32_t rounding,
481                                  const uint32_t rounding)          const int ref,
482                    const int bvop)
483  {  {
   
         DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);  
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
   
484          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
485          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
         uint32_t next_block = stride * 8;  
486          uint32_t i;          uint32_t i;
487          uint32_t iQuant = pMB->quant;  
488          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
489    
490          int uv_dx, uv_dy;          int uv_dx, uv_dy;
491      VECTOR mv[4]; /* local copy of mvs */
492    
493          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
494          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
495          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
496      for (i = 0; i < 4; i++)
497        mv[i] = pMB->mvs[i];
498    
499          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;  
500    
501                  if (dec->quarterpel)    start_timer();
502                  {  
503      if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
504    
505        uv_dx = mv[0].x;
506        uv_dy = mv[0].y;
507        if (dec->quarterpel) {
508                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
509                          uv_dx = (uv_dx >> 1) | (uv_dx & 1);                          uv_dx = (uv_dx >> 1) | (uv_dx & 1);
510                          uv_dy = (uv_dy >> 1) | (uv_dy & 1);                          uv_dy = (uv_dy >> 1) | (uv_dy & 1);
511                  }                  }
512                            else {
513                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;          uv_dx /= 2;
514                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;          uv_dy /= 2;
         } else {  
                 int sum;  
                 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
   
                 if (dec->quarterpel)  
                 {  
                         sum /= 2;  
515                  }                  }
516        }
517                  uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));      uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
518        uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
                 sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;  
519    
520                  if (dec->quarterpel)                  if (dec->quarterpel)
521                  {        interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,
522                          sum /= 2;                    dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
523                  }                        mv[0].x, mv[0].y, stride, rounding);
524        else
525          interpolate16x16_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos, 16*y_pos,
526                      mv[0].x, mv[0].y, stride, rounding);
527    
528                  uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));    } else {  /* MODE_INTER4V */
         }  
529    
         start_timer();  
530          if(dec->quarterpel) {          if(dec->quarterpel) {
531                  DPRINTF(DPRINTF_DEBUG, "QUARTERPEL\n");                          if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
532                  interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos,                                  int z;
533                                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride,  rounding);                                  uv_dx = 0; uv_dy = 0;
534                  interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,                                  for (z = 0; z < 4; z++) {
535                                                                    pMB->mvs[1].x, pMB->mvs[1].y, stride,  rounding);                                    uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
536                  interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,                                    uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
537                                                                    pMB->mvs[2].x, pMB->mvs[2].y, stride,  rounding);                                  }
                 interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,  
                                                                   pMB->mvs[3].x, pMB->mvs[3].y, stride,  rounding);  
538          }          }
539          else {          else {
540            uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
541            uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
542          }
543        } else {
544          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
545          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
546        }
547    
548        uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
549        uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
550    
551        if (dec->quarterpel) {
552          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
553                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
554                      mv[0].x, mv[0].y, stride, rounding);
555          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
556                      dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
557                      mv[1].x, mv[1].y, stride, rounding);
558          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
559                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
560                      mv[2].x, mv[2].y, stride, rounding);
561          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
562                      dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
563                      mv[3].x, mv[3].y, stride, rounding);
564        } else {
565                  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,
566                                                            pMB->mvs[0].x, pMB->mvs[0].y, stride,  rounding);                  mv[0].x, mv[0].y, stride, rounding);
567                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,
568                                                            pMB->mvs[1].x, pMB->mvs[1].y, stride,  rounding);                  mv[1].x, mv[1].y, stride, rounding);
569                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,
570                                                            pMB->mvs[2].x, pMB->mvs[2].y, stride,  rounding);                  mv[2].x, mv[2].y, stride, rounding);
571                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,
572                                                            pMB->mvs[3].x, pMB->mvs[3].y, stride,  rounding);                  mv[3].x, mv[3].y, stride, rounding);
573        }
574          }          }
575    
576          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,    /* chroma */
577      interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
578                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
579          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,
580                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
581    
582          stop_comp_timer();          stop_comp_timer();
583    
584          for (i = 0; i < 6; i++) {    if (cbp)
585                  if (cbp & (1 << (5 - i)))       // coded      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
586    }
587    
588    /* decode an inter macroblock in field mode */
589    static void
590    decoder_mbinter_field(DECODER * dec,
591            const MACROBLOCK * pMB,
592            const uint32_t x_pos,
593            const uint32_t y_pos,
594            const uint32_t cbp,
595            Bitstream * bs,
596            const uint32_t rounding,
597            const int ref,
598                    const int bvop)
599                  {                  {
600                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear    uint32_t stride = dec->edged_width;
601      uint32_t stride2 = stride / 2;
602    
603                          start_timer();    uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
                         get_inter_block(bs, &block[i * 64]);  
                         stop_coding_timer();  
604    
605                          start_timer();    int uvtop_dx, uvtop_dy;
606                          if (dec->quant_type == 0) {    int uvbot_dx, uvbot_dy;
607                                  dequant_inter(&data[i * 64], &block[i * 64], iQuant);    VECTOR mv[4]; /* local copy of mvs */
608                          } else {  
609                                  dequant4_inter(&data[i * 64], &block[i * 64], iQuant);    /* Get pointer to memory areas */
610                          }    pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
611                          stop_iquant_timer();    pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
612      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
613    
614      mv[0] = pMB->mvs[0];
615      mv[1] = pMB->mvs[1];
616      memset(&mv[2],0,2*sizeof(VECTOR));
617    
618      validate_vector(mv, x_pos, y_pos, dec);
619    
620                          start_timer();                          start_timer();
621                          idct(&data[i * 64]);  
622                          stop_idct_timer();    if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
623      {
624        /* Prepare top field vector */
625        uvtop_dx = DIV2ROUND(mv[0].x);
626        uvtop_dy = DIV2ROUND(mv[0].y);
627    
628        /* Prepare bottom field vector */
629        uvbot_dx = DIV2ROUND(mv[1].x);
630        uvbot_dy = DIV2ROUND(mv[1].y);
631    
632        if(dec->quarterpel)
633        {
634          /* NOT supported */
635        }
636        else
637        {
638          /* Interpolate top field left part(we use double stride for every 2nd line) */
639          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
640                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
641          /* top field right part */
642          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
643                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
644    
645          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
646          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
647                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
648          /* Bottom field right part */
649          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
650                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
651    
652          /* Interpolate field1 U */
653          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
654                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
655    
656          /* Interpolate field1 V */
657          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
658                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
659    
660          /* Interpolate field2 U */
661          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
662                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
663    
664          /* Interpolate field2 V */
665          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
666                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
667        }
668                  }                  }
669      else
670      {
671        /* We don't expect 4 motion vectors in interlaced mode */
672          }          }
673    
674          if (dec->interlacing && pMB->field_dct) {    stop_comp_timer();
675                  next_block = stride;  
676                  stride *= 2;    /* Must add error correction? */
677      if(cbp)
678       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
679          }          }
680    
681    static void
682    decoder_mbgmc(DECODER * dec,
683            MACROBLOCK * const pMB,
684            const uint32_t x_pos,
685            const uint32_t y_pos,
686            const uint32_t fcode,
687            const uint32_t cbp,
688            Bitstream * bs,
689            const uint32_t rounding)
690    {
691      const uint32_t stride = dec->edged_width;
692      const uint32_t stride2 = stride / 2;
693    
694      uint8_t *const pY_Cur=dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
695      uint8_t *const pU_Cur=dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
696      uint8_t *const pV_Cur=dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
697    
698      NEW_GMC_DATA * gmc_data = &dec->new_gmc_data;
699    
700      pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
701    
702          start_timer();          start_timer();
703          if (cbp & 32)  
704                  transfer_16to8add(pY_Cur, &data[0 * 64], stride);  /* this is where the calculations are done */
705          if (cbp & 16)  
706                  transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);    gmc_data->predict_16x16(gmc_data,
707          if (cbp & 8)        dec->cur.y + y_pos*16*stride + x_pos*16, dec->refn[0].y,
708                  transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);        stride, stride, x_pos, y_pos, rounding);
709          if (cbp & 4)  
710                  transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);    gmc_data->predict_8x8(gmc_data,
711          if (cbp & 2)        dec->cur.u + y_pos*8*stride2 + x_pos*8, dec->refn[0].u,
712                  transfer_16to8add(pU_Cur, &data[4 * 64], stride2);        dec->cur.v + y_pos*8*stride2 + x_pos*8, dec->refn[0].v,
713          if (cbp & 1)        stride2, stride2, x_pos, y_pos, rounding);
714                  transfer_16to8add(pV_Cur, &data[5 * 64], stride2);  
715      gmc_data->get_average_mv(gmc_data, &pMB->amv, x_pos, y_pos, dec->quarterpel);
716    
717      pMB->amv.x = gmc_sanitize(pMB->amv.x, dec->quarterpel, fcode);
718      pMB->amv.y = gmc_sanitize(pMB->amv.y, dec->quarterpel, fcode);
719    
720      pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
721    
722          stop_transfer_timer();          stop_transfer_timer();
723    
724      if (cbp)
725        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
726    
727  }  }
728    
729    
730  void  static void
731  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
732                             Bitstream * bs,                             Bitstream * bs,
733                             int quant,                             int quant,
# Line 462  Line 735 
735  {  {
736          uint32_t bound;          uint32_t bound;
737          uint32_t x, y;          uint32_t x, y;
738      const uint32_t mb_width = dec->mb_width;
739      const uint32_t mb_height = dec->mb_height;
740    
741          bound = 0;          bound = 0;
742    
743          for (y = 0; y < dec->mb_height; y++) {    for (y = 0; y < mb_height; y++) {
744                  for (x = 0; x < dec->mb_width; x++) {      for (x = 0; x < mb_width; x++) {
745                          MACROBLOCK *mb;                          MACROBLOCK *mb;
746                          uint32_t mcbpc;                          uint32_t mcbpc;
747                          uint32_t cbpc;                          uint32_t cbpc;
# Line 479  Line 754 
754    
755                          if (check_resync_marker(bs, 0))                          if (check_resync_marker(bs, 0))
756                          {                          {
757                                  bound = read_video_packet_header(bs, 0, &quant);          bound = read_video_packet_header(bs, dec, 0,
758                                  x = bound % dec->mb_width;                &quant, NULL, NULL, &intra_dc_threshold);
759                                  y = bound / dec->mb_width;          x = bound % mb_width;
760            y = MIN((bound / mb_width), (mb_height-1));
761                          }                          }
762                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
763    
764                          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));
765    
766                          mcbpc = get_mcbpc_intra(bs);                          mcbpc = get_mcbpc_intra(bs);
767                          mb->mode = mcbpc & 7;                          mb->mode = mcbpc & 7;
# Line 512  Line 788 
788    
789                          if (dec->interlacing) {                          if (dec->interlacing) {
790                                  mb->field_dct = BitstreamGetBit(bs);                                  mb->field_dct = BitstreamGetBit(bs);
791                                  DPRINTF(DPRINTF_DEBUG, "deci: field_dct: %d", mb->field_dct);          DPRINTF(XVID_DEBUG_MB,"deci: field_dct: %i\n", mb->field_dct);
792                          }                          }
793    
794                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
795                                                          intra_dc_threshold, bound);                                                          intra_dc_threshold, bound);
796    
797                  }                  }
798                  if(dec->out_frm)                  if(dec->out_frm)
799                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,dec->mb_width);        output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,mb_width);
   
800          }          }
801    
802  }  }
803    
804    
805  void  static void
806  get_motion_vector(DECODER * dec,  get_motion_vector(DECODER * dec,
807                                    Bitstream * bs,                                    Bitstream * bs,
808                                    int x,                                    int x,
809                                    int y,                                    int y,
810                                    int k,                                    int k,
811                                    VECTOR * mv,          VECTOR * ret_mv,
812                                    int fcode,                                    int fcode,
813                                    const int bound)                                    const int bound)
814  {  {
815    
816          int scale_fac = 1 << (fcode - 1);    const int scale_fac = 1 << (fcode - 1);
817          int high = (32 * scale_fac) - 1;    const int high = (32 * scale_fac) - 1;
818          int low = ((-32) * scale_fac);    const int low = ((-32) * scale_fac);
819          int range = (64 * scale_fac);    const int range = (64 * scale_fac);
820    
821          VECTOR pmv;    const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
822          int mv_x, mv_y;    VECTOR mv;
   
         pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);  
823    
824          mv_x = get_mv(bs, fcode);    mv.x = get_mv(bs, fcode);
825          mv_y = get_mv(bs, fcode);    mv.y = get_mv(bs, fcode);
826    
827          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);
828    
829          mv_x += pmv.x;    mv.x += pmv.x;
830          mv_y += pmv.y;    mv.y += pmv.y;
831    
832          if (mv_x < low) {    if (mv.x < low) {
833                  mv_x += range;      mv.x += range;
834          } else if (mv_x > high) {    } else if (mv.x > high) {
835                  mv_x -= range;      mv.x -= range;
836          }          }
837    
838          if (mv_y < low) {    if (mv.y < low) {
839                  mv_y += range;      mv.y += range;
840          } else if (mv_y > high) {    } else if (mv.y > high) {
841                  mv_y -= range;      mv.y -= range;
842          }          }
843    
844          mv->x = mv_x;    ret_mv->x = mv.x;
845          mv->y = mv_y;    ret_mv->y = mv.y;
   
846  }  }
847    
848    /* We use this when decoder runs interlaced -> different prediction */
849    
850  void  static void get_motion_vector_interlaced(DECODER * dec,
 decoder_pframe(DECODER * dec,  
851                             Bitstream * bs,                             Bitstream * bs,
852                             int rounding,          int x,
853                             int quant,          int y,
854            int k,
855            MACROBLOCK *pMB,
856                             int fcode,                             int fcode,
857                             int intra_dc_threshold)          const int bound)
858  {  {
859      const int scale_fac = 1 << (fcode - 1);
860      const int high = (32 * scale_fac) - 1;
861      const int low = ((-32) * scale_fac);
862      const int range = (64 * scale_fac);
863    
864          uint32_t x, y;    /* Get interlaced prediction */
865          uint32_t bound;    const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
866          int cp_mb, st_mb;    VECTOR mv,mvf1,mvf2;
867    
868          start_timer();    if(!pMB->field_pred)
869          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,    {
870                                     dec->width, dec->height);      mv.x = get_mv(bs,fcode);
871          stop_edges_timer();      mv.y = get_mv(bs,fcode);
872    
873          bound = 0;      mv.x += pmv.x;
874        mv.y += pmv.y;
875    
876          for (y = 0; y < dec->mb_height; y++) {      if(mv.x<low) {
877                  cp_mb = st_mb = 0;        mv.x += range;
878                  for (x = 0; x < dec->mb_width; x++) {      } else if (mv.x>high) {
879                          MACROBLOCK *mb;        mv.x-=range;
880        }
881    
882                          // skip stuffing      if (mv.y < low) {
883                          while (BitstreamShowBits(bs, 10) == 1)        mv.y += range;
884                                  BitstreamSkip(bs, 10);      } else if (mv.y > high) {
885          mv.y -= range;
886        }
887    
888                          if (check_resync_marker(bs, fcode - 1))      pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
889      }
890      else
891                          {                          {
892                                  bound = read_video_packet_header(bs, fcode - 1, &quant);      mvf1.x = get_mv(bs, fcode);
893                                  x = bound % dec->mb_width;      mvf1.y = get_mv(bs, fcode);
894                                  y = bound / dec->mb_width;  
895        mvf1.x += pmv.x;
896        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
897    
898        if (mvf1.x < low) {
899          mvf1.x += range;
900        } else if (mvf1.x > high) {
901          mvf1.x -= range;
902                          }                          }
                         mb = &dec->mbs[y * dec->mb_width + x];  
903    
904                          DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));      if (mvf1.y < low) {
905          mvf1.y += range;
906        } else if (mvf1.y > high) {
907          mvf1.y -= range;
908        }
909    
910        mvf2.x = get_mv(bs, fcode);
911        mvf2.y = get_mv(bs, fcode);
912    
913        mvf2.x += pmv.x;
914        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
915    
916                          //if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs)))         // not_coded      if (mvf2.x < low) {
917                          if (!(BitstreamGetBit(bs)))     // not_coded        mvf2.x += range;
918        } else if (mvf2.x > high) {
919          mvf2.x -= range;
920        }
921    
922        if (mvf2.y < low) {
923          mvf2.y += range;
924        } else if (mvf2.y > high) {
925          mvf2.y -= range;
926        }
927    
928        pMB->mvs[0]=mvf1;
929        pMB->mvs[1]=mvf2;
930        pMB->mvs[2].x=pMB->mvs[3].x=0;
931        pMB->mvs[2].y=pMB->mvs[3].y=0;
932    
933        /* Calculate average for as it is field predicted */
934        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
935        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
936      }
937    }
938    
939    /* for P_VOP set gmc_warp to NULL */
940    static void
941    decoder_pframe(DECODER * dec,
942            Bitstream * bs,
943            int rounding,
944            int quant,
945            int fcode,
946            int intra_dc_threshold,
947            const WARPPOINTS *const gmc_warp)
948                          {                          {
949                                  uint32_t mcbpc;    uint32_t x, y;
950                                  uint32_t cbpc;    uint32_t bound;
951                                  uint32_t acpred_flag;    int cp_mb, st_mb;
952                                  uint32_t cbpy;    const uint32_t mb_width = dec->mb_width;
953                                  uint32_t cbp;    const uint32_t mb_height = dec->mb_height;
954                                  uint32_t intra;  
955      if (!dec->is_edged[0]) {
956        start_timer();
957        image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
958                dec->width, dec->height, dec->bs_version);
959        dec->is_edged[0] = 1;
960        stop_edges_timer();
961      }
962    
963      if (gmc_warp) {
964        /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
965        generate_GMCparameters( dec->sprite_warping_points,
966            dec->sprite_warping_accuracy, gmc_warp,
967            dec->width, dec->height, &dec->new_gmc_data);
968    
969        /* image warping is done block-based in decoder_mbgmc(), now */
970      }
971    
972      bound = 0;
973    
974      for (y = 0; y < mb_height; y++) {
975        cp_mb = st_mb = 0;
976        for (x = 0; x < mb_width; x++) {
977          MACROBLOCK *mb;
978    
979          /* skip stuffing */
980          while (BitstreamShowBits(bs, 10) == 1)
981            BitstreamSkip(bs, 10);
982    
983          if (check_resync_marker(bs, fcode - 1)) {
984            bound = read_video_packet_header(bs, dec, fcode - 1,
985              &quant, &fcode, NULL, &intra_dc_threshold);
986            x = bound % mb_width;
987            y = MIN((bound / mb_width), (mb_height-1));
988          }
989          mb = &dec->mbs[y * dec->mb_width + x];
990    
991          DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
992    
993          if (!(BitstreamGetBit(bs))) { /* block _is_ coded */
994            uint32_t mcbpc, cbpc, cbpy, cbp;
995            uint32_t intra, acpred_flag = 0;
996            int mcsel = 0;    /* mcsel: '0'=local motion, '1'=GMC */
997    
998                                  cp_mb++;                                  cp_mb++;
999                                  mcbpc = get_mcbpc_inter(bs);                                  mcbpc = get_mcbpc_inter(bs);
1000                                  mb->mode = mcbpc & 7;                                  mb->mode = mcbpc & 7;
1001                                  cbpc = (mcbpc >> 4);                                  cbpc = (mcbpc >> 4);
1002    
1003                                  DPRINTF(DPRINTF_MB, "mode %i", mb->mode);          DPRINTF(XVID_DEBUG_MB, "mode %i\n", mb->mode);
1004                                  DPRINTF(DPRINTF_MB, "cbpc %i", cbpc);          DPRINTF(XVID_DEBUG_MB, "cbpc %i\n", cbpc);
                                 acpred_flag = 0;  
1005    
1006                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);
1007    
1008                                  if (intra) {          if (gmc_warp && (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q))
1009              mcsel = BitstreamGetBit(bs);
1010            else if (intra)
1011                                          acpred_flag = BitstreamGetBit(bs);                                          acpred_flag = BitstreamGetBit(bs);
                                 }  
1012    
1013                                  cbpy = get_cbpy(bs, intra);                                  cbpy = get_cbpy(bs, intra);
1014                                  DPRINTF(DPRINTF_MB, "cbpy %i", cbpy);          DPRINTF(XVID_DEBUG_MB, "cbpy %i mcsel %i \n", cbpy,mcsel);
1015    
1016                                  cbp = (cbpy << 2) | cbpc;                                  cbp = (cbpy << 2) | cbpc;
1017    
1018                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {
1019                                          int dquant = dquant_table[BitstreamGetBits(bs, 2)];                                          int dquant = dquant_table[BitstreamGetBits(bs, 2)];
1020                                          DPRINTF(DPRINTF_MB, "dquant %i", dquant);            DPRINTF(XVID_DEBUG_MB, "dquant %i\n", dquant);
1021                                          quant += dquant;                                          quant += dquant;
1022                                          if (quant > 31) {                                          if (quant > 31) {
1023                                                  quant = 31;                                                  quant = 31;
1024                                          } else if (quant < 1) {                                          } else if (quant < 1) {
1025                                                  quant = 1;                                                  quant = 1;
1026                                          }                                          }
1027                                          DPRINTF(DPRINTF_MB, "quant %i", quant);            DPRINTF(XVID_DEBUG_MB, "quant %i\n", quant);
1028                                  }                                  }
1029                                  mb->quant = quant;                                  mb->quant = quant;
1030    
1031            mb->field_pred=0;
1032                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1033                                          if (cbp || intra) {                                          if (cbp || intra) {
1034                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
1035                                                  DPRINTF(DPRINTF_DEBUG, "decp: field_dct: %d", mb->field_dct);              DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1036                                          }                                          }
1037    
1038                                          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {            if ((mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) && !mcsel) {
1039                                                  mb->field_pred = BitstreamGetBit(bs);                                                  mb->field_pred = BitstreamGetBit(bs);
1040                                                  DPRINTF(DPRINTF_DEBUG, "decp: field_pred: %d", mb->field_pred);              DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1041    
1042                                                  if (mb->field_pred) {                                                  if (mb->field_pred) {
1043                                                          mb->field_for_top = BitstreamGetBit(bs);                                                          mb->field_for_top = BitstreamGetBit(bs);
1044                                                          DPRINTF(DPRINTF_DEBUG, "decp: field_for_top: %d", mb->field_for_top);                DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1045                                                          mb->field_for_bot = BitstreamGetBit(bs);                                                          mb->field_for_bot = BitstreamGetBit(bs);
1046                                                          DPRINTF(DPRINTF_DEBUG, "decp: field_for_bot: %d", mb->field_for_bot);                DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1047                                                  }                                                  }
1048                                          }                                          }
1049                                  }                                  }
1050    
1051                                  if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {          if (mcsel) {
1052                                          if (dec->interlacing && mb->field_pred) {            decoder_mbgmc(dec, mb, x, y, fcode, cbp, bs, rounding);
1053                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],            continue;
1054                                                                                    fcode, bound);  
1055                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],          } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1056                                                                                    fcode, bound);  
1057              if(dec->interlacing) {
1058                /* Get motion vectors interlaced, field_pred is handled there */
1059                get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1060                                          } else {                                          } else {
1061                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],              get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1062                                                                                    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;  
1063                                          }                                          }
1064                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1065              /* interlaced missing here */
1066                                          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);
1067                                          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);
1068                                          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);
1069                                          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);
1070                                  } else                  // MODE_INTRA, MODE_INTRA_Q          } else { /* MODE_INTRA, MODE_INTRA_Q */
1071                                  {            mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1072                                          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;  
1073                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1074                                                                          intra_dc_threshold, bound);                                                                          intra_dc_threshold, bound);
1075                                          continue;                                          continue;
1076                                  }                                  }
1077    
1078                                  decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant,          /* See how to decode */
1079                                                                  rounding);          if(!mb->field_pred)
1080                          } else                          // not coded           decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1081                          {          else
1082                                  DPRINTF(DPRINTF_DEBUG, "P-frame MB at (X,Y)=(%d,%d)", x, y);           decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1083    
1084          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1085            mb->mode = MODE_NOT_CODED_GMC;
1086            mb->quant = quant;
1087            decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
1088    
1089            if(dec->out_frm && cp_mb > 0) {
1090              output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1091              cp_mb = 0;
1092            }
1093            st_mb = x+1;
1094          } else { /* not coded P_VOP macroblock */
1095                                  mb->mode = MODE_NOT_CODED;                                  mb->mode = MODE_NOT_CODED;
1096            mb->quant = quant;
1097    
1098                                  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;
1099                                  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;
1100            mb->field_pred=0; /* (!) */
1101    
1102                                  // copy macroblock directly from ref to cur          decoder_mbinter(dec, mb, x, y, 0, bs,
1103                                    rounding, 0, 0);
                                 start_timer();  
1104    
                                 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);  
                                 stop_transfer_timer();  
1105                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1106                                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);                                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1107                                    cp_mb = 0;                                    cp_mb = 0;
# Line 760  Line 1109 
1109                                  st_mb = x+1;                                  st_mb = x+1;
1110                          }                          }
1111                  }                  }
1112    
1113                  if(dec->out_frm && cp_mb > 0)                  if(dec->out_frm && cp_mb > 0)
1114                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1115          }          }
1116  }  }
1117    
1118    
1119  // add by MinChen <chenm001@163.com>  /* decode B-frame motion vector */
1120  // decode B-frame motion vector  static void
1121  void  get_b_motion_vector(Bitstream * bs,
 get_b_motion_vector(DECODER * dec,  
                                         Bitstream * bs,  
                                         int x,  
                                         int y,  
1122                                          VECTOR * mv,                                          VECTOR * mv,
1123                                          int fcode,                                          int fcode,
1124                                          const VECTOR pmv)            const VECTOR pmv,
1125  {            const DECODER * const dec,
1126          int scale_fac = 1 << (fcode - 1);            const int x, const int y)
1127          int high = (32 * scale_fac) - 1;  {
1128          int low = ((-32) * scale_fac);    const int scale_fac = 1 << (fcode - 1);
1129          int range = (64 * scale_fac);    const int high = (32 * scale_fac) - 1;
1130      const int low = ((-32) * scale_fac);
1131          int mv_x, mv_y;    const int range = (64 * scale_fac);
         int pmv_x, pmv_y;  
   
         pmv_x = pmv.x;  
         pmv_y = pmv.y;  
1132    
1133          mv_x = get_mv(bs, fcode);    int mv_x = get_mv(bs, fcode);
1134          mv_y = get_mv(bs, fcode);    int mv_y = get_mv(bs, fcode);
1135    
1136          mv_x += pmv_x;    mv_x += pmv.x;
1137          mv_y += pmv_y;    mv_y += pmv.y;
1138    
1139          if (mv_x < low) {    if (mv_x < low)
1140                  mv_x += range;                  mv_x += range;
1141          } else if (mv_x > high) {    else if (mv_x > high)
1142                  mv_x -= range;                  mv_x -= range;
         }  
1143    
1144          if (mv_y < low) {    if (mv_y < low)
1145                  mv_y += range;                  mv_y += range;
1146          } else if (mv_y > high) {    else if (mv_y > high)
1147                  mv_y -= range;                  mv_y -= range;
         }  
1148    
1149          mv->x = mv_x;          mv->x = mv_x;
1150          mv->y = mv_y;          mv->y = mv_y;
1151  }  }
1152    
1153    /* decode an B-frame direct & interpolate macroblock */
1154  // add by MinChen <chenm001@163.com>  static void
1155  // decode an B-frame forward & backward inter macroblock  decoder_bf_interpolate_mbinter(DECODER * dec,
1156  void                  IMAGE forward,
1157  decoder_bf_mbinter(DECODER * dec,                  IMAGE backward,
1158                                     const MACROBLOCK * pMB,                  MACROBLOCK * pMB,
1159                                     const uint32_t x_pos,                                     const uint32_t x_pos,
1160                                     const uint32_t y_pos,                                     const uint32_t y_pos,
                                    const uint32_t cbp,  
1161                                     Bitstream * bs,                                     Bitstream * bs,
1162                                     const uint32_t quant,                  const int direct)
                                    const uint8_t ref)  
1163  {  {
   
         DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);  
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
   
1164          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
1165          uint32_t stride2 = stride / 2;          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;  
1166          int uv_dx, uv_dy;          int uv_dx, uv_dy;
1167      int b_uv_dx, b_uv_dy;
1168      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
1169      const uint32_t cbp = pMB->cbp;
1170    
1171          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
1172          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
1173          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
1174    
1175      validate_vector(pMB->mvs, x_pos, y_pos, dec);
1176      validate_vector(pMB->b_mvs, x_pos, y_pos, dec);
1177    
1178          if (!(pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {    if (!direct) {
1179                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
1180                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
1181        b_uv_dx = pMB->b_mvs[0].x;
1182        b_uv_dy = pMB->b_mvs[0].y;
1183    
1184                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;      if (dec->quarterpel) {
1185                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;                          if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1186          } else {                                  uv_dx = (uv_dx>>1) | (uv_dx&1);
1187                  int sum;                                  uv_dy = (uv_dy>>1) | (uv_dy&1);
1188                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1189                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                                  b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1190                  uv_dx =                          }
1191                          (sum ==                          else {
1192                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +          uv_dx /= 2;
1193                                                                    (ABS(sum) / 16) * 2));          uv_dy /= 2;
1194            b_uv_dx /= 2;
1195                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;          b_uv_dy /= 2;
1196                  uv_dy =        }
                         (sum ==  
                          0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +  
                                                                   (ABS(sum) / 16) * 2));  
1197          }          }
1198    
1199          start_timer();      uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1200          interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos, 16 * y_pos,      uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
1201                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);      b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];
1202          interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos + 8,      b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
                                                   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();  
1203    
                         start_timer();  
                         if (dec->quant_type == 0) {  
                                 dequant_inter(&data[i * 64], &block[i * 64], iQuant);  
1204                          } else {                          } else {
1205                                  dequant4_inter(&data[i * 64], &block[i * 64], iQuant);            if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1206                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1207                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1208                            int z;
1209                            uv_dx = 0; uv_dy = 0;
1210                            b_uv_dx = 0; b_uv_dy = 0;
1211                            for (z = 0; z < 4; z++) {
1212                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1213                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1214                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1215                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1216                          }                          }
                         stop_iquant_timer();  
   
                         start_timer();  
                         idct(&data[i * 64]);  
                         stop_idct_timer();  
1217                  }                  }
1218                    else {
1219                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1220                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1221                            b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1222                            b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1223          }          }
1224            } else {
1225          if (dec->interlacing && pMB->field_dct) {        uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1226                  next_block = stride;        uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1227                  stride *= 2;        b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1228          b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;
1229          }          }
1230    
1231          start_timer();      uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
1232          if (cbp & 32)      uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
1233                  transfer_16to8add(pY_Cur, &data[0 * 64], stride);      b_uv_dx = (b_uv_dx >> 3) + roundtab_76[b_uv_dx & 0xf];
1234          if (cbp & 16)      b_uv_dy = (b_uv_dy >> 3) + roundtab_76[b_uv_dy & 0xf];
                 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();  
1235  }  }
1236    
1237      start_timer();
1238  // add by MinChen <chenm001@163.com>    if(dec->quarterpel) {
1239  // decode an B-frame direct &  inter macroblock      if(!direct) {
1240  void        interpolate16x16_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1241  decoder_bf_interpolate_mbinter(DECODER * dec,                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1242                                                             IMAGE forward,                      pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
                                                            IMAGE backward,  
                                                            const MACROBLOCK * pMB,  
                                                            const uint32_t x_pos,  
                                                            const uint32_t y_pos,  
                                                            Bitstream * bs)  
 {  
   
         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 iQuant = pMB->quant;  
         int uv_dx, uv_dy;  
         int b_uv_dx, b_uv_dy;  
         uint32_t i;  
         uint8_t *pY_Cur, *pU_Cur, *pV_Cur;  
     const uint32_t cbp = pMB->cbp;  
   
         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;  
   
                 b_uv_dx = pMB->b_mvs[0].x;  
                 b_uv_dy = pMB->b_mvs[0].y;  
   
                 b_uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;  
                 b_uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
1243          } else {          } else {
1244                  int sum;        interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1245                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1246                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                      pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1247                  uv_dx =        interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1248                          (sum ==                      dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1249                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +                      pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1250                                                                    (ABS(sum) / 16) * 2));        interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1251                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1252                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;                      pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1253                  uv_dy =        interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1254                          (sum ==                      dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1255                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +                      pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
                                                                   (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));  
1256          }          }
1257      } else {
   
         start_timer();  
1258          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,
1259                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1260          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,
1261                                                    pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);                                                    pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1262          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,
1263                                                    pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);                                                    pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1264          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,
1265                                                    16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,                pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1266                                                    0);    }
1267    
1268          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,
1269                                                    uv_dy, stride2, 0);                                                    uv_dy, stride2, 0);
1270          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,
1271                                                    uv_dy, stride2, 0);                                                    uv_dy, stride2, 0);
1272    
1273    
1274          interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos, 16 * y_pos,    if(dec->quarterpel) {
1275        if(!direct) {
1276          interpolate16x16_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1277              dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1278                                                    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);  
1279                          } else {                          } else {
1280                                  dequant4_inter(&data[i * 64], &block[i * 64], iQuant);        interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1281                          }            dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1282                          stop_iquant_timer();            pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1283          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1284                          start_timer();            dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1285                          idct(&data[i * 64]);            pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1286                          stop_idct_timer();        interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1287              dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1288              pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1289          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1290              dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1291              pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1292                  }                  }
1293      } else {
1294        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos, 16 * y_pos,
1295            pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1296        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1297            16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1298        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos,
1299            16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1300        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1301            16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1302          }          }
1303    
1304          if (dec->interlacing && pMB->field_dct) {    interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1305                  next_block = stride;        b_uv_dx, b_uv_dy, stride2, 0);
1306                  stride *= 2;    interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1307          }        b_uv_dx, b_uv_dy, stride2, 0);
1308    
1309          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();  
 }  
1310    
1311      if (cbp)
1312        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1313    }
1314    
1315  // add by MinChen <chenm001@163.com>  /* for decode B-frame dbquant */
1316  // for decode B-frame dbquant  static __inline int32_t
 int32_t __inline  
1317  get_dbquant(Bitstream * bs)  get_dbquant(Bitstream * bs)
1318  {  {
1319          if (!BitstreamGetBit(bs))       // '0'    if (!BitstreamGetBit(bs))   /*  '0' */
1320                  return (0);                  return (0);
1321          else if (!BitstreamGetBit(bs))  // '10'    else if (!BitstreamGetBit(bs))  /* '10' */
1322                  return (-2);                  return (-2);
1323          else    else              /* '11' */
1324                  return (2);                             // '11'      return (2);
1325  }  }
1326    
1327  // add by MinChen <chenm001@163.com>  /*
1328  // for decode B-frame mb_type   * decode B-frame mb_type
1329  // bit   ret_value   * bit    ret_value
1330  // 1        0   * 1    0
1331  // 01       1   * 01   1
1332  // 001      2   * 001    2
1333  // 0001     3   * 0001   3
1334  int32_t __inline   */
1335    static int32_t __inline
1336  get_mbtype(Bitstream * bs)  get_mbtype(Bitstream * bs)
1337  {  {
1338          int32_t mb_type;          int32_t mb_type;
1339    
1340          for (mb_type = 0; mb_type <= 3; mb_type++) {    for (mb_type = 0; mb_type <= 3; mb_type++)
1341                  if (BitstreamGetBit(bs))                  if (BitstreamGetBit(bs))
1342                          break;        return (mb_type);
1343    
1344      return -1;
1345          }          }
1346    
1347          if (mb_type <= 3)  static int __inline get_resync_len_b(const int fcode_backward,
1348                  return (mb_type);                                       const int fcode_forward) {
1349          else    int resync_len = ((fcode_forward>fcode_backward) ? fcode_forward : fcode_backward) - 1;
1350                  return (-1);    if (resync_len < 1) resync_len = 1;
1351      return resync_len;
1352  }  }
1353    
1354  void  static void
1355  decoder_bframe(DECODER * dec,  decoder_bframe(DECODER * dec,
1356                             Bitstream * bs,                             Bitstream * bs,
1357                             int quant,                             int quant,
# Line 1136  Line 1361 
1361          uint32_t x, y;          uint32_t x, y;
1362          VECTOR mv;          VECTOR mv;
1363          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
1364  #ifdef BFRAMES_DEC_DEBUG    int i;
1365          FILE *fp;    int resync_len;
         static char first=0;  
 #define BFRAME_DEBUG    if (!first && fp){ \  
                 fprintf(fp,"Y=%3d   X=%3d   MB=%2d   CBP=%02X\n",y,x,mb->mb_type,mb->cbp); \  
         }  
 #endif  
1366    
1367      if (!dec->is_edged[0]) {
1368          start_timer();          start_timer();
1369          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1370                                     dec->width, dec->height);              dec->width, dec->height, dec->bs_version);
1371          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,      dec->is_edged[0] = 1;
                                    dec->width, dec->height);  
1372          stop_edges_timer();          stop_edges_timer();
1373      }
1374    
1375  #ifdef BFRAMES_DEC_DEBUG    if (!dec->is_edged[1]) {
1376          if (!first){      start_timer();
1377                  fp=fopen("C:\\XVIDDBG.TXT","w");      image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1378                dec->width, dec->height, dec->bs_version);
1379        dec->is_edged[1] = 1;
1380        stop_edges_timer();
1381          }          }
 #endif  
1382    
1383      resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1384          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1385                  // Initialize Pred Motion Vector      /* Initialize Pred Motion Vector */
1386                  dec->p_fmv = dec->p_bmv = zeromv;                  dec->p_fmv = dec->p_bmv = zeromv;
1387                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
1388                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1389                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1390          int intra_dc_threshold; /* fake variable */
1391    
1392                          mv =                          mv =
1393                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1394                          mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;                          mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1395          mb->quant = quant;
1396    
1397          /*
1398           * skip if the co-located P_VOP macroblock is not coded
1399           * if not codec in co-located S_VOP macroblock is _not_
1400           * automatically skipped
1401           */
1402    
                         // the last P_VOP is skip macroblock ?  
1403                          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);  
1404                                  mb->cbp = 0;                                  mb->cbp = 0;
1405  #ifdef BFRAMES_DEC_DEBUG          mb->mode = MODE_FORWARD;
1406                                  mb->mb_type = MODE_NOT_CODED;          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
         BFRAME_DEBUG  
 #endif  
                                 mb->mb_type = MODE_FORWARD;  
                                 mb->quant = last_mb->quant;  
                                 //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;  
   
                                 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, mb->quant, 1);  
1407                                  continue;                                  continue;
1408                          }                          }
1409    
1410                          if (!BitstreamGetBit(bs)) {     // modb=='0'        if (check_resync_marker(bs, resync_len)) {
1411            int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1412                               &fcode_forward, &fcode_backward, &intra_dc_threshold);
1413    
1414                    bound = MAX(0, bound-1); /* valid bound must always be >0 */
1415            x = bound % dec->mb_width;
1416            y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1417            /* reset predicted macroblocks */
1418            dec->p_fmv = dec->p_bmv = zeromv;
1419            /* update resync len with new fcodes */
1420            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1421                    continue; /* re-init loop */
1422              }
1423    
1424          if (!BitstreamGetBit(bs)) { /* modb=='0' */
1425                                  const uint8_t modb2 = BitstreamGetBit(bs);                                  const uint8_t modb2 = BitstreamGetBit(bs);
1426    
1427                                  mb->mb_type = get_mbtype(bs);          mb->mode = get_mbtype(bs);
1428    
1429                                  if (!modb2) {   // modb=='00'          if (!modb2)   /* modb=='00' */
1430                                          mb->cbp = BitstreamGetBits(bs, 6);                                          mb->cbp = BitstreamGetBits(bs, 6);
1431                                  } else {          else
1432                                          mb->cbp = 0;                                          mb->cbp = 0;
                                 }  
                                 if (mb->mb_type && mb->cbp) {  
                                         quant += get_dbquant(bs);  
1433    
1434                                          if (quant > 31) {          if (mb->mode && mb->cbp) {
1435              quant += get_dbquant(bs);
1436              if (quant > 31)
1437                                                  quant = 31;                                                  quant = 31;
1438                                          } else if (quant < 1) {            else if (quant < 1)
1439                                                  quant = 1;                                                  quant = 1;
1440                                          }                                          }
1441            mb->quant = quant;
1442    
1443            if (dec->interlacing) {
1444              if (mb->cbp) {
1445                mb->field_dct = BitstreamGetBit(bs);
1446                DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1447              }
1448    
1449              if (mb->mode) {
1450                mb->field_pred = BitstreamGetBit(bs);
1451                DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1452    
1453                if (mb->field_pred) {
1454                  mb->field_for_top = BitstreamGetBit(bs);
1455                  DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1456                  mb->field_for_bot = BitstreamGetBit(bs);
1457                  DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1458                }
1459              }
1460                                  }                                  }
1461    
1462                          } else {                          } else {
1463                                  mb->mb_type = MODE_DIRECT_NONE_MV;          mb->mode = MODE_DIRECT_NONE_MV;
1464                                  mb->cbp = 0;                                  mb->cbp = 0;
1465                          }                          }
1466    
1467                          mb->quant = quant;        switch (mb->mode) {
                         mb->mode = MODE_INTER4V;  
                         //DEBUG1("Switch bm_type=",mb->mb_type);  
   
 #ifdef BFRAMES_DEC_DEBUG  
         BFRAME_DEBUG  
 #endif  
   
                         switch (mb->mb_type) {  
1468                          case MODE_DIRECT:                          case MODE_DIRECT:
1469                                  get_b_motion_vector(dec, bs, x, y, &mv, 1, zeromv);          get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);
1470    
1471                          case MODE_DIRECT_NONE_MV:                          case MODE_DIRECT_NONE_MV:
                                 {  
                                         const int64_t TRB = dec->time_pp - dec->time_bp, TRD = dec->time_pp;  
                                         int i;  
   
1472                                          for (i = 0; i < 4; i++) {                                          for (i = 0; i < 4; i++) {
1473                                                  mb->mvs[i].x = (int32_t) ((TRB * last_mb->mvs[i].x)            mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1474                                                                        / TRD + mv.x);            mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1475                                                  mb->b_mvs[i].x = (int32_t) ((mv.x == 0)  
1476                                                                                  ? ((TRB - TRD) * last_mb->mvs[i].x)            mb->b_mvs[i].x = (mv.x)
1477                                                                                    / TRD              ?  mb->mvs[i].x - last_mb->mvs[i].x
1478                                                                                  : mb->mvs[i].x - last_mb->mvs[i].x);              : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1479                                                  mb->mvs[i].y = (int32_t) ((TRB * last_mb->mvs[i].y)            mb->b_mvs[i].y = (mv.y)
1480                                                                        / TRD + mv.y);              ? mb->mvs[i].y - last_mb->mvs[i].y
1481                                                  mb->b_mvs[i].y = (int32_t) ((mv.y == 0)              : last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
                                                                                 ? ((TRB - TRD) * last_mb->mvs[i].y)  
                                                                                   / TRD  
                                                                             : mb->mvs[i].y - last_mb->mvs[i].y);  
                                         }  
                                         //DEBUG("B-frame Direct!\n");  
1482                                  }                                  }
1483    
1484                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1485                                                                                             mb, x, y, bs);                          mb, x, y, bs, 1);
1486                                  break;                                  break;
1487    
1488                          case MODE_INTERPOLATE:                          case MODE_INTERPOLATE:
1489                                  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);
                                                                         dec->p_fmv);  
1490                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1491    
1492                                  get_b_motion_vector(dec, bs, x, y, &mb->b_mvs[0],          get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1493                                                                          fcode_backward, dec->p_bmv);          dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] = mb->b_mvs[0];
                                 dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] =  
                                         mb->b_mvs[3] = mb->b_mvs[0];  
1494    
1495                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1496                                                                                             mb, x, y, bs);                        mb, x, y, bs, 0);
                                 //DEBUG("B-frame Bidir!\n");  
1497                                  break;                                  break;
1498    
1499                          case MODE_BACKWARD:                          case MODE_BACKWARD:
1500                                  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);
                                                                         dec->p_bmv);  
1501                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1502    
1503                                  mb->mode = MODE_INTER;          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
                                 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 0);  
                                 //DEBUG("B-frame Backward!\n");  
1504                                  break;                                  break;
1505    
1506                          case MODE_FORWARD:                          case MODE_FORWARD:
1507                                  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);
                                                                         dec->p_fmv);  
1508                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1509    
1510                                  mb->mode = MODE_INTER;          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
                                 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);  
                                 //DEBUG("B-frame Forward!\n");  
1511                                  break;                                  break;
1512    
1513                          default:                          default:
1514                                  DPRINTF(DPRINTF_ERROR, "Not support B-frame mb_type = %d", mb->mb_type);          DPRINTF(XVID_DEBUG_ERROR,"Not supported B-frame mb_type = %i\n", mb->mode);
1515                          }                          }
1516        } /* End of for */
                 }                                               // end of FOR  
         }  
 #ifdef BFRAMES_DEC_DEBUG  
         if (!first){  
                 first=1;  
                 if (fp)  
                         fclose(fp);  
1517          }          }
 #endif  
1518  }  }
1519    
1520  // swap two MACROBLOCK array  /* perform post processing if necessary, and output the image */
1521  void  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1522  mb_swap(MACROBLOCK ** mb1,            xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1523                  MACROBLOCK ** mb2)            int coding_type, int quant)
1524  {  {
1525          MACROBLOCK *temp = *mb1;    const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1526    
1527      if (dec->cartoon_mode)
1528        frame->general &= ~XVID_FILMEFFECT;
1529    
1530          *mb1 = *mb2;    if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1531          *mb2 = temp;      && mbs != NULL) /* post process */
1532      {
1533        /* note: image is stored to tmp */
1534        image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1535        image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1536                 mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1537                 frame->general, brightness, dec->frames, (coding_type == B_VOP), dec->num_threads);
1538        img = &dec->tmp;
1539      }
1540    
1541      if ((frame->output.plane[0] != NULL) && (frame->output.stride[0] >= dec->width)) {
1542        image_output(img, dec->width, dec->height,
1543               dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,
1544               frame->output.csp, dec->interlacing);
1545      }
1546    
1547      if (stats) {
1548        stats->type = coding2type(coding_type);
1549        stats->data.vop.time_base = (int)dec->time_base;
1550        stats->data.vop.time_increment = 0; /* XXX: todo */
1551        stats->data.vop.qscale_stride = dec->mb_width;
1552        stats->data.vop.qscale = dec->qscale;
1553        if (stats->data.vop.qscale != NULL && mbs != NULL) {
1554          unsigned int i;
1555          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1556            stats->data.vop.qscale[i] = mbs[i].quant;
1557        } else
1558          stats->data.vop.qscale = NULL;
1559      }
1560  }  }
1561    
1562  int  int
1563  decoder_decode(DECODER * dec,  decoder_decode(DECODER * dec,
1564                             XVID_DEC_FRAME * frame)          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
1565  {  {
1566    
1567          Bitstream bs;          Bitstream bs;
1568          uint32_t rounding;    uint32_t rounding = 0;
1569          uint32_t quant;    uint32_t quant = 2;
1570          uint32_t fcode_forward;    uint32_t fcode_forward = 0;
1571          uint32_t fcode_backward;    uint32_t fcode_backward = 0;
1572          uint32_t intra_dc_threshold;    uint32_t intra_dc_threshold = 0;
1573          uint32_t vop_type;    WARPPOINTS gmc_warp;
1574      int coding_type = -1;
1575      int success, output, seen_something;
1576    
1577      if (XVID_VERSION_MAJOR(frame->version) != 1 || (stats && XVID_VERSION_MAJOR(stats->version) != 1))  /* v1.x.x */
1578        return XVID_ERR_VERSION;
1579    
1580          start_global_timer();          start_global_timer();
1581      memset((void *)&gmc_warp, 0, sizeof(WARPPOINTS));
1582    
1583          dec->out_frm = (frame->colorspace == XVID_CSP_EXTERN) ? frame->image : NULL;    dec->low_delay_default = (frame->general & XVID_LOWDELAY);
1584      if ((frame->general & XVID_DISCONTINUITY))
1585        dec->frames = 0;
1586      dec->out_frm = (frame->output.csp == XVID_CSP_SLICE) ? &frame->output : NULL;
1587    
1588      if(frame->length<0) {  /* decoder flush */
1589        int ret;
1590        /* if not decoding "low_delay/packed", and this isn't low_delay and
1591          we have a reference frame, then outout the reference frame */
1592        if (!(dec->low_delay_default && dec->packed_mode) && !dec->low_delay && dec->frames>0) {
1593          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1594          dec->frames = 0;
1595          ret = 0;
1596        } else {
1597          if (stats) stats->type = XVID_TYPE_NOTHING;
1598          ret = XVID_ERR_END;
1599        }
1600    
1601        emms();
1602        stop_global_timer();
1603        return ret;
1604      }
1605    
1606          BitstreamInit(&bs, frame->bitstream, frame->length);          BitstreamInit(&bs, frame->bitstream, frame->length);
1607    
1608          // add by chenm001 <chenm001@163.com>    /* XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's */
1609          // for support B-frame to reference last 2 frame    if(dec->low_delay_default && frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1610          dec->frames++;    {
1611          vop_type =      image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1612                  BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode_forward,             (uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1613                                                           &fcode_backward, &intra_dc_threshold);      if (stats) stats->type = XVID_TYPE_NOTHING;
1614        emms();
1615        return 1; /* one byte consumed */
1616      }
1617    
1618          dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  // init pred vector to 0    success = 0;
1619      output = 0;
1620      seen_something = 0;
1621    
1622          switch (vop_type) {  repeat:
1623          case P_VOP:  
1624                  decoder_pframe(dec, &bs, rounding, quant, fcode_forward,    coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1625                                             intra_dc_threshold);        &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1626  #ifdef BFRAMES_DEC  
1627                  DPRINTF(DPRINTF_DEBUG, "P_VOP  Time=%d", dec->time);    DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%"
1628    #if defined(_MSC_VER)
1629        "I64"
1630    #else
1631        "ll"
1632  #endif  #endif
1633                  break;      "i,  time_pp=%i,  time_bp=%i\n",
1634                  coding_type,  dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1635    
1636      if (coding_type == -1) { /* nothing */
1637        if (success) goto done;
1638        if (stats) stats->type = XVID_TYPE_NOTHING;
1639        emms();
1640        return BitstreamPos(&bs)/8;
1641      }
1642    
1643      if (coding_type == -2 || coding_type == -3) { /* vol and/or resize */
1644    
1645        if (coding_type == -3)
1646          if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1647    
1648        if(stats) {
1649          stats->type = XVID_TYPE_VOL;
1650          stats->data.vol.general = 0;
1651              stats->data.vop.general = 0;
1652              if (dec->interlacing) {
1653                      stats->data.vol.general |= XVID_VOL_INTERLACING;
1654                      if (dec->top_field_first) {
1655                              stats->data.vop.general |= XVID_VOP_TOPFIELDFIRST;
1656                      }
1657              }      stats->data.vol.width = dec->width;
1658          stats->data.vol.height = dec->height;
1659          stats->data.vol.par = dec->aspect_ratio;
1660          stats->data.vol.par_width = dec->par_width;
1661          stats->data.vol.par_height = dec->par_height;
1662          emms();
1663          return BitstreamPos(&bs)/8; /* number of bytes consumed */
1664        }
1665        goto repeat;
1666      }
1667    
1668      if((dec->frames == 0 && coding_type != I_VOP) || (!dec->width || !dec->height)) {
1669        /* 1st frame is not an i-vop */
1670        goto repeat;
1671      }
1672    
1673      dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.x = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1674    
1675      /* packed_mode: special-N_VOP treament */
1676      if (dec->packed_mode && coding_type == N_VOP) {
1677        if (dec->low_delay_default && dec->frames > 0) {
1678          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1679          output = 1;
1680        }
1681        /* ignore otherwise */
1682      } else if (coding_type != B_VOP) {
1683        switch(coding_type) {
1684          case I_VOP:          case I_VOP:
1685                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);
 #ifdef BFRAMES_DEC  
                 DPRINTF(DPRINTF_DEBUG, "I_VOP  Time=%d", dec->time);  
 #endif  
1686                  break;                  break;
1687        case P_VOP :
1688          case B_VOP:        decoder_pframe(dec, &bs, rounding, quant,
1689  #ifdef BFRAMES_DEC                          fcode_forward, intra_dc_threshold, NULL);
                 if (dec->time_pp > dec->time_bp) {  
                         DPRINTF(DPRINTF_DEBUG, "B_VOP  Time=%d", dec->time);  
                         decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);  
                 } else {  
                         DPRINTF(DPRINTF_DEBUG, "Broken B_VOP");  
                 }  
 #else  
                 image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);  
 #endif  
1690                  break;                  break;
1691        case S_VOP :
1692          case N_VOP:                             // vop not coded        decoder_pframe(dec, &bs, rounding, quant,
1693                  // when low_delay==0, N_VOP's should interpolate between the past and future frames                          fcode_forward, intra_dc_threshold, &gmc_warp);
1694          break;
1695        case N_VOP :
1696          /* XXX: not_coded vops are not used for forward prediction */
1697          /* we should not swap(last_mbs,mbs) */
1698                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1699          SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs); /* it will be swapped back */
1700                  break;                  break;
   
         default:  
                 return XVID_ERR_FAIL;  
1701          }          }
1702    
1703  #ifdef BFRAMES_DEC_DEBUG      /* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1704          if (frame->length != BitstreamPos(&bs) / 8){      if (!(dec->low_delay_default && dec->packed_mode)) {
1705                  DPRINTF(DPRINTF_DEBUG, "InLen: %d / UseLen: %d", frame->length, BitstreamPos(&bs) / 8);        if(dec->low_delay) {
1706            decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1707            output = 1;
1708          } else if (dec->frames > 0) { /* is the reference frame valid? */
1709            /* output the reference frame */
1710            decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1711            output = 1;
1712          }
1713          }          }
 #endif  
         frame->length = BitstreamPos(&bs) / 8;  
1714    
1715        image_swap(&dec->refn[0], &dec->refn[1]);
1716        dec->is_edged[1] = dec->is_edged[0];
1717        image_swap(&dec->cur, &dec->refn[0]);
1718        dec->is_edged[0] = 0;
1719        SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
1720        dec->last_coding_type = coding_type;
1721    
1722  #ifdef BFRAMES_DEC      dec->frames++;
1723          // test if no B_VOP      seen_something = 1;
         if (dec->low_delay || dec->frames == 0) {  
 #endif  
         image_output(&dec->cur, dec->width, dec->height, dec->edged_width,  
                                          frame->image, frame->stride, frame->colorspace);  
1724    
1725  #ifdef BFRAMES_DEC    } else {  /* B_VOP */
1726          } else {  
1727                  if (dec->frames >= 1) {      if (dec->low_delay) {
1728                          start_timer();        DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1729                          if ((vop_type == I_VOP || vop_type == P_VOP)) {        dec->low_delay = 0;
                                 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);  
1730                          }                          }
1731                          stop_conv_timer();  
1732        if (dec->frames < 2) {
1733          /* attemping to decode a bvop without atleast 2 reference frames */
1734          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1735                "broken b-frame, mising ref frames");
1736          if (stats) stats->type = XVID_TYPE_NOTHING;
1737        } else if (dec->time_pp <= dec->time_bp) {
1738          /* this occurs when dx50_bvop_compatibility==0 sequences are
1739          decoded in vfw. */
1740          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1741                "broken b-frame, tpp=%i tbp=%i", dec->time_pp, dec->time_bp);
1742          if (stats) stats->type = XVID_TYPE_NOTHING;
1743        } else {
1744          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1745          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1746                  }                  }
1747    
1748        output = 1;
1749        dec->frames++;
1750          }          }
 #endif  
1751    
1752          if (vop_type == I_VOP || vop_type == P_VOP) {  #if 0 /* Avoids to read to much data because of 32bit reads in our BS functions */
1753                  image_swap(&dec->refn[0], &dec->refn[1]);     BitstreamByteAlign(&bs);
1754                  image_swap(&dec->cur, &dec->refn[0]);  #endif
1755    
1756                  // swap MACROBLOCK    /* low_delay_default mode: repeat in packed_mode */
1757                  // the Divx will not set the low_delay flage some times    if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {
1758                  // so follow code will wrong to not swap at that time      success = 1;
1759                  // this will broken bitstream! so I'm change it,      goto repeat;
1760                  // But that is not the best way! can anyone tell me how    }
1761                  // to do another way?  
1762                  // 18-07-2002   MinChen<chenm001@163.com>  done :
1763                  //if (!dec->low_delay && vop_type == P_VOP)  
1764                  if (vop_type == P_VOP)    /* if we reach here without outputing anything _and_
1765                          mb_swap(&dec->mbs, &dec->last_mbs);       the calling application has specified low_delay_default,
1766         we *must* output something.
1767         this always occurs on the first call to decode() call
1768         when bframes are present in the bitstream. it may also
1769         occur if no vops  were seen in the bitstream
1770    
1771         if packed_mode is enabled, then we output the recently
1772         decoded frame (the very first ivop). otherwise we have
1773         nothing to display, and therefore output a black screen.
1774      */
1775      if (dec->low_delay_default && output == 0) {
1776        if (dec->packed_mode && seen_something) {
1777          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1778        } else {
1779          image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);
1780          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1781          if (stats) stats->type = XVID_TYPE_NOTHING;
1782        }
1783          }          }
1784    
1785          emms();          emms();
   
1786          stop_global_timer();          stop_global_timer();
1787    
1788          return XVID_ERR_OK;    return (BitstreamPos(&bs)+7)/8; /* number of bytes consumed */
1789  }  }
Legend:
Removed from v.605  
changed lines
  Added in v.2180
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4