[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.51.2.6, Sat Jul 3 09:18:35 2004 UTC revision 1.78, Mon Mar 27 11:21:48 2006 UTC
# Line 4  Line 4 
4   *  - Decoder Module -   *  - Decoder Module -
5   *   *
6   *  Copyright(C) 2002      MinChen <chenm001@163.com>   *  Copyright(C) 2002      MinChen <chenm001@163.com>
7   *               2002-2003 Peter Ross <pross@xvid.org>   *               2002-2004 Peter Ross <pross@xvid.org>
8   *   *
9   *  This program is free software ; you can redistribute it and/or modify   *  This program is free software ; you can redistribute it and/or modify
10   *  it under the terms of the GNU General Public License as published by   *  it under the terms of the GNU General Public License as published by
# Line 46  Line 46 
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"
 #include "image/reduced.h"  
49  #include "image/font.h"  #include "image/font.h"
50    #include "image/qpel.h"
51    
52  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
53  #include "prediction/mbprediction.h"  #include "prediction/mbprediction.h"
# Line 61  Line 61 
61  #include "image/postprocessing.h"  #include "image/postprocessing.h"
62  #include "utils/mem_align.h"  #include "utils/mem_align.h"
63    
64    #define DIV2ROUND(n)  (((n)>>1)|((n)&1))
65    #define DIV2(n)       ((n)>>1)
66    #define DIVUVMOV(n) (((n) >> 1) + roundtab_79[(n) & 0x3]) //
67    
68  static int  static int
69  decoder_resize(DECODER * dec)  decoder_resize(DECODER * dec)
70  {  {
# Line 73  Line 77 
77    
78          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
79    
80          if (dec->last_mbs)    image_null(&dec->cur);
81      image_null(&dec->refn[0]);
82      image_null(&dec->refn[1]);
83      image_null(&dec->tmp);
84      image_null(&dec->qtmp);
85      image_null(&dec->gmc);
86    
87    
88                  xvid_free(dec->last_mbs);                  xvid_free(dec->last_mbs);
         if (dec->mbs)  
89                  xvid_free(dec->mbs);                  xvid_free(dec->mbs);
         if (dec->qscale)  
90                  xvid_free(dec->qscale);                  xvid_free(dec->qscale);
91      dec->last_mbs = NULL;
92      dec->mbs = NULL;
93      dec->qscale = NULL;
94    
95          /* realloc */          /* realloc */
96          dec->mb_width = (dec->width + 15) / 16;          dec->mb_width = (dec->width + 15) / 16;
# Line 87  Line 99 
99          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
100          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
101    
102          if (image_create(&dec->cur, dec->edged_width, dec->edged_height)) {          if (   image_create(&dec->cur, dec->edged_width, dec->edged_height)
103                  xvid_free(dec);              || image_create(&dec->refn[0], dec->edged_width, dec->edged_height)
104                  return XVID_ERR_MEMORY;              || image_create(&dec->refn[1], dec->edged_width, dec->edged_height)         /* Support B-frame to reference last 2 frame */
105          }              || image_create(&dec->tmp, dec->edged_width, dec->edged_height)
106                || image_create(&dec->qtmp, dec->edged_width, dec->edged_height)
107          if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {        || image_create(&dec->gmc, dec->edged_width, dec->edged_height) )
108                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);      goto memory_error;
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         /* Support B-frame to reference last 2 frame */  
         if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
         if (image_create(&dec->tmp, dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         if (image_create(&dec->qtmp, dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         if (image_create(&dec->gmc, dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
109    
110          dec->mbs =          dec->mbs =
111                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
112                                          CACHE_LINE);                                          CACHE_LINE);
113          if (dec->mbs == NULL) {          if (dec->mbs == NULL)
114                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);            goto memory_error;
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
115          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
116    
117          /* For skip MB flag */          /* For skip MB flag */
118          dec->last_mbs =          dec->last_mbs =
119                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120                                          CACHE_LINE);                                          CACHE_LINE);
121          if (dec->last_mbs == NULL) {          if (dec->last_mbs == NULL)
122                  xvid_free(dec->mbs);            goto memory_error;
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
123          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124    
125          /* nothing happens if that fails */          /* nothing happens if that fails */
# Line 171  Line 130 
130                  memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);                  memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131    
132          return 0;          return 0;
133    
134    memory_error:
135            /* Most structures were deallocated / nullifieded, so it should be safe */
136            /* decoder_destroy(dec) minus the write_timer */
137      xvid_free(dec->mbs);
138      image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139      image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140      image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141      image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143    
144      xvid_free(dec);
145      return XVID_ERR_MEMORY;
146  }  }
147    
148    
# Line 223  Line 195 
195          dec->low_delay = 0;          dec->low_delay = 0;
196          dec->packed_mode = 0;          dec->packed_mode = 0;
197          dec->time_inc_resolution = 1; /* until VOL header says otherwise */          dec->time_inc_resolution = 1; /* until VOL header says otherwise */
198      dec->ver_id = 1;
199    
200      dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
201    
202          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
203    
# Line 270  Line 245 
245                                  Bitstream * bs,                                  Bitstream * bs,
246                                  const uint32_t quant,                                  const uint32_t quant,
247                                  const uint32_t intra_dc_threshold,                                  const uint32_t intra_dc_threshold,
248                                  const unsigned int bound,          const unsigned int bound)
                                 const int reduced_resolution)  
249  {  {
250    
251          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
# Line 284  Line 258 
258          uint32_t iQuant = pMB->quant;          uint32_t iQuant = pMB->quant;
259          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
260    
         if (reduced_resolution) {  
                 pY_Cur = dec->cur.y + (y_pos << 5) * stride + (x_pos << 5);  
                 pU_Cur = dec->cur.u + (y_pos << 4) * stride2 + (x_pos << 4);  
                 pV_Cur = dec->cur.v + (y_pos << 4) * stride2 + (x_pos << 4);  
         }else{  
261                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
262                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
263                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
         }  
264    
265          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */
266    
# Line 351  Line 319 
319                  stop_iquant_timer();                  stop_iquant_timer();
320    
321                  start_timer();                  start_timer();
322                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
323                  stop_idct_timer();                  stop_idct_timer();
324    
325          }          }
# Line 362  Line 330 
330          }          }
331    
332          start_timer();          start_timer();
   
         if (reduced_resolution)  
         {  
                 next_block*=2;  
                 copy_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);  
                 copy_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);  
                 copy_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);  
                 copy_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);  
                 copy_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);  
                 copy_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);  
         }else{  
333                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
334                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
335                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
336                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
337                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
338                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
         }  
