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

Legend:
Removed from v.1.9  
changed lines
  Added in v.1.69

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