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%dDC\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%dAC %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