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

Legend:
Removed from v.1.46  
changed lines
  Added in v.1.85

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