339          stop_transfer_timer();          stop_transfer_timer();
340  }  }
341    
# Line 390  Line 346 
346                                  uint8_t * pY_Cur,                                  uint8_t * pY_Cur,
347                                  uint8_t * pU_Cur,                                  uint8_t * pU_Cur,
348                                  uint8_t * pV_Cur,                                  uint8_t * pV_Cur,
                                 const int reduced_resolution,  
349                                  const MACROBLOCK * pMB)                                  const MACROBLOCK * pMB)
350  {  {
351          DECLARE_ALIGNED_MATRIX(block, 1, 64, int16_t, CACHE_LINE);    DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
352    
353          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * (reduced_resolution ? 16 : 8);  
         const int stride2 = stride/2;  
354          int i;          int i;
355          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
356          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
357          const quant_interFuncPtr dequant = dec->quant_type == 0 ? dequant_h263_inter : dequant_mpeg_inter;    typedef void (*get_inter_block_function_t)(
358          Bitstream * bs,
359          int16_t * block,
360          int direction,
361          const int quant,
362          const uint16_t *matrix);
363      typedef void (*add_residual_function_t)(
364          uint8_t *predicted_block,
365          const int16_t *residual,
366          int stride);
367    
368      const get_inter_block_function_t get_inter_block = (dec->quant_type == 0)
369        ? (get_inter_block_function_t)get_inter_block_h263
370        : (get_inter_block_function_t)get_inter_block_mpeg;
371    
372      uint8_t *dst[6];
373      int strides[6];
374    
         for (i = 0; i < 6; i++) {  
375    
376                  if (cbp & (1 << (5 - i))) {     /* coded */    if (dec->interlacing && pMB->field_dct) {
377        dst[0] = pY_Cur;
378        dst[1] = pY_Cur + 8;
379        dst[2] = pY_Cur + stride;
380        dst[3] = dst[2] + 8;
381        dst[4] = pU_Cur;
382        dst[5] = pV_Cur;
383        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
384        strides[4] = stride/2;
385        strides[5] = stride/2;
386      } else {
387        dst[0] = pY_Cur;
388        dst[1] = pY_Cur + 8;
389        dst[2] = pY_Cur + 8*stride;
390        dst[3] = dst[2] + 8;
391        dst[4] = pU_Cur;
392        dst[5] = pV_Cur;
393        strides[0] = strides[1] = strides[2] = strides[3] = stride;
394        strides[4] = stride/2;
395        strides[5] = stride/2;
396      }
397    
398      for (i = 0; i < 6; i++) {
399        /* Process only coded blocks */
400        if (cbp & (1 << (5 - i))) {
401    
402                          memset(block, 0, 64 * sizeof(int16_t)); /* clear */        /* Clear the block */
403          memset(&data[0], 0, 64*sizeof(int16_t));
404    
405          /* Decode coeffs and dequantize on the fly */
406                          start_timer();                          start_timer();
407                          get_inter_block(bs, block, direction);        get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
408                          stop_coding_timer();                          stop_coding_timer();
409    
410          /* iDCT */
411                          start_timer();                          start_timer();
412                          dequant(&data[i * 64], block, iQuant, dec->mpeg_quant_matrices);        idct((short * const)&data[0]);
413                          stop_iquant_timer();        stop_idct_timer();
414    
415          /* Add this residual to the predicted block */
416                          start_timer();                          start_timer();
417                          idct(&data[i * 64]);        transfer_16to8add(dst[i], &data[0], strides[i]);
418                          stop_idct_timer();        stop_transfer_timer();
419                  }                  }
420          }          }
   
         if (dec->interlacing && pMB->field_dct) {  
                 next_block = stride;  
                 stride *= 2;  
421          }          }
422    
423          start_timer();  static void __inline
424          if (reduced_resolution) {  validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
425                  if (cbp & 32)  {
426                          add_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);    /* clip a vector to valid range
427                  if (cbp & 16)       prevents crashes if bitstream is broken
428                          add_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);    */
429                  if (cbp & 8)    int shift = 5 + dec->quarterpel;
430                          add_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);    int xborder_high = (int)(dec->mb_width - x_pos) << shift;
431                  if (cbp & 4)    int xborder_low = (-(int)x_pos-1) << shift;
432                          add_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);    int yborder_high = (int)(dec->mb_height - y_pos) << shift;
433                  if (cbp & 2)    int yborder_low = (-(int)y_pos-1) << shift;
434                          add_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);  
435                  if (cbp & 1)  #define CHECK_MV(mv) \
436                          add_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);    do { \
437          } else {    if ((mv).x > xborder_high) { \
438                  if (cbp & 32)      DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
439                          transfer_16to8add(pY_Cur, &data[0 * 64], stride);      (mv).x = xborder_high; \
440                  if (cbp & 16)    } else if ((mv).x < xborder_low) { \
441                          transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);      DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
442                  if (cbp & 8)      (mv).x = xborder_low; \
443                          transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);    } \
444                  if (cbp & 4)    if ((mv).y > yborder_high) { \
445                          transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);      DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
446                  if (cbp & 2)      (mv).y = yborder_high; \
447                          transfer_16to8add(pU_Cur, &data[4 * 64], stride2);    } else if ((mv).y < yborder_low) { \
448                  if (cbp & 1)      DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
449                          transfer_16to8add(pV_Cur, &data[5 * 64], stride2);      (mv).y = yborder_low; \
450          }    } \
451          stop_transfer_timer();    } while (0)
452  }  
453      CHECK_MV(mv[0]);
454      CHECK_MV(mv[1]);
455      CHECK_MV(mv[2]);
456      CHECK_MV(mv[3]);
457    }
458    
459    /* Up to this version, chroma rounding was wrong with qpel.
460     * So we try to be backward compatible to avoid artifacts */
461    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
462    
463  /* decode an inter macroblock */  /* decode an inter macroblock */
464  static void  static void
# Line 469  Line 469 
469                                  const uint32_t cbp,                                  const uint32_t cbp,
470                                  Bitstream * bs,                                  Bitstream * bs,
471                                  const uint32_t rounding,                                  const uint32_t rounding,
472                                  const int reduced_resolution,          const int ref,
473                                  const int ref)                  const int bvop)
474  {  {
475          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
476          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 481  Line 481 
481          int uv_dx, uv_dy;          int uv_dx, uv_dy;
482          VECTOR mv[4];   /* local copy of mvs */          VECTOR mv[4];   /* local copy of mvs */
483    
         if (reduced_resolution) {  
                 pY_Cur = dec->cur.y + (y_pos << 5) * stride + (x_pos << 5);  
                 pU_Cur = dec->cur.u + (y_pos << 4) * stride2 + (x_pos << 4);  
                 pV_Cur = dec->cur.v + (y_pos << 4) * stride2 + (x_pos << 4);  
                 for (i = 0; i < 4; i++) {  
                         mv[i].x = RRV_MV_SCALEUP(pMB->mvs[i].x);  
                         mv[i].y = RRV_MV_SCALEUP(pMB->mvs[i].y);  
                 }  
         } else {  
484                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
485                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
486                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
487                  for (i = 0; i < 4; i++)                  for (i = 0; i < 4; i++)
488                          mv[i] = pMB->mvs[i];                          mv[i] = pMB->mvs[i];
         }  
489    
490          for (i = 0; i < 4; i++) {    validate_vector(mv, x_pos, y_pos, dec);
                 /* clip to valid range */  
                 int border = (int)(dec->mb_width - x_pos) << (5 + dec->quarterpel);  
                 if (mv[i].x > border) {  
                         DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", mv[i].x, border, x_pos, y_pos);  
                         mv[i].x = border;  
                 } else {  
                         border = (-(int)x_pos-1) << (5 + dec->quarterpel);  
                         if (mv[i].x < border) {  
                                 DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", mv[i].x, border, x_pos, y_pos);  
                                 mv[i].x = border;  
                         }  
                 }  
   
                 border = (int)(dec->mb_height - y_pos) << (5 + dec->quarterpel);  
                 if (mv[i].y >  border) {  
                         DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", mv[i].y, border, x_pos, y_pos);  
                         mv[i].y = border;  
                 } else {  
                         border = (-(int)y_pos-1) << (5 + dec->quarterpel);  
                         if (mv[i].y < border) {  
                                 DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", mv[i].y, border, x_pos, y_pos);  
                                 mv[i].y = border;  
                         }  
                 }  
         }  
491    
492          start_timer();          start_timer();
493    
494          if (pMB->mode != MODE_INTER4V) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */    if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
495    
496                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
497                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
498                  if (dec->quarterpel) {                  if (dec->quarterpel) {
499                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
500                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
501                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
502                            }
503                            else {
504                          uv_dx /= 2;                          uv_dx /= 2;
505                          uv_dy /= 2;                          uv_dy /= 2;
506                  }                  }
507        }
508                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
509                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
510    
511                  if (reduced_resolution)      if (dec->quarterpel)
                         interpolate32x32_switch(dec->cur.y, dec->refn[0].y, 32*x_pos, 32*y_pos,  
                                                                         mv[0].x, mv[0].y, stride, rounding);  
                 else if (dec->quarterpel)  
512                          interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,                          interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,
513                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
514                                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 551  Line 519 
519          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
520    
521                  if(dec->quarterpel) {                  if(dec->quarterpel) {
522                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
523                                    int z;
524                                    uv_dx = 0; uv_dy = 0;
525                                    for (z = 0; z < 4; z++) {
526                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
527                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
528                                    }
529                            }
530                            else {
531                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
532                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
533          }
534                  } else {                  } else {
535                          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;                          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
536                          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;                          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
# Line 561  Line 539 
539                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
540                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
541    
542                  if (reduced_resolution) {      if (dec->quarterpel) {
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y, 32*x_pos, 32*y_pos,  
                                                                 mv[0].x, mv[0].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y , 32*x_pos + 16, 32*y_pos,  
                                                                 mv[1].x, mv[1].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y , 32*x_pos, 32*y_pos + 16,  
                                                                 mv[2].x, mv[2].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y , 32*x_pos + 16, 32*y_pos + 16,  
                                                                 mv[3].x, mv[3].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.u, dec->refn[0].u , 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
                         interpolate16x16_switch(dec->cur.v, dec->refn[0].v , 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
   
                 } else if (dec->quarterpel) {  
543                          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,                          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
544                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
545                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 601  Line 565 
565          }          }
566    
567          /* chroma */          /* chroma */
         if (reduced_resolution) {  
                 interpolate16x16_switch(dec->cur.u, dec->refn[0].u, 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
                 interpolate16x16_switch(dec->cur.v, dec->refn[0].v, 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
         } else {  
568                  interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,                  interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
569                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
570                  interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,                  interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
571                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
572    
573      stop_comp_timer();
574    
575      if (cbp)
576        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
577    }
578    
579    /* decode an inter macroblock in field mode */
580    static void
581    decoder_mbinter_field(DECODER * dec,
582            const MACROBLOCK * pMB,
583            const uint32_t x_pos,
584            const uint32_t y_pos,
585            const uint32_t cbp,
586            Bitstream * bs,
587            const uint32_t rounding,
588            const int ref,
589                    const int bvop)
590    {
591      uint32_t stride = dec->edged_width;
592      uint32_t stride2 = stride / 2;
593    
594      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
595    
596      int uvtop_dx, uvtop_dy;
597      int uvbot_dx, uvbot_dy;
598      VECTOR mv[4]; /* local copy of mvs */
599    
600      /* Get pointer to memory areas */
601      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
602      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
603      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
604    
605      mv[0] = pMB->mvs[0];
606      mv[1] = pMB->mvs[1];
607      memset(&mv[2],0,2*sizeof(VECTOR));
608    
609      validate_vector(mv, x_pos, y_pos, dec);
610    
611      start_timer();
612    
613      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
614      {
615        /* Prepare top field vector */
616        uvtop_dx = DIV2ROUND(mv[0].x);
617        uvtop_dy = DIV2ROUND(mv[0].y);
618    
619        /* Prepare bottom field vector */
620        uvbot_dx = DIV2ROUND(mv[1].x);
621        uvbot_dy = DIV2ROUND(mv[1].y);
622    
623        if(dec->quarterpel)
624        {
625          /* NOT supported */
626        }
627        else
628        {
629          /* Interpolate top field left part(we use double stride for every 2nd line) */
630          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
631                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
632          /* top field right part */
633          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
634                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
635    
636          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
637          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
638                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
639          /* Bottom field right part */
640          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
641                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
642    
643          /* Interpolate field1 U */
644          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
645                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
646    
647          /* Interpolate field1 V */
648          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
649                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
650    
651          /* Interpolate field2 U */
652          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
653                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
654    
655          /* Interpolate field2 V */
656          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
657                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
658        }
659      }
660      else
661      {
662        /* We don't expect 4 motion vectors in interlaced mode */
663          }          }
664    
665          stop_comp_timer();          stop_comp_timer();
666    
667      /* Must add error correction? */
668          if (cbp)          if (cbp)
669                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur,     decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
                                                         reduced_resolution, pMB);  
670  }  }
671    
672  static void  static void
# Line 664  Line 713 
713          stop_transfer_timer();          stop_transfer_timer();
714    
715          if (cbp)          if (cbp)
716                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, 0, pMB);      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
717    
718  }  }
719    
# Line 672  Line 721 
721  static void  static void
722  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
723                                  Bitstream * bs,                                  Bitstream * bs,
                                 int reduced_resolution,  
