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

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.86.2.1

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