« back to all changes in this revision
Viewing changes to libavcodec/h264.c
- browse files at revision 11
- compare with another revision
- download diff
- download tarball
- view history from revision 11
- Committer: Bazaar Package Importer
- Author(s): Reinhard Tartler
- Date: 2009-01-20 09:20:53 UTC
- mfrom: (1.1.3 upstream)
- Revision ID: james.westby@ubuntu.com-20090120092053-izz63p40hc98qfgp
Tags: 3:0.svn20090119-1ubuntu1
* merge from debian. LP: #318501
* new version fixes CVE-2008-3230, LP: #253767
* new version fixes CVE-2008-3230, LP: #253767
- files added:
- .svnrevision
- libavcodec/arm
- libavcodec/x86
- files removed:
- debian/patches/050_fix_pkgconfig_files.patch
- libavcodec/armv4l
- libavcodec/i386
- files modified:
- Changelog
added
removed
libavcodec/h264.c
32
32
#include "h264data.h"
33
33
#include "h264_parser.h"
34
34
#include "golomb.h"
35
#include "mathops.h"
35
36
#include "rectangle.h"
37
#include "vdpau_internal.h"
36
38
37
39
#include "cabac.h"
38
#ifdef ARCH_X86
39
#include "i386/h264_i386.h"
40
#if ARCH_X86
41
#include "x86/h264_i386.h"
40
42
#endif
41
43
42
44
//#undef NDEBUG
101
103
{0,2,0,2,7,10,7,10}
102
104
};
103
105
106
#define LEVEL_TAB_BITS 8
107
static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
108
104
109
static void fill_caches(H264Context *h, int mb_type, int for_deblock){
105
110
MpegEncContext * const s = &h->s;
106
111
const int mb_xy= h->mb_xy;
107
112
int topleft_xy, top_xy, topright_xy, left_xy[2];
108
113
int topleft_type, top_type, topright_type, left_type[2];
109
int * left_block;
114
const int * left_block;
110
115
int topleft_partition= -1;
111
116
int i;
112
117
128
133
const int top_pair_xy = pair_xy - s->mb_stride;
129
134
const int topleft_pair_xy = top_pair_xy - 1;
130
135
const int topright_pair_xy = top_pair_xy + 1;
131
const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
132
const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
133
const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
134
const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
135
const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);
136
const int topleft_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
137
const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
138
const int topright_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
139
const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
140
const int curr_mb_field_flag = IS_INTERLACED(mb_type);
136
141
const int bottom = (s->mb_y & 1);
137
tprintf(s->avctx, "fill_caches: curr_mb_frame_flag:%d, left_mb_frame_flag:%d, topleft_mb_frame_flag:%d, top_mb_frame_flag:%d, topright_mb_frame_flag:%d\n", curr_mb_frame_flag, left_mb_frame_flag, topleft_mb_frame_flag, top_mb_frame_flag, topright_mb_frame_flag);
138
if (bottom
139
? !curr_mb_frame_flag // bottom macroblock
140
: (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
141
) {
142
tprintf(s->avctx, "fill_caches: curr_mb_field_flag:%d, left_mb_field_flag:%d, topleft_mb_field_flag:%d, top_mb_field_flag:%d, topright_mb_field_flag:%d\n", curr_mb_field_flag, left_mb_field_flag, topleft_mb_field_flag, top_mb_field_flag, topright_mb_field_flag);
143
144
if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
142
145
top_xy -= s->mb_stride;
143
146
}
144
if (bottom
145
? !curr_mb_frame_flag // bottom macroblock
146
: (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock
147
) {
147
if (curr_mb_field_flag && (bottom || topleft_mb_field_flag)){
148
148
topleft_xy -= s->mb_stride;
149
} else if(bottom && curr_mb_frame_flag && !left_mb_frame_flag) {
149
} else if(bottom && !curr_mb_field_flag && left_mb_field_flag) {
150
150
topleft_xy += s->mb_stride;
151
151
// take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition
152
152
topleft_partition = 0;
153
153
}
154
if (bottom
155
? !curr_mb_frame_flag // bottom macroblock
156
: (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock
157
) {
154
if (curr_mb_field_flag && (bottom || topright_mb_field_flag)){
158
155
topright_xy -= s->mb_stride;
159
156
}
160
if (left_mb_frame_flag != curr_mb_frame_flag) {
157
if (left_mb_field_flag != curr_mb_field_flag) {
161
158
left_xy[1] = left_xy[0] = pair_xy - 1;
162
if (curr_mb_frame_flag) {
163
if (bottom) {
164
left_block = left_block_options[1];
165
} else {
166
left_block= left_block_options[2];
167
}
168
} else {
159
if (curr_mb_field_flag) {
169
160
left_xy[1] += s->mb_stride;
170
161
left_block = left_block_options[3];
162
} else {
163
left_block= left_block_options[2 - bottom];
171
164
}
172
165
}
173
166
}
589
582
static const int mask[4]={0x8000,0x2000,0x80,0x20};
590
583
for(i=0; i<4; i++){
591
584
if(!(h->left_samples_available&mask[i])){
592
int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
593
if(status<0){
594
av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
595
return -1;
596
} else if(status){
597
h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
598
}
585
int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
586
if(status<0){
587
av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
588
return -1;
589
} else if(status){
590
h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
591
}
599
592
}
600
593
}
601
594
}
882
875
tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
883
876
884
877
if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
885
|| (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
886
|| (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
878
|| !( top_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ])
879
|| !(left_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ])){
887
880
888
881
*mx = *my = 0;
889
882
return;
1387
1380
for(i=0; i<length; i++)
1388
1381
printf("%2X ", src[i]);
1389
1382
#endif
1383
1384
#if HAVE_FAST_UNALIGNED
1385
# if HAVE_FAST_64BIT
1386
# define RS 7
1387
for(i=0; i+1<length; i+=9){
1388
if(!((~*(uint64_t*)(src+i) & (*(uint64_t*)(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))
1389
# else
1390
# define RS 3
1391
for(i=0; i+1<length; i+=5){
1392
if(!((~*(uint32_t*)(src+i) & (*(uint32_t*)(src+i) - 0x01000101U)) & 0x80008080U))
1393
# endif
1394
continue;
1395
if(i>0 && !src[i]) i--;
1396
while(src[i]) i++;
1397
#else
1398
# define RS 0
1390
1399
for(i=0; i+1<length; i+=2){
1391
1400
if(src[i]) continue;
1392
1401
if(i>0 && src[i-1]==0) i--;
1402
#endif
1393
1403
if(i+2<length && src[i+1]==0 && src[i+2]<=3){
1394
1404
if(src[i+2]!=3){
1395
1405
/* startcode, so we must be past the end */
1397
1407
}
1398
1408
break;
1399
1409
}
1410
i-= RS;
1400
1411
}
1401
1412
1402
1413
if(i>=length-1){ //no escaped 0
1406
1417
}
1407
1418
1408
1419
bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
1409
h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length);
1420
h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
1410
1421
dst= h->rbsp_buffer[bufidx];
1411
1422
1412
1423
if (dst == NULL){
1414
1425
}
1415
1426
1416
1427
//printf("decoding esc\n");
1417
si=di=0;
1418
while(si<length){
1428
memcpy(dst, src, i);
1429
si=di=i;
1430
while(si+2<length){
1419
1431
//remove escapes (very rare 1:2^22)
1420
if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1432
if(src[si+2]>3){
1433
dst[di++]= src[si++];
1434
dst[di++]= src[si++];
1435
}else if(src[si]==0 && src[si+1]==0){
1421
1436
if(src[si+2]==3){ //escape
1422
1437
dst[di++]= 0;
1423
1438
dst[di++]= 0;
1424
1439
si+=3;
1425
1440
continue;
1426
1441
}else //next start code
1427
break;
1442
goto nsc;
1428
1443
}
1429
1444
1430
1445
dst[di++]= src[si++];
1431
1446
}
1447
while(si<length)
1448
dst[di++]= src[si++];
1449
nsc:
1450
1451
memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1432
1452
1433
1453
*dst_length= di;
1434
1454
*consumed= si + 1;//+1 for the header
1587
1607
return h->pps.chroma_qp_table[t][qscale];
1588
1608
}
1589
1609
1590
//FIXME need to check that this does not overflow signed 32 bit for low qp, I am not sure, it's very close
1591
//FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away)
1592
static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int separate_dc){
1593
int i;
1594
const int * const quant_table= quant_coeff[qscale];
1595
const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;
1596
const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;
1597
const unsigned int threshold2= (threshold1<<1);
1598
int last_non_zero;
1599
1600
if(separate_dc){
1601
if(qscale<=18){
1602
//avoid overflows
1603
const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;
1604
const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;
1605
const unsigned int dc_threshold2= (dc_threshold1<<1);
1606
1607
int level= block[0]*quant_coeff[qscale+18][0];
1608
if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1609
if(level>0){
1610
level= (dc_bias + level)>>(QUANT_SHIFT-2);
1611
block[0]= level;
1612
}else{
1613
level= (dc_bias - level)>>(QUANT_SHIFT-2);
1614
block[0]= -level;
1615
}
1616
// last_non_zero = i;
1617
}else{
1618
block[0]=0;
1619
}
1620
}else{
1621
const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;
1622
const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;
1623
const unsigned int dc_threshold2= (dc_threshold1<<1);
1624
1625
int level= block[0]*quant_table[0];
1626
if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1627
if(level>0){
1628
level= (dc_bias + level)>>(QUANT_SHIFT+1);
1629
block[0]= level;
1630
}else{
1631
level= (dc_bias - level)>>(QUANT_SHIFT+1);
1632
block[0]= -level;
1633
}
1634
// last_non_zero = i;
1635
}else{
1636
block[0]=0;
1637
}
1638
}
1639
last_non_zero= 0;
1640
i=1;
1641
}else{
1642
last_non_zero= -1;
1643
i=0;
1644
}
1645
1646
for(; i<16; i++){
1647
const int j= scantable[i];
1648
int level= block[j]*quant_table[j];
1649
1650
// if( bias+level >= (1<<(QMAT_SHIFT - 3))
1651
// || bias-level >= (1<<(QMAT_SHIFT - 3))){
1652
if(((unsigned)(level+threshold1))>threshold2){
1653
if(level>0){
1654
level= (bias + level)>>QUANT_SHIFT;
1655
block[j]= level;
1656
}else{
1657
level= (bias - level)>>QUANT_SHIFT;
1658
block[j]= -level;
1659
}
1660
last_non_zero = i;
1661
}else{
1662
block[j]=0;
1663
}
1664
}
1665
1666
return last_non_zero;
1667
}
1668
1669
1610
static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
1670
1611
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1671
1612
int src_x_offset, int src_y_offset,
1684
1625
const int pic_width = 16*s->mb_width;
1685
1626
const int pic_height = 16*s->mb_height >> MB_FIELD;
1686
1627
1687
if(!pic->data[0]) //FIXME this is unacceptable, some sensible error concealment must be done for missing reference frames
1688
return;
1689
1690
1628
if(mx&7) extra_width -= 3;
1691
1629
if(my&7) extra_height -= 3;
1692
1630
1704
1642
qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
1705
1643
}
1706
1644
1707
if(ENABLE_GRAY && s->flags&CODEC_FLAG_GRAY) return;
1645
if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
1708
1646
1709
1647
if(MB_FIELD){
1710
1648
// chroma offset when predicting from a field of opposite parity
1949
1887
prefetch_motion(h, 1);
1950
1888
}
1951
1889
1890
static av_cold void init_cavlc_level_tab(void){
1891
int suffix_length, mask;
1892
unsigned int i;
1893
1894
for(suffix_length=0; suffix_length<7; suffix_length++){
1895
for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
1896
int prefix= LEVEL_TAB_BITS - av_log2(2*i);
1897
int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);
1898
1899
mask= -(level_code&1);
1900
level_code= (((2+level_code)>>1) ^ mask) - mask;
1901
if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
1902
cavlc_level_tab[suffix_length][i][0]= level_code;
1903
cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
1904
}else if(prefix + 1 <= LEVEL_TAB_BITS){
1905
cavlc_level_tab[suffix_length][i][0]= prefix+100;
1906
cavlc_level_tab[suffix_length][i][1]= prefix + 1;
1907
}else{
1908
cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
1909
cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
1910
}
1911
}
1912
}
1913
}
1914
1952
1915
static av_cold void decode_init_vlc(void){
1953
1916
static int done = 0;
1954
1917
2015
1978
&run_len [6][0], 1, 1,
2016
1979
&run_bits[6][0], 1, 1,
2017
1980
INIT_VLC_USE_NEW_STATIC);
1981
1982
init_cavlc_level_tab();
2018
1983
}
2019
1984
}
2020
1985
2200
2165
s->unrestricted_mv=1;
2201
2166
s->decode=1; //FIXME
2202
2167
2168
dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
2169
2203
2170
memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
2204
2171
memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
2205
2172
}
2223
2190
2224
2191
if(avctx->codec_id == CODEC_ID_SVQ3)
2225
2192
avctx->pix_fmt= PIX_FMT_YUVJ420P;
2193
else if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2194
avctx->pix_fmt= PIX_FMT_VDPAU_H264;
2226
2195
else
2227
2196
avctx->pix_fmt= PIX_FMT_YUV420P;
2228
2197
2318
2287
if(!MB_MBAFF){
2319
2288
*(uint64_t*)(h->top_borders[0][s->mb_x]+ 0)= *(uint64_t*)(src_y + 15*linesize);
2320
2289
*(uint64_t*)(h->top_borders[0][s->mb_x]+ 8)= *(uint64_t*)(src_y +8+15*linesize);
2321
if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2290
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2322
2291
*(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+7*uvlinesize);
2323
2292
*(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+7*uvlinesize);
2324
2293
}
2326
2295
}else{
2327
2296
if(!MB_MBAFF){
2328
2297
h->left_border[0]= h->top_borders[0][s->mb_x][15];
2329
if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2298
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2330
2299
h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7 ];
2331
2300
h->left_border[34+18]= h->top_borders[0][s->mb_x][16+8+7];
2332
2301
}
2349
2318
*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize);
2350
2319
*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
2351
2320
2352
if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2321
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2353
2322
h->left_border[uvoffset+34 ]= h->top_borders[top_idx][s->mb_x][16+7];
2354
2323
h->left_border[uvoffset+34+18]= h->top_borders[top_idx][s->mb_x][24+7];
2355
2324
for(i=1; i<9 - skiplast; i++){
2419
2388
}
2420
2389
}
2421
2390
2422
if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2391
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2423
2392
if(deblock_left){
2424
2393
for(i = !deblock_top; i<8; i++){
2425
2394
XCHG(h->left_border[uvoffset+34 +i*step], src_cb[i*uvlinesize], temp8, xchg);
2445
2414
int linesize, uvlinesize /*dct_offset*/;
2446
2415
int i;
2447
2416
int *block_offset = &h->block_offset[0];
2448
const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass), is_h264 = (simple || s->codec_id == CODEC_ID_H264);
2417
const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
2418
/* is_h264 should always be true if SVQ3 is disabled. */
2419
const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;
2449
2420
void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
2450
2421
void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
2451
2422
2452
dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
2453
dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2454
dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2423
dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
2424
dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
2425
dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
2455
2426
2456
2427
s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
2457
2428
s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);
2488
2459
// dct_offset = s->linesize * 16;
2489
2460
}
2490
2461
2491
if(transform_bypass){
2492
idct_dc_add =
2493
idct_add = IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
2494
}else if(IS_8x8DCT(mb_type)){
2495
idct_dc_add = s->dsp.h264_idct8_dc_add;
2496
idct_add = s->dsp.h264_idct8_add;
2497
}else{
2498
idct_dc_add = s->dsp.h264_idct_dc_add;
2499
idct_add = s->dsp.h264_idct_add;
2500
}
2501
2502
2462
if (!simple && IS_INTRA_PCM(mb_type)) {
2503
2463
for (i=0; i<16; i++) {
2504
2464
memcpy(dest_y + i* linesize, h->mb + i*8, 16);
2512
2472
if(h->deblocking_filter)
2513
2473
xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
2514
2474
2515
if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2475
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2516
2476
h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
2517
2477
h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
2518
2478
}
2520
2480
if(IS_INTRA4x4(mb_type)){
2521
2481
if(simple || !s->encoding){
2522
2482
if(IS_8x8DCT(mb_type)){
2483
if(transform_bypass){
2484
idct_dc_add =
2485
idct_add = s->dsp.add_pixels8;
2486
}else{
2487
idct_dc_add = s->dsp.h264_idct8_dc_add;
2488
idct_add = s->dsp.h264_idct8_add;
2489
}
2523
2490
for(i=0; i<16; i+=4){
2524
2491
uint8_t * const ptr= dest_y + block_offset[i];
2525
2492
const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2526
const int nnz = h->non_zero_count_cache[ scan8[i] ];
2527
h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
2528
(h->topright_samples_available<<i)&0x4000, linesize);
2529
if(nnz){
2530
if(nnz == 1 && h->mb[i*16])
2531
idct_dc_add(ptr, h->mb + i*16, linesize);
2532
else
2533
idct_add(ptr, h->mb + i*16, linesize);
2534
}
2535
}
2536
}else
2537
for(i=0; i<16; i++){
2538
uint8_t * const ptr= dest_y + block_offset[i];
2539
uint8_t *topright;
2540
const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2541
int nnz, tr;
2542
2543
if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
2544
const int topright_avail= (h->topright_samples_available<<i)&0x8000;
2545
assert(mb_y || linesize <= block_offset[i]);
2546
if(!topright_avail){
2547
tr= ptr[3 - linesize]*0x01010101;
2548
topright= (uint8_t*) &tr;
2549
}else
2550
topright= ptr + 4 - linesize;
2551
}else
2552
topright= NULL;
2553
2554
h->hpc.pred4x4[ dir ](ptr, topright, linesize);
2555
nnz = h->non_zero_count_cache[ scan8[i] ];
2556
if(nnz){
2557
if(is_h264){
2558
if(nnz == 1 && h->mb[i*16])
2559
idct_dc_add(ptr, h->mb + i*16, linesize);
2560
else
2561
idct_add(ptr, h->mb + i*16, linesize);
2562
}else
2563
svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
2493
if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
2494
h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);
2495
}else{
2496
const int nnz = h->non_zero_count_cache[ scan8[i] ];
2497
h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
2498
(h->topright_samples_available<<i)&0x4000, linesize);
2499
if(nnz){
2500
if(nnz == 1 && h->mb[i*16])
2501
idct_dc_add(ptr, h->mb + i*16, linesize);
2502
else
2503
idct_add (ptr, h->mb + i*16, linesize);
2504
}
2505
}
2506
}
2507
}else{
2508
if(transform_bypass){
2509
idct_dc_add =
2510
idct_add = s->dsp.add_pixels4;
2511
}else{
2512
idct_dc_add = s->dsp.h264_idct_dc_add;
2513
idct_add = s->dsp.h264_idct_add;
2514
}
2515
for(i=0; i<16; i++){
2516
uint8_t * const ptr= dest_y + block_offset[i];
2517
const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2518
2519
if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
2520
h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
2521
}else{
2522
uint8_t *topright;
2523
int nnz, tr;
2524
if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
2525
const int topright_avail= (h->topright_samples_available<<i)&0x8000;
2526
assert(mb_y || linesize <= block_offset[i]);
2527
if(!topright_avail){
2528
tr= ptr[3 - linesize]*0x01010101;
2529
topright= (uint8_t*) &tr;
2530
}else
2531
topright= ptr + 4 - linesize;
2532
}else
2533
topright= NULL;
2534
2535
h->hpc.pred4x4[ dir ](ptr, topright, linesize);
2536
nnz = h->non_zero_count_cache[ scan8[i] ];
2537
if(nnz){
2538
if(is_h264){
2539
if(nnz == 1 && h->mb[i*16])
2540
idct_dc_add(ptr, h->mb + i*16, linesize);
2541
else
2542
idct_add (ptr, h->mb + i*16, linesize);
2543
}else
2544
svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
2545
}
2546
}
2564
2547
}
2565
2548
}
2566
2549
}
2585
2568
if(!IS_INTRA4x4(mb_type)){
2586
2569
if(is_h264){
2587
2570
if(IS_INTRA16x16(mb_type)){
2588
for(i=0; i<16; i++){
2589
if(h->non_zero_count_cache[ scan8[i] ])
2590
idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
2591
else if(h->mb[i*16])
2592
idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
2571
if(transform_bypass){
2572
if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
2573
h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
2574
}else{
2575
for(i=0; i<16; i++){
2576
if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2577
s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize);
2578
}
2579
}
2580
}else{
2581
s->dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2593
2582
}
2594
}else{
2595
const int di = IS_8x8DCT(mb_type) ? 4 : 1;
2596
for(i=0; i<16; i+=di){
2597
int nnz = h->non_zero_count_cache[ scan8[i] ];
2598
if(nnz){
2599
if(nnz==1 && h->mb[i*16])
2600
idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
2601
else
2583
}else if(h->cbp&15){
2584
if(transform_bypass){
2585
const int di = IS_8x8DCT(mb_type) ? 4 : 1;
2586
idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
2587
for(i=0; i<16; i+=di){
2588
if(h->non_zero_count_cache[ scan8[i] ]){
2602
2589
idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
2590
}
2591
}
2592
}else{
2593
if(IS_8x8DCT(mb_type)){
2594
s->dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2595
}else{
2596
s->dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2603
2597
}
2604
2598
}
2605
2599
}
2613
2607
}
2614
2608
}
2615
2609
2616
if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2610
if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
2617
2611
uint8_t *dest[2] = {dest_cb, dest_cr};
2618
2612
if(transform_bypass){
2619
idct_add = idct_dc_add = s->dsp.add_pixels4;
2613
if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
2614
h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize);
2615
h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize);
2616
}else{
2617
idct_add = s->dsp.add_pixels4;
2618
for(i=16; i<16+8; i++){
2619
if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2620
idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2621
}
2622
}
2620
2623
}else{
2621
idct_add = s->dsp.h264_idct_add;
2622
idct_dc_add = s->dsp.h264_idct_dc_add;
2623
2624
chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp[0], h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
2624
2625
chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp[1], h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
2625
}
2626
if(is_h264){
2627
for(i=16; i<16+8; i++){
2628
if(h->non_zero_count_cache[ scan8[i] ])
2629
idct_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2630
else if(h->mb[i*16])
2631
idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2632
}
2633
}else{
2634
for(i=16; i<16+8; i++){
2635
if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2636
uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
2637
svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
2626
if(is_h264){
2627
idct_add = s->dsp.h264_idct_add;
2628
idct_dc_add = s->dsp.h264_idct_dc_add;
2629
for(i=16; i<16+8; i++){
2630
if(h->non_zero_count_cache[ scan8[i] ])
2631
idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2632
else if(h->mb[i*16])
2633
idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2634
}
2635
}else{
2636
for(i=16; i<16+8; i++){
2637
if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2638
uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
2639
svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
2640
}
2638
2641
}
2639
2642
}
2640
2643
}
2641
2644
}
2642
2645
}
2646
if(h->cbp || IS_INTRA(mb_type))
2647
s->dsp.clear_blocks(h->mb);
2648
2643
2649
if(h->deblocking_filter) {
2644
2650
backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, simple);
2645
2651
fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
2671
2677
MpegEncContext * const s = &h->s;
2672
2678
const int mb_xy= h->mb_xy;
2673
2679
const int mb_type= s->current_picture.mb_type[mb_xy];
2674
int is_complex = FRAME_MBAFF || MB_FIELD || IS_INTRA_PCM(mb_type) || s->codec_id != CODEC_ID_H264 ||
2675
(ENABLE_GRAY && (s->flags&CODEC_FLAG_GRAY)) || (ENABLE_H264_ENCODER && s->encoding) || ENABLE_SMALL;
2680
int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
2676
2681
2677
if(ENABLE_H264_ENCODER && !s->decode)
2682
if(CONFIG_H264_ENCODER && !s->decode)
2678
2683
return;
2679
2684
2680
2685
if (is_complex)
2848
2853
int pred= h->curr_pic_num;
2849
2854
2850
2855
for(index=0; ; index++){
2851
unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
2856
unsigned int reordering_of_pic_nums_idc= get_ue_golomb_31(&s->gb);
2852
2857
unsigned int pic_id;
2853
2858
int i;
2854
2859
Picture *ref = NULL;
3414
3419
}else{
3415
3420
if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag
3416
3421
for(i= 0; i<MAX_MMCO_COUNT; i++) {
3417
MMCOOpcode opcode= get_ue_golomb(gb);
3422
MMCOOpcode opcode= get_ue_golomb_31(gb);
3418
3423
3419
3424
h->mmco[i].opcode= opcode;
3420
3425
if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
3425
3430
}*/
3426
3431
}
3427
3432
if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
3428
unsigned int long_arg= get_ue_golomb(gb);
3433
unsigned int long_arg= get_ue_golomb_31(gb);
3429
3434
if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){
3430
3435
av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
3431
3436
return -1;
3631
3636
unsigned int first_mb_in_slice;
3632
3637
unsigned int pps_id;
3633
3638
int num_ref_idx_active_override_flag;
3634
static const uint8_t slice_type_map[5]= {FF_P_TYPE, FF_B_TYPE, FF_I_TYPE, FF_SP_TYPE, FF_SI_TYPE};
3635
3639
unsigned int slice_type, tmp, i, j;
3636
3640
int default_ref_list_done = 0;
3637
3641
int last_pic_structure;
3654
3658
s->current_picture_ptr= NULL;
3655
3659
}
3656
3660
3657
slice_type= get_ue_golomb(&s->gb);
3661
slice_type= get_ue_golomb_31(&s->gb);
3658
3662
if(slice_type > 9){
3659
3663
av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
3660
3664
return -1;
3665
3669
}else
3666
3670
h->slice_type_fixed=0;
3667
3671
3668
slice_type= slice_type_map[ slice_type ];
3672
slice_type= golomb_to_pict_type[ slice_type ];
3669
3673
if (slice_type == FF_I_TYPE
3670
3674
|| (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
3671
3675
default_ref_list_done = 1;
3719
3723
if(h != h0)
3720
3724
return -1; // width / height changed during parallelized decoding
3721
3725
free_tables(h);
3726
flush_dpb(s->avctx);
3722
3727
MPV_common_end(s);
3723
3728
}
3724
3729
if (!s->context_initialized) {
3947
3952
direct_ref_list_init(h);
3948
3953
3949
3954
if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){
3950
tmp = get_ue_golomb(&s->gb);
3955
tmp = get_ue_golomb_31(&s->gb);
3951
3956
if(tmp > 2){
3952
3957
av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
3953
3958
return -1;
3976
3981
h->slice_alpha_c0_offset = 0;
3977
3982
h->slice_beta_offset = 0;
3978
3983
if( h->pps.deblocking_filter_parameters_present ) {
3979
tmp= get_ue_golomb(&s->gb);
3984
tmp= get_ue_golomb_31(&s->gb);
3980
3985
if(tmp > 2){
3981
3986
av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
3982
3987
return -1;
4041
4046
h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
4042
4047
h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
4043
4048
4049
s->avctx->refs= h->sps.ref_frame_count;
4050
4044
4051
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4045
4052
av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
4046
4053
h->slice_num,
4085
4092
}
4086
4093
4087
4094
static inline int get_dct8x8_allowed(H264Context *h){
4088
int i;
4089
for(i=0; i<4; i++){
4090
if(!IS_SUB_8X8(h->sub_mb_type[i])
4091
|| (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))
4092
return 0;
4093
}
4094
return 1;
4095
if(h->sps.direct_8x8_inference_flag)
4096
return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8 )*0x0001000100010001ULL));
4097
else
4098
return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8|MB_TYPE_DIRECT2)*0x0001000100010001ULL));
4095
4099
}
4096
4100
4097
4101
/**
4138
4142
tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
4139
4143
assert(total_coeff<=16);
4140
4144
4141
for(i=0; i<trailing_ones; i++){
4142
level[i]= 1 - 2*get_bits1(gb);
4143
}
4145
i = show_bits(gb, 3);
4146
skip_bits(gb, trailing_ones);
4147
level[0] = 1-((i&4)>>1);
4148
level[1] = 1-((i&2) );
4149
level[2] = 1-((i&1)<<1);
4144
4150
4145
if(i<total_coeff) {
4146
int level_code, mask;
4151
if(trailing_ones<total_coeff) {
4152
int mask, prefix;
4147
4153
int suffix_length = total_coeff > 10 && trailing_ones < 3;
4148
int prefix= get_level_prefix(gb);
4149
4150
//first coefficient has suffix_length equal to 0 or 1
4151
if(prefix<14){ //FIXME try to build a large unified VLC table for all this
4152
if(suffix_length)
4153
level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4154
else
4155
level_code= (prefix<<suffix_length); //part
4156
}else if(prefix==14){
4157
if(suffix_length)
4158
level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4159
else
4160
level_code= prefix + get_bits(gb, 4); //part
4161
}else{
4162
level_code= (15<<suffix_length) + get_bits(gb, prefix-3); //part
4163
if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
4164
if(prefix>=16)
4165
level_code += (1<<(prefix-3))-4096;
4166
}
4167
4168
if(trailing_ones < 3) level_code += 2;
4169
4170
suffix_length = 1;
4171
if(level_code > 5)
4172
suffix_length++;
4173
mask= -(level_code&1);
4174
level[i]= (((2+level_code)>>1) ^ mask) - mask;
4175
i++;
4176
4177
//remaining coefficients have suffix_length > 0
4178
for(;i<total_coeff;i++) {
4179
static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };
4180
prefix = get_level_prefix(gb);
4181
if(prefix<15){
4182
level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
4154
int bitsi= show_bits(gb, LEVEL_TAB_BITS);
4155
int level_code= cavlc_level_tab[suffix_length][bitsi][0];
4156
4157
skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
4158
if(level_code >= 100){
4159
prefix= level_code - 100;
4160
if(prefix == LEVEL_TAB_BITS)
4161
prefix += get_level_prefix(gb);
4162
4163
//first coefficient has suffix_length equal to 0 or 1
4164
if(prefix<14){ //FIXME try to build a large unified VLC table for all this
4165
if(suffix_length)
4166
level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4167
else
4168
level_code= (prefix<<suffix_length); //part
4169
}else if(prefix==14){
4170
if(suffix_length)
4171
level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4172
else
4173
level_code= prefix + get_bits(gb, 4); //part
4183
4174
}else{
4184
level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
4175
level_code= (15<<suffix_length) + get_bits(gb, prefix-3); //part
4176
if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
4185
4177
if(prefix>=16)
4186
4178
level_code += (1<<(prefix-3))-4096;
4187
4179
}
4180
4181
if(trailing_ones < 3) level_code += 2;
4182
4183
suffix_length = 2;
4188
4184
mask= -(level_code&1);
4189
level[i]= (((2+level_code)>>1) ^ mask) - mask;
4190
if(level_code > suffix_limit[suffix_length])
4185
level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
4186
}else{
4187
if(trailing_ones < 3) level_code += (level_code>>31)|1;
4188
4189
suffix_length = 1;
4190
if(level_code + 3U > 6U)
4191
suffix_length++;
4192
level[trailing_ones]= level_code;
4193
}
4194
4195
//remaining coefficients have suffix_length > 0
4196
for(i=trailing_ones+1;i<total_coeff;i++) {
4197
static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
4198
int bitsi= show_bits(gb, LEVEL_TAB_BITS);
4199
level_code= cavlc_level_tab[suffix_length][bitsi][0];
4200
4201
skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
4202
if(level_code >= 100){
4203
prefix= level_code - 100;
4204
if(prefix == LEVEL_TAB_BITS){
4205
prefix += get_level_prefix(gb);
4206
}
4207
if(prefix<15){
4208
level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
4209
}else{
4210
level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
4211
if(prefix>=16)
4212
level_code += (1<<(prefix-3))-4096;
4213
}
4214
mask= -(level_code&1);
4215
level_code= (((2+level_code)>>1) ^ mask) - mask;
4216
}
4217
level[i]= level_code;
4218
4219
if(suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length])
4191
4220
suffix_length++;
4192
4221
}
4193
4222
}
4310
4339
4311
4340
mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
4312
4341
4313
s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?
4314
4315
4342
tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
4316
4343
cbp = 0; /* avoid warning. FIXME: find a solution without slowing
4317
4344
down the code */
4436
4463
return -1;
4437
4464
}
4438
4465
if(CHROMA){
4439
pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb));
4466
pred_mode= check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));
4440
4467
if(pred_mode < 0)
4441
4468
return -1;
4442
4469
h->chroma_pred_mode= pred_mode;
4446
4473
4447
4474
if(h->slice_type_nos == FF_B_TYPE){
4448
4475
for(i=0; i<4; i++){
4449
h->sub_mb_type[i]= get_ue_golomb(&s->gb);
4476
h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
4450
4477
if(h->sub_mb_type[i] >=13){
4451
4478
av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
4452
4479
return -1;
4465
4492
}else{
4466
4493
assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
4467
4494
for(i=0; i<4; i++){
4468
h->sub_mb_type[i]= get_ue_golomb(&s->gb);
4495
h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
4469
4496
if(h->sub_mb_type[i] >=4){
4470
4497
av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
4471
4498
return -1;
4480
4507
for(i=0; i<4; i++){
4481
4508
if(IS_DIRECT(h->sub_mb_type[i])) continue;
4482
4509
if(IS_DIR(h->sub_mb_type[i], 0, list)){
4483
unsigned int tmp = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
4484
if(tmp>=ref_count){
4485
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
4486
return -1;
4510
unsigned int tmp;
4511
if(ref_count == 1){
4512
tmp= 0;
4513
}else if(ref_count == 2){
4514
tmp= get_bits1(&s->gb)^1;
4515
}else{
4516
tmp= get_ue_golomb_31(&s->gb);
4517
if(tmp>=ref_count){
4518
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
4519
return -1;
4520
}
4487
4521
}
4488
4522
ref[list][i]= tmp;
4489
4523
}else{
4549
4583
for(list=0; list<h->list_count; list++){
4550
4584
unsigned int val;
4551
4585
if(IS_DIR(mb_type, 0, list)){
4552
val= get_te0_golomb(&s->gb, h->ref_count[list]);
4553
if(val >= h->ref_count[list]){
4554
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
4555
return -1;
4586
if(h->ref_count[list]==1){
4587
val= 0;
4588
}else if(h->ref_count[list]==2){
4589
val= get_bits1(&s->gb)^1;
4590
}else{
4591
val= get_ue_golomb_31(&s->gb);
4592
if(val >= h->ref_count[list]){
4593
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
4594
return -1;
4595
}
4556
4596
}
4557
4597
}else
4558
4598
val= LIST_NOT_USED&0xFF;
4577
4617
for(i=0; i<2; i++){
4578
4618
unsigned int val;
4579
4619
if(IS_DIR(mb_type, i, list)){
4580
val= get_te0_golomb(&s->gb, h->ref_count[list]);
4581
if(val >= h->ref_count[list]){
4582
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
4583
return -1;
4620
if(h->ref_count[list] == 1){
4621
val= 0;
4622
}else if(h->ref_count[list] == 2){
4623
val= get_bits1(&s->gb)^1;
4624
}else{
4625
val= get_ue_golomb_31(&s->gb);
4626
if(val >= h->ref_count[list]){
4627
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
4628
return -1;
4629
}
4584
4630
}
4585
4631
}else
4586
4632
val= LIST_NOT_USED&0xFF;
4608
4654
for(i=0; i<2; i++){
4609
4655
unsigned int val;
4610
4656
if(IS_DIR(mb_type, i, list)){ //FIXME optimize
4611
val= get_te0_golomb(&s->gb, h->ref_count[list]);
4612
if(val >= h->ref_count[list]){
4613
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
4614
return -1;
4657
if(h->ref_count[list]==1){
4658
val= 0;
4659
}else if(h->ref_count[list]==2){
4660
val= get_bits1(&s->gb)^1;
4661
}else{
4662
val= get_ue_golomb_31(&s->gb);
4663
if(val >= h->ref_count[list]){
4664
av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
4665
return -1;
4666
}
4615
4667
}
4616
4668
}else
4617
4669
val= LIST_NOT_USED&0xFF;
4836
4888
return mb_type;
4837
4889
}
4838
4890
4839
static int decode_cabac_mb_type( H264Context *h ) {
4891
static int decode_cabac_mb_type_b( H264Context *h ) {
4840
4892
MpegEncContext * const s = &h->s;
4841
4893
4842
if( h->slice_type_nos == FF_I_TYPE ) {
4843
return decode_cabac_intra_mb_type(h, 3, 1);
4844
} else if( h->slice_type_nos == FF_P_TYPE ) {
4845
if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
4846
/* P-type */
4847
if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
4848
/* P_L0_D16x16, P_8x8 */
4849
return 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
4850
} else {
4851
/* P_L0_D8x16, P_L0_D16x8 */
4852
return 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
4853
}
4854
} else {
4855
return decode_cabac_intra_mb_type(h, 17, 0) + 5;
4856
}
4857
} else if( h->slice_type_nos == FF_B_TYPE ) {
4858
4894
const int mba_xy = h->left_mb_xy[0];
4859
4895
const int mbb_xy = h->top_mb_xy;
4860
4896
int ctx = 0;
4861
4897
int bits;
4898
assert(h->slice_type_nos == FF_B_TYPE);
4862
4899
4863
4900
if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
4864
4901
ctx++;
4887
4924
4888
4925
bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
4889
4926
return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
4890
} else {
4891
/* TODO SI/SP frames? */
4892
return -1;
4893
}
4894
4927
}
4895
4928
4896
4929
static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
5004
5037
return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
5005
5038
}
5006
5039
static int decode_cabac_mb_dqp( H264Context *h) {
5007
int ctx = 0;
5040
int ctx= h->last_qscale_diff != 0;
5008
5041
int val = 0;
5009
5042
5010
if( h->last_qscale_diff != 0 )
5011
ctx++;
5012
5013
5043
while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
5014
if( ctx < 2 )
5015
ctx = 2;
5016
else
5017
ctx = 3;
5044
ctx= 2+(ctx>>1);
5018
5045
val++;
5019
5046
if(val > 102) //prevent infinite loop
5020
5047
return INT_MIN;
5021
5048
}
5022
5049
5023
5050
if( val&0x01 )
5024
return (val + 1)/2;
5051
return (val + 1)>>1 ;
5025
5052
else
5026
return -(val + 1)/2;
5053
return -((val + 1)>>1);
5027
5054
}
5028
5055
static int decode_cabac_p_mb_sub_type( H264Context *h ) {
5029
5056
if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
5075
5102
5076
5103
while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
5077
5104
ref++;
5078
if( ctx < 4 )
5079
ctx = 4;
5080
else
5081
ctx = 5;
5105
ctx = (ctx>>2)+4;
5082
5106
if(ref >= 32 /*h->ref_list[list]*/){
5083
av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_ref\n");
5084
return 0; //FIXME we should return -1 and check the return everywhere
5107
return -1;
5085
5108
}
5086
5109
}
5087
5110
return ref;
5091
5114
int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
5092
5115
abs( h->mvd_cache[list][scan8[n] - 8][l] );
5093
5116
int ctxbase = (l == 0) ? 40 : 47;
5094
int ctx, mvd;
5095
5096
if( amvd < 3 )
5097
ctx = 0;
5098
else if( amvd > 32 )
5099
ctx = 2;
5100
else
5101
ctx = 1;
5117
int mvd;
5118
int ctx = (amvd>2) + (amvd>32);
5102
5119
5103
5120
if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
5104
5121
return 0;
5142
5159
nzb = (h-> top_cbp>>(6+idx))&0x01;
5143
5160
}
5144
5161
} else {
5145
if( cat == 4 ) {
5146
nza = h->non_zero_count_cache[scan8[16+idx] - 1];
5147
nzb = h->non_zero_count_cache[scan8[16+idx] - 8];
5148
} else {
5149
assert(cat == 1 || cat == 2);
5150
nza = h->non_zero_count_cache[scan8[idx] - 1];
5151
nzb = h->non_zero_count_cache[scan8[idx] - 8];
5152
}
5162
assert(cat == 1 || cat == 2 || cat == 4);
5163
nza = h->non_zero_count_cache[scan8[idx] - 1];
5164
nzb = h->non_zero_count_cache[scan8[idx] - 8];
5153
5165
}
5154
5166
5155
5167
if( nza > 0 )
5213
5225
uint8_t *last_coeff_ctx_base;
5214
5226
uint8_t *abs_level_m1_ctx_base;
5215
5227
5216
#ifndef ARCH_X86
5228
#if !ARCH_X86
5217
5229
#define CABAC_ON_STACK
5218
5230
#endif
5219
5231
#ifdef CABAC_ON_STACK
5231
5243
* 1-> AC 16x16 n = luma4x4idx
5232
5244
* 2-> Luma4x4 n = luma4x4idx
5233
5245
* 3-> DC Chroma n = iCbCr
5234
* 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx
5246
* 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
5235
5247
* 5-> Luma8x8 n = 4 * luma8x8idx
5236
5248
*/
5237
5249
5238
5250
/* read coded block flag */
5239
5251
if( is_dc || cat != 5 ) {
5240
5252
if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
5241
if( !is_dc ) {
5242
if( cat == 4 )
5243
h->non_zero_count_cache[scan8[16+n]] = 0;
5244
else
5245
h->non_zero_count_cache[scan8[n]] = 0;
5246
}
5253
if( !is_dc )
5254
h->non_zero_count_cache[scan8[n]] = 0;
5247
5255
5248
5256
#ifdef CABAC_ON_STACK
5249
5257
h->cabac.range = cc.range ;
5278
5286
index[coeff_count++] = last;\
5279
5287
}
5280
5288
const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
5281
#if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
5289
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
5282
5290
coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
5283
5291
} else {
5284
5292
coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
5298
5306
} else {
5299
5307
if( cat == 5 )
5300
5308
fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
5301
else if( cat == 4 )
5302
h->non_zero_count_cache[scan8[16+n]] = coeff_count;
5303
5309
else {
5304
assert( cat == 1 || cat == 2 );
5310
assert( cat == 1 || cat == 2 || cat == 4 );
5305
5311
h->non_zero_count_cache[scan8[n]] = coeff_count;
5306
5312
}
5307
5313
}
5355
5361
5356
5362
}
5357
5363
5358
#ifndef CONFIG_SMALL
5364
#if !CONFIG_SMALL
5359
5365
static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
5360
5366
decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
5361
5367
}
5366
5372
#endif
5367
5373
5368
5374
static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
5369
#ifdef CONFIG_SMALL
5375
#if CONFIG_SMALL
5370
5376
decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
5371
5377
#else
5372
5378
if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
5383
5389
if(FRAME_MBAFF){
5384
5390
const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
5385
5391
const int top_pair_xy = pair_xy - s->mb_stride;
5386
const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
5387
const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
5388
const int curr_mb_frame_flag = !MB_FIELD;
5392
const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
5393
const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
5394
const int curr_mb_field_flag = MB_FIELD;
5389
5395
const int bottom = (s->mb_y & 1);
5390
if (bottom
5391
? !curr_mb_frame_flag // bottom macroblock
5392
: (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
5393
) {
5396
5397
if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
5394
5398
h->top_mb_xy -= s->mb_stride;
5395
5399
}
5396
if (left_mb_frame_flag != curr_mb_frame_flag) {
5400
if (!left_mb_field_flag == curr_mb_field_flag) {
5397
5401
h->left_mb_xy[0] = pair_xy - 1;
5398
5402
}
5399
5403
} else if (FIELD_PICTURE) {
5414
5418
5415
5419
mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
5416
5420
5417
s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)
5418
5419
5421
tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
5420
5422
if( h->slice_type_nos != FF_I_TYPE ) {
5421
5423
int skip;
5431
5433
if( FRAME_MBAFF && (s->mb_y&1)==0 ){
5432
5434
s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
5433
5435
h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
5434
if(h->next_mb_skipped)
5435
predict_field_decoding_flag(h);
5436
else
5436
if(!h->next_mb_skipped)
5437
5437
h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
5438
5438
}
5439
5439
5456
5456
h->prev_mb_skipped = 0;
5457
5457
5458
5458
compute_mb_neighbors(h);
5459
if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) {
5460
av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" );
5461
return -1;
5462
}
5463
5459
5464
5460
if( h->slice_type_nos == FF_B_TYPE ) {
5461
mb_type = decode_cabac_mb_type_b( h );
5465
5462
if( mb_type < 23 ){
5466
5463
partition_count= b_mb_type_info[mb_type].partition_count;
5467
5464
mb_type= b_mb_type_info[mb_type].type;
5470
5467
goto decode_intra_mb;
5471
5468
}
5472
5469
} else if( h->slice_type_nos == FF_P_TYPE ) {
5473
if( mb_type < 5) {
5470
if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
5471
/* P-type */
5472
if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
5473
/* P_L0_D16x16, P_8x8 */
5474
mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
5475
} else {
5476
/* P_L0_D8x16, P_L0_D16x8 */
5477
mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
5478
}
5474
5479
partition_count= p_mb_type_info[mb_type].partition_count;
5475
5480
mb_type= p_mb_type_info[mb_type].type;
5476
5481
} else {
5477
mb_type -= 5;
5482
mb_type= decode_cabac_intra_mb_type(h, 17, 0);
5478
5483
goto decode_intra_mb;
5479
5484
}
5480
5485
} else {
5486
mb_type= decode_cabac_intra_mb_type(h, 3, 1);
5481
5487
if(h->slice_type == FF_SI_TYPE && mb_type)
5482
5488
mb_type--;
5483
5489
assert(h->slice_type_nos == FF_I_TYPE);
5597
5603
for( i = 0; i < 4; i++ ) {
5598
5604
if(IS_DIRECT(h->sub_mb_type[i])) continue;
5599
5605
if(IS_DIR(h->sub_mb_type[i], 0, list)){
5600
if( h->ref_count[list] > 1 )
5606
if( h->ref_count[list] > 1 ){
5601
5607
ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
5602
else
5608
if(ref[list][i] >= (unsigned)h->ref_count[list]){
5609
av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
5610
return -1;
5611
}
5612
}else
5603
5613
ref[list][i] = 0;
5604
5614
} else {
5605
5615
ref[list][i] = -1;
5682
5692
if(IS_16X16(mb_type)){
5683
5693
for(list=0; list<h->list_count; list++){
5684
5694
if(IS_DIR(mb_type, 0, list)){
5685
const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;
5695
int ref;
5696
if(h->ref_count[list] > 1){
5697
ref= decode_cabac_mb_ref(h, list, 0);
5698
if(ref >= (unsigned)h->ref_count[list]){
5699
av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
5700
return -1;
5701
}
5702
}else
5703
ref=0;
5686
5704
fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
5687
5705
}else
5688
5706
fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too
5705
5723
for(list=0; list<h->list_count; list++){
5706
5724
for(i=0; i<2; i++){
5707
5725
if(IS_DIR(mb_type, i, list)){
5708
const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;
5726
int ref;
5727
if(h->ref_count[list] > 1){
5728
ref= decode_cabac_mb_ref( h, list, 8*i );
5729
if(ref >= (unsigned)h->ref_count[list]){
5730
av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
5731
return -1;
5732
}
5733
}else
5734
ref=0;
5709
5735
fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
5710
5736
}else
5711
5737
fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
5732
5758
for(list=0; list<h->list_count; list++){
5733
5759
for(i=0; i<2; i++){
5734
5760
if(IS_DIR(mb_type, i, list)){ //FIXME optimize
5735
const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;
5761
int ref;
5762
if(h->ref_count[list] > 1){
5763
ref= decode_cabac_mb_ref( h, list, 4*i );
5764
if(ref >= (unsigned)h->ref_count[list]){
5765
av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
5766
return -1;
5767
}
5768
}else
5769
ref=0;
5736
5770
fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
5737
5771
}else
5738
5772
fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
5857
5891
for( i = 0; i < 4; i++ ) {
5858
5892
const int index = 16 + 4 * c + i;
5859
5893
//av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
5860
decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, qmul, 15);
5894
decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
5861
5895
}
5862
5896
}
5863
5897
} else {
5886
5920
5887
5921
5888
5922
static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
5889
int i, d;
5890
5923
const int index_a = qp + h->slice_alpha_c0_offset;
5891
5924
const int alpha = (alpha_table+52)[index_a];
5892
5925
const int beta = (beta_table+52)[qp + h->slice_beta_offset];
5893
5926
5894
5927
if( bS[0] < 4 ) {
5895
5928
int8_t tc[4];
5896
for(i=0; i<4; i++)
5897
tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;
5929
tc[0] = (tc0_table+52)[index_a][bS[0]];
5930
tc[1] = (tc0_table+52)[index_a][bS[1]];
5931
tc[2] = (tc0_table+52)[index_a][bS[2]];
5932
tc[3] = (tc0_table+52)[index_a][bS[3]];
5898
5933
h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
5899
5934
} else {
5900
/* 16px edge length, because bS=4 is triggered by being at
5901
* the edge of an intra MB, so all 4 bS are the same */
5902
for( d = 0; d < 16; d++ ) {
5903
const int p0 = pix[-1];
5904
const int p1 = pix[-2];
5905
const int p2 = pix[-3];
5906
5907
const int q0 = pix[0];
5908
const int q1 = pix[1];
5909
const int q2 = pix[2];
5910
5911
if( FFABS( p0 - q0 ) < alpha &&
5912
FFABS( p1 - p0 ) < beta &&
5913
FFABS( q1 - q0 ) < beta ) {
5914
5915
if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
5916
if( FFABS( p2 - p0 ) < beta)
5917
{
5918
const int p3 = pix[-4];
5919
/* p0', p1', p2' */
5920
pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
5921
pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
5922
pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
5923
} else {
5924
/* p0' */
5925
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
5926
}
5927
if( FFABS( q2 - q0 ) < beta)
5928
{
5929
const int q3 = pix[3];
5930
/* q0', q1', q2' */
5931
pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
5932
pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
5933
pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
5934
} else {
5935
/* q0' */
5936
pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
5937
}
5938
}else{
5939
/* p0', q0' */
5940
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
5941
pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
5942
}
5943
tprintf(h->s.avctx, "filter_mb_edgev i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, p2, p1, p0, q0, q1, q2, pix[-2], pix[-1], pix[0], pix[1]);
5944
}
5945
pix += stride;
5946
}
5935
h->s.dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
5947
5936
}
5948
5937
}
5949
5938
static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
5950
int i;
5951
5939
const int index_a = qp + h->slice_alpha_c0_offset;
5952
5940
const int alpha = (alpha_table+52)[index_a];
5953
5941
const int beta = (beta_table+52)[qp + h->slice_beta_offset];
5954
5942
5955
5943
if( bS[0] < 4 ) {
5956
5944
int8_t tc[4];
5957
for(i=0; i<4; i++)
5958
tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
5945
tc[0] = (tc0_table+52)[index_a][bS[0]]+1;
5946
tc[1] = (tc0_table+52)[index_a][bS[1]]+1;
5947
tc[2] = (tc0_table+52)[index_a][bS[2]]+1;
5948
tc[3] = (tc0_table+52)[index_a][bS[3]]+1;
5959
5949
h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
5960
5950
} else {
5961
5951
h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
5986
5976
beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];
5987
5977
5988
5978
if( bS[bS_index] < 4 ) {
5989
const int tc0 = (tc0_table+52)[index_a][bS[bS_index] - 1];
5979
const int tc0 = (tc0_table+52)[index_a][bS[bS_index]];
5990
5980
const int p0 = pix[-1];
5991
5981
const int p1 = pix[-2];
5992
5982
const int p2 = pix[-3];
6080
6070
beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];
6081
6071
6082
6072
if( bS[bS_index] < 4 ) {
6083
const int tc = (tc0_table+52)[index_a][bS[bS_index] - 1] + 1;
6073
const int tc = (tc0_table+52)[index_a][bS[bS_index]] + 1;
6084
6074
const int p0 = pix[-1];
6085
6075
const int p1 = pix[-2];
6086
6076
const int q0 = pix[0];
6114
6104
}
6115
6105
6116
6106
static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6117
int i, d;
6118
6107
const int index_a = qp + h->slice_alpha_c0_offset;
6119
6108
const int alpha = (alpha_table+52)[index_a];
6120
6109
const int beta = (beta_table+52)[qp + h->slice_beta_offset];
6121
const int pix_next = stride;
6122
6110
6123
6111
if( bS[0] < 4 ) {
6124
6112
int8_t tc[4];
6125
for(i=0; i<4; i++)
6126
tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;
6113
tc[0] = (tc0_table+52)[index_a][bS[0]];
6114
tc[1] = (tc0_table+52)[index_a][bS[1]];
6115
tc[2] = (tc0_table+52)[index_a][bS[2]];
6116
tc[3] = (tc0_table+52)[index_a][bS[3]];
6127
6117
h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
6128
6118
} else {
6129
/* 16px edge length, see filter_mb_edgev */
6130
for( d = 0; d < 16; d++ ) {
6131
const int p0 = pix[-1*pix_next];
6132
const int p1 = pix[-2*pix_next];
6133
const int p2 = pix[-3*pix_next];
6134
const int q0 = pix[0];
6135
const int q1 = pix[1*pix_next];
6136
const int q2 = pix[2*pix_next];
6137
6138
if( FFABS( p0 - q0 ) < alpha &&
6139
FFABS( p1 - p0 ) < beta &&
6140
FFABS( q1 - q0 ) < beta ) {
6141
6142
const int p3 = pix[-4*pix_next];
6143
const int q3 = pix[ 3*pix_next];
6144
6145
if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6146
if( FFABS( p2 - p0 ) < beta) {
6147
/* p0', p1', p2' */
6148
pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6149
pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6150
pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6151
} else {
6152
/* p0' */
6153
pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6154
}
6155
if( FFABS( q2 - q0 ) < beta) {
6156
/* q0', q1', q2' */
6157
pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6158
pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6159
pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6160
} else {
6161
/* q0' */
6162
pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6163
}
6164
}else{
6165
/* p0', q0' */
6166
pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6167
pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6168
}
6169
tprintf(h->s.avctx, "filter_mb_edgeh i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, bS[i], p2, p1, p0, q0, q1, q2, pix[-2*pix_next], pix[-pix_next], pix[0], pix[pix_next]);
6170
}
6171
pix++;
6172
}
6119
h->s.dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta);
6173
6120
}
6174
6121
}
6175
6122
6176
6123
static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6177
int i;
6178
6124
const int index_a = qp + h->slice_alpha_c0_offset;
6179
6125
const int alpha = (alpha_table+52)[index_a];
6180
6126
const int beta = (beta_table+52)[qp + h->slice_beta_offset];
6181
6127
6182
6128
if( bS[0] < 4 ) {
6183
6129
int8_t tc[4];
6184
for(i=0; i<4; i++)
6185
tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
6130
tc[0] = (tc0_table+52)[index_a][bS[0]]+1;
6131
tc[1] = (tc0_table+52)[index_a][bS[1]]+1;
6132
tc[2] = (tc0_table+52)[index_a][bS[2]]+1;
6133
tc[3] = (tc0_table+52)[index_a][bS[3]]+1;
6186
6134
h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
6187
6135
} else {
6188
6136
h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
6198
6146
mb_xy = h->mb_xy;
6199
6147
6200
6148
if(mb_x==0 || mb_y==mb_y_firstrow || !s->dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff ||
6201
1 ||
6149
!(s->flags2 & CODEC_FLAG2_FAST) || //FIXME filter_mb_fast is broken, thus hasto be, but should not under CODEC_FLAG2_FAST
6202
6150
(h->deblocking_filter == 2 && (h->slice_table[mb_xy] != h->slice_table[h->top_mb_xy] ||
6203
6151
h->slice_table[mb_xy] != h->slice_table[mb_xy - 1]))) {
6204
6152
filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
6303
6251
}
6304
6252
}
6305
6253
6254
6255
static void av_always_inline filter_mb_dir(H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int mb_xy, int mb_type, int mvy_limit, int first_vertical_edge_done, int dir) {
6256
MpegEncContext * const s = &h->s;
6257
int edge;
6258
const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
6259
const int mbm_type = s->current_picture.mb_type[mbm_xy];
6260
int (*ref2frm) [64] = h->ref2frm[ h->slice_num &(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
6261
int (*ref2frmm)[64] = h->ref2frm[ h->slice_table[mbm_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
6262
int start = h->slice_table[mbm_xy] == 0xFFFF ? 1 : 0;
6263
6264
const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))
6265
== (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
6266
// how often to recheck mv-based bS when iterating between edges
6267
const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
6268
(mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
6269
// how often to recheck mv-based bS when iterating along each edge
6270
const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
6271
6272
if (first_vertical_edge_done) {
6273
start = 1;
6274
}
6275
6276
if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
6277
start = 1;
6278
6279
if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0
6280
&& !IS_INTERLACED(mb_type)
6281
&& IS_INTERLACED(mbm_type)
6282
) {
6283
// This is a special case in the norm where the filtering must
6284
// be done twice (one each of the field) even if we are in a
6285
// frame macroblock.
6286
//
6287
static const int nnz_idx[4] = {4,5,6,3};
6288
unsigned int tmp_linesize = 2 * linesize;
6289
unsigned int tmp_uvlinesize = 2 * uvlinesize;
6290
int mbn_xy = mb_xy - 2 * s->mb_stride;
6291
int qp;
6292
int i, j;
6293
int16_t bS[4];
6294
6295
for(j=0; j<2; j++, mbn_xy += s->mb_stride){
6296
if( IS_INTRA(mb_type) ||
6297
IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
6298
bS[0] = bS[1] = bS[2] = bS[3] = 3;
6299
} else {
6300
const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy];
6301
for( i = 0; i < 4; i++ ) {
6302
if( h->non_zero_count_cache[scan8[0]+i] != 0 ||
6303
mbn_nnz[nnz_idx[i]] != 0 )
6304
bS[i] = 2;
6305
else
6306
bS[i] = 1;
6307
}
6308
}
6309
// Do not use s->qscale as luma quantizer because it has not the same
6310
// value in IPCM macroblocks.
6311
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6312
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
6313
{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
6314
filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp );
6315
filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS,
6316
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6317
filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS,
6318
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6319
}
6320
6321
start = 1;
6322
}
6323
6324
/* Calculate bS */
6325
for( edge = start; edge < edges; edge++ ) {
6326
/* mbn_xy: neighbor macroblock */
6327
const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
6328
const int mbn_type = s->current_picture.mb_type[mbn_xy];
6329
int (*ref2frmn)[64] = edge > 0 ? ref2frm : ref2frmm;
6330
int16_t bS[4];
6331
int qp;
6332
6333
if( (edge&1) && IS_8x8DCT(mb_type) )
6334
continue;
6335
6336
if( IS_INTRA(mb_type) ||
6337
IS_INTRA(mbn_type) ) {
6338
int value;
6339
if (edge == 0) {
6340
if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
6341
|| ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
6342
) {
6343
value = 4;
6344
} else {
6345
value = 3;
6346
}
6347
} else {
6348
value = 3;
6349
}
6350
bS[0] = bS[1] = bS[2] = bS[3] = value;
6351
} else {
6352
int i, l;
6353
int mv_done;
6354
6355
if( edge & mask_edge ) {
6356
bS[0] = bS[1] = bS[2] = bS[3] = 0;
6357
mv_done = 1;
6358
}
6359
else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {
6360
bS[0] = bS[1] = bS[2] = bS[3] = 1;
6361
mv_done = 1;
6362
}
6363
else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
6364
int b_idx= 8 + 4 + edge * (dir ? 8:1);
6365
int bn_idx= b_idx - (dir ? 8:1);
6366
int v = 0;
6367
6368
for( l = 0; !v && l < 1 + (h->slice_type_nos == FF_B_TYPE); l++ ) {
6369
v |= ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[l][h->ref_cache[l][bn_idx]] ||
6370
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6371
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;
6372
}
6373
6374
if(h->slice_type_nos == FF_B_TYPE && v){
6375
v=0;
6376
for( l = 0; !v && l < 2; l++ ) {
6377
int ln= 1-l;
6378
v |= ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[ln][h->ref_cache[ln][bn_idx]] ||
6379
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] ) >= 4 ||
6380
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit;
6381
}
6382
}
6383
6384
bS[0] = bS[1] = bS[2] = bS[3] = v;
6385
mv_done = 1;
6386
}
6387
else
6388
mv_done = 0;
6389
6390
for( i = 0; i < 4; i++ ) {
6391
int x = dir == 0 ? edge : i;
6392
int y = dir == 0 ? i : edge;
6393
int b_idx= 8 + 4 + x + 8*y;
6394
int bn_idx= b_idx - (dir ? 8:1);
6395
6396
if( h->non_zero_count_cache[b_idx] |
6397
h->non_zero_count_cache[bn_idx] ) {
6398
bS[i] = 2;
6399
}
6400
else if(!mv_done)
6401
{
6402
bS[i] = 0;
6403
for( l = 0; l < 1 + (h->slice_type_nos == FF_B_TYPE); l++ ) {
6404
if( ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[l][h->ref_cache[l][bn_idx]] ||
6405
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6406
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {
6407
bS[i] = 1;
6408
break;
6409
}
6410
}
6411
6412
if(h->slice_type_nos == FF_B_TYPE && bS[i]){
6413
bS[i] = 0;
6414
for( l = 0; l < 2; l++ ) {
6415
int ln= 1-l;
6416
if( ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[ln][h->ref_cache[ln][bn_idx]] ||
6417
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] ) >= 4 ||
6418
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit ) {
6419
bS[i] = 1;
6420
break;
6421
}
6422
}
6423
}
6424
}
6425
}
6426
6427
if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
6428
continue;
6429
}
6430
6431
/* Filter edge */
6432
// Do not use s->qscale as luma quantizer because it has not the same
6433
// value in IPCM macroblocks.
6434
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6435
//tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]);
6436
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
6437
{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
6438
if( dir == 0 ) {
6439
filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
6440
if( (edge&1) == 0 ) {
6441
filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS,
6442
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6443
filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS,
6444
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6445
}
6446
} else {
6447
filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
6448
if( (edge&1) == 0 ) {
6449
filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS,
6450
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6451
filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS,
6452
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6453
}
6454
}
6455
}
6456
}
6457
6306
6458
static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {
6307
6459
MpegEncContext * const s = &h->s;
6308
6460
const int mb_xy= mb_x + mb_y*s->mb_stride;
6347
6499
6348
6500
if(IS_8x8DCT(mb_type)){
6349
6501
h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=
6350
h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp_table[mb_xy] & 1;
6502
h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp & 1;
6351
6503
6352
6504
h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
6353
h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp_table[mb_xy] & 2;
6505
h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
6354
6506
6355
6507
h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
6356
h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp_table[mb_xy] & 4;
6508
h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
6357
6509
6358
6510
h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
6359
h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp_table[mb_xy] & 8;
6511
h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
6360
6512
}
6361
6513
}
6362
6514
6420
6572
filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, bqp );
6421
6573
filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, rqp );
6422
6574
}
6423
/* dir : 0 -> vertical edge, 1 -> horizontal edge */
6575
6576
#if CONFIG_SMALL
6424
6577
for( dir = 0; dir < 2; dir++ )
6425
{
6426
int edge;
6427
const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
6428
const int mbm_type = s->current_picture.mb_type[mbm_xy];
6429
int (*ref2frm) [64] = h->ref2frm[ h->slice_num &(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
6430
int (*ref2frmm)[64] = h->ref2frm[ h->slice_table[mbm_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
6431
int start = h->slice_table[mbm_xy] == 0xFFFF ? 1 : 0;
6432
6433
const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))
6434
== (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
6435
// how often to recheck mv-based bS when iterating between edges
6436
const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
6437
(mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
6438
// how often to recheck mv-based bS when iterating along each edge
6439
const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
6440
6441
if (first_vertical_edge_done) {
6442
start = 1;
6443
first_vertical_edge_done = 0;
6444
}
6445
6446
if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
6447
start = 1;
6448
6449
if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0
6450
&& !IS_INTERLACED(mb_type)
6451
&& IS_INTERLACED(mbm_type)
6452
) {
6453
// This is a special case in the norm where the filtering must
6454
// be done twice (one each of the field) even if we are in a
6455
// frame macroblock.
6456
//
6457
static const int nnz_idx[4] = {4,5,6,3};
6458
unsigned int tmp_linesize = 2 * linesize;
6459
unsigned int tmp_uvlinesize = 2 * uvlinesize;
6460
int mbn_xy = mb_xy - 2 * s->mb_stride;
6461
int qp;
6462
int i, j;
6463
int16_t bS[4];
6464
6465
for(j=0; j<2; j++, mbn_xy += s->mb_stride){
6466
if( IS_INTRA(mb_type) ||
6467
IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
6468
bS[0] = bS[1] = bS[2] = bS[3] = 3;
6469
} else {
6470
const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy];
6471
for( i = 0; i < 4; i++ ) {
6472
if( h->non_zero_count_cache[scan8[0]+i] != 0 ||
6473
mbn_nnz[nnz_idx[i]] != 0 )
6474
bS[i] = 2;
6475
else
6476
bS[i] = 1;
6477
}
6478
}
6479
// Do not use s->qscale as luma quantizer because it has not the same
6480
// value in IPCM macroblocks.
6481
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6482
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
6483
{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
6484
filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp );
6485
filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS,
6486
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6487
filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS,
6488
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6489
}
6490
6491
start = 1;
6492
}
6493
6494
/* Calculate bS */
6495
for( edge = start; edge < edges; edge++ ) {
6496
/* mbn_xy: neighbor macroblock */
6497
const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
6498
const int mbn_type = s->current_picture.mb_type[mbn_xy];
6499
int (*ref2frmn)[64] = edge > 0 ? ref2frm : ref2frmm;
6500
int16_t bS[4];
6501
int qp;
6502
6503
if( (edge&1) && IS_8x8DCT(mb_type) )
6504
continue;
6505
6506
if( IS_INTRA(mb_type) ||
6507
IS_INTRA(mbn_type) ) {
6508
int value;
6509
if (edge == 0) {
6510
if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
6511
|| ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
6512
) {
6513
value = 4;
6514
} else {
6515
value = 3;
6516
}
6517
} else {
6518
value = 3;
6519
}
6520
bS[0] = bS[1] = bS[2] = bS[3] = value;
6521
} else {
6522
int i, l;
6523
int mv_done;
6524
6525
if( edge & mask_edge ) {
6526
bS[0] = bS[1] = bS[2] = bS[3] = 0;
6527
mv_done = 1;
6528
}
6529
else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {
6530
bS[0] = bS[1] = bS[2] = bS[3] = 1;
6531
mv_done = 1;
6532
}
6533
else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
6534
int b_idx= 8 + 4 + edge * (dir ? 8:1);
6535
int bn_idx= b_idx - (dir ? 8:1);
6536
int v = 0;
6537
6538
for( l = 0; !v && l < 1 + (h->slice_type_nos == FF_B_TYPE); l++ ) {
6539
v |= ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[l][h->ref_cache[l][bn_idx]] ||
6540
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6541
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;
6542
}
6543
6544
if(h->slice_type_nos == FF_B_TYPE && v){
6545
v=0;
6546
for( l = 0; !v && l < 2; l++ ) {
6547
int ln= 1-l;
6548
v |= ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[ln][h->ref_cache[ln][bn_idx]] ||
6549
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] ) >= 4 ||
6550
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit;
6551
}
6552
}
6553
6554
bS[0] = bS[1] = bS[2] = bS[3] = v;
6555
mv_done = 1;
6556
}
6557
else
6558
mv_done = 0;
6559
6560
for( i = 0; i < 4; i++ ) {
6561
int x = dir == 0 ? edge : i;
6562
int y = dir == 0 ? i : edge;
6563
int b_idx= 8 + 4 + x + 8*y;
6564
int bn_idx= b_idx - (dir ? 8:1);
6565
6566
if( h->non_zero_count_cache[b_idx] != 0 ||
6567
h->non_zero_count_cache[bn_idx] != 0 ) {
6568
bS[i] = 2;
6569
}
6570
else if(!mv_done)
6571
{
6572
bS[i] = 0;
6573
for( l = 0; l < 1 + (h->slice_type_nos == FF_B_TYPE); l++ ) {
6574
if( ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[l][h->ref_cache[l][bn_idx]] ||
6575
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6576
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {
6577
bS[i] = 1;
6578
break;
6579
}
6580
}
6581
6582
if(h->slice_type_nos == FF_B_TYPE && bS[i]){
6583
bS[i] = 0;
6584
for( l = 0; l < 2; l++ ) {
6585
int ln= 1-l;
6586
if( ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[ln][h->ref_cache[ln][bn_idx]] ||
6587
FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] ) >= 4 ||
6588
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit ) {
6589
bS[i] = 1;
6590
break;
6591
}
6592
}
6593
}
6594
}
6595
}
6596
6597
if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
6598
continue;
6599
}
6600
6601
/* Filter edge */
6602
// Do not use s->qscale as luma quantizer because it has not the same
6603
// value in IPCM macroblocks.
6604
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6605
//tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]);
6606
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
6607
{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
6608
if( dir == 0 ) {
6609
filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
6610
if( (edge&1) == 0 ) {
6611
filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS,
6612
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6613
filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS,
6614
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6615
}
6616
} else {
6617
filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
6618
if( (edge&1) == 0 ) {
6619
filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS,
6620
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6621
filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS,
6622
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
6623
}
6624
}
6625
}
6626
}
6578
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, dir ? 0 : first_vertical_edge_done, dir);
6579
#else
6580
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, first_vertical_edge_done, 0);
6581
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, 0, 1);
6582
#endif
6627
6583
}
6628
6584
6629
6585
static int decode_slice(struct AVCodecContext *avctx, void *arg){
6633
6589
6634
6590
s->mb_skip_run= -1;
6635
6591
6592
h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
6593
(CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY)) || (CONFIG_H264_ENCODER && s->encoding);
6594
6636
6595
if( h->pps.cabac ) {
6637
6596
int i;
6638
6597
6669
6628
if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
6670
6629
s->mb_y++;
6671
6630
6672
if(ret>=0) ret = decode_mb_cabac(h);
6631
ret = decode_mb_cabac(h);
6673
6632
6674
6633
if(ret>=0) hl_decode_mb(h);
6675
6634
s->mb_y--;
6913
6872
return 0;
6914
6873
}
6915
6874
6916
static inline void decode_hrd_parameters(H264Context *h, SPS *sps){
6875
static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
6917
6876
MpegEncContext * const s = &h->s;
6918
6877
int cpb_count, i;
6919
cpb_count = get_ue_golomb(&s->gb) + 1;
6878
cpb_count = get_ue_golomb_31(&s->gb) + 1;
6879
6880
if(cpb_count > 32U){
6881
av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
6882
return -1;
6883
}
6884
6920
6885
get_bits(&s->gb, 4); /* bit_rate_scale */
6921
6886
get_bits(&s->gb, 4); /* cpb_size_scale */
6922
6887
for(i=0; i<cpb_count; i++){
6928
6893
sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
6929
6894
sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
6930
6895
sps->time_offset_length = get_bits(&s->gb, 5);
6896
return 0;
6931
6897
}
6932
6898
6933
6899
static inline int decode_vui_parameters(H264Context *h, SPS *sps){
6982
6948
6983
6949
sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
6984
6950
if(sps->nal_hrd_parameters_present_flag)
6985
decode_hrd_parameters(h, sps);
6951
if(decode_hrd_parameters(h, sps) < 0)
6952
return -1;
6986
6953
sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
6987
6954
if(sps->vcl_hrd_parameters_present_flag)
6988
decode_hrd_parameters(h, sps);
6955
if(decode_hrd_parameters(h, sps) < 0)
6956
return -1;
6989
6957
if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
6990
6958
get_bits1(&s->gb); /* low_delay_hrd_flag */
6991
6959
sps->pic_struct_present_flag = get_bits1(&s->gb);
6992
6960
6993
6961
sps->bitstream_restriction_flag = get_bits1(&s->gb);
6994
6962
if(sps->bitstream_restriction_flag){
6995
unsigned int num_reorder_frames;
6996
6963
get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
6997
6964
get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
6998
6965
get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
6999
6966
get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
7000
6967
get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
7001
num_reorder_frames= get_ue_golomb(&s->gb);
6968
sps->num_reorder_frames= get_ue_golomb(&s->gb);
7002
6969
get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
7003
6970
7004
if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
7005
av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames);
6971
if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
6972
av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
7006
6973
return -1;
7007
6974
}
7008
7009
sps->num_reorder_frames= num_reorder_frames;
7010
6975
}
7011
6976
7012
6977
return 0;
7056
7021
}
7057
7022
}
7058
7023
7059
/**
7060
* Returns and optionally allocates SPS / PPS structures in the supplied array 'vec'
7061
*/
7062
static void *
7063
alloc_parameter_set(H264Context *h, void **vec, const unsigned int id, const unsigned int max,
7064
const size_t size, const char *name)
7065
{
7066
if(id>=max) {
7067
av_log(h->s.avctx, AV_LOG_ERROR, "%s_id (%d) out of range\n", name, id);
7068
return NULL;
7069
}
7070
7071
if(!vec[id]) {
7072
vec[id] = av_mallocz(size);
7073
if(vec[id] == NULL)
7074
av_log(h->s.avctx, AV_LOG_ERROR, "cannot allocate memory for %s\n", name);
7075
}
7076
return vec[id];
7077
}
7078
7079
7024
static inline int decode_seq_parameter_set(H264Context *h){
7080
7025
MpegEncContext * const s = &h->s;
7081
7026
int profile_idc, level_idc;
7082
unsigned int sps_id, tmp, mb_width, mb_height;
7027
unsigned int sps_id;
7083
7028
int i;
7084
7029
SPS *sps;
7085
7030
7090
7035
get_bits1(&s->gb); //constraint_set3_flag
7091
7036
get_bits(&s->gb, 4); // reserved
7092
7037
level_idc= get_bits(&s->gb, 8);
7093
sps_id= get_ue_golomb(&s->gb);
7038
sps_id= get_ue_golomb_31(&s->gb);
7094
7039
7095
sps = alloc_parameter_set(h, (void **)h->sps_buffers, sps_id, MAX_SPS_COUNT, sizeof(SPS), "sps");
7040
if(sps_id >= MAX_SPS_COUNT) {
7041
av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
7042
return -1;
7043
}
7044
sps= av_mallocz(sizeof(SPS));
7096
7045
if(sps == NULL)
7097
7046
return -1;
7098
7047
7104
7053
sps->scaling_matrix_present = 0;
7105
7054
7106
7055
if(sps->profile_idc >= 100){ //high profile
7107
sps->chroma_format_idc= get_ue_golomb(&s->gb);
7056
sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
7108
7057
if(sps->chroma_format_idc == 3)
7109
7058
get_bits1(&s->gb); //residual_color_transform_flag
7110
7059
get_ue_golomb(&s->gb); //bit_depth_luma_minus8
7116
7065
}
7117
7066
7118
7067
sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
7119
sps->poc_type= get_ue_golomb(&s->gb);
7068
sps->poc_type= get_ue_golomb_31(&s->gb);
7120
7069
7121
7070
if(sps->poc_type == 0){ //FIXME #define
7122
7071
sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
7124
7073
sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
7125
7074
sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
7126
7075
sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
7127
tmp= get_ue_golomb(&s->gb);
7076
sps->poc_cycle_length = get_ue_golomb(&s->gb);
7128
7077
7129
if(tmp >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
7130
av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", tmp);
7131
return -1;
7078
if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
7079
av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
7080
goto fail;
7132
7081
}
7133
sps->poc_cycle_length= tmp;
7134
7082
7135
7083
for(i=0; i<sps->poc_cycle_length; i++)
7136
7084
sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
7137
7085
}else if(sps->poc_type != 2){
7138
7086
av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
7139
return -1;
7087
goto fail;
7140
7088
}
7141
7089
7142
tmp= get_ue_golomb(&s->gb);
7143
if(tmp > MAX_PICTURE_COUNT-2 || tmp >= 32){
7090
sps->ref_frame_count= get_ue_golomb_31(&s->gb);
7091
if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
7144
7092
av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
7145
return -1;
7093
goto fail;
7146
7094
}
7147
sps->ref_frame_count= tmp;
7148
7095
sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
7149
mb_width= get_ue_golomb(&s->gb) + 1;
7150
mb_height= get_ue_golomb(&s->gb) + 1;
7151
if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 ||
7152
avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){
7096
sps->mb_width = get_ue_golomb(&s->gb) + 1;
7097
sps->mb_height= get_ue_golomb(&s->gb) + 1;
7098
if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
7099
avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)){
7153
7100
av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
7154
return -1;
7101
goto fail;
7155
7102
}
7156
sps->mb_width = mb_width;
7157
sps->mb_height= mb_height;
7158
7103
7159
7104
sps->frame_mbs_only_flag= get_bits1(&s->gb);
7160
7105
if(!sps->frame_mbs_only_flag)
7205
7150
((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc]
7206
7151
);
7207
7152
}
7153
av_free(h->sps_buffers[sps_id]);
7154
h->sps_buffers[sps_id]= sps;
7208
7155
return 0;
7156
fail:
7157
av_free(sps);
7158
return -1;
7209
7159
}
7210
7160
7211
7161
static void
7218
7168
7219
7169
static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
7220
7170
MpegEncContext * const s = &h->s;
7221
unsigned int tmp, pps_id= get_ue_golomb(&s->gb);
7171
unsigned int pps_id= get_ue_golomb(&s->gb);
7222
7172
PPS *pps;
7223
7173
7224
pps = alloc_parameter_set(h, (void **)h->pps_buffers, pps_id, MAX_PPS_COUNT, sizeof(PPS), "pps");
7174
if(pps_id >= MAX_PPS_COUNT) {
7175
av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
7176
return -1;
7177
}
7178
7179
pps= av_mallocz(sizeof(PPS));
7225
7180
if(pps == NULL)
7226
7181
return -1;
7227
7228
tmp= get_ue_golomb(&s->gb);
7229
if(tmp>=MAX_SPS_COUNT || h->sps_buffers[tmp] == NULL){
7182
pps->sps_id= get_ue_golomb_31(&s->gb);
7183
if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
7230
7184
av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
7231
return -1;
7185
goto fail;
7232
7186
}
7233
pps->sps_id= tmp;
7234
7187
7235
7188
pps->cabac= get_bits1(&s->gb);
7236
7189
pps->pic_order_present= get_bits1(&s->gb);
7276
7229
pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
7277
7230
if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
7278
7231
av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
7279
pps->ref_count[0]= pps->ref_count[1]= 1;
7280
return -1;
7232
goto fail;
7281
7233
}
7282
7234
7283
7235
pps->weighted_pred= get_bits1(&s->gb);
7322
7274
);
7323
7275
}
7324
7276
7277
av_free(h->pps_buffers[pps_id]);
7278
h->pps_buffers[pps_id]= pps;
7325
7279
return 0;
7280
fail:
7281
av_free(pps);
7282
return -1;
7326
7283
}
7327
7284
7328
7285
/**
7337
7294
H264Context *hx;
7338
7295
int i;
7339
7296
7297
if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
7298
return;
7340
7299
if(context_count == 1) {
7341
7300
decode_slice(avctx, &h);
7342
7301
} else {
7464
7423
&& (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
7465
7424
&& (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=FF_B_TYPE)
7466
7425
&& (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
7467
&& avctx->skip_frame < AVDISCARD_ALL)
7468
context_count++;
7426
&& avctx->skip_frame < AVDISCARD_ALL){
7427
if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
7428
static const uint8_t start_code[] = {0x00, 0x00, 0x01};
7429
ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code));
7430
ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed );
7431
}else
7432
context_count++;
7433
}
7469
7434
break;
7470
7435
case NAL_DPA:
7471
7436
init_get_bits(&hx->s.gb, ptr, bit_length);
7660
7625
s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
7661
7626
s->current_picture_ptr->pict_type= s->pict_type;
7662
7627
7628
if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
7629
ff_vdpau_h264_set_reference_frames(s);
7630
7663
7631
if(!s->dropable) {
7664
7632
execute_ref_pic_marking(h, h->mmco, h->mmco_index);
7665
7633
h->prev_poc_msb= h->poc_msb;
7668
7636
h->prev_frame_num_offset= h->frame_num_offset;
7669
7637
h->prev_frame_num= h->frame_num;
7670
7638
7639
if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
7640
ff_vdpau_h264_picture_complete(s);
7641
7671
7642
/*
7672
7643
* FIXME: Error handling code does not seem to support interlaced
7673
7644
* when slices span multiple rows
8053
8024
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
8054
8025
};
8055
8026
8027
#if CONFIG_H264_VDPAU_DECODER
8028
AVCodec h264_vdpau_decoder = {
8029
"h264_vdpau",
8030
CODEC_TYPE_VIDEO,
8031
CODEC_ID_H264,
8032
sizeof(H264Context),
8033
decode_init,
8034
NULL,
8035
decode_end,
8036
decode_frame,
8037
CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
8038
.flush= flush_dpb,
8039
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
8040
};
8041
#endif
8042
8043
#if CONFIG_SVQ3_DECODER
8056
8044
#include "svq3.c"
8045
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1