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

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.78

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