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

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

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