724                                  int quant,                                  int quant,
725                                  int intra_dc_threshold)                                  int intra_dc_threshold)
726  {  {
727          uint32_t bound;          uint32_t bound;
728          uint32_t x, y;          uint32_t x, y;
729          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
730          uint32_t mb_height = dec->mb_height;    const uint32_t mb_height = dec->mb_height;
   
         if (reduced_resolution) {  
                 mb_width = (dec->width + 31) / 32;  
                 mb_height = (dec->height + 31) / 32;  
         }  
731    
732          bound = 0;          bound = 0;
733    
# Line 740  Line 783 
783                          }                          }
784    
785                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
786                                                          intra_dc_threshold, bound, reduced_resolution);                intra_dc_threshold, bound);
787    
788                  }                  }
789                  if(dec->out_frm)                  if(dec->out_frm)
# Line 793  Line 836 
836          ret_mv->y = mv.y;          ret_mv->y = mv.y;
837  }  }
838    
839    /* We use this when decoder runs interlaced -> different prediction */
840    
841    static void get_motion_vector_interlaced(DECODER * dec,
842            Bitstream * bs,
843            int x,
844            int y,
845            int k,
846            MACROBLOCK *pMB,
847            int fcode,
848            const int bound)
849    {
850      const int scale_fac = 1 << (fcode - 1);
851      const int high = (32 * scale_fac) - 1;
852      const int low = ((-32) * scale_fac);
853      const int range = (64 * scale_fac);
854    
855      /* Get interlaced prediction */
856      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
857      VECTOR mv,mvf1,mvf2;
858    
859      if(!pMB->field_pred)
860      {
861        mv.x = get_mv(bs,fcode);
862        mv.y = get_mv(bs,fcode);
863    
864        mv.x += pmv.x;
865        mv.y += pmv.y;
866    
867        if(mv.x<low) {
868          mv.x += range;
869        } else if (mv.x>high) {
870          mv.x-=range;
871        }
872    
873        if (mv.y < low) {
874          mv.y += range;
875        } else if (mv.y > high) {
876          mv.y -= range;
877        }
878    
879        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
880      }
881      else
882      {
883        mvf1.x = get_mv(bs, fcode);
884        mvf1.y = get_mv(bs, fcode);
885    
886        mvf1.x += pmv.x;
887        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
888    
889        if (mvf1.x < low) {
890          mvf1.x += range;
891        } else if (mvf1.x > high) {
892          mvf1.x -= range;
893        }
894    
895        if (mvf1.y < low) {
896          mvf1.y += range;
897        } else if (mvf1.y > high) {
898          mvf1.y -= range;
899        }
900    
901        mvf2.x = get_mv(bs, fcode);
902        mvf2.y = get_mv(bs, fcode);
903    
904        mvf2.x += pmv.x;
905        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
906    
907        if (mvf2.x < low) {
908          mvf2.x += range;
909        } else if (mvf2.x > high) {
910          mvf2.x -= range;
911        }
912    
913        if (mvf2.y < low) {
914          mvf2.y += range;
915        } else if (mvf2.y > high) {
916          mvf2.y -= range;
917        }
918    
919        pMB->mvs[0]=mvf1;
920        pMB->mvs[1]=mvf2;
921        pMB->mvs[2].x=pMB->mvs[3].x=0;
922        pMB->mvs[2].y=pMB->mvs[3].y=0;
923    
924        /* Calculate average for as it is field predicted */
925        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
926        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
927      }
928    }
929    
930  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
931  static void  static void
932  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
933                                  Bitstream * bs,                                  Bitstream * bs,
934                                  int rounding,                                  int rounding,
                                 int reduced_resolution,  
935                                  int quant,                                  int quant,
936                                  int fcode,                                  int fcode,
937                                  int intra_dc_threshold,                                  int intra_dc_threshold,
# Line 807  Line 940 
940          uint32_t x, y;          uint32_t x, y;
941          uint32_t bound;          uint32_t bound;
942          int cp_mb, st_mb;          int cp_mb, st_mb;
943          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
944          uint32_t mb_height = dec->mb_height;    const uint32_t mb_height = dec->mb_height;
   
         if (reduced_resolution) {  
                 mb_width = (dec->width + 31) / 32;  
                 mb_height = (dec->height + 31) / 32;  
         }  
945    
946      if (!dec->is_edged[0]) {
947          start_timer();          start_timer();
948          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
949                                          dec->width, dec->height, dec->bs_version);                                          dec->width, dec->height, dec->bs_version);
950        dec->is_edged[0] = 1;
951          stop_edges_timer();          stop_edges_timer();
952      }
953    
954          if (gmc_warp) {          if (gmc_warp) {
955                  /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */                  /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
# Line 888  Line 1019 
1019                                  }                                  }
1020                                  mb->quant = quant;                                  mb->quant = quant;
1021    
1022            mb->field_pred=0;
1023                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1024                                          if (cbp || intra) {                                          if (cbp || intra) {
1025                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 913  Line 1045 
1045    
1046                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1047    
1048                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1049                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1050                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1], fcode, bound);              get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1051                                          } else {                                          } else {
1052                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1053                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1054                                          }                                          }
1055                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1056              /* interlaced missing here */
1057                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1058                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
1059                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
# Line 929  Line 1062 
1062                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1063                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =     0;                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =     0;
1064                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1065                                                                          intra_dc_threshold, bound, reduced_resolution);                    intra_dc_threshold, bound);
1066                                          continue;                                          continue;
1067                                  }                                  }
1068    
1069                                  decoder_mbinter(dec, mb, x, y, cbp, bs,          /* See how to decode */
1070                                                                  rounding, reduced_resolution, 0);          if(!mb->field_pred)
1071             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1072            else
1073             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1074    
1075                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1076                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 952  Line 1088 
1088    
1089                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1090                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1091            mb->field_pred=0; /* (!) */
1092    
1093                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1094                                                                  rounding, reduced_resolution, 0);                                  rounding, 0, 0);
1095    
1096                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1097                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
# Line 1009  Line 1146 
1146  decoder_bf_interpolate_mbinter(DECODER * dec,  decoder_bf_interpolate_mbinter(DECODER * dec,
1147                                                                  IMAGE forward,                                                                  IMAGE forward,
1148                                                                  IMAGE backward,                                                                  IMAGE backward,
1149                                                                  const MACROBLOCK * pMB,                  MACROBLOCK * pMB,
1150                                                                  const uint32_t x_pos,                                                                  const uint32_t x_pos,
1151                                                                  const uint32_t y_pos,                                                                  const uint32_t y_pos,
1152                                                                  Bitstream * bs,                                                                  Bitstream * bs,
# Line 1026  Line 1163 
1163          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
1164          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
1165    
1166      validate_vector(pMB->mvs, x_pos, y_pos, dec);
1167      validate_vector(pMB->b_mvs, x_pos, y_pos, dec);
1168    
1169          if (!direct) {          if (!direct) {
1170                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
1171                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
   
1172                  b_uv_dx = pMB->b_mvs[0].x;                  b_uv_dx = pMB->b_mvs[0].x;
1173                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1174    
1175                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1176                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1177                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1178                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1179                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1180                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1181                            }
1182                            else {
1183                          uv_dx /= 2;                          uv_dx /= 2;
1184                          uv_dy /= 2;                          uv_dy /= 2;
1185                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1186                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1187                  }                  }
1188        }
1189    
1190                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1191                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
   
1192                  b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];                  b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];
1193                  b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];                  b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
1194    
1195          } else {          } else {
1196                  if(dec->quarterpel) {            if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1197                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1198                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1199                            int z;
1200                            uv_dx = 0; uv_dy = 0;
1201                            b_uv_dx = 0; b_uv_dy = 0;
1202                            for (z = 0; z < 4; z++) {
1203                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1204                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1205                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1206                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1207                            }
1208                    }
1209                    else {
1210                          uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);                          uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1211                          uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);                          uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1212                          b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);                          b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1213                          b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);                          b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1214                    }
1215                  } else {                  } else {
1216                          uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                          uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1217                          uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;                          uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
# Line 1104  Line 1264 
1264    
1265          if(dec->quarterpel) {          if(dec->quarterpel) {
1266                  if(!direct) {                  if(!direct) {
1267                          interpolate16x16_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        interpolate16x16_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1268                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1269                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1270                  } else {                  } else {
1271                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1272                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1273                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1274                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1275                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1276                                                                                  pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);                                                                                  pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1277                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1278                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1279                                                                                  pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);                                                                                  pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1280                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1281                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1282                                                                                  pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);                                                                                  pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1283                  }                  }
1284          } else {          } else {
1285                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos, 16 * y_pos,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos, 16 * y_pos,
1286                                                          pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                          pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1287                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos + 8,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1288                                                          16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);                                                          16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1289                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos,
1290                                                          16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);                                                          16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1291                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos + 8,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1292                                                          16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);                                                          16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1293          }          }
1294    
1295          interpolate8x8_switch(dec->tmp.u, backward.u, 8 * x_pos, 8 * y_pos,    interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1296                                                  b_uv_dx, b_uv_dy, stride2, 0);                                                  b_uv_dx, b_uv_dy, stride2, 0);
1297          interpolate8x8_switch(dec->tmp.v, backward.v, 8 * x_pos, 8 * y_pos,    interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1298                                                  b_uv_dx, b_uv_dy, stride2, 0);                                                  b_uv_dx, b_uv_dy, stride2, 0);
1299    
         interpolate8x8_avg2(dec->cur.y + (16 * y_pos * stride) + 16 * x_pos,  
                                                 dec->cur.y + (16 * y_pos * stride) + 16 * x_pos,  
                                                 dec->tmp.y + (16 * y_pos * stride) + 16 * x_pos,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.y + (16 * y_pos * stride) + 16 * x_pos + 8,  
                                                 dec->cur.y + (16 * y_pos * stride) + 16 * x_pos + 8,  
                                                 dec->tmp.y + (16 * y_pos * stride) + 16 * x_pos + 8,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,  
                                                 dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,  
                                                 dec->tmp.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,  
                                                 dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,  
                                                 dec->tmp.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.u + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->cur.u + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->tmp.u + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 stride2, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.v + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->cur.v + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->tmp.v + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 stride2, 1, 8);  
   
1300          stop_comp_timer();          stop_comp_timer();
1301    
1302          if (cbp)          if (cbp)
1303                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, 0, pMB);      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1304  }  }
1305    
1306  /* for decode B-frame dbquant */  /* for decode B-frame dbquant */
# Line 1217  Line 1347 
1347          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
1348          int i;          int i;
1349    
1350      if (!dec->is_edged[0]) {
1351          start_timer();          start_timer();
1352          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1353                                          dec->width, dec->height, dec->bs_version);                                          dec->width, dec->height, dec->bs_version);
1354        dec->is_edged[0] = 1;
1355        stop_edges_timer();
1356      }
1357    
1358      if (!dec->is_edged[1]) {
1359        start_timer();
1360          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1361                                          dec->width, dec->height, dec->bs_version);                                          dec->width, dec->height, dec->bs_version);
1362        dec->is_edged[1] = 1;
1363          stop_edges_timer();          stop_edges_timer();
1364      }
1365    
1366          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1367                  /* Initialize Pred Motion Vector */                  /* Initialize Pred Motion Vector */
# Line 1231  Line 1370 
1370                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1371                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1372                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
1373                          uint32_t intra_dc_threshold; /* fake variable */        int intra_dc_threshold; /* fake variable */
1374    
1375                          if (check_resync_marker(bs, fcode_max  - 1)) {                          if (check_resync_marker(bs, fcode_max  - 1)) {
1376                                  int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,                                  int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,
# Line 1256  Line 1395 
1395                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1396                                  mb->cbp = 0;                                  mb->cbp = 0;
1397                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1398                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1399                                  continue;                                  continue;
1400                          }                          }
1401    
# Line 1339  Line 1478 
1478                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1479                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1480    
1481                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1482                                  break;                                  break;
1483    
1484                          case MODE_FORWARD:                          case MODE_FORWARD:
1485                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1486                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1487    
1488                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1489                                  break;                                  break;
1490    
1491                          default:                          default:
# Line 1357  Line 1496 
1496  }  }
1497    
1498  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1499  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1500                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1501                                          int coding_type, int quant)                                          int coding_type, int quant)
1502  {  {
1503      const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1504    
1505          if (dec->cartoon_mode)          if (dec->cartoon_mode)
1506                  frame->general &= ~XVID_FILMEFFECT;                  frame->general &= ~XVID_FILMEFFECT;
1507    
1508          if (frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) && mbs != NULL)     /* post process */    if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1509        && mbs != NULL) /* post process */
1510          {          {
1511                  /* note: image is stored to tmp */                  /* note: image is stored to tmp */
1512                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1513                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1514                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1515                                             frame->general, dec->frames, (coding_type == B_VOP));               frame->general, brightness, dec->frames, (coding_type == B_VOP));
1516                  img = &dec->tmp;                  img = &dec->tmp;
1517          }          }
1518    
# Line 1385  Line 1527 
1527                  stats->data.vop.qscale_stride = dec->mb_width;                  stats->data.vop.qscale_stride = dec->mb_width;
1528                  stats->data.vop.qscale = dec->qscale;                  stats->data.vop.qscale = dec->qscale;
1529                  if (stats->data.vop.qscale != NULL && mbs != NULL) {                  if (stats->data.vop.qscale != NULL && mbs != NULL) {
1530                          int i;        unsigned int i;
1531                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1532                                  stats->data.vop.qscale[i] = mbs[i].quant;                                  stats->data.vop.qscale[i] = mbs[i].quant;
1533                  } else                  } else
# Line 1393  Line 1535 
1535          }          }
1536  }  }
1537    
   
