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

Diff of /xvidcore/src/decoder.c

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

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

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

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