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

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.80.2.1

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