getpic.c

h263解码程序.。。。。。。。。。。。

      {
        /* Set MVs to 0 for potential future use in true B direct mode
         * prediction. */
        if (PCT_INTER == pict_type)
        {
          for (k=0; k<5; k++)
          {
            true_B_direct_mode_MV[0][k][ypos + 1][xpos + 1] = 0;
            true_B_direct_mode_MV[1][k][ypos + 1][xpos + 1] = 0;
          }
        }
      }
      if (fault)
        goto resync;
    } 
    else
    {
      /* COD == 1 --> skipped MB */
      if (MBA >= MBAmax)
      {
        /* all macroblocks decoded */
        memcpy(anchorframemodemap,modemap,(sizeof(int)*(MBR+1)*(MBC+2)) );
        return;
      }
      if (!syntax_arith_coding)
        if (PCT_INTER == pict_type || PCT_IPB == pict_type)
          flushbits (1);

      Mode = MODE_INTER;
      /* Reset CBP */
      CBP = CBPB = 0;
      coded_map[ypos + 1][xpos + 1] = 0;
     
      /* reset motion vectors */
      MV[0][0][ypos + 1][xpos + 1] = 0;
      MV[1][0][ypos + 1][xpos + 1] = 0;

      if (PCT_INTER == pict_type)
      {
        for (k=0; k<5; k++)
        {
          true_B_direct_mode_MV[0][k][ypos + 1][xpos + 1] = 0;
          true_B_direct_mode_MV[1][k][ypos + 1][xpos + 1] = 0;
        }
      }
      mvdbx = 0;
      mvdby = 0;    
    }

    /* Store mode and prediction type */
    modemap[ypos + 1][xpos + 1] = Mode;
    
    /* store defaults for advanced intra coding mode */
    if (advanced_intra_coding)
    {
      for (i = 0; i < blk_cnt; i++)
        store_qcoeff[MBA * blk_cnt * 64 + i * 64] = 1024;
    }
    if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
    {
      if (!pb_frame)
      {
        MV[0][0][ypos + 1][xpos + 1] = MV[1][0][ypos + 1][xpos + 1] = 0;
      }
    }

