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

Diff of /xvidcore/src/decoder.c

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

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

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

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