[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.46, Tue Feb 11 21:56:31 2003 UTC revision 1.81, Thu May 28 15:42:06 2009 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  -  Decoder main module  -   *  - Decoder Module -
5   *   *
6   *  Copyright(C) 2002 MinChen <chenm001@163.com>   *  Copyright(C) 2002 MinChen <chenm001@163.com>
7   *               2002 Peter Ross <pross@xvid.org>   *               2002-2004 Peter Ross <pross@xvid.org>
8   *   *
9   *  This file is part of XviD, a free MPEG-4 video encoder/decoder   *  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
  *  XviD is free software; you can redistribute it and/or modify it  
  *  under the terms of the GNU General Public License as published by  
11   *  the Free Software Foundation; either version 2 of the License, or   *  the Free Software Foundation; either version 2 of the License, or
12   *  (at your option) any later version.   *  (at your option) any later version.
13   *   *
# Line 22  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   *   *
  *  Under section 8 of the GNU General Public License, the copyright  
  *  holders of XVID explicitly forbid distribution in the following  
  *  countries:  
  *  
  *    - Japan  
  *    - United States of America  
  *  
  *  Linking XviD statically or dynamically with other modules is making a  
  *  combined work based on XviD.  Thus, the terms and conditions of the  
  *  GNU General Public License cover the whole combination.  
  *  
  *  As a special exception, the copyright holders of XviD give you  
  *  permission to link XviD with independent modules that communicate with  
  *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the  
  *  license terms of these independent modules, and to copy and distribute  
  *  the resulting combined work under terms of your choice, provided that  
  *  every copy of the combined work is accompanied by a complete copy of  
  *  the source code of XviD (the version of XviD used to produce the  
  *  combined work), being distributed under the terms of the GNU General  
  *  Public License plus this exception.  An independent module is a module  
  *  which is not derived from or based on XviD.  
  *  
  *  Note that people who make modified versions of XviD are not obligated  
  *  to grant this special exception for their modified versions; it is  
  *  their choice whether to do so.  The GNU General Public License gives  
  *  permission to release a modified version without this exception; this  
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
  *  
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    
# Line 64  Line 34 
34    
35  #include "xvid.h"  #include "xvid.h"
36  #include "portab.h"  #include "portab.h"
37    #include "global.h"
38    
39  #include "decoder.h"  #include "decoder.h"
40  #include "bitstream/bitstream.h"  #include "bitstream/bitstream.h"
41  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
42    
43  #include "quant/quant_h263.h"  #include "quant/quant.h"
44  #include "quant/quant_mpeg4.h"  #include "quant/quant_matrix.h"
45  #include "dct/idct.h"  #include "dct/idct.h"
46  #include "dct/fdct.h"  #include "dct/fdct.h"
47  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
48  #include "image/interpolate8x8.h"  #include "image/interpolate8x8.h"
49    #include "image/font.h"
50    #include "image/qpel.h"
51    
52  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
53  #include "prediction/mbprediction.h"  #include "prediction/mbprediction.h"
54  #include "utils/timer.h"  #include "utils/timer.h"
55  #include "utils/emms.h"  #include "utils/emms.h"
56    #include "motion/motion.h"
57    #include "motion/gmc.h"
58    
59  #include "image/image.h"  #include "image/image.h"
60  #include "image/colorspace.h"  #include "image/colorspace.h"
61    #include "image/postprocessing.h"
62  #include "utils/mem_align.h"  #include "utils/mem_align.h"
63    
64  int  #define DIV2ROUND(n)  (((n)>>1)|((n)&1))
65  decoder_create(XVID_DEC_PARAM * param)  #define DIV2(n)       ((n)>>1)
66    #define DIVUVMOV(n) (((n) >> 1) + roundtab_79[(n) & 0x3]) //
67    
68    static int
69    decoder_resize(DECODER * dec)
70  {  {
71          DECODER *dec;          /* free existing */
72            image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
73            image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
74            image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
75            image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
76            image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
77    
78          dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
79          if (dec == NULL) {  
80                  return XVID_ERR_MEMORY;    image_null(&dec->cur);
81          }    image_null(&dec->refn[0]);
82          param->handle = dec;    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;
         dec->low_delay = 0;  
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                  xvid_free(dec);              || image_create(&dec->refn[0], dec->edged_width, dec->edged_height)
104                  return XVID_ERR_MEMORY;              || image_create(&dec->refn[1], dec->edged_width, dec->edged_height)         /* Support B-frame to reference last 2 frame */
105          }              || image_create(&dec->tmp, dec->edged_width, dec->edged_height)
106                || image_create(&dec->qtmp, dec->edged_width, dec->edged_height)
107          if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {        || image_create(&dec->gmc, dec->edged_width, dec->edged_height) )
108                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);      goto memory_error;
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
         /* add by chenm001 <chenm001@163.com> */  
         /* for support B-frame to reference last 2 frame */  
         if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
         if (image_create(&dec->refn[2], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
109    
110          dec->mbs =          dec->mbs =
111                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
112                                          CACHE_LINE);                                          CACHE_LINE);
113          if (dec->mbs == NULL) {          if (dec->mbs == NULL)
114                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);            goto memory_error;
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
115          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
116    
117          /* add by chenm001 <chenm001@163.com> */          /* For skip MB flag */
         /* for skip MB flag */  
118          dec->last_mbs =          dec->last_mbs =
119                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120                                          CACHE_LINE);                                          CACHE_LINE);
121          if (dec->last_mbs == NULL) {          if (dec->last_mbs == NULL)
122              goto memory_error;
123            memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124    
125            /* nothing happens if that fails */
126            dec->qscale =
127                    xvid_malloc(sizeof(int) * dec->mb_width * dec->mb_height, CACHE_LINE);
128    
129            if (dec->qscale)
130                    memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131    
132            return 0;
133    
134    memory_error:
135            /* Most structures were deallocated / nullifieded, so it should be safe */
136            /* decoder_destroy(dec) minus the write_timer */
137                  xvid_free(dec->mbs);                  xvid_free(dec->mbs);
138                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141                  image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143    
144                  xvid_free(dec);                  xvid_free(dec);
145                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
146          }          }
147    
148          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);  
149    int
150    decoder_create(xvid_dec_create_t * create)
151    {
152      DECODER *dec;
153    
154      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;
160      }
161    
162      memset(dec, 0, sizeof(DECODER));
163    
164      dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
165      if (dec->mpeg_quant_matrices == NULL) {
166        xvid_free(dec);
167        return XVID_ERR_MEMORY;
168      }
169    
170      create->handle = dec;
171    
172      dec->width = create->width;
173      dec->height = create->height;
174    
175      image_null(&dec->cur);
176      image_null(&dec->refn[0]);
177      image_null(&dec->refn[1]);
178      image_null(&dec->tmp);
179      image_null(&dec->qtmp);
180    
181      /* image based GMC */
182      image_null(&dec->gmc);
183    
184      dec->mbs = NULL;
185      dec->last_mbs = NULL;
186      dec->qscale = NULL;
187    
188          init_timer();          init_timer();
189      init_postproc(&dec->postproc);
190      init_mpeg_matrix(dec->mpeg_quant_matrices);
191    
192          /* add by chenm001 <chenm001@163.com> */    /* For B-frame support (used to save reference frame's time */
193          /* for support B-frame to save reference frame's time */    dec->frames = 0;
         dec->frames = -1;  