reconstruct_mb:

    /* pixel coordinates of top left corner of current macroblock */
    /* one delayed because of OBMC */
    if (xpos > 0)
    {
      bx = 16 * (xpos - 1);
      by = 16 * ypos;
    } 
    else
    {
      bx = coded_picture_width - 16;
      by = 16 * (ypos - 1);
    }

    if (MBA > 0 && !dont_reconstruct_next_mb)
    {
      Mode = modemap[by / 16 + 1][bx / 16 + 1];

      /* forward motion compensation for B-frame */
      if (pb_frame)
      {
        if (pCOD)
        {
          /* if the macroblock is not coded then it is bidir predicted */
          pMODB = PBMODE_BIDIR_PRED;
          reconstruct (bx, by, 0, pmvdbx, pmvdby, PBMODE_BIDIR_PRED, pnewgob);
        } 
        else
        {
          if (!(pb_frame == IM_PB_FRAMES && (pMODB == PBMODE_CBPB_BCKW_PRED || pMODB == PBMODE_BCKW_PRED)))
            reconstruct (bx, by, 0, pmvdbx, pmvdby, pMODB, pnewgob);
        }
      }
    
      /* motion compensation for P-frame */
      if (Mode == MODE_INTER || Mode == MODE_INTER_Q ||
          Mode == MODE_INTER4V || Mode == MODE_INTER4V_Q)
      {
        reconstruct (bx, by, 1, 0, 0, pMODB, pnewgob);
      }

      /* copy or add block data into P-picture */
      for (comp = 0; comp < blk_cnt; comp++)
      {
        /* inverse DCT */
        if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
        {
          if (refidct)
            idctref (ld->block[comp]);
          else
            idct (ld->block[comp]);
          addblock (comp, bx, by, 0);
        } 
        else if ((pCBP & (1 << (blk_cnt - 1 - comp))))
        {
          /* No need to to do this for blocks with no coeffs */
          if (refidct)
            idctref (ld->block[comp]);
          else
            idct (ld->block[comp]);
          addblock (comp, bx, by, 1);
        }
      }

      if (pb_frame)
      {

        if (pMODB == PBMODE_CBPB_BCKW_PRED || pMODB == PBMODE_BCKW_PRED)
        {
          reconstruct (bx, by, 0, 0, 0, pMODB, pnewgob);
        }
        /* add block data into B-picture */
        for (comp = 6; comp < blk_cnt + 6; comp++)
        {
          if (!pCOD || adv_pred_mode)
          {
            if (pb_frame == IM_PB_FRAMES)
            {
              if (pMODB == PBMODE_CBPB_BIDIR_PRED || pMODB == PBMODE_BIDIR_PRED || pCOD)
              {
                reconblock_b (comp - 6, bx, by, Mode, 0, 0);
              }
            } 
            else
            {
              reconblock_b (comp - 6, bx, by, Mode, pmvdbx, pmvdby);
            }
          }
          if ((pCBPB & (1 << (blk_cnt - 1 - comp % 6))))
          {
            if (refidct)
              idctref (ld->block[comp]);
            else
              idct (ld->block[comp]);
            addblock (comp, bx, by, 1);
          }
        }
      }
    }
    /* end if (MBA > 0) */
    if (!COD)
    {
      Mode = modemap[ypos + 1][xpos + 1];
    
      /* decode blocks */
      for (comp = 0; comp < blk_cnt; comp++)
      {
        clearblock (comp);
        if ((Mode == MODE_INTRA || Mode == MODE_INTRA_Q) && !(advanced_intra_coding))
        {
          /* Intra (except in advanced intra coding mode) */
          bp = ld->block[comp];
          if (syntax_arith_coding)
          {
            //20070702
          } 
          else
          {
            bp[0] = getbits (8);
            if (trace)
            {
              fprintf (trace_file, "DC[%d]: (", comp);
              printbits ((int) bp[0], 8, 8);
              fprintf (trace_file, "): %d\n", (int) bp[0]);
            }
          }

          if (bp[0] == 128)
            if (!quiet)
              fprintf (stderr, "Illegal DC-coeff: 1000000\n");
          if (bp[0] == 255)   /* Spec. in H.26P, not in TMN4 */
            bp[0] = 128;
          bp[0] *= 8;         /* Iquant */
          if ((CBP & (1 << (blk_cnt - 1 - comp))))
          {
            if (!syntax_arith_coding)
              getblock (comp, 0, 0, Mode);
            //20070702
          }
        } 
        else
        {
          /* Inter (or Intra in advanced intra coding mode) */
          if ((CBP & (1 << (blk_cnt - 1 - comp))))
          {
            if (!syntax_arith_coding)
              getblock (comp, 1, INTRA_AC_DC, Mode);
            //20070702
          }
        }
        if ((advanced_intra_coding) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
        {
          Intra_AC_DC_Decode (store_qcoeff, INTRA_AC_DC, MBA, xpos, ypos, comp, newgob);
          memcpy ((void *) (store_qcoeff + MBA * blk_cnt * 64 + comp * 64),
                  (void *) ld->block[comp], sizeof (short) * 64);
        }
        if (fault)
          goto resync;
      }

      /* Decode B blocks */
      if (pb_frame)
      {
        for (comp = 6; comp < blk_cnt + 6; comp++)
        {
          clearblock (comp);
          if ((CBPB & (1 << (blk_cnt - 1 - comp % 6))))
          {
            if (!syntax_arith_coding)
              getblock (comp, 1, 0, MODE_INTER);
            //20070702
          } 
          if (fault)
            goto resync;        
        }
      }
    }
  
conceal_gob:
    /* decode the last MB if data is missing */
    if (decode_last_mb)
    {
      conceal_missing_gobs(start_mb_row_missing, number_of_mb_rows_missing);
      /* all macroblocks in the picture are done, return 
       * if the first gob in the next frame is also missing, 
       * we will also lose the secon gob of that next frame.
       * This can be dealt with, but we will live with that for now. */
      if ( (number_of_mb_rows_missing + start_mb_row_missing) * mb_width >= MBAmax) return;
      ypos = gob;
      decode_last_mb = 0;
      dont_reconstruct_next_mb = 1;
      goto finish_gob;
    }
    else
    {
      /* advance to next macroblock */
      MBA++;
      pCBP = CBP;
      pCBPB = CBPB;
      pCOD = COD;
      pMODB = MODB;
      quant_map[ypos + 1][xpos + 1] = quant;
      
      pmvdbx = mvdbx;
      pmvdby = mvdby;
      fflush (stdout);
      pnewgob = newgob;
      
      if (MBA >= MBAmax && !last_done)
      {
        COD = 1;
        xpos = 0;
        ypos++;
        last_done = 1;
        goto reconstruct_mb;   
      }
    }
  }
}

/* set block to zero */

static void clearblock (int comp)
{
  int *bp;
  int i;

  bp = (int *) ld->block[comp];

  for (i = 0; i < 8; i++)
  {
    bp[0] = bp[1] = bp[2] = bp[3] = 0;
    bp += 4;
  }
}


