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

Diff of /xvidcore/src/decoder.c

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

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

Legend:
Removed from v.1.16  
changed lines
  Added in v.1.80

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