194          dec->time = dec->time_base = dec->last_time_base = 0;          dec->time = dec->time_base = dec->last_time_base = 0;
195      dec->low_delay = 0;
196      dec->packed_mode = 0;
197      dec->time_inc_resolution = 1; /* until VOL header says otherwise */
198      dec->ver_id = 1;
199    
200      dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
201    
202          return XVID_ERR_OK;    dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
203    
204      if (dec->fixed_dimensions) {
205        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    
# Line 179  Line 216 
216  {  {
217          xvid_free(dec->last_mbs);          xvid_free(dec->last_mbs);
218          xvid_free(dec->mbs);          xvid_free(dec->mbs);
219      xvid_free(dec->qscale);
220    
221      /* image based GMC */
222      image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
223    
224          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
225          image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);          image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
226          image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);    image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
227      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
228          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
229      xvid_free(dec->mpeg_quant_matrices);
230          xvid_free(dec);          xvid_free(dec);
231    
232          write_timer();          write_timer();
233          return XVID_ERR_OK;    return 0;
234  }  }
235    
   
   
236  static const int32_t dquant_table[4] = {  static const int32_t dquant_table[4] = {
237          -1, -2, 1, 2          -1, -2, 1, 2
238  };  };
239    
   
   
   
240  /* decode an intra macroblock */  /* decode an intra macroblock */
241    static void
 void  