1538  int  int
1539  decoder_decode(DECODER * dec,  decoder_decode(DECODER * dec,
1540                                  xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)                                  xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
# Line 1401  Line 1542 
1542    
1543          Bitstream bs;          Bitstream bs;
1544          uint32_t rounding;          uint32_t rounding;
         uint32_t reduced_resolution;  
1545          uint32_t quant = 2;          uint32_t quant = 2;
1546          uint32_t fcode_forward;          uint32_t fcode_forward;
1547          uint32_t fcode_backward;          uint32_t fcode_backward;
# Line 1456  Line 1596 
1596    
1597  repeat:  repeat:
1598    
1599          coding_type = BitstreamReadHeaders(&bs, dec, &rounding, &reduced_resolution,    coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1600                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1601    
1602          DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%lli,  time_pp=%i,  time_bp=%i\n",    DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%"
1603    #if defined(_MSC_VER)
1604        "I64"
1605    #else
1606        "ll"
1607    #endif
1608        "i,  time_pp=%i,  time_bp=%i\n",
1609                                                          coding_type,    dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);                                                          coding_type,    dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1610    
1611          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1507  Line 1653 
1653          } else if (coding_type != B_VOP) {          } else if (coding_type != B_VOP) {
1654                  switch(coding_type) {                  switch(coding_type) {
1655                  case I_VOP :                  case I_VOP :
1656                          decoder_iframe(dec, &bs, reduced_resolution, quant, intra_dc_threshold);        decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1657                          break;                          break;
1658                  case P_VOP :                  case P_VOP :
1659                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1660                                                  fcode_forward, intra_dc_threshold, NULL);                                                  fcode_forward, intra_dc_threshold, NULL);
1661                          break;                          break;
1662                  case S_VOP :                  case S_VOP :
1663                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1664                                                  fcode_forward, intra_dc_threshold, &gmc_warp);                                                  fcode_forward, intra_dc_threshold, &gmc_warp);
1665                          break;                          break;
1666                  case N_VOP :                  case N_VOP :
# Line 1525  Line 1671 
1671                          break;                          break;
1672                  }                  }
1673    
                 if (reduced_resolution) {  
                         image_deblock_rrv(&dec->cur, dec->edged_width, dec->mbs,  
                                 (dec->width + 31) / 32, (dec->height + 31) / 32, dec->mb_width,  
                                 16, 0);  
                 }  
   
