[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.66, Sun Aug 15 11:28:38 2004 UTC revision 1.77, Fri Dec 30 14:04:49 2005 UTC
# 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"  #include "image/qpel.h"
51    
# Line 62  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 74  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 88  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 172  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 225  Line 196 
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    
199      dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
200    
201          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
202    
203          if (dec->fixed_dimensions)          if (dec->fixed_dimensions)
# Line 271  Line 244 
244                                  Bitstream * bs,                                  Bitstream * bs,
245                                  const uint32_t quant,                                  const uint32_t quant,
246                                  const uint32_t intra_dc_threshold,                                  const uint32_t intra_dc_threshold,
247                                  const unsigned int bound,          const unsigned int bound)
                                 const int reduced_resolution)  
248  {  {
249    
250          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
# Line 285  Line 257 
257          uint32_t iQuant = pMB->quant;          uint32_t iQuant = pMB->quant;
258          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
259    
         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{  
260                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
261                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
262                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
         }  
263    
264          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */
265    
# Line 352  Line 318 
318                  stop_iquant_timer();                  stop_iquant_timer();
319    
320                  start_timer();                  start_timer();
321                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
322                  stop_idct_timer();                  stop_idct_timer();
323    
324          }          }
# Line 363  Line 329 
329          }          }
330    
331          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{  
332                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
333                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
334                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
335                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
336                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
337                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
         }  
338          stop_transfer_timer();          stop_transfer_timer();
339  }  }
340    
# Line 391  Line 345 
345                                  uint8_t * pY_Cur,                                  uint8_t * pY_Cur,
346                                  uint8_t * pU_Cur,                                  uint8_t * pU_Cur,
347                                  uint8_t * pV_Cur,                                  uint8_t * pV_Cur,
                                 int reduced_resolution,  
348                                  const MACROBLOCK * pMB)                                  const MACROBLOCK * pMB)
349  {  {
350          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
351    
352          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * (reduced_resolution ? 16 : 8);  
353          int i;          int i;
354          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
355          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
# Line 416  Line 368 
368                  ? (get_inter_block_function_t)get_inter_block_h263                  ? (get_inter_block_function_t)get_inter_block_h263
369                  : (get_inter_block_function_t)get_inter_block_mpeg;                  : (get_inter_block_function_t)get_inter_block_mpeg;
370    
         const add_residual_function_t add_residual = (reduced_resolution)  
                 ? (add_residual_function_t)add_upsampled_8x8_16to8  
                 : (add_residual_function_t)transfer_16to8add;  
   
371          uint8_t *dst[6];          uint8_t *dst[6];
372          int strides[6];          int strides[6];
373    
374    
375          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
                 next_block = stride;  
                 stride *= 2;  
         }  
   
         reduced_resolution = !!reduced_resolution;  
376          dst[0] = pY_Cur;          dst[0] = pY_Cur;
377          dst[2] = pY_Cur + next_block;      dst[1] = pY_Cur + 8;
378          dst[1] = dst[0] + (8<<reduced_resolution);      dst[2] = pY_Cur + stride;
379          dst[3] = dst[2] + (8<<reduced_resolution);      dst[3] = dst[2] + 8;
380        dst[4] = pU_Cur;
381        dst[5] = pV_Cur;
382        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
383        strides[4] = stride/2;
384        strides[5] = stride/2;
385      } else {
386        dst[0] = pY_Cur;
387        dst[1] = pY_Cur + 8;
388        dst[2] = pY_Cur + 8*stride;
389        dst[3] = dst[2] + 8;
390          dst[4] = pU_Cur;          dst[4] = pU_Cur;
391          dst[5] = pV_Cur;          dst[5] = pV_Cur;
392          strides[0] = strides[1] = strides[2] = strides[3] = stride;          strides[0] = strides[1] = strides[2] = strides[3] = stride;
393          strides[4] = stride/2;          strides[4] = stride/2;
394          strides[5] = stride/2;          strides[5] = stride/2;
395      }
396    
397          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
398                  /* Process only coded blocks */                  /* Process only coded blocks */
# Line 454  Line 408 
408    
409                          /* iDCT */                          /* iDCT */
410                          start_timer();                          start_timer();
411                          idct(&data[0]);        idct((short * const)&data[0]);
412                          stop_idct_timer();                          stop_idct_timer();
413    
414                          /* Add this residual to the predicted block */                          /* Add this residual to the predicted block */
415                          start_timer();                          start_timer();
416                          add_residual(dst[i], &data[0], strides[i]);        transfer_16to8add(dst[i], &data[0], strides[i]);
417                          stop_transfer_timer();                          stop_transfer_timer();
418                  }                  }
419          }          }
420  }  }
421    
422  static void  static void __inline
423  validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)  validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
424  {  {
425          /* clip a vector to valid range          /* clip a vector to valid range
426             prevents crashes if bitstream is broken             prevents crashes if bitstream is broken
427          */          */
428          int i;    int shift = 5 + dec->quarterpel;
429      int xborder_high = (int)(dec->mb_width - x_pos) << shift;
430          for (i = 0; i < 4; i++) {    int xborder_low = (-(int)x_pos-1) << shift;
431      int yborder_high = (int)(dec->mb_height - y_pos) << shift;
432                  int border = (int)(dec->mb_width - x_pos) << (5 + dec->quarterpel);    int yborder_low = (-(int)y_pos-1) << shift;
433                  if (mv[i].x > border) {  
434                          DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", mv[i].x, border, x_pos, y_pos);  #define CHECK_MV(mv) \
435                          mv[i].x = border;    do { \
436                  } else {    if ((mv).x > xborder_high) { \
437                          border = (-(int)x_pos-1) << (5 + dec->quarterpel);      DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
438                          if (mv[i].x < border) {      (mv).x = xborder_high; \
439                                  DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", mv[i].x, border, x_pos, y_pos);    } else if ((mv).x < xborder_low) { \
440                                  mv[i].x = border;      DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
441                          }      (mv).x = xborder_low; \
442                  }    } \
443      if ((mv).y > yborder_high) { \
444                  border = (int)(dec->mb_height - y_pos) << (5 + dec->quarterpel);      DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
445                  if (mv[i].y >  border) {      (mv).y = yborder_high; \
446                          DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", mv[i].y, border, x_pos, y_pos);    } else if ((mv).y < yborder_low) { \
447                          mv[i].y = border;      DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
448                  } else {      (mv).y = yborder_low; \
449                          border = (-(int)y_pos-1) << (5 + dec->quarterpel);    } \
450                          if (mv[i].y < border) {    } while (0)
451                                  DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", mv[i].y, border, x_pos, y_pos);  
452                                  mv[i].y = border;    CHECK_MV(mv[0]);
453                          }    CHECK_MV(mv[1]);
454                  }    CHECK_MV(mv[2]);
455          }    CHECK_MV(mv[3]);
456  }  }
457    
458    /* Up to this version, chroma rounding was wrong with qpel.
459     * So we try to be backward compatible to avoid artifacts */
460    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
461    
462  /* decode an inter macroblock */  /* decode an inter macroblock */
463  static void  static void
# Line 510  Line 468 
468                                  const uint32_t cbp,                                  const uint32_t cbp,
469                                  Bitstream * bs,                                  Bitstream * bs,
470                                  const uint32_t rounding,                                  const uint32_t rounding,
471                                  const int reduced_resolution,          const int ref,
472                                  const int ref)                  const int bvop)
473  {  {
474          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
475          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 522  Line 480 
480          int uv_dx, uv_dy;          int uv_dx, uv_dy;
481          VECTOR mv[4];   /* local copy of mvs */          VECTOR mv[4];   /* local copy of mvs */
482    
         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 {  
483                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
484                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
485                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
486                  for (i = 0; i < 4; i++)                  for (i = 0; i < 4; i++)
487                          mv[i] = pMB->mvs[i];                          mv[i] = pMB->mvs[i];
         }  
488    
489          validate_vector(mv, x_pos, y_pos, dec);          validate_vector(mv, x_pos, y_pos, dec);
490    
491          start_timer();          start_timer();
492    
493          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 */
494    
495                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
496                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
497                  if (dec->quarterpel) {                  if (dec->quarterpel) {
498                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
499                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
500                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
501                            }
502                            else {
503                          uv_dx /= 2;                          uv_dx /= 2;
504                          uv_dy /= 2;                          uv_dy /= 2;
505                  }                  }
506        }
507                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
508                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
509    
510                  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)  
511                          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,
512                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
513                                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 567  Line 518 
518          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
519    
520                  if(dec->quarterpel) {                  if(dec->quarterpel) {
521                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
522                                    int z;
523                                    uv_dx = 0; uv_dy = 0;
524                                    for (z = 0; z < 4; z++) {
525                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
526                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
527                                    }
528                            }
529                            else {
530                          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);
531                          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);
532          }
533                  } else {                  } else {
534                          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;
535                          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 577  Line 538 
538                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
539                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
540    
541                  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) {  
542                          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,
543                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
544                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 617  Line 564 
564          }          }
565    
566          /* 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 {  
567                  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,
568                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
569                  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,
570                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
571    
572      stop_comp_timer();
573    
574      if (cbp)
575        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
576    }
577    
578    /* decode an inter macroblock in field mode */
579    static void
580    decoder_mbinter_field(DECODER * dec,
581            const MACROBLOCK * pMB,
582            const uint32_t x_pos,
583            const uint32_t y_pos,
584            const uint32_t cbp,
585            Bitstream * bs,
586            const uint32_t rounding,
587            const int ref,
588                    const int bvop)
589    {
590      uint32_t stride = dec->edged_width;
591      uint32_t stride2 = stride / 2;
592    
593      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
594    
595      int uvtop_dx, uvtop_dy;
596      int uvbot_dx, uvbot_dy;
597      VECTOR mv[4]; /* local copy of mvs */
598    
599      /* Get pointer to memory areas */
600      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
601      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
602      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
603    
604      mv[0] = pMB->mvs[0];
605      mv[1] = pMB->mvs[1];
606      memset(&mv[2],0,2*sizeof(VECTOR));
607    
608      validate_vector(mv, x_pos, y_pos, dec);
609    
610      start_timer();
611    
612      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
613      {
614        /* Prepare top field vector */
615        uvtop_dx = DIV2ROUND(mv[0].x);
616        uvtop_dy = DIV2ROUND(mv[0].y);
617    
618        /* Prepare bottom field vector */
619        uvbot_dx = DIV2ROUND(mv[1].x);
620        uvbot_dy = DIV2ROUND(mv[1].y);
621    
622        if(dec->quarterpel)
623        {
624          /* NOT supported */
625        }
626        else
627        {
628          /* Interpolate top field left part(we use double stride for every 2nd line) */
629          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
630                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
631          /* top field right part */
632          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
633                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
634    
635          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
636          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
637                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
638          /* Bottom field right part */
639          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
640                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
641    
642          /* Interpolate field1 U */
643          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
644                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
645    
646          /* Interpolate field1 V */
647          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
648                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
649    
650          /* Interpolate field2 U */
651          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
652                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
653    
654          /* Interpolate field2 V */
655          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
656                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
657        }
658      }
659      else
660      {
661        /* We don't expect 4 motion vectors in interlaced mode */
662          }          }
663    
664          stop_comp_timer();          stop_comp_timer();
665    
666      /* Must add error correction? */
667          if (cbp)          if (cbp)
668                  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);  
669  }  }
670    
671  static void  static void
# Line 680  Line 712 
712          stop_transfer_timer();          stop_transfer_timer();
713    
714          if (cbp)          if (cbp)
715                  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);
716    
717  }  }
718    
# Line 688  Line 720 
720  static void  static void
721  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
722                                  Bitstream * bs,                                  Bitstream * bs,
                                 int reduced_resolution,  
723                                  int quant,                                  int quant,
724                                  int intra_dc_threshold)                                  int intra_dc_threshold)
725  {  {
726          uint32_t bound;          uint32_t bound;
727          uint32_t x, y;          uint32_t x, y;
728          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
729          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;  
         }  
730    
731          bound = 0;          bound = 0;
732    
# Line 756  Line 782 
782                          }                          }
783    
784                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
785                                                          intra_dc_threshold, bound, reduced_resolution);                intra_dc_threshold, bound);
786    
787                  }                  }
788                  if(dec->out_frm)                  if(dec->out_frm)
# Line 809  Line 835 
835          ret_mv->y = mv.y;          ret_mv->y = mv.y;
836  }  }
837    
838    /* We use this when decoder runs interlaced -> different prediction */
839    
840    static void get_motion_vector_interlaced(DECODER * dec,
841            Bitstream * bs,
842            int x,
843            int y,
844            int k,
845            MACROBLOCK *pMB,
846            int fcode,
847            const int bound)
848    {
849      const int scale_fac = 1 << (fcode - 1);
850      const int high = (32 * scale_fac) - 1;
851      const int low = ((-32) * scale_fac);
852      const int range = (64 * scale_fac);
853    
854      /* Get interlaced prediction */
855      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
856      VECTOR mv,mvf1,mvf2;
857    
858      if(!pMB->field_pred)
859      {
860        mv.x = get_mv(bs,fcode);
861        mv.y = get_mv(bs,fcode);
862    
863        mv.x += pmv.x;
864        mv.y += pmv.y;
865    
866        if(mv.x<low) {
867          mv.x += range;
868        } else if (mv.x>high) {
869          mv.x-=range;
870        }
871    
872        if (mv.y < low) {
873          mv.y += range;
874        } else if (mv.y > high) {
875          mv.y -= range;
876        }
877    
878        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
879      }
880      else
881      {
882        mvf1.x = get_mv(bs, fcode);
883        mvf1.y = get_mv(bs, fcode);
884    
885        mvf1.x += pmv.x;
886        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
887    
888        if (mvf1.x < low) {
889          mvf1.x += range;
890        } else if (mvf1.x > high) {
891          mvf1.x -= range;
892        }
893    
894        if (mvf1.y < low) {
895          mvf1.y += range;
896        } else if (mvf1.y > high) {
897          mvf1.y -= range;
898        }
899    
900        mvf2.x = get_mv(bs, fcode);
901        mvf2.y = get_mv(bs, fcode);
902    
903        mvf2.x += pmv.x;
904        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
905    
906        if (mvf2.x < low) {
907          mvf2.x += range;
908        } else if (mvf2.x > high) {
909          mvf2.x -= range;
910        }
911    
912        if (mvf2.y < low) {
913          mvf2.y += range;
914        } else if (mvf2.y > high) {
915          mvf2.y -= range;
916        }
917    
918        pMB->mvs[0]=mvf1;
919        pMB->mvs[1]=mvf2;
920        pMB->mvs[2].x=pMB->mvs[3].x=0;
921        pMB->mvs[2].y=pMB->mvs[3].y=0;
922    
923        /* Calculate average for as it is field predicted */
924        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
925        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
926      }
927    }
928    
929  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
930  static void  static void
931  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
932                                  Bitstream * bs,                                  Bitstream * bs,
933                                  int rounding,                                  int rounding,
                                 int reduced_resolution,  
934                                  int quant,                                  int quant,
935                                  int fcode,                                  int fcode,
936                                  int intra_dc_threshold,                                  int intra_dc_threshold,
# Line 823  Line 939 
939          uint32_t x, y;          uint32_t x, y;
940          uint32_t bound;          uint32_t bound;
941          int cp_mb, st_mb;          int cp_mb, st_mb;
942          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
943          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;  
         }  
944    
945          if (!dec->is_edged[0]) {          if (!dec->is_edged[0]) {
946                  start_timer();                  start_timer();
# Line 907  Line 1018 
1018                                  }                                  }
1019                                  mb->quant = quant;                                  mb->quant = quant;
1020    
1021            mb->field_pred=0;
1022                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1023                                          if (cbp || intra) {                                          if (cbp || intra) {
1024                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 932  Line 1044 
1044    
1045                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1046    
1047                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1048                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1049                                                  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);
1050                                          } else {                                          } else {
1051                                                  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);
1052                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1053                                          }                                          }
1054                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1055              /* interlaced missing here */
1056                                          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);
1057                                          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);
1058                                          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 948  Line 1061 
1061                                          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;
1062                                          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;
1063                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1064                                                                          intra_dc_threshold, bound, reduced_resolution);                    intra_dc_threshold, bound);
1065                                          continue;                                          continue;
1066                                  }                                  }
1067    
1068                                  decoder_mbinter(dec, mb, x, y, cbp, bs,          /* See how to decode */
1069                                                                  rounding, reduced_resolution, 0);          if(!mb->field_pred)
1070             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1071            else
1072             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1073    
1074                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1075                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 971  Line 1087 
1087    
1088                                  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;
1089                                  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;
1090            mb->field_pred=0; /* (!) */
1091    
1092                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1093                                                                  rounding, reduced_resolution, 0);                                  rounding, 0, 0);
1094    
1095                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1096                                          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 1055  Line 1172 
1172                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1173    
1174                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1175                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1176                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1177                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1178                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1179                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1180                            }
1181                            else {
1182                          uv_dx /= 2;                          uv_dx /= 2;
1183                          uv_dy /= 2;                          uv_dy /= 2;
1184                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1185                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1186                  }                  }
1187        }
1188    
1189                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1190                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
# Line 1067  Line 1192 
1192                  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];
1193    
1194          } else {          } else {
1195              if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1196                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1197                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1198                            int z;
1199                            uv_dx = 0; uv_dy = 0;
1200                            b_uv_dx = 0; b_uv_dy = 0;
1201                            for (z = 0; z < 4; z++) {
1202                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1203                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1204                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1205                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1206                            }
1207                    }
1208                    else {
1209                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1210                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1211                            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);
1212                            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);
1213                    }
1214            } else {
1215                  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;
1216                  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;
1217                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1218                  b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;                  b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;
   
                 if (dec->quarterpel) {  
                         uv_dx /= 2;  
                         uv_dy /= 2;  
                         b_uv_dx /= 2;  
                         b_uv_dy /= 2;  
1219                  }                  }
1220    
1221                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
# Line 1160  Line 1299 
1299          stop_comp_timer();          stop_comp_timer();
1300    
1301          if (cbp)          if (cbp)
1302                  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);
1303  }  }
1304    
1305  /* for decode B-frame dbquant */  /* for decode B-frame dbquant */
# Line 1230  Line 1369 
1369                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1370                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1371                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
1372                          uint32_t intra_dc_threshold; /* fake variable */        int intra_dc_threshold; /* fake variable */
1373    
1374                          if (check_resync_marker(bs, fcode_max  - 1)) {                          if (check_resync_marker(bs, fcode_max  - 1)) {
1375                                  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 1255  Line 1394 
1394                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1395                                  mb->cbp = 0;                                  mb->cbp = 0;
1396                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1397                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1398                                  continue;                                  continue;
1399                          }                          }
1400    
# Line 1338  Line 1477 
1477                                  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);
1478                                  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];
1479    
1480                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1481                                  break;                                  break;
1482    
1483                          case MODE_FORWARD:                          case MODE_FORWARD:
1484                                  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);
1485                                  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];
1486    
1487                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1488                                  break;                                  break;
1489    
1490                          default:                          default:
# Line 1356  Line 1495 
1495  }  }
1496    
1497  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1498  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1499                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1500                                          int coding_type, int quant)                                          int coding_type, int quant)
1501  {  {
# Line 1387  Line 1526 
1526                  stats->data.vop.qscale_stride = dec->mb_width;                  stats->data.vop.qscale_stride = dec->mb_width;
1527                  stats->data.vop.qscale = dec->qscale;                  stats->data.vop.qscale = dec->qscale;
1528                  if (stats->data.vop.qscale != NULL && mbs != NULL) {                  if (stats->data.vop.qscale != NULL && mbs != NULL) {
1529                          int i;        unsigned int i;
1530                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1531                                  stats->data.vop.qscale[i] = mbs[i].quant;                                  stats->data.vop.qscale[i] = mbs[i].quant;
1532                  } else                  } else
# Line 1402  Line 1541 
1541    
1542          Bitstream bs;          Bitstream bs;
1543          uint32_t rounding;          uint32_t rounding;
         uint32_t reduced_resolution;  
1544          uint32_t quant = 2;          uint32_t quant = 2;
1545          uint32_t fcode_forward;          uint32_t fcode_forward;
1546          uint32_t fcode_backward;          uint32_t fcode_backward;
# Line 1457  Line 1595 
1595    
1596  repeat:  repeat:
1597    
1598          coding_type = BitstreamReadHeaders(&bs, dec, &rounding, &reduced_resolution,    coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1599                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1600    
1601          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=%"
1602    #if defined(_MSC_VER)
1603        "I64"
1604    #else
1605        "ll"
1606    #endif
1607        "i,  time_pp=%i,  time_bp=%i\n",
1608                                                          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);
1609    
1610          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1508  Line 1652 
1652          } else if (coding_type != B_VOP) {          } else if (coding_type != B_VOP) {
1653                  switch(coding_type) {                  switch(coding_type) {
1654                  case I_VOP :                  case I_VOP :
1655                          decoder_iframe(dec, &bs, reduced_resolution, quant, intra_dc_threshold);        decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1656                          break;                          break;
1657                  case P_VOP :                  case P_VOP :
1658                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1659                                                  fcode_forward, intra_dc_threshold, NULL);                                                  fcode_forward, intra_dc_threshold, NULL);
1660                          break;                          break;
1661                  case S_VOP :                  case S_VOP :
1662                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1663                                                  fcode_forward, intra_dc_threshold, &gmc_warp);                                                  fcode_forward, intra_dc_threshold, &gmc_warp);
1664                          break;                          break;
1665                  case N_VOP :                  case N_VOP :
# Line 1526  Line 1670 
1670                          break;                          break;
1671                  }                  }
1672    
                 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);  
                 }  
   
1673                  /* 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 */
1674                  if (!(dec->low_delay_default && dec->packed_mode)) {                  if (!(dec->low_delay_default && dec->packed_mode)) {
1675                          if (dec->low_delay) {                          if (dec->low_delay) {
# Line 1549  Line 1687 
1687                  image_swap(&dec->cur, &dec->refn[0]);                  image_swap(&dec->cur, &dec->refn[0]);
1688                  dec->is_edged[0] = 0;                  dec->is_edged[0] = 0;
1689                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
                 dec->last_reduced_resolution = reduced_resolution;  
1690                  dec->last_coding_type = coding_type;                  dec->last_coding_type = coding_type;
1691    
1692                  dec->frames++;                  dec->frames++;
# Line 1594  Line 1731 
1731    
1732  done :  done :
1733    
1734          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1735             then output the recently decoded frame, or print an error message  */       the calling application has specified low_delay_default,
1736         we *must* output something.
1737         this always occurs on the first call to decode() call
1738         when bframes are present in the bitstream. it may also
1739         occur if no vops  were seen in the bitstream
1740    
1741         if packed_mode is enabled, then we output the recently
1742         decoded frame (the very first ivop). otherwise we have
1743         nothing to display, and therefore output a black screen.
1744      */
1745          if (dec->low_delay_default && output == 0) {          if (dec->low_delay_default && output == 0) {
1746                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
                         /* output the recently decoded frame */  
1747                          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);
1748                  } else {                  } else {
1749                          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");  
   
1750                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1751                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1752                  }                  }

Legend:
Removed from v.1.66  
changed lines
  Added in v.1.77

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