242  decoder_mbintra(DECODER * dec,  decoder_mbintra(DECODER * dec,
243                                  MACROBLOCK * pMB,                                  MACROBLOCK * pMB,
244                                  const uint32_t x_pos,                                  const uint32_t x_pos,
# Line 256  Line 294 
294                          block[i * 64 + 0] = dc_dif;                          block[i * 64 + 0] = dc_dif;
295                          start_coeff = 1;                          start_coeff = 1;
296    
297                          DPRINTF(DPRINTF_COEFF,"block[0] %i", dc_dif);        DPRINTF(XVID_DEBUG_COEFF,"block[0] %i\n", dc_dif);
298                  } else {                  } else {
299                          start_coeff = 0;                          start_coeff = 0;
300                  }                  }
# Line 264  Line 302 
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],        int direction = dec->alternate_vertical_scan ?
306                                                          start_coeff);          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_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);        dequant_h263_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
319                  } else {                  } else {
320                          dequant4_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);        dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
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) {
# Line 301  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  #define SIGN(X) (((X)>0)?1:-1)    if (dec->interlacing && pMB->field_dct) {
380  #define ABS(X) (((X)>0)?(X):-(X))      dst[0] = pY_Cur;
381  static const uint32_t roundtab[16] =      dst[1] = pY_Cur + 8;
382          { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };      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 an inter macroblock */        /* 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          /* Add this residual to the predicted block */
419          start_timer();
420          transfer_16to8add(dst[i], &data[0], strides[i]);
421          stop_transfer_timer();
422        }
423      }
424    }
425    
426  void  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,  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;  
   
                 uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;  
                 uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
         } else {  
                 int sum;  
                 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
494    
495                  uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));    start_timer();
496    
497                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;    if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
498    
499                  uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));      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
519          interpolate16x16_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos, 16*y_pos,
520                      mv[0].x, mv[0].y, stride, rounding);
521    
522      } else {  /* MODE_INTER4V */
523    
524        if(dec->quarterpel) {
525                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
526                                    int z;
527                                    uv_dx = 0; uv_dy = 0;
528                                    for (z = 0; z < 4; z++) {
529                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
530                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
531                                    }
532                            }
533                            else {
534            uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
535            uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
536          }
537        } else {
538          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
539          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
540          }          }
541    
542          start_timer();      uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
543        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,          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos,
560                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride,  rounding);                  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,          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,
562                                                    pMB->mvs[1].x, pMB->mvs[1].y, stride,  rounding);                  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,          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,
564                                                    pMB->mvs[2].x, pMB->mvs[2].y, stride,  rounding);                  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,          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,
566                                                    pMB->mvs[3].x, pMB->mvs[3].y, stride,  rounding);                  mv[3].x, mv[3].y, stride, rounding);
567          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,      }
568      }
569    
570      /* chroma */
571      interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
572                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
573          interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,    interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
574                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
575    
576          stop_comp_timer();          stop_comp_timer();
577    
578          for (i = 0; i < 6; i++) {    if (cbp)
579                  if (cbp & (1 << (5 - i)))       /* coded */      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
580    }
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;
                         get_inter_block(bs, &block[i * 64]);  
                         stop_coding_timer();  
