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

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

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