/* move/add 8x8-Block from block[comp] to refframe or bframe */

static void addblock (int comp, int bx, int by, int addflag)
{
  int cc, i, iincr, P = 1;
  unsigned char *rfp;
  short *bp;
  unsigned char *curr[3];

  if (enhancement_layer_num > 1)
  {
    curr[0] = current_enhancement_frame[enhancement_layer_num-2][0];
    curr[1] = current_enhancement_frame[enhancement_layer_num-2][1];
    curr[2] = current_enhancement_frame[enhancement_layer_num-2][2];
  }
  else
  {
    curr[0] = current_frame[0];
    curr[1] = current_frame[1];
    curr[2] = current_frame[2];
  }


  bp = ld->block[comp];

  if (comp >= 6)
  {
    /* This is a component for B-frame forward prediction */
    P = 0;
    addflag = 1;
    comp -= 6;
  }
  cc = (comp < 4) ? 0 : (comp & 1) + 1; /* color component index */

  if (cc == 0)
  {
    /* luminance */

    /* frame DCT coding */
    if (P)
      rfp = curr[0]
        + coded_picture_width * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
    else  
      rfp = bframe[0]
        + coded_picture_width * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
    iincr = coded_picture_width;
  } 
  else
  {
    /* chrominance */

    /* scale coordinates */
    bx >>= 1;
    by >>= 1;
    /* frame DCT coding */
    if (P)
      rfp = curr[cc] + chrom_width * by + bx;
    else
      rfp = bframe[cc] + chrom_width * by + bx;
    iincr = chrom_width;
  }


  if (addflag)
  {
    for (i = 0; i < 8; i++)
    {
      rfp[0] = clp[bp[0] + rfp[0]];
      rfp[1] = clp[bp[1] + rfp[1]];
      rfp[2] = clp[bp[2] + rfp[2]];
      rfp[3] = clp[bp[3] + rfp[3]];
      rfp[4] = clp[bp[4] + rfp[4]];
      rfp[5] = clp[bp[5] + rfp[5]];
      rfp[6] = clp[bp[6] + rfp[6]];
      rfp[7] = clp[bp[7] + rfp[7]];
      bp += 8;
      rfp += iincr;
    }
  } else
  {
    for (i = 0; i < 8; i++)
    {
      rfp[0] = clp[bp[0]];
      rfp[1] = clp[bp[1]];
      rfp[2] = clp[bp[2]];
      rfp[3] = clp[bp[3]];
      rfp[4] = clp[bp[4]];
      rfp[5] = clp[bp[5]];
      rfp[6] = clp[bp[6]];
      rfp[7] = clp[bp[7]];
      bp += 8;
      rfp += iincr;
    }
  }

  /* printf("%s", (cc ? "Chrominance\n" : "Luminance\n"));  for (i=0; i<8;
   * ++i) { printf("%d %d %d %d %d %d %d %d\n", rfp[0], rfp[1], rfp[2],
   * rfp[3],  rfp[4], rfp[5], rfp[6], rfp[7]); rfp+= iincr; }
   * printf("\n");  */
}

/* bidirectionally reconstruct 8x8-Block from block[comp] to bframe */

static void reconblock_b (int comp, int bx, int by, int mode, int bdx, int bdy)
{
  int cc, i, j, k, ii;
  unsigned char *bfr, *ffr;
  int BMVx, BMVy;
  int xa, xb, ya, yb, x, y, xvec, yvec, mvx, mvy;
  int xint, xhalf, yint, yhalf, pel;

  x = bx / 16 + 1;
  y = by / 16 + 1;

  if (mode == MODE_INTER4V || mode == MODE_INTER4V_Q)
  {
    if (comp < 4)
    {
      /* luma */
      mvx = MV[0][comp + 1][y][x];
      mvy = MV[1][comp + 1][y][x];
      BMVx = (bdx == 0 ? (trb - trd) * mvx / trd : trb * mvx / trd + bdx - mvx);
      BMVy = (bdy == 0 ? (trb - trd) * mvy / trd : trb * mvy / trd + bdy - mvy);
    } else
    {
      /* chroma */
      xvec = yvec = 0;
      for (k = 1; k <= 4; k++)
      {
        mvx = MV[0][k][y][x];
        mvy = MV[1][k][y][x];
        xvec += (bdx == 0 ? (trb - trd) * mvx / trd : trb * mvx / trd + bdx - mvx);
        yvec += (bdy == 0 ? (trb - trd) * mvy / trd : trb * mvy / trd + bdy - mvy);
      }

      /* chroma rounding (table 16/H.263) */