598    
599                          start_timer();    int uvtop_dx, uvtop_dy;
600                          if (dec->quant_type == 0) {    int uvbot_dx, uvbot_dy;
601                                  dequant_inter(&data[i * 64], &block[i * 64], iQuant);    VECTOR mv[4]; /* local copy of mvs */
602                          } else {  
603                                  dequant4_inter(&data[i * 64], &block[i * 64], iQuant);    /* Get pointer to memory areas */
604                          }    pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
605                          stop_iquant_timer();    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                          idct(&data[i * 64]);  
616                          stop_idct_timer();    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          /* NOT supported */
629                  }                  }
630        else
631        {
632          /* 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        }
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                  next_block = stride;  
670                  stride *= 2;    /* Must add error correction? */
671      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  static void
725  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
726                             Bitstream * bs,                             Bitstream * bs,
727                             int quant,                             int quant,
# Line 425  Line 729 
729  {  {
730          uint32_t bound;          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          bound = 0;          bound = 0;
736    
737          for (y = 0; y < dec->mb_height; y++) {    for (y = 0; y < mb_height; y++) {
738                  for (x = 0; x < dec->mb_width; x++) {      for (x = 0; x < mb_width; x++) {
739                          MACROBLOCK *mb;                          MACROBLOCK *mb;
740                          uint32_t mcbpc;                          uint32_t mcbpc;
741                          uint32_t cbpc;                          uint32_t cbpc;
# Line 442  Line 748 
748    
749                          if (check_resync_marker(bs, 0))                          if (check_resync_marker(bs, 0))
750                          {                          {
751                                  bound = read_video_packet_header(bs, 0, &quant);          bound = read_video_packet_header(bs, dec, 0,
752                                  x = bound % dec->mb_width;                &quant, NULL, NULL, &intra_dc_threshold);
753                                  y = bound / dec->mb_width;          x = bound % mb_width;
754            y = MIN((bound / mb_width), (mb_height-1));
755                          }                          }
756                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
757    
758                          DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));        DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
759    
760                          mcbpc = get_mcbpc_intra(bs);                          mcbpc = get_mcbpc_intra(bs);
761                          mb->mode = mcbpc & 7;                          mb->mode = mcbpc & 7;
# Line 475  Line 782 
782    
783                          if (dec->interlacing) {                          if (dec->interlacing) {
784                                  mb->field_dct = BitstreamGetBit(bs);                                  mb->field_dct = BitstreamGetBit(bs);
785                                  DPRINTF(DPRINTF_DEBUG, "deci: field_dct: %d", 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,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
789                                                          intra_dc_threshold, bound);                                                          intra_dc_threshold, bound);
790    
791                  }                  }
792                  if(dec->out_frm)                  if(dec->out_frm)
793                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,dec->mb_width);        output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,mb_width);
   
794          }          }
795    
796  }  }
797    
798    
799  void  static void
800  get_motion_vector(DECODER * dec,  get_motion_vector(DECODER * dec,
801                                    Bitstream * bs,                                    Bitstream * bs,
802                                    int x,                                    int x,
803                                    int y,                                    int y,
804                                    int k,                                    int k,
805                                    VECTOR * mv,          VECTOR * ret_mv,
806                                    int fcode,                                    int fcode,
807                                    const int bound)                                    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;    const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
816          int mv_x, mv_y;    VECTOR mv;
817    
818          pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);    mv.x = get_mv(bs, fcode);
819      mv.y = get_mv(bs, fcode);
820    
821          mv_x = get_mv(bs, fcode);    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);
         mv_y = get_mv(bs, fcode);  
