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

Legend:
Removed from v.1.37.2.11  
changed lines
  Added in v.1.86.2.1

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