📄 bitstream.cpp
字号:
}
}
else
{
if (PCT_INTER == pict_type || PCT_IPB == pict_type)
{
/* flush COD bit */
flushbits (1);
}
if (PCT_INTRA == pict_type)
{
MCBPC = getMCBPCintra ();
}
else
{
MCBPC = getMCBPC ();
}
}
if (fault)
goto resync;
if (MCBPC == 255)
{
/* stuffing - read next COD without advancing MB count. */
goto read_cod;
}
else
{
/* normal MB data */
Mode = MCBPC & 7;
if (advanced_intra_coding && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
{
/* get INTRA_AC_DC mode for annex I */
if (syntax_arith_coding)
{
INTRA_AC_DC_index = decode_a_symbol (De_cumf_INTRA_AC_DC);
INTRA_AC_DC = De_intra_ac_dctab[INTRA_AC_DC_index];
}
else
{
/* using VLC */
if (!showbits (1))
INTRA_AC_DC = getbits (1);
else
INTRA_AC_DC = getbits (2);
}
}
/* MODB and CBPB */
if (pb_frame)
{
CBPB = 0;
if (syntax_arith_coding)
{
if (pb_frame== PB_FRAMES)
{
MODB_index = decode_a_symbol (De_cumf_MODB_G);
MODB = De_modb_tab_G[MODB_index];
}
else
{
MODB_index = decode_a_symbol (De_cumf_MODB_M);
MODB = De_modb_tab_M[MODB_index];
}
}
else
MODB = getMODB ();
if ( (MODB == PBMODE_CBPB_MVDB && pb_frame == PB_FRAMES) ||
(pb_frame == IM_PB_FRAMES &&
(MODB == PBMODE_CBPB_FRW_PRED ||
MODB == PBMODE_CBPB_BIDIR_PRED || MODB == PBMODE_CBPB_BCKW_PRED) ) )
{
if (syntax_arith_coding)
{
for (i = 0; i < 4; i++)
{
YCBPB_index = decode_a_symbol (De_cumf_YCBPB);
YCBPB = De_ycbpb_tab[YCBPB_index];
CBPB |= (YCBPB << (6 - 1 - i));
}
for (i = 4; i < 6; i++)
{
UVCBPB_index = decode_a_symbol (De_cumf_UVCBPB);
UVCBPB = De_uvcbpb_tab[UVCBPB_index];
CBPB |= (UVCBPB << (6 - 1 - i));
}
}
else
CBPB = getbits (6);
}
}
if (syntax_arith_coding)
{
if ((Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
{
/* Intra */
CBPY_index = decode_a_symbol (De_cumf_CBPY_intra);
CBPY = De_cbpy_intratab[CBPY_index];
}
else
{
CBPY_index = decode_a_symbol (De_cumf_CBPY);
CBPY = De_cbpytab[CBPY_index];
}
}
else
{
CBPY = getCBPY ();
}
}
/* Decode Mode and CBP */
if ((Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
{
/* Intra */
coded_map[ypos + 1][xpos + 1] = 1;
if (!syntax_arith_coding)
CBPY = CBPY ^ 15; /* needed in huffman coding only */
}
else if (!syntax_arith_coding && alternative_inter_VLC_mode && ((MCBPC >> 4) == 3))
CBPY = CBPY ^ 15; /* Annex S.3 change */
CBP = (CBPY << 2) | (MCBPC >> 4);
if ((Mode == MODE_INTER4V || Mode == MODE_INTER4V_Q) && !De_use_4mv)
{
fault = 1;
}
if (Mode == MODE_INTER_Q || Mode == MODE_INTRA_Q || Mode == MODE_INTER4V_Q)
{
/* Read DQUANT if necessary */
if (syntax_arith_coding)
{
DQUANT_index = decode_a_symbol (De_cumf_DQUANT);
DQUANT = De_dquanttab[DQUANT_index] - 2;
quant += DQUANT;
}
else
{
if (!modified_quantization_mode)
{
DQUANT = getbits (2);
quant += DQ_tab[DQUANT];
}
else
{
tmp = getbits (1);
if (tmp)
{
/* only one more additional bit was sent */
tmp = getbits (1);
if (tmp)
{
/* second bit of quant is 1 */
DQUANT = change_of_quant_tab_11[quant];
}
else
{
/* second bit of quant is 0 */
DQUANT = change_of_quant_tab_10[quant];
}
quant += DQUANT;
}
else
{
/* five additional bits were sent as
* DQUANT */
DQUANT = getbits (5);
quant = DQUANT;
}
}
}
if (quant > 31 || quant < 1)
{
quant = mmax (1, mmin (31, quant));
/* could set fault-flag and resync here */
fault = 1;
}
}
/* motion vectors */
if (Mode == MODE_INTER || Mode == MODE_INTER_Q ||
Mode == MODE_INTER4V || Mode == MODE_INTER4V_Q || pb_frame)
{
if (Mode == MODE_INTER4V || Mode == MODE_INTER4V_Q)
{
startmv = 1;
stopmv = 4;
}
else
{
startmv = 0;
stopmv = 0;
}
for (k = startmv; k <= stopmv; k++)
{
if (syntax_arith_coding)
{
mvx_index = decode_a_symbol (De_cumf_MVD);
mvx = De_mvdtab[mvx_index];
mvy_index = decode_a_symbol (De_cumf_MVD);
mvy = De_mvdtab[mvy_index];
}
else
{
if (plus_type && long_vectors)
{
mvx = getRVLC ();
mvy = getRVLC ();
/* flush start code emulation bit */
if (mvx == 1 && mvy == 1)
flushbits(1);
}
else
{
mvx = getTMNMV ();
mvy = getTMNMV ();
}
}
pmv0 = find_pmv (xpos, ypos, k, 0);
pmv1 = find_pmv (xpos, ypos, k, 1);
if (plus_type && long_vectors && !syntax_arith_coding)
{
mvx += pmv0;
mvy += pmv1;
}
else
{
mvx = motion_decode (mvx, pmv0);
mvy = motion_decode (mvy, pmv1);
}
/* store coded or not-coded */
coded_map[ypos + 1][xpos + 1] = 1;
/* Check mv's to prevent seg.faults when error rate is high */
if (!De_mv_outside_frame)
{
bsize = k ? 8 : 16;
offset = k ? (((k - 1) & 1) << 3) : 0;
/* checking only integer component */
if ((xpos << 4) + (mvx / 2) + offset < 0 ||
(xpos << 4) + (mvx / 2) + offset > (mb_width << 4) - bsize)
{
fault = 1;
}
offset = k ? (((k - 1) & 2) << 2) : 0;
if ((ypos << 4) + (mvy / 2) + offset < 0 ||
(ypos << 4) + (mvy / 2) + offset > (mb_height << 4) - bsize)
{
fault = 1;
}
}
De_true_B_direct_mode_MV[0][k][ypos + 1][xpos + 1] = De_MV[0][k][ypos + 1][xpos + 1] = mvx;
De_true_B_direct_mode_MV[1][k][ypos + 1][xpos + 1] = De_MV[1][k][ypos + 1][xpos + 1] = mvy;
}
/* PB frame delta vectors */
if (pb_frame)
{
if (((MODB == PBMODE_MVDB || MODB == PBMODE_CBPB_MVDB) && pb_frame == PB_FRAMES) ||
(pb_frame == IM_PB_FRAMES && (MODB == PBMODE_CBPB_FRW_PRED || MODB == PBMODE_FRW_PRED)))
{
if (syntax_arith_coding)
{
mvdbx_index = decode_a_symbol (De_cumf_MVD);
mvdbx = De_mvdtab[mvdbx_index];
mvdby_index = decode_a_symbol (De_cumf_MVD);
mvdby = De_mvdtab[mvdby_index];
}
else
{
if (plus_type && long_vectors)
{
mvdbx = getRVLC ();
mvdby = getRVLC ();
/* flush start code emulation bit */
if (mvdbx == 1 && mvdby == 1)
flushbits(1);
}
else
{
mvdbx = getTMNMV ();
mvdby = getTMNMV ();
}
}
long_vectors_bak = long_vectors;
/* turn off long vectors when decoding forward motion vector
* of im.pb frames */
pmv0 = 0;
pmv1 = 0;
if (pb_frame == IM_PB_FRAMES &&
(MODB == PBMODE_CBPB_FRW_PRED || MODB == PBMODE_FRW_PRED))
{
long_vectors = 0;
if (MBA % mb_width && (pMODB == PBMODE_CBPB_FRW_PRED ||
pMODB == PBMODE_FRW_PRED))
{
/* MBA%mb_width : if not new gob */
pmv0 = pmvdbx;
pmv1 = pmvdby;
}
}
if (plus_type && long_vectors && !syntax_arith_coding)
{
mvdbx += pmv0;
mvdby += pmv1;
}
else
{
mvdbx = motion_decode (mvdbx, pmv0);
mvdby = motion_decode (mvdby, pmv1);
}
long_vectors = long_vectors_bak;
/* This will not work if the PB deltas are so large they
* require the second colums of the motion vector VLC table to
* be used. To fix this it is necessary to calculate the De_MV
* predictor for the PB delta: TRB*De_MV/TRD here, and use this
* as the second parameter to motion_decode(). The B vector
* itself will then be returned from motion_decode(). This
* will have to be changed to the PB delta again, since it is
* the PB delta which is used later */
}
else
{
mvdbx = 0;
mvdby = 0;
}
}
}
/* Intra. */
else
{
/* 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++)
{
De_true_B_direct_mode_MV[0][k][ypos + 1][xpos + 1] = 0;
De_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(De_anchorframemodemap,De_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 */
De_MV[0][0][ypos + 1][xpos + 1] = 0;
De_MV[1][0][ypos + 1][xpos + 1] = 0;
if (PCT_INTER == pict_type)
{
for (k=0; k<5; k++)
{
De_true_B_direct_mode_MV[0][k][ypos + 1][xpos + 1] = 0;
De_true_B_direct_mode_MV[1][k][ypos + 1][xpos + 1] = 0;
}
}
mvdbx = 0;
mvdby = 0;
}
/* Store mode and prediction type */
De_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)
{
De_MV[0][0][ypos + 1][xpos + 1] = De_MV[1][0][ypos + 1][xpos + 1] = 0;
}
}
reconstruct_mb:
AT_TRACE1(4,"CBitStream::get_I_P_MBs reconstruct_mb\n");
/* 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);
}
AT_TRACE1(4,"CBitStream::get_I_P_MBs reconstruct_mb 1\n");
if (MBA > 0 && !dont_reconstruct_next_mb)
{
Mode = De_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)
{
De_decode(ld->block[comp], comp, bx, by, 0);
//De_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 */
De_decode(ld->block[comp], comp, bx, by, 1);
//De_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))))
{
De_⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -