[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.69, Sun Mar 27 03:59:41 2005 UTC revision 1.80.2.1, Thu May 28 15:52:34 2009 UTC
# 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    
204          if (dec->fixed_dimensions)    if (dec->fixed_dimensions) {
205                  return decoder_resize(dec);      int ret = decoder_resize(dec);
206        if (ret == XVID_ERR_MEMORY) create->handle = NULL;
207        return ret;
208      }
209          else          else
210                  return 0;                  return 0;
211  }  }
# Line 344  Line 322 
322                  stop_iquant_timer();                  stop_iquant_timer();
323    
324                  start_timer();                  start_timer();
325                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
326                  stop_idct_timer();                  stop_idct_timer();
327    
328          }          }
# Line 376  Line 354 
354          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
355    
356          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * 8;  
357          int i;          int i;
358          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
359          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
# Line 400  Line 377 
377    
378    
379          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
                 next_block = stride;  
                 stride *= 2;  
         }  
   
380          dst[0] = pY_Cur;          dst[0] = pY_Cur;
381          dst[2] = pY_Cur + next_block;      dst[1] = pY_Cur + 8;
382          dst[1] = dst[0] + 8;      dst[2] = pY_Cur + stride;
383        dst[3] = dst[2] + 8;
384        dst[4] = pU_Cur;
385        dst[5] = pV_Cur;
386        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
387        strides[4] = stride/2;
388        strides[5] = stride/2;
389      } else {
390        dst[0] = pY_Cur;
391        dst[1] = pY_Cur + 8;
392        dst[2] = pY_Cur + 8*stride;
393          dst[3] = dst[2] + 8;          dst[3] = dst[2] + 8;
394          dst[4] = pU_Cur;          dst[4] = pU_Cur;
395          dst[5] = pV_Cur;          dst[5] = pV_Cur;
396          strides[0] = strides[1] = strides[2] = strides[3] = stride;          strides[0] = strides[1] = strides[2] = strides[3] = stride;
397          strides[4] = stride/2;          strides[4] = stride/2;
398          strides[5] = stride/2;          strides[5] = stride/2;
399      }
400    
401          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
402                  /* Process only coded blocks */                  /* Process only coded blocks */
# Line 428  Line 412 
412    
413                          /* iDCT */                          /* iDCT */
414                          start_timer();                          start_timer();
415                          idct(&data[0]);        idct((short * const)&data[0]);
416                          stop_idct_timer();                          stop_idct_timer();
417    
418                          /* Add this residual to the predicted block */                          /* Add this residual to the predicted block */
# Line 475  Line 459 
459          CHECK_MV(mv[3]);          CHECK_MV(mv[3]);
460  }  }
461    
462    /* Up to this version, chroma rounding was wrong with qpel.
463     * So we try to be backward compatible to avoid artifacts */
464    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
465    
466  /* decode an inter macroblock */  /* decode an inter macroblock */
467  static void  static void
468  decoder_mbinter(DECODER * dec,  decoder_mbinter(DECODER * dec,
# Line 484  Line 472 
472                                  const uint32_t cbp,                                  const uint32_t cbp,
473                                  Bitstream * bs,                                  Bitstream * bs,
474                                  const uint32_t rounding,                                  const uint32_t rounding,
475                                  const int ref)          const int ref,
476                    const int bvop)
477  {  {
478          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
479          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 505  Line 494 
494    
495          start_timer();          start_timer();
496    
497          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 */
498    
499                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
500                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
501                  if (dec->quarterpel) {                  if (dec->quarterpel) {
502                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
503                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
504                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
505                            }
506                            else {
507                          uv_dx /= 2;                          uv_dx /= 2;
508                          uv_dy /= 2;                          uv_dy /= 2;
509                  }                  }
510        }
511                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
512                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
513    
# Line 527  Line 522 
522          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
523    
524                  if(dec->quarterpel) {                  if(dec->quarterpel) {
525                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
526                                    int z;
527                                    uv_dx = 0; uv_dy = 0;
528                                    for (z = 0; z < 4; z++) {
529                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
530                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
531                                    }
532                            }
533                            else {
534                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
535                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
536          }
537                  } else {                  } else {
538                          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;
539                          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 574  Line 579 
579                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
580  }  }
581    
582    /* decode an inter macroblock in field mode */
583    static void
584    decoder_mbinter_field(DECODER * dec,
585            const MACROBLOCK * pMB,
586            const uint32_t x_pos,
587            const uint32_t y_pos,
588            const uint32_t cbp,
589            Bitstream * bs,
590            const uint32_t rounding,
591            const int ref,
592                    const int bvop)
593    {
594      uint32_t stride = dec->edged_width;
595      uint32_t stride2 = stride / 2;
596    
597      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
598    
599      int uvtop_dx, uvtop_dy;
600      int uvbot_dx, uvbot_dy;
601      VECTOR mv[4]; /* local copy of mvs */
602    
603      /* Get pointer to memory areas */
604      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
605      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
606      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
607    
608      mv[0] = pMB->mvs[0];
609      mv[1] = pMB->mvs[1];
610      memset(&mv[2],0,2*sizeof(VECTOR));
611    
612      validate_vector(mv, x_pos, y_pos, dec);
613    
614      start_timer();
615    
616      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
617      {
618        /* Prepare top field vector */
619        uvtop_dx = DIV2ROUND(mv[0].x);
620        uvtop_dy = DIV2ROUND(mv[0].y);
621    
622        /* Prepare bottom field vector */
623        uvbot_dx = DIV2ROUND(mv[1].x);
624        uvbot_dy = DIV2ROUND(mv[1].y);
625    
626        if(dec->quarterpel)
627        {
628          /* NOT supported */
629        }
630        else
631        {
632          /* Interpolate top field left part(we use double stride for every 2nd line) */
633          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
634                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
635          /* top field right part */
636          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
637                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
638    
639          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
640          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
641                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
642          /* Bottom field right part */
643          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
644                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
645    
646          /* Interpolate field1 U */
647          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
648                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
649    
650          /* Interpolate field1 V */
651          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
652                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
653    
654          /* Interpolate field2 U */
655          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
656                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
657    
658          /* Interpolate field2 V */
659          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
660                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
661        }
662      }
663      else
664      {
665        /* We don't expect 4 motion vectors in interlaced mode */
666      }
667    
668      stop_comp_timer();
669    
670      /* Must add error correction? */
671      if(cbp)
672       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
673    }
674    
675  static void  static void
676  decoder_mbgmc(DECODER * dec,  decoder_mbgmc(DECODER * dec,
677                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
# Line 653  Line 751 
751                                  bound = read_video_packet_header(bs, dec, 0,                                  bound = read_video_packet_header(bs, dec, 0,
752                                                          &quant, NULL, NULL, &intra_dc_threshold);                                                          &quant, NULL, NULL, &intra_dc_threshold);
753                                  x = bound % mb_width;                                  x = bound % mb_width;
754                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
755                          }                          }
756                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
757    
# Line 741  Line 839 
839          ret_mv->y = mv.y;          ret_mv->y = mv.y;
840  }  }
841    
842    /* We use this when decoder runs interlaced -> different prediction */
843    
844    static void get_motion_vector_interlaced(DECODER * dec,
845            Bitstream * bs,
846            int x,
847            int y,
848            int k,
849            MACROBLOCK *pMB,
850            int fcode,
851            const int bound)
852    {
853      const int scale_fac = 1 << (fcode - 1);
854      const int high = (32 * scale_fac) - 1;
855      const int low = ((-32) * scale_fac);
856      const int range = (64 * scale_fac);
857    
858      /* Get interlaced prediction */
859      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
860      VECTOR mv,mvf1,mvf2;
861    
862      if(!pMB->field_pred)
863      {
864        mv.x = get_mv(bs,fcode);
865        mv.y = get_mv(bs,fcode);
866    
867        mv.x += pmv.x;
868        mv.y += pmv.y;
869    
870        if(mv.x<low) {
871          mv.x += range;
872        } else if (mv.x>high) {
873          mv.x-=range;
874        }
875    
876        if (mv.y < low) {
877          mv.y += range;
878        } else if (mv.y > high) {
879          mv.y -= range;
880        }
881    
882        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
883      }
884      else
885      {
886        mvf1.x = get_mv(bs, fcode);
887        mvf1.y = get_mv(bs, fcode);
888    
889        mvf1.x += pmv.x;
890        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
891    
892        if (mvf1.x < low) {
893          mvf1.x += range;
894        } else if (mvf1.x > high) {
895          mvf1.x -= range;
896        }
897    
898        if (mvf1.y < low) {
899          mvf1.y += range;
900        } else if (mvf1.y > high) {
901          mvf1.y -= range;
902        }
903    
904        mvf2.x = get_mv(bs, fcode);
905        mvf2.y = get_mv(bs, fcode);
906    
907        mvf2.x += pmv.x;
908        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
909    
910        if (mvf2.x < low) {
911          mvf2.x += range;
912        } else if (mvf2.x > high) {
913          mvf2.x -= range;
914        }
915    
916        if (mvf2.y < low) {
917          mvf2.y += range;
918        } else if (mvf2.y > high) {
919          mvf2.y -= range;
920        }
921    
922        pMB->mvs[0]=mvf1;
923        pMB->mvs[1]=mvf2;
924        pMB->mvs[2].x=pMB->mvs[3].x=0;
925        pMB->mvs[2].y=pMB->mvs[3].y=0;
926    
927        /* Calculate average for as it is field predicted */
928        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
929        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
930      }
931    }
932    
933  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
934  static void  static void
935  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
# Line 789  Line 978 
978                                  bound = read_video_packet_header(bs, dec, fcode - 1,                                  bound = read_video_packet_header(bs, dec, fcode - 1,
979                                          &quant, &fcode, NULL, &intra_dc_threshold);                                          &quant, &fcode, NULL, &intra_dc_threshold);
980                                  x = bound % mb_width;                                  x = bound % mb_width;
981                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
982                          }                          }
983                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
984    
# Line 833  Line 1022 
1022                                  }                                  }
1023                                  mb->quant = quant;                                  mb->quant = quant;
1024    
1025            mb->field_pred=0;
1026                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1027                                          if (cbp || intra) {                                          if (cbp || intra) {
1028                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 858  Line 1048 
1048    
1049                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1050    
1051                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1052                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1053                                                  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);
1054                                          } else {                                          } else {
1055                                                  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);
1056                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1057                                          }                                          }
1058                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1059              /* interlaced missing here */
1060                                          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);
1061                                          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);
1062                                          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 878  Line 1069 
1069                                          continue;                                          continue;
1070                                  }                                  }
1071    
1072                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);          /* See how to decode */
1073            if(!mb->field_pred)
1074             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1075            else
1076             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1077    
1078                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1079                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 896  Line 1091 
1091    
1092                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1093                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1094            mb->field_pred=0; /* (!) */
1095    
1096                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1097                                                                  rounding, 0);                                  rounding, 0, 0);
1098    
1099                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1100                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
# Line 980  Line 1176 
1176                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1177    
1178                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1179                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1180                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1181                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1182                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1183                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1184                            }
1185                            else {
1186                          uv_dx /= 2;                          uv_dx /= 2;
1187                          uv_dy /= 2;                          uv_dy /= 2;
1188                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1189                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1190                  }                  }
1191        }
1192    
1193                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1194                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
# Line 992  Line 1196 
1196                  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];
1197    
1198          } else {          } else {
1199              if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1200                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1201                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1202                            int z;
1203                            uv_dx = 0; uv_dy = 0;
1204                            b_uv_dx = 0; b_uv_dy = 0;
1205                            for (z = 0; z < 4; z++) {
1206                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1207                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1208                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1209                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1210                            }
1211                    }
1212                    else {
1213                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1214                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1215                            b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1216                            b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1217                    }
1218            } else {
1219                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1220                  uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;                  uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1221                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1222                  b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;                  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;  
1223                  }                  }
1224    
1225                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
# Line 1120  Line 1338 
1338          return -1;          return -1;
1339  }  }
1340    
1341    static int __inline get_resync_len_b(const int fcode_backward,
1342                                         const int fcode_forward) {
1343      int resync_len = ((fcode_forward>fcode_backward) ? fcode_forward : fcode_backward) - 1;
1344      if (resync_len < 1) resync_len = 1;
1345      return resync_len;
1346    }
1347    
1348  static void  static void
1349  decoder_bframe(DECODER * dec,  decoder_bframe(DECODER * dec,
1350                                  Bitstream * bs,                                  Bitstream * bs,
# Line 1131  Line 1356 
1356          VECTOR mv;          VECTOR mv;
1357          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
1358          int i;          int i;
1359      int resync_len;
1360    
1361          if (!dec->is_edged[0]) {          if (!dec->is_edged[0]) {
1362                  start_timer();                  start_timer();
# Line 1148  Line 1374 
1374                  stop_edges_timer();                  stop_edges_timer();
1375          }          }
1376    
1377      resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1378          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1379                  /* Initialize Pred Motion Vector */                  /* Initialize Pred Motion Vector */
1380                  dec->p_fmv = dec->p_bmv = zeromv;                  dec->p_fmv = dec->p_bmv = zeromv;
1381                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
1382                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1383                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1384                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;        int intra_dc_threshold; /* fake variable */
                         uint32_t intra_dc_threshold; /* fake variable */  
1385    
1386                          if (check_resync_marker(bs, fcode_max  - 1)) {        if (check_resync_marker(bs, resync_len)) {
1387                                  int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,          int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1388                                                                                                           &fcode_forward, &fcode_backward, &intra_dc_threshold);                                                                                                           &fcode_forward, &fcode_backward, &intra_dc_threshold);
1389                                  x = bound % dec->mb_width;                                  x = bound % dec->mb_width;
1390                                  y = bound / dec->mb_width;          y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1391                                  /* reset predicted macroblocks */                                  /* reset predicted macroblocks */
1392                                  dec->p_fmv = dec->p_bmv = zeromv;                                  dec->p_fmv = dec->p_bmv = zeromv;
1393            /* update resync len with new fcodes */
1394            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1395                          }                          }
1396    
1397                          mv =                          mv =
# Line 1180  Line 1408 
1408                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1409                                  mb->cbp = 0;                                  mb->cbp = 0;
1410                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1411                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1412                                  continue;                                  continue;
1413                          }                          }
1414    
# Line 1263  Line 1491 
1491                                  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);
1492                                  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];
1493    
1494                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1495                                  break;                                  break;
1496    
1497                          case MODE_FORWARD:                          case MODE_FORWARD:
1498                                  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);
1499                                  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];
1500    
1501                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1502                                  break;                                  break;
1503    
1504                          default:                          default:
# Line 1281  Line 1509 
1509  }  }
1510    
1511  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1512  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1513                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1514                                          int coding_type, int quant)                                          int coding_type, int quant)
1515  {  {
# Line 1312  Line 1540 
1540                  stats->data.vop.qscale_stride = dec->mb_width;                  stats->data.vop.qscale_stride = dec->mb_width;
1541                  stats->data.vop.qscale = dec->qscale;                  stats->data.vop.qscale = dec->qscale;
1542                  if (stats->data.vop.qscale != NULL && mbs != NULL) {                  if (stats->data.vop.qscale != NULL && mbs != NULL) {
1543                          int i;        unsigned int i;
1544                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1545                                  stats->data.vop.qscale[i] = mbs[i].quant;                                  stats->data.vop.qscale[i] = mbs[i].quant;
1546                  } else                  } else
# Line 1403  Line 1631 
1631          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */
1632    
1633                  if (coding_type == -3)                  if (coding_type == -3)
1634                          decoder_resize(dec);        if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1635    
1636                  if (stats) {                  if (stats) {
1637                          stats->type = XVID_TYPE_VOL;                          stats->type = XVID_TYPE_VOL;

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

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