[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.13, Sun Apr 28 23:35:25 2002 UTC revision 1.80.2.1, Thu May 28 15:52:34 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:  
  *  
  *  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    
         dec->width = param->width;  
         dec->height = param->height;  
87    
88      xvid_free(dec->last_mbs);
89      xvid_free(dec->mbs);
90      xvid_free(dec->qscale);
91      dec->last_mbs = NULL;
92      dec->mbs = NULL;
93      dec->qscale = NULL;
94    
95            /* realloc */
96          dec->mb_width = (dec->width + 15) / 16;          dec->mb_width = (dec->width + 15) / 16;
97          dec->mb_height = (dec->height + 15) / 16;          dec->mb_height = (dec->height + 15) / 16;
98    
99          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
100          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
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                    xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120                                            CACHE_LINE);
121            if (dec->last_mbs == NULL)
122              goto memory_error;
123            memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124    
125            /* nothing happens if that fails */
126            dec->qscale =
127                    xvid_malloc(sizeof(int) * dec->mb_width * dec->mb_height, CACHE_LINE);
128    
129            if (dec->qscale)
130                    memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131    
132            return 0;
133    
134    memory_error:
135            /* Most structures were deallocated / nullifieded, so it should be safe */
136            /* decoder_destroy(dec) minus the write_timer */
137      xvid_free(dec->mbs);
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);
140      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          // add by chenm001 <chenm001@163.com>  
148          // for support B-frame to reference last 2 frame  
149          if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height))  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                  xvid_free(dec);    if (XVID_VERSION_MAJOR(create->version) != 1) /* v1.x.x */
155        return XVID_ERR_VERSION;
156    
157      dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
158      if (dec == NULL) {
159                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
160          }          }
161    
162          dec->mbs = xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height, CACHE_LINE);    memset(dec, 0, sizeof(DECODER));
163          if (dec->mbs == NULL)  
164          {    dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
165                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);    if (dec->mpeg_quant_matrices == NULL) {
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          return XVID_ERR_OK;    /* For B-frame support (used to save reference frame's time */
193      dec->frames = 0;
194      dec->time = dec->time_base = dec->last_time_base = 0;
195      dec->low_delay = 0;
196      dec->packed_mode = 0;
197      dec->time_inc_resolution = 1; /* until VOL header says otherwise */
198      dec->ver_id = 1;
199    
200      dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
201    
202      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);
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);
226      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  // decode an intra macroblock  static void
242    decoder_mbintra(DECODER * dec,
 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 157  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 174  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 254  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          /* iDCT */
414          start_timer();
415          idct((short * const)&data[0]);
416          stop_idct_timer();
417    
418  #define SIGN(X) (((X)>0)?1:-1)        /* Add this residual to the predicted block */
419  #define ABS(X) (((X)>0)?(X):-(X))        start_timer();
420  static const uint32_t roundtab[16] =        transfer_16to8add(dst[i], &data[0], strides[i]);
421  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };        stop_transfer_timer();
422        }
423      }
424  // decode an inter macroblock  }
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);
         {  
                 uv_dx = pMB->mvs[0].x;  
                 uv_dy = pMB->mvs[0].y;  
494    
495                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;    start_timer();
496                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
497          }    if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
498    
499        uv_dx = mv[0].x;
500        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);
521                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
522                  uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );    } else {  /* MODE_INTER4V */
523    
524                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;      if(dec->quarterpel) {
525                  uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );                          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        uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
543        uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
544    
545        if (dec->quarterpel) {
546          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
547                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
548                      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          start_timer();    /* chroma */
571          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);    interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
572          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);                uv_dx, uv_dy, stride2, rounding);
573          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);    interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
574          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);                uv_dx, uv_dy, stride2, rounding);
575          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, rounding);  
         interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8*x_pos,      8*y_pos,      uv_dx,         uv_dy,         stride2, rounding);  
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          VECTOR pmv[4];    const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
816          int32_t psad[4];    VECTOR mv;
817    
818          int mv_x, mv_y;    mv.x = get_mv(bs, fcode);
819          int pmv_x, pmv_y;    mv.y = get_mv(bs, fcode);
820    
821      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);
822    
823          get_pmvdata(dec->mbs, x, y, dec->mb_width, k, pmv, psad);    mv.x += pmv.x;
824      mv.y += pmv.y;
825    
826          pmv_x = pmv[0].x;    if (mv.x < low) {
827          pmv_y = pmv[0].y;      mv.x += range;
828      } else if (mv.x > high) {
829        mv.x -= range;
830      }
831    
832          mv_x = get_mv(bs, fcode);    if (mv.y < low) {
833          mv_y = get_mv(bs, fcode);      mv.y += range;
834      } else if (mv.y > high) {
835        mv.y -= range;
836      }
837    
838          mv_x += pmv_x;    ret_mv->x = mv.x;
839          mv_y += pmv_y;    ret_mv->y = mv.y;
840    }
841    
842          if (mv_x < low)  /* We use this when decoder runs interlaced -> different prediction */
843    
844    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;
883      }
884      else
885          {          {
886                  mv_y -= range;      mvf1.x = get_mv(bs, fcode);
887        mvf1.y = get_mv(bs, fcode);
888    
889        mvf1.x += pmv.x;
890        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          mv->x = mv_x;      if (mvf1.y < low) {
899          mv->y = mv_y;        mvf1.y += range;
900        } else if (mvf1.y > high) {
901          mvf1.y -= range;
902        }
903    
904        mvf2.x = get_mv(bs, fcode);
905        mvf2.y = get_mv(bs, fcode);
906    
907        mvf2.x += pmv.x;
908        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
909    
910        if (mvf2.x < low) {
911          mvf2.x += range;
912        } else if (mvf2.x > high) {
913          mvf2.x -= range;
914  }  }
915    
916        if (mvf2.y < low) {
917          mvf2.y += range;
918        } else if (mvf2.y > high) {
919          mvf2.y -= range;
920        }
921    
922  void decoder_pframe(DECODER * dec, Bitstream * bs, int rounding, int quant, int fcode, int intra_dc_threshold)      pMB->mvs[0]=mvf1;
923  {      pMB->mvs[1]=mvf2;
924        pMB->mvs[2].x=pMB->mvs[3].x=0;
925        pMB->mvs[2].y=pMB->mvs[3].y=0;
926    
927        /* Calculate average for as it is field predicted */
928        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
929        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
930      }
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;          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();          start_timer();
951          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,
952                dec->width, dec->height, dec->bs_version);
953        dec->is_edged[0] = 1;
954          stop_edges_timer();          stop_edges_timer();
955      }
956    
957          for (y = 0; y < dec->mb_height; y++)    if (gmc_warp) {
958          {      /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
959                  for (x = 0; x < dec->mb_width; x++)      generate_GMCparameters( dec->sprite_warping_points,
960                  {          dec->sprite_warping_accuracy, gmc_warp,
961                          MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];          dec->width, dec->height, &dec->new_gmc_data);
962    
963                          if (!BitstreamGetBit(bs))                       // not_coded      /* image warping is done block-based in decoder_mbgmc(), now */
964                          {    }
965                                  uint32_t mcbpc;  
966                                  uint32_t cbpc;    bound = 0;
967                                  uint32_t acpred_flag;  
968                                  uint32_t cbpy;    for (y = 0; y < mb_height; y++) {
969                                  uint32_t cbp;      cp_mb = st_mb = 0;
970                                  uint32_t intra;      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                /* Get motion vectors interlaced, field_pred is handled there */
1053                get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1054              } else {
1055                get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1056                mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1057              }
1058            } 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;
1066              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,
1068                      intra_dc_threshold, bound);
1069              continue;
1070                                          }                                          }
1071    
1072            /* See how to decode */
1073            if(!mb->field_pred)
1074             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1075                                          else                                          else
1076                                          {           decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1077                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);  
1078                                                  mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;        } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1079                                                  mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;          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            st_mb = x+1;
1088          } else { /* not coded P_VOP macroblock */
1089            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;
1093            mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1094            mb->field_pred=0; /* (!) */
1095    
1096            decoder_mbinter(dec, mb, x, y, 0, bs,
1097                                    rounding, 0, 0);
1098    
1099            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                                  else if (mb->mode == MODE_INTER4V /* || mb->mode == MODE_INTER4V_Q */)          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    
1112    
1113    /* decode B-frame motion vector */
1114    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                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);    const int scale_fac = 1 << (fcode - 1);
1123                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode);    const int high = (32 * scale_fac) - 1;
1124                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode);    const int low = ((-32) * scale_fac);
1125                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode);    const int range = (64 * scale_fac);
1126    
1127      int mv_x = get_mv(bs, fcode);
1128      int mv_y = get_mv(bs, fcode);
1129    
1130      mv_x += pmv.x;
1131      mv_y += pmv.y;
1132    
1133      if (mv_x < low)
1134        mv_x += range;
1135      else if (mv_x > high)
1136        mv_x -= range;
1137    
1138      if (mv_y < low)
1139        mv_y += range;
1140      else if (mv_y > high)
1141        mv_y -= range;
1142    
1143      mv->x = mv_x;
1144      mv->y = mv_y;
1145                                  }                                  }
1146                                  else  // MODE_INTRA, MODE_INTRA_Q  
1147    /* decode an B-frame direct & interpolate macroblock */
1148    static void
1149    decoder_bf_interpolate_mbinter(DECODER * dec,
1150                    IMAGE forward,
1151                    IMAGE backward,
1152                    MACROBLOCK * pMB,
1153                    const uint32_t x_pos,
1154                    const uint32_t y_pos,
1155                    Bitstream * bs,
1156                    const int direct)
1157                                  {                                  {
1158                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;    uint32_t stride = dec->edged_width;
1159                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;    uint32_t stride2 = stride / 2;
1160                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant, intra_dc_threshold);    int uv_dx, uv_dy;
1161                                          continue;    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);
1166      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);
1168    
1169      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;
1174        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        if (dec->quarterpel) {
1179                            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          }
1191                                  }                                  }
1192    
1193                                  decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant, rounding);      uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1194        uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
1195        b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];
1196        b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
1197    
1198      } else {
1199              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                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1202                            int z;
1203                            uv_dx = 0; uv_dy = 0;
1204                            b_uv_dx = 0; b_uv_dy = 0;
1205                            for (z = 0; z < 4; z++) {
1206                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1207                              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                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1210                            }
1211                    }
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        uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
1226        uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
1227        b_uv_dx = (b_uv_dx >> 3) + roundtab_76[b_uv_dx & 0xf];
1228        b_uv_dy = (b_uv_dy >> 3) + roundtab_76[b_uv_dy & 0xf];
1229                          }                          }
1230                          else    // not coded  
1231      start_timer();
1232      if(dec->quarterpel) {
1233        if(!direct) {
1234          interpolate16x16_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1235                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1236                        pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1237        } else {
1238          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1239                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1240                        pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1241          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1242                        dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1243                        pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1244          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1245                        dec->qtmp.y + 128, 16*x_pos, 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                  pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1254        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1255                  pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1256        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos + 8,
1257                  pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1258        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos + 8,
1259                  pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1260      }
1261    
1262      interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1263                uv_dy, stride2, 0);
1264      interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1265                uv_dy, stride2, 0);
1266    
1267    
1268      if(dec->quarterpel) {
1269        if(!direct) {
1270          interpolate16x16_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1271              dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1272              pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1273        } else {
1274          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              pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1277          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1278              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          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              pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1283          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              pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1286        }
1287      } else {
1288        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos, 16 * y_pos,
1289            pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1290        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1291            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            16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1294        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);
1296      }
1297    
1298      interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1299          b_uv_dx, b_uv_dy, stride2, 0);
1300      interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1301          b_uv_dx, b_uv_dy, stride2, 0);
1302    
1303      stop_comp_timer();
1304    
1305      if (cbp)
1306        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1307    }
1308    
1309    /* for decode B-frame dbquant */
1310    static __inline int32_t
1311    get_dbquant(Bitstream * bs)
1312                          {                          {
1313      if (!BitstreamGetBit(bs))   /*  '0' */
1314        return (0);
1315      else if (!BitstreamGetBit(bs))  /* '10' */
1316        return (-2);
1317      else              /* '11' */
1318        return (2);
1319    }
1320    
1321                                  mb->mode = MODE_NOT_CODED;  /*
1322                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;   * decode B-frame mb_type
1323                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;   * bit    ret_value
1324     * 1    0
1325     * 01   1
1326     * 001    2
1327     * 0001   3
1328     */
1329    static int32_t __inline
1330    get_mbtype(Bitstream * bs)
1331    {
1332      int32_t mb_type;
1333    
1334      for (mb_type = 0; mb_type <= 3; mb_type++)
1335        if (BitstreamGetBit(bs))
1336          return (mb_type);
1337    
1338      return -1;
1339    }
1340    
1341    static int __inline get_resync_len_b(const int fcode_backward,
1342                                         const int fcode_forward) {
1343      int resync_len = ((fcode_forward>fcode_backward) ? fcode_forward : fcode_backward) - 1;
1344      if (resync_len < 1) resync_len = 1;
1345      return resync_len;
1346    }
1347    
1348                                  // copy macroblock directly from ref to cur  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;
1356      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,
1364                dec->width, dec->height, dec->bs_version);
1365        dec->is_edged[0] = 1;
1366        stop_edges_timer();
1367      }
1368    
1369                                  transfer8x8_copy(dec->cur.y + (16*y)*dec->edged_width + (16*x),    if (!dec->is_edged[1]) {
1370                                                   dec->refn[0].y + (16*y)*dec->edged_width + (16*x),      start_timer();
1371                                                   dec->edged_width);      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                                  transfer8x8_copy(dec->cur.y + (16*y)*dec->edged_width + (16*x+8),    resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1378                                                   dec->refn[0].y + (16*y)*dec->edged_width + (16*x+8),    for (y = 0; y < dec->mb_height; y++) {
1379                                                   dec->edged_width);      /* Initialize Pred Motion Vector */
1380        dec->p_fmv = dec->p_bmv = zeromv;
1381        for (x = 0; x < dec->mb_width; x++) {
1382          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1383          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1384          int intra_dc_threshold; /* fake variable */
1385    
1386                                  transfer8x8_copy(dec->cur.y + (16*y+8)*dec->edged_width + (16*x),        if (check_resync_marker(bs, resync_len)) {
1387                                                   dec->refn[0].y + (16*y+8)*dec->edged_width + (16*x),          int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1388                                                   dec->edged_width);                             &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                                  transfer8x8_copy(dec->cur.y + (16*y+8)*dec->edged_width + (16*x+8),        /*
1403                                                   dec->refn[0].y + (16*y+8)*dec->edged_width + (16*x+8),         * skip if the co-located P_VOP macroblock is not coded
1404                                                   dec->edged_width);         * if not codec in co-located S_VOP macroblock is _not_
1405           * automatically skipped
1406           */
1407    
1408          if (last_mb->mode == MODE_NOT_CODED) {
1409            mb->cbp = 0;
1410            mb->mode = MODE_FORWARD;
1411            decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1412            continue;
1413          }
1414    
1415                                  transfer8x8_copy(dec->cur.u + (8*y)*dec->edged_width/2 + (8*x),        if (!BitstreamGetBit(bs)) { /* modb=='0' */
1416                                                   dec->refn[0].u + (8*y)*dec->edged_width/2 + (8*x),          const uint8_t modb2 = BitstreamGetBit(bs);
                                                  dec->edged_width/2);  
1417    
1418                                  transfer8x8_copy(dec->cur.v + (8*y)*dec->edged_width/2 + (8*x),          mb->mode = get_mbtype(bs);
                                                  dec->refn[0].v + (8*y)*dec->edged_width/2 + (8*x),  
                                                  dec->edged_width/2);  
1419    
1420                                  stop_transfer_timer();          if (!modb2)   /* modb=='00' */
1421              mb->cbp = BitstreamGetBits(bs, 6);
1422            else
1423              mb->cbp = 0;
1424    
1425            if (mb->mode && mb->cbp) {
1426              quant += get_dbquant(bs);
1427              if (quant > 31)
1428                quant = 31;
1429              else if (quant < 1)
1430                quant = 1;
1431            }
1432            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 {
1454            mb->mode = MODE_DIRECT_NONE_MV;
1455            mb->cbp = 0;
1456          }
1457    
1458          switch (mb->mode) {
1459          case MODE_DIRECT:
1460            get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);
1461    
1462          case MODE_DIRECT_NONE_MV:
1463            for (i = 0; i < 4; i++) {
1464              mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1465              mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1466    
1467              mb->b_mvs[i].x = (mv.x)
1468                ?  mb->mvs[i].x - last_mb->mvs[i].x
1469                : 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    
1475            decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1476                            mb, x, y, bs, 1);
1477            break;
1478    
1479          case MODE_INTERPOLATE:
1480            get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1481            dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1482    
1483            get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1484            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;
1489    
1490          case MODE_BACKWARD:
1491            get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1492            dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1493    
1494            decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1495            break;
1496    
1497          case MODE_FORWARD:
1498            get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1499            dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1500    
1501            decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1502            break;
1503    
1504          default:
1505            DPRINTF(XVID_DEBUG_ERROR,"Not supported B-frame mb_type = %i\n", mb->mode);
1506          }
1507        } /* End of for */
1508      }
1509                          }                          }
1510    
1511    /* perform post processing if necessary, and output the image */
1512    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        /* note: image is stored to tmp */
1525        image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1526        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;    uint32_t fcode_forward;
1560      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      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        emms();
1590        stop_global_timer();
1591        return ret;
1592      }
1593    
1594          BitstreamInit(&bs, frame->bitstream, frame->length);          BitstreamInit(&bs, frame->bitstream, frame->length);
1595    
1596          // add by chenm001 <chenm001@163.com>    /* XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's */
1597          // for support B-frame to reference last 2 frame    if(dec->low_delay_default && frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1598          vop_type=BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode, &intra_dc_threshold);    {
1599        image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1600               (uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1601        if (stats) stats->type = XVID_TYPE_NOTHING;
1602        emms();
1603        return 1; /* one byte consumed */
1604      }
1605    
1606          if (vop_type==I_VOP || vop_type==P_VOP){    success = 0;
1607                  image_swap(&dec->refn[0], &dec->refn[1]);    output = 0;
1608                  image_swap(&dec->cur, &dec->refn[0]);    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          switch (vop_type)    if (coding_type == -2 || coding_type == -3) { /* vol and/or resize */
1632          {  
1633          case P_VOP :      if (coding_type == -3)
1634                  decoder_pframe(dec, &bs, rounding, quant, fcode, intra_dc_threshold);        if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1635                  break;  
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 :
                 //DEBUG1("",intra_dc_threshold);  
1669                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1670                  break;                  break;
1671        case P_VOP :
1672          case B_VOP :    // ignore        decoder_pframe(dec, &bs, rounding, quant,
1673                            fcode_forward, intra_dc_threshold, NULL);
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;
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;                  break;
   
         default :  
                 return XVID_ERR_FAIL;  
1685          }          }
1686    
1687          frame->length = BitstreamPos(&bs) / 8;      /* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1688        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          start_timer();      image_swap(&dec->refn[0], &dec->refn[1]);
1700          image_output(&dec->cur, dec->width, dec->height, dec->edged_width,      dec->is_edged[1] = dec->is_edged[0];
1701                       frame->image, frame->stride, frame->colorspace);      image_swap(&dec->cur, &dec->refn[0]);
1702          stop_conv_timer();      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      } else {  /* B_VOP */
1710    
1711        if (dec->low_delay) {
1712          DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1713          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 {
1728          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1729          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1730        }
1731    
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        }
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.13  
changed lines
  Added in v.1.80.2.1

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