[cvs] / xvidcore / src / decoder.c Repository:
ViewVC logotype

Diff of /xvidcore/src/decoder.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

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

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