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

Legend:
Removed from v.1.37.2.14  
changed lines
  Added in v.1.75.2.2

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