822    
823          DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv.x, pmv.y);    mv.x += pmv.x;
824      mv.y += pmv.y;
825    
826          mv_x += pmv.x;    if (mv.x < low) {
827          mv_y += pmv.y;      mv.x += range;
828      } else if (mv.x > high) {
829        mv.x -= range;
830      }
831    
832          if (mv_x < low) {    if (mv.y < low) {
833                  mv_x += range;      mv.y += range;
834          } else if (mv_x > high) {    } else if (mv.y > high) {
835                  mv_x -= range;      mv.y -= range;
836          }          }
837    
838          if (mv_y < low) {    ret_mv->x = mv.x;
839                  mv_y += range;    ret_mv->y = mv.y;
         } else if (mv_y > high) {  
                 mv_y -= range;  
840          }          }
841    
842          mv->x = mv_x;  /* We use this when decoder runs interlaced -> different prediction */
         mv->y = mv_y;  
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      const int scale_fac = 1 << (fcode - 1);
854      const int high = (32 * scale_fac) - 1;
855      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 = 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) {
877          mv.y += range;
878        } else if (mv.y > high) {
879          mv.y -= range;
880  }  }
881    
882        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
883      }
884      else
885      {
886        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        if (mvf1.y < low) {
899          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        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  void  /* for P_VOP set gmc_warp to NULL */
934    static void
935  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
936                             Bitstream * bs,                             Bitstream * bs,
937                             int rounding,                             int rounding,
938                             int quant,                             int quant,
939                             int fcode,                             int fcode,
940                             int intra_dc_threshold)          int intra_dc_threshold,
941            const WARPPOINTS *const gmc_warp)
942  {  {
   
943          uint32_t x, y;          uint32_t x, y;
944          uint32_t bound;          uint32_t bound;
945          int cp_mb, st_mb;          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,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
952                                     dec->width, dec->height);              dec->width, dec->height, dec->bs_version);
953        dec->is_edged[0] = 1;
954          stop_edges_timer();          stop_edges_timer();
955      }
956    
957      if (gmc_warp) {
958        /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
959        generate_GMCparameters( dec->sprite_warping_points,
960            dec->sprite_warping_accuracy, gmc_warp,
961            dec->width, dec->height, &dec->new_gmc_data);
962    
963        /* image warping is done block-based in decoder_mbgmc(), now */
964      }
965    
966          bound = 0;          bound = 0;
967    
968          for (y = 0; y < dec->mb_height; y++) {    for (y = 0; y < mb_height; y++) {
969                  cp_mb = st_mb = 0;                  cp_mb = st_mb = 0;
970                  for (x = 0; x < dec->mb_width; x++) {      for (x = 0; x < mb_width; x++) {
971                          MACROBLOCK *mb;                          MACROBLOCK *mb;
972    
973                          /* skip stuffing */                          /* skip stuffing */
974                          while (BitstreamShowBits(bs, 10) == 1)                          while (BitstreamShowBits(bs, 10) == 1)
975                                  BitstreamSkip(bs, 10);                                  BitstreamSkip(bs, 10);
976    
977                          if (check_resync_marker(bs, fcode - 1))        if (check_resync_marker(bs, fcode - 1)) {
978                          {          bound = read_video_packet_header(bs, dec, fcode - 1,
979                                  bound = read_video_packet_header(bs, fcode - 1, &quant);            &quant, &fcode, NULL, &intra_dc_threshold);
980                                  x = bound % dec->mb_width;          x = bound % mb_width;
981                                  y = bound / dec->mb_width;          y = MIN((bound / mb_width), (mb_height-1));
982                          }                          }
983                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
984    
985                          DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));        DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
986    
987                          /*if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs)))          not_coded */        if (!(BitstreamGetBit(bs))) { /* block _is_ coded */
988                          if (!(BitstreamGetBit(bs)))     /* not_coded */          uint32_t mcbpc, cbpc, cbpy, cbp;
989                          {          uint32_t intra, acpred_flag = 0;
990                                  uint32_t mcbpc;          int mcsel = 0;    /* mcsel: '0'=local motion, '1'=GMC */
                                 uint32_t cbpc;  
                                 uint32_t acpred_flag;  
                                 uint32_t cbpy;  
                                 uint32_t cbp;  
                                 uint32_t intra;  
991    
992                                  cp_mb++;                                  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    
997                                  DPRINTF(DPRINTF_MB, "mode %i", mb->mode);          DPRINTF(XVID_DEBUG_MB, "mode %i\n", mb->mode);
998                                  DPRINTF(DPRINTF_MB, "cbpc %i", cbpc);          DPRINTF(XVID_DEBUG_MB, "cbpc %i\n", cbpc);
                                 acpred_flag = 0;  
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);
                                 }  
1006    
1007                                  cbpy = get_cbpy(bs, intra);                                  cbpy = get_cbpy(bs, intra);
1008                                  DPRINTF(DPRINTF_MB, "cbpy %i", cbpy);          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)];                                          int dquant = dquant_table[BitstreamGetBits(bs, 2)];
1014                                          DPRINTF(DPRINTF_MB, "dquant %i", dquant);            DPRINTF(XVID_DEBUG_MB, "dquant %i\n", dquant);
1015                                          quant += dquant;                                          quant += dquant;
1016                                          if (quant > 31) {                                          if (quant > 31) {
1017                                                  quant = 31;                                                  quant = 31;
1018                                          } else if (quant < 1) {                                          } else if (quant < 1) {
1019                                                  quant = 1;                                                  quant = 1;
1020                                          }                                          }
1021                                          DPRINTF(DPRINTF_MB, "quant %i", quant);            DPRINTF(XVID_DEBUG_MB, "quant %i\n", quant);
1022                                  }                                  }
1023                                  mb->quant = quant;                                  mb->quant = quant;
1024    
1025            mb->field_pred=0;
1026                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1027                                          if (cbp || intra) {                                          if (cbp || intra) {
1028                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
1029                                                  DPRINTF(DPRINTF_DEBUG, "decp: field_dct: %d", 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                                                  DPRINTF(DPRINTF_DEBUG, "decp: field_pred: %d", 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                                                          DPRINTF(DPRINTF_DEBUG, "decp: field_for_top: %d", mb->field_for_top);                DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1039                                                          mb->field_for_bot = BitstreamGetBit(bs);                                                          mb->field_for_bot = BitstreamGetBit(bs);
1040                                                          DPRINTF(DPRINTF_DEBUG, "decp: field_for_bot: %d", mb->field_for_bot);                DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1041                                                  }                                                  }
1042                                          }                                          }
1043                                  }                                  }
1044    
1045                                  if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {          if (mcsel) {
1046                                          if (dec->interlacing && mb->field_pred) {            decoder_mbgmc(dec, mb, x, y, fcode, cbp, bs, rounding);
1047                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],            continue;
1048                                                                                    fcode, bound);  
1049                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],          } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1050                                                                                    fcode, bound);  
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 {                                          } else {
1055                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],              get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1056                                                                                    fcode, bound);              mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
                                                 mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =  
                                                         mb->mvs[0].x;  
                                                 mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =  
                                                         mb->mvs[0].y;  
1057                                          }                                          }
1058                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1059              /* interlaced missing here */
1060                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1061                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
1062                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
1063                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
1064                                  } else                  /* MODE_INTRA, MODE_INTRA_Q */          } 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].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =            mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
                                                 0;  
                                         mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =  
                                                 0;  
1067                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1068                                                                          intra_dc_threshold, bound);                                                                          intra_dc_threshold, bound);
1069                                          continue;                                          continue;
1070                                  }                                  }
1071    
1072                                  decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant,          /* See how to decode */
1073                                                                  rounding);          if(!mb->field_pred)
1074                          } else                          /* not coded */           decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1075                          {          else
1076                                  DPRINTF(DPRINTF_DEBUG, "P-frame MB at (X,Y)=(%d,%d)", x, y);           decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1077    
1078          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1079            mb->mode = MODE_NOT_CODED_GMC;
1080            mb->quant = quant;
1081            decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
1082    
1083            if(dec->out_frm && cp_mb > 0) {
1084              output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1085              cp_mb = 0;
1086            }
1087            st_mb = x+1;
1088          } else { /* not coded P_VOP macroblock */
1089                                  mb->mode = MODE_NOT_CODED;                                  mb->mode = MODE_NOT_CODED;
1090            mb->quant = quant;
1091    
1092                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1093                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1094            mb->field_pred=0; /* (!) */
1095    
1096                                  /* copy macroblock directly from ref to cur */          decoder_mbinter(dec, mb, x, y, 0, bs,
1097                                    rounding, 0, 0);
                                 start_timer();  
1098    
                                 transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +  
                                                                  (16 * x),  
                                                                  dec->refn[0].y + (16 * y) * dec->edged_width +  
                                                                  (16 * x), dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +  
                                                                  (16 * x + 8),  
                                                                  dec->refn[0].y + (16 * y) * dec->edged_width +  
                                                                  (16 * x + 8), dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.y + (16 * y + 8) * dec->edged_width +  
                                                                  (16 * x),  
                                                                  dec->refn[0].y + (16 * y +  
                                                                                                    8) * dec->edged_width +  
                                                                  (16 * x), dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.y + (16 * y + 8) * dec->edged_width +  
                                                                  (16 * x + 8),  
                                                                  dec->refn[0].y + (16 * y +  
                                                                                                    8) * dec->edged_width +  
                                                                  (16 * x + 8), dec->edged_width);  
   
                                 transfer8x8_copy(dec->cur.u + (8 * y) * dec->edged_width / 2 +  
                                                                  (8 * x),  
                                                                  dec->refn[0].u +  
                                                                  (8 * y) * dec->edged_width / 2 + (8 * x),  
                                                                  dec->edged_width / 2);  
   
                                 transfer8x8_copy(dec->cur.v + (8 * y) * dec->edged_width / 2 +  
                                                                  (8 * x),  
                                                                  dec->refn[0].v +  
                                                                  (8 * y) * dec->edged_width / 2 + (8 * x),  
                                                                  dec->edged_width / 2);  
                                 stop_transfer_timer();  
1099                                  if(dec->out_frm && cp_mb > 0) {                                  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);                                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1101                                    cp_mb = 0;                                    cp_mb = 0;
# Line 723  Line 1103 
1103                                  st_mb = x+1;                                  st_mb = x+1;
1104                          }                          }
1105                  }                  }
1106    
1107                  if(dec->out_frm && cp_mb > 0)                  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);                    output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1109          }          }
1110  }  }
1111    
1112  /* swap two MACROBLOCK array */  
1113  void  /* decode B-frame motion vector */
1114  mb_swap(MACROBLOCK ** mb1,  static void
1115                  MACROBLOCK ** mb2)  get_b_motion_vector(Bitstream * bs,
1116              VECTOR * mv,
1117              int fcode,
1118              const VECTOR pmv,
1119              const DECODER * const dec,
1120              const int x, const int y)
1121    {
1122      const int scale_fac = 1 << (fcode - 1);
1123      const int high = (32 * scale_fac) - 1;
1124      const int low = ((-32) * scale_fac);
1125      const int range = (64 * scale_fac);
1126    
1127      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    
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      uint32_t stride = dec->edged_width;
1159      uint32_t stride2 = stride / 2;
1160      int uv_dx, uv_dy;
1161      int b_uv_dx, b_uv_dy;
1162      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
1163      const uint32_t cbp = pMB->cbp;
1164    
1165      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
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        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    
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    /*
1322     * decode B-frame mb_type
1323     * 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    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();
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      if (!dec->is_edged[1]) {
1370        start_timer();
1371        image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1372                dec->width, dec->height, dec->bs_version);
1373        dec->is_edged[1] = 1;
1374        stop_edges_timer();
1375      }
1376    
1377      resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1378      for (y = 0; y < dec->mb_height; y++) {
1379        /* 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          if (check_resync_marker(bs, resync_len)) {
1387            int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1388                               &fcode_forward, &fcode_backward, &intra_dc_threshold);
1389            x = bound % dec->mb_width;
1390            y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1391            /* reset predicted macroblocks */
1392            dec->p_fmv = dec->p_bmv = zeromv;
1393            /* update resync len with new fcodes */
1394            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1395          }
1396    
1397          mv =
1398          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1399          mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1400          mb->quant = quant;
1401    
1402          /*
1403           * skip if the co-located P_VOP macroblock is not coded
1404           * if not codec in co-located S_VOP macroblock is _not_
1405           * automatically skipped
1406           */
1407    
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          if (!BitstreamGetBit(bs)) { /* modb=='0' */
1416            const uint8_t modb2 = BitstreamGetBit(bs);
1417    
1418            mb->mode = get_mbtype(bs);
1419    
1420            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          MACROBLOCK *temp = *mb1;    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          *mb1 = *mb2;    if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1522          *mb2 = temp;      && 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  int
1552  decoder_decode(DECODER * dec,  decoder_decode(DECODER * dec,
1553                             XVID_DEC_FRAME * frame)          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
1554  {  {
1555    
1556          Bitstream bs;          Bitstream bs;
1557          uint32_t rounding;          uint32_t rounding;
1558          uint32_t quant;    uint32_t quant = 2;
1559          uint32_t fcode_forward;          uint32_t fcode_forward;
1560          uint32_t fcode_backward;          uint32_t fcode_backward;
1561          uint32_t intra_dc_threshold;          uint32_t intra_dc_threshold;
1562          uint32_t vop_type;    WARPPOINTS gmc_warp;
1563      int coding_type;
1564      int success, output, seen_something;
1565    
1566      if (XVID_VERSION_MAJOR(frame->version) != 1 || (stats && XVID_VERSION_MAJOR(stats->version) != 1))  /* v1.x.x */
1567        return XVID_ERR_VERSION;
1568    
1569          start_global_timer();          start_global_timer();
1570    
1571          dec->out_frm = (frame->colorspace == XVID_CSP_EXTERN) ? frame->image : NULL;    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          dec->frames++;    {
1599          vop_type =      image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1600                  BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode_forward,             (uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1601                                                           &fcode_backward, &intra_dc_threshold);      if (stats) stats->type = XVID_TYPE_NOTHING;
1602        emms();
1603        return 1; /* one byte consumed */
1604      }
1605    
1606          dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */    success = 0;
1607      output = 0;
1608      seen_something = 0;
1609    
1610          switch (vop_type) {  repeat:
1611          case P_VOP:  
1612                  decoder_pframe(dec, &bs, rounding, quant, fcode_forward,    coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1613                                             intra_dc_threshold);        &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1614                  break;  
1615      DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%"
1616    #if defined(_MSC_VER)
1617        "I64"
1618    #else
1619        "ll"
1620    #endif
1621        "i,  time_pp=%i,  time_bp=%i\n",
1622                  coding_type,  dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1623    
1624      if (coding_type == -1) { /* nothing */
1625        if (success) goto done;
1626        if (stats) stats->type = XVID_TYPE_NOTHING;
1627        emms();
1628        return BitstreamPos(&bs)/8;
1629      }
1630    
1631      if (coding_type == -2 || coding_type == -3) { /* vol and/or resize */
1632    
1633        if (coding_type == -3)
1634          if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1635    
1636        if(stats) {
1637          stats->type = XVID_TYPE_VOL;
1638          stats->data.vol.general = 0;
1639          /*XXX: if (dec->interlacing)
1640            stats->data.vol.general |= ++INTERLACING; */
1641          stats->data.vol.width = dec->width;
1642          stats->data.vol.height = dec->height;
1643          stats->data.vol.par = dec->aspect_ratio;
1644          stats->data.vol.par_width = dec->par_width;
1645          stats->data.vol.par_height = dec->par_height;
1646          emms();
1647          return BitstreamPos(&bs)/8; /* number of bytes consumed */
1648        }
1649        goto repeat;
1650      }
1651    
1652      if(dec->frames == 0 && coding_type != I_VOP) {
1653        /* 1st frame is not an i-vop */
1654        goto repeat;
1655      }
1656    
1657      dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1658    
1659      /* packed_mode: special-N_VOP treament */
1660      if (dec->packed_mode && coding_type == N_VOP) {
1661        if (dec->low_delay_default && dec->frames > 0) {
1662          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1663          output = 1;
1664        }
1665        /* ignore otherwise */
1666      } else if (coding_type != B_VOP) {
1667        switch(coding_type) {
1668          case I_VOP:          case I_VOP:
1669                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1670                  break;                  break;
1671          case B_VOP:      case P_VOP :
1672                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);        decoder_pframe(dec, &bs, rounding, quant,
1673                            fcode_forward, intra_dc_threshold, NULL);
1674          break;
1675        case S_VOP :
1676          decoder_pframe(dec, &bs, rounding, quant,
1677                            fcode_forward, intra_dc_threshold, &gmc_warp);
1678                  break;                  break;
1679          case N_VOP:          case N_VOP:
1680                  /* when low_delay==0, N_VOP's should interpolate between the past and future frames */        /* 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);                  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          image_output(&dec->cur, dec->width, dec->height, dec->edged_width,        if(dec->low_delay) {
1690                                           frame->image, frame->stride, frame->colorspace);          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    
         if (vop_type == I_VOP || vop_type == P_VOP) {  
1699                  image_swap(&dec->refn[0], &dec->refn[1]);                  image_swap(&dec->refn[0], &dec->refn[1]);
1700        dec->is_edged[1] = dec->is_edged[0];
1701                  image_swap(&dec->cur, &dec->refn[0]);                  image_swap(&dec->cur, &dec->refn[0]);
1702        dec->is_edged[0] = 0;
1703        SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
1704        dec->last_coding_type = coding_type;
1705    
1706        dec->frames++;
1707        seen_something = 1;
1708    
1709      } else {  /* B_VOP */
1710    
1711                  /* swap MACROBLOCK */      if (dec->low_delay) {
1712                  /* the Divx will not set the low_delay flage some times */        DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1713                  /* so follow code will wrong to not swap at that time */        dec->low_delay = 0;
                 /* this will broken bitstream! so I'm change it, */  
                 /* But that is not the best way! can anyone tell me how */  
                 /* to do another way? */  
                 /* 18-07-2002   MinChen<chenm001@163.com> */  
                 /*if (!dec->low_delay && vop_type == P_VOP) */  
                 if (vop_type == P_VOP)  
                         mb_swap(&dec->mbs, &dec->last_mbs);  
1714          }          }
1715    
1716          emms();      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();
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.46  
changed lines
  Added in v.1.81

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