Revision dc172ecc libavcodec/h264_cabac.c
| libavcodec/h264_cabac.c | ||
|---|---|---|
| 1105 | 1105 |
|
| 1106 | 1106 |
int j= scantable[index[--coeff_count]]; |
| 1107 | 1107 |
|
| 1108 |
if( get_cabac( CC, ctx ) == 0 ) {
|
|
| 1109 |
node_ctx = coeff_abs_level_transition[0][node_ctx]; |
|
| 1110 |
if( is_dc ) {
|
|
| 1111 |
block[j] = get_cabac_bypass_sign( CC, -1); |
|
| 1112 |
}else{
|
|
| 1113 |
block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; |
|
| 1114 |
} |
|
| 1115 |
} else {
|
|
| 1116 |
int coeff_abs = 2; |
|
| 1117 |
ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; |
|
| 1118 |
node_ctx = coeff_abs_level_transition[1][node_ctx]; |
|
| 1119 |
|
|
| 1120 |
while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
|
|
| 1121 |
coeff_abs++; |
|
| 1122 |
} |
|
| 1123 |
|
|
| 1124 |
if( coeff_abs >= 15 ) {
|
|
| 1125 |
int j = 0; |
|
| 1126 |
while( get_cabac_bypass( CC ) ) {
|
|
| 1127 |
j++; |
|
| 1128 |
} |
|
| 1129 |
|
|
| 1130 |
coeff_abs=1; |
|
| 1131 |
while( j-- ) {
|
|
| 1132 |
coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
|
| 1133 |
} |
|
| 1134 |
coeff_abs+= 14; |
|
| 1135 |
} |
|
| 1108 |
#define STORE_BLOCK(type) \ |
|
| 1109 |
if( get_cabac( CC, ctx ) == 0 ) { \
|
|
| 1110 |
node_ctx = coeff_abs_level_transition[0][node_ctx]; \ |
|
| 1111 |
if( is_dc ) { \
|
|
| 1112 |
((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \ |
|
| 1113 |
}else{ \
|
|
| 1114 |
((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \ |
|
| 1115 |
} \ |
|
| 1116 |
} else { \
|
|
| 1117 |
int coeff_abs = 2; \ |
|
| 1118 |
ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; \ |
|
| 1119 |
node_ctx = coeff_abs_level_transition[1][node_ctx]; \ |
|
| 1120 |
\ |
|
| 1121 |
while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \
|
|
| 1122 |
coeff_abs++; \ |
|
| 1123 |
} \ |
|
| 1124 |
\ |
|
| 1125 |
if( coeff_abs >= 15 ) { \
|
|
| 1126 |
int j = 0; \ |
|
| 1127 |
while( get_cabac_bypass( CC ) ) { \
|
|
| 1128 |
j++; \ |
|
| 1129 |
} \ |
|
| 1130 |
\ |
|
| 1131 |
coeff_abs=1; \ |
|
| 1132 |
while( j-- ) { \
|
|
| 1133 |
coeff_abs += coeff_abs + get_cabac_bypass( CC ); \ |
|
| 1134 |
} \ |
|
| 1135 |
coeff_abs+= 14; \ |
|
| 1136 |
} \ |
|
| 1137 |
\ |
|
| 1138 |
if( is_dc ) { \
|
|
| 1139 |
((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \ |
|
| 1140 |
}else{ \
|
|
| 1141 |
((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \ |
|
| 1142 |
} \ |
|
| 1143 |
} |
|
| 1136 | 1144 |
|
| 1137 |
if( is_dc ) {
|
|
| 1138 |
block[j] = get_cabac_bypass_sign( CC, -coeff_abs ); |
|
| 1139 |
}else{
|
|
| 1140 |
block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6; |
|
| 1141 |
} |
|
| 1145 |
if (h->pixel_size == 2) {
|
|
| 1146 |
STORE_BLOCK(int32_t) |
|
| 1147 |
} else {
|
|
| 1148 |
STORE_BLOCK(int16_t) |
|
| 1142 | 1149 |
} |
| 1143 | 1150 |
} while( coeff_count ); |
| 1144 | 1151 |
#ifdef CABAC_ON_STACK |
| ... | ... | |
| 1304 | 1311 |
h->slice_table[ mb_xy ]= h->slice_num; |
| 1305 | 1312 |
|
| 1306 | 1313 |
if(IS_INTRA_PCM(mb_type)) {
|
| 1314 |
const int mb_size = 384*h->sps.bit_depth_luma/8; |
|
| 1307 | 1315 |
const uint8_t *ptr; |
| 1308 | 1316 |
|
| 1309 | 1317 |
// We assume these blocks are very rare so we do not optimize it. |
| ... | ... | |
| 1316 | 1324 |
} |
| 1317 | 1325 |
|
| 1318 | 1326 |
// The pixels are stored in the same order as levels in h->mb array. |
| 1319 |
memcpy(h->mb, ptr, 256); ptr+=256;
|
|
| 1327 |
memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
|
|
| 1320 | 1328 |
if(CHROMA){
|
| 1321 |
memcpy(h->mb+128, ptr, 128); ptr+=128;
|
|
| 1329 |
memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
|
|
| 1322 | 1330 |
} |
| 1323 | 1331 |
|
| 1324 | 1332 |
ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); |
| ... | ... | |
| 1652 | 1660 |
//av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
| 1653 | 1661 |
AV_ZERO128(h->mb_luma_dc+0); |
| 1654 | 1662 |
AV_ZERO128(h->mb_luma_dc+8); |
| 1663 |
AV_ZERO128(h->mb_luma_dc+16); |
|
| 1664 |
AV_ZERO128(h->mb_luma_dc+24); |
|
| 1655 | 1665 |
decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16); |
| 1656 | 1666 |
|
| 1657 | 1667 |
if( cbp&15 ) {
|
| 1658 | 1668 |
qmul = h->dequant4_coeff[0][s->qscale]; |
| 1659 | 1669 |
for( i = 0; i < 16; i++ ) {
|
| 1660 | 1670 |
//av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
| 1661 |
decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); |
|
| 1671 |
decode_cabac_residual_nondc(h, h->mb + 16*i*h->pixel_size, 1, i, scan + 1, qmul, 15);
|
|
| 1662 | 1672 |
} |
| 1663 | 1673 |
} else {
|
| 1664 | 1674 |
fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
| ... | ... | |
| 1668 | 1678 |
for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
|
| 1669 | 1679 |
if( cbp & (1<<i8x8) ) {
|
| 1670 | 1680 |
if( IS_8x8DCT(mb_type) ) {
|
| 1671 |
decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8, |
|
| 1681 |
decode_cabac_residual_nondc(h, h->mb + 64*i8x8*h->pixel_size, 5, 4*i8x8,
|
|
| 1672 | 1682 |
scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); |
| 1673 | 1683 |
} else {
|
| 1674 | 1684 |
qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; |
| ... | ... | |
| 1676 | 1686 |
const int index = 4*i8x8 + i4x4; |
| 1677 | 1687 |
//av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); |
| 1678 | 1688 |
//START_TIMER |
| 1679 |
decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16); |
|
| 1689 |
decode_cabac_residual_nondc(h, h->mb + 16*index*h->pixel_size, 2, index, scan, qmul, 16);
|
|
| 1680 | 1690 |
//STOP_TIMER("decode_residual")
|
| 1681 | 1691 |
} |
| 1682 | 1692 |
} |
| ... | ... | |
| 1691 | 1701 |
int c; |
| 1692 | 1702 |
for( c = 0; c < 2; c++ ) {
|
| 1693 | 1703 |
//av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
| 1694 |
decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
|
|
| 1704 |
decode_cabac_residual_dc(h, h->mb + (256 + 16*4*c)*h->pixel_size, 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
|
|
| 1695 | 1705 |
} |
| 1696 | 1706 |
} |
| 1697 | 1707 |
|
| ... | ... | |
| 1702 | 1712 |
for( i = 0; i < 4; i++ ) {
|
| 1703 | 1713 |
const int index = 16 + 4 * c + i; |
| 1704 | 1714 |
//av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
| 1705 |
decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15); |
|
| 1715 |
decode_cabac_residual_nondc(h, h->mb + 16*index*h->pixel_size, 4, index, scan + 1, qmul, 15);
|
|
| 1706 | 1716 |
} |
| 1707 | 1717 |
} |
| 1708 | 1718 |
} else {
|
Also available in: Unified diff