1674                  /* note: for packed_mode, output is performed when the special-N_VOP is decoded */                  /* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1675                  if (!(dec->low_delay_default && dec->packed_mode)) {                  if (!(dec->low_delay_default && dec->packed_mode)) {
1676                          if (dec->low_delay) {                          if (dec->low_delay) {
# Line 1544  Line 1684 
1684                  }                  }
1685    
1686                  image_swap(&dec->refn[0], &dec->refn[1]);                  image_swap(&dec->refn[0], &dec->refn[1]);
1687        dec->is_edged[1] = dec->is_edged[0];
1688                  image_swap(&dec->cur, &dec->refn[0]);                  image_swap(&dec->cur, &dec->refn[0]);
1689        dec->is_edged[0] = 0;
1690                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
                 dec->last_reduced_resolution = reduced_resolution;  
1691                  dec->last_coding_type = coding_type;                  dec->last_coding_type = coding_type;
1692    
1693                  dec->frames++;                  dec->frames++;
# Line 1591  Line 1732 
1732    
1733  done :  done :
1734    
1735          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1736             then output the recently decoded frame, or print an error message  */       the calling application has specified low_delay_default,
1737         we *must* output something.
1738         this always occurs on the first call to decode() call
1739         when bframes are present in the bitstream. it may also
1740         occur if no vops  were seen in the bitstream
1741    
1742         if packed_mode is enabled, then we output the recently
1743         decoded frame (the very first ivop). otherwise we have
1744         nothing to display, and therefore output a black screen.
1745      */
1746          if (dec->low_delay_default && output == 0) {          if (dec->low_delay_default && output == 0) {
1747                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
                         /* output the recently decoded frame */  
1748                          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);                          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1749                  } else {                  } else {
1750                          image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);                          image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);
                         image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,  
                                 "warning: nothing to output");  
                         image_printf(&dec->cur, dec->edged_width, dec->height, 16, 64,  
                                 "bframe decoder lag");  
   
1751                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1752                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1753                  }                  }

Legend:
Removed from v.1.51.2.6  
changed lines
  Added in v.1.78

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