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

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

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