[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.68, Sun Dec 5 13:56:13 2004 UTC revision 1.76, Sat Dec 24 01:06:20 2005 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 344  Line 316 
316                  stop_iquant_timer();                  stop_iquant_timer();
317    
318                  start_timer();                  start_timer();
319                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
320                  stop_idct_timer();                  stop_idct_timer();
321    
322          }          }
# Line 376  Line 348 
348          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
349    
350          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * 8;  
351          int i;          int i;
352          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
353          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
# Line 400  Line 371 
371    
372    
373          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
                 next_block = stride;  
                 stride *= 2;  
         }  
   
374          dst[0] = pY_Cur;          dst[0] = pY_Cur;
375          dst[2] = pY_Cur + next_block;      dst[1] = pY_Cur + 8;
376          dst[1] = dst[0] + 8;      dst[2] = pY_Cur + stride;
377        dst[3] = dst[2] + 8;
378        dst[4] = pU_Cur;
379        dst[5] = pV_Cur;
380        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
381        strides[4] = stride/2;
382        strides[5] = stride/2;
383      } else {
384        dst[0] = pY_Cur;
385        dst[1] = pY_Cur + 8;
386        dst[2] = pY_Cur + 8*stride;
387          dst[3] = dst[2] + 8;          dst[3] = dst[2] + 8;
388          dst[4] = pU_Cur;          dst[4] = pU_Cur;
389          dst[5] = pV_Cur;          dst[5] = pV_Cur;
390          strides[0] = strides[1] = strides[2] = strides[3] = stride;          strides[0] = strides[1] = strides[2] = strides[3] = stride;
391          strides[4] = stride/2;          strides[4] = stride/2;
392          strides[5] = stride/2;          strides[5] = stride/2;
393      }
394    
395          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
396                  /* Process only coded blocks */                  /* Process only coded blocks */
# Line 428  Line 406 
406    
407                          /* iDCT */                          /* iDCT */
408                          start_timer();                          start_timer();
409                          idct(&data[0]);        idct((short * const)&data[0]);
410                          stop_idct_timer();                          stop_idct_timer();
411    
412                          /* Add this residual to the predicted block */                          /* Add this residual to the predicted block */
# Line 475  Line 453 
453          CHECK_MV(mv[3]);          CHECK_MV(mv[3]);
454  }  }
455    
456    /* Up to this version, chroma rounding was wrong with qpel.
457     * So we try to be backward compatible to avoid artifacts */
458    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
459    
460  /* decode an inter macroblock */  /* decode an inter macroblock */
461  static void  static void
462  decoder_mbinter(DECODER * dec,  decoder_mbinter(DECODER * dec,
# Line 484  Line 466 
466                                  const uint32_t cbp,                                  const uint32_t cbp,
467                                  Bitstream * bs,                                  Bitstream * bs,
468                                  const uint32_t rounding,                                  const uint32_t rounding,
469                                  const int ref)          const int ref,
470                    const int bvop)
471  {  {
472          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
473          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 505  Line 488 
488    
489          start_timer();          start_timer();
490    
491          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 */
492    
493                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
494                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
495                  if (dec->quarterpel) {                  if (dec->quarterpel) {
496                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
497                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
498                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
499                            }
500                            else {
501                          uv_dx /= 2;                          uv_dx /= 2;
502                          uv_dy /= 2;                          uv_dy /= 2;
503                  }                  }
504        }
505                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
506                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
507    
# Line 527  Line 516 
516          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
517    
518                  if(dec->quarterpel) {                  if(dec->quarterpel) {
519                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
520                                    int z;
521                                    uv_dx = 0; uv_dy = 0;
522                                    for (z = 0; z < 4; z++) {
523                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
524                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
525                                    }
526                            }
527                            else {
528                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
529                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
530          }
531                  } else {                  } else {
532                          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;
533                          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 573 
573                  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);
574  }  }
575    
576    /* decode an inter macroblock in field mode */
577    static void
578    decoder_mbinter_field(DECODER * dec,
579            const MACROBLOCK * pMB,
580            const uint32_t x_pos,
581            const uint32_t y_pos,
582            const uint32_t cbp,
583            Bitstream * bs,
584            const uint32_t rounding,
585            const int ref,
586                    const int bvop)
587    {
588      uint32_t stride = dec->edged_width;
589      uint32_t stride2 = stride / 2;
590    
591      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
592    
593      int uvtop_dx, uvtop_dy;
594      int uvbot_dx, uvbot_dy;
595      VECTOR mv[4]; /* local copy of mvs */
596    
597      /* Get pointer to memory areas */
598      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
599      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
600      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
601    
602      mv[0] = pMB->mvs[0];
603      mv[1] = pMB->mvs[1];
604      memset(&mv[2],0,2*sizeof(VECTOR));
605    
606      validate_vector(mv, x_pos, y_pos, dec);
607    
608      start_timer();
609    
610      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
611      {
612        /* Prepare top field vector */
613        uvtop_dx = DIV2ROUND(mv[0].x);
614        uvtop_dy = DIV2ROUND(mv[0].y);
615    
616        /* Prepare bottom field vector */
617        uvbot_dx = DIV2ROUND(mv[1].x);
618        uvbot_dy = DIV2ROUND(mv[1].y);
619    
620        if(dec->quarterpel)
621        {
622          /* NOT supported */
623        }
624        else
625        {
626          /* Interpolate top field left part(we use double stride for every 2nd line) */
627          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
628                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
629          /* top field right part */
630          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
631                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
632    
633          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
634          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
635                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
636          /* Bottom field right part */
637          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
638                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
639    
640          /* Interpolate field1 U */
641          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
642                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
643    
644          /* Interpolate field1 V */
645          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
646                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
647    
648          /* Interpolate field2 U */
649          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
650                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
651    
652          /* Interpolate field2 V */
653          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
654                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
655        }
656      }
657      else
658      {
659        /* We don't expect 4 motion vectors in interlaced mode */
660      }
661    
662      stop_comp_timer();
663    
664      /* Must add error correction? */
665      if(cbp)
666       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
667    }
668    
669  static void  static void
670  decoder_mbgmc(DECODER * dec,  decoder_mbgmc(DECODER * dec,
671                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
# Line 741  Line 833 
833          ret_mv->y = mv.y;          ret_mv->y = mv.y;
834  }  }
835    
836    /* We use this when decoder runs interlaced -> different prediction */
837    
838    static void get_motion_vector_interlaced(DECODER * dec,
839            Bitstream * bs,
840            int x,
841            int y,
842            int k,
843            MACROBLOCK *pMB,
844            int fcode,
845            const int bound)
846    {
847      const int scale_fac = 1 << (fcode - 1);
848      const int high = (32 * scale_fac) - 1;
849      const int low = ((-32) * scale_fac);
850      const int range = (64 * scale_fac);
851    
852      /* Get interlaced prediction */
853      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
854      VECTOR mv,mvf1,mvf2;
855    
856      if(!pMB->field_pred)
857      {
858        mv.x = get_mv(bs,fcode);
859        mv.y = get_mv(bs,fcode);
860    
861        mv.x += pmv.x;
862        mv.y += pmv.y;
863    
864        if(mv.x<low) {
865          mv.x += range;
866        } else if (mv.x>high) {
867          mv.x-=range;
868        }
869    
870        if (mv.y < low) {
871          mv.y += range;
872        } else if (mv.y > high) {
873          mv.y -= range;
874        }
875    
876        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
877      }
878      else
879      {
880        mvf1.x = get_mv(bs, fcode);
881        mvf1.y = get_mv(bs, fcode);
882    
883        mvf1.x += pmv.x;
884        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
885    
886        if (mvf1.x < low) {
887          mvf1.x += range;
888        } else if (mvf1.x > high) {
889          mvf1.x -= range;
890        }
891    
892        if (mvf1.y < low) {
893          mvf1.y += range;
894        } else if (mvf1.y > high) {
895          mvf1.y -= range;
896        }
897    
898        mvf2.x = get_mv(bs, fcode);
899        mvf2.y = get_mv(bs, fcode);
900    
901        mvf2.x += pmv.x;
902        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
903    
904        if (mvf2.x < low) {
905          mvf2.x += range;
906        } else if (mvf2.x > high) {
907          mvf2.x -= range;
908        }
909    
910        if (mvf2.y < low) {
911          mvf2.y += range;
912        } else if (mvf2.y > high) {
913          mvf2.y -= range;
914        }
915    
916        pMB->mvs[0]=mvf1;
917        pMB->mvs[1]=mvf2;
918        pMB->mvs[2].x=pMB->mvs[3].x=0;
919        pMB->mvs[2].y=pMB->mvs[3].y=0;
920    
921        /* Calculate average for as it is field predicted */
922        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
923        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
924      }
925    }
926    
927  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
928  static void  static void
929  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
# Line 833  Line 1016 
1016                                  }                                  }
1017                                  mb->quant = quant;                                  mb->quant = quant;
1018    
1019            mb->field_pred=0;
1020                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1021                                          if (cbp || intra) {                                          if (cbp || intra) {
1022                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 858  Line 1042 
1042    
1043                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1044    
1045                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1046                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1047                                                  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);
1048                                          } else {                                          } else {
1049                                                  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);
1050                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1051                                          }                                          }
1052                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1053              /* interlaced missing here */
1054                                          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);
1055                                          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);
1056                                          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 1063 
1063                                          continue;                                          continue;
1064                                  }                                  }
1065    
1066                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);          /* See how to decode */
1067            if(!mb->field_pred)
1068             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1069            else
1070             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1071    
1072                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1073                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 896  Line 1085 
1085    
1086                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1087                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1088            mb->field_pred=0; /* (!) */
1089    
1090                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1091                                                                  rounding, 0);                                  rounding, 0, 0);
1092    
1093                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1094                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
# Line 980  Line 1170 
1170                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1171    
1172                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1173                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1174                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1175                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1176                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1177                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1178                            }
1179                            else {
1180                          uv_dx /= 2;                          uv_dx /= 2;
1181                          uv_dy /= 2;                          uv_dy /= 2;
1182                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1183                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1184                  }                  }
1185        }
1186    
1187                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1188                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
# Line 992  Line 1190 
1190                  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];
1191    
1192          } else {          } else {
1193              if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1194                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1195                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1196                            int z;
1197                            uv_dx = 0; uv_dy = 0;
1198                            b_uv_dx = 0; b_uv_dy = 0;
1199                            for (z = 0; z < 4; z++) {
1200                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1201                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1202                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1203                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1204                            }
1205                    }
1206                    else {
1207                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1208                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1209                            b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1210                            b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1211                    }
1212            } else {
1213                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1214                  uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;                  uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1215                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1216                  b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;                  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;  
1217                  }                  }
1218    
1219                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
# Line 1155  Line 1367 
1367                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1368                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1369                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
1370                          uint32_t intra_dc_threshold; /* fake variable */        int intra_dc_threshold; /* fake variable */
1371    
1372                          if (check_resync_marker(bs, fcode_max  - 1)) {                          if (check_resync_marker(bs, fcode_max  - 1)) {
1373                                  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 1180  Line 1392 
1392                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1393                                  mb->cbp = 0;                                  mb->cbp = 0;
1394                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1395                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1396                                  continue;                                  continue;
1397                          }                          }
1398    
# Line 1263  Line 1475 
1475                                  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);
1476                                  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];
1477    
1478                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1479                                  break;                                  break;
1480    
1481                          case MODE_FORWARD:                          case MODE_FORWARD:
1482                                  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);
1483                                  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];
1484    
1485                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1486                                  break;                                  break;
1487    
1488                          default:                          default:
# Line 1281  Line 1493 
1493  }  }
1494    
1495  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1496  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1497                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1498                                          int coding_type, int quant)                                          int coding_type, int quant)
1499  {  {
# Line 1312  Line 1524 
1524                  stats->data.vop.qscale_stride = dec->mb_width;                  stats->data.vop.qscale_stride = dec->mb_width;
1525                  stats->data.vop.qscale = dec->qscale;                  stats->data.vop.qscale = dec->qscale;
1526                  if (stats->data.vop.qscale != NULL && mbs != NULL) {                  if (stats->data.vop.qscale != NULL && mbs != NULL) {
1527                          int i;        unsigned int i;
1528                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1529                                  stats->data.vop.qscale[i] = mbs[i].quant;                                  stats->data.vop.qscale[i] = mbs[i].quant;
1530                  } else                  } else
# Line 1384  Line 1596 
1596          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1597                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1598    
1599          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=%"
1600    #if defined(_MSC_VER)
1601        "I64"
1602    #else
1603        "ll"
1604    #endif
1605        "i,  time_pp=%i,  time_bp=%i\n",
1606                                                          coding_type,    dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);                                                          coding_type,    dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1607    
1608          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1511  Line 1729 
1729    
1730  done :  done :
1731    
1732          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1733             then output the recently decoded frame, or print an error message  */       the calling application has specified low_delay_default,
1734         we *must* output something.
1735         this always occurs on the first call to decode() call
1736         when bframes are present in the bitstream. it may also
1737         occur if no vops  were seen in the bitstream
1738    
1739         if packed_mode is enabled, then we output the recently
1740         decoded frame (the very first ivop). otherwise we have
1741         nothing to display, and therefore output a black screen.
1742      */
1743          if (dec->low_delay_default && output == 0) {          if (dec->low_delay_default && output == 0) {
1744                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
                         /* output the recently decoded frame */  
1745                          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);
1746                  } else {                  } else {
1747                          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");  
   
1748                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1749                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1750                  }                  }

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

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