mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-11-21 10:55:51 +02:00
Split fill_caches() between loopfilter & decode, the 2 no longer where common
enough to justify the messy interleaving. Originally committed as revision 21469 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Michael Niedermayer
parent
5a0f713118
commit
599fe45b8d
@ -729,7 +729,7 @@ static inline int get_chroma_qp(H264Context *h, int t, int qscale){
|
||||
|
||||
static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my);
|
||||
|
||||
static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deblock){
|
||||
static void fill_decode_caches(H264Context *h, int mb_type){
|
||||
MpegEncContext * const s = &h->s;
|
||||
const int mb_xy= h->mb_xy;
|
||||
int topleft_xy, top_xy, topright_xy, left_xy[2];
|
||||
@ -746,10 +746,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
|
||||
top_xy = mb_xy - (s->mb_stride << MB_FIELD);
|
||||
|
||||
//FIXME deblocking could skip the intra and nnz parts.
|
||||
// if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF)
|
||||
// return;
|
||||
|
||||
/* Wow, what a mess, why didn't they simplify the interlacing & intra
|
||||
* stuff, I can't imagine that these complex rules are worth it. */
|
||||
|
||||
@ -762,10 +758,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
const int curr_mb_field_flag = IS_INTERLACED(mb_type);
|
||||
if(s->mb_y&1){
|
||||
if (left_mb_field_flag != curr_mb_field_flag) {
|
||||
if(for_deblock){
|
||||
left_xy[0] = mb_xy - s->mb_stride - 1;
|
||||
left_xy[1] = mb_xy - 1;
|
||||
}else{
|
||||
left_xy[1] = left_xy[0] = mb_xy - s->mb_stride - 1;
|
||||
if (curr_mb_field_flag) {
|
||||
left_xy[1] += s->mb_stride;
|
||||
@ -776,7 +768,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
topleft_partition = 0;
|
||||
left_block = left_block_options[1];
|
||||
}
|
||||
}
|
||||
}
|
||||
}else{
|
||||
if(curr_mb_field_flag){
|
||||
@ -785,10 +776,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1);
|
||||
}
|
||||
if (left_mb_field_flag != curr_mb_field_flag) {
|
||||
if(for_deblock){
|
||||
left_xy[0] = mb_xy - 1;
|
||||
left_xy[1] = mb_xy + s->mb_stride - 1;
|
||||
}else{
|
||||
left_xy[1] = left_xy[0] = mb_xy - 1;
|
||||
if (curr_mb_field_flag) {
|
||||
left_xy[1] += s->mb_stride;
|
||||
@ -796,7 +783,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
} else {
|
||||
left_block = left_block_options[2];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -804,79 +790,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
h->top_mb_xy = top_xy;
|
||||
h->left_mb_xy[0] = left_xy[0];
|
||||
h->left_mb_xy[1] = left_xy[1];
|
||||
if(for_deblock){
|
||||
|
||||
//for sufficiently low qp, filtering wouldn't do anything
|
||||
//this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
|
||||
int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
|
||||
int qp = s->current_picture.qscale_table[mb_xy];
|
||||
if(qp <= qp_thresh
|
||||
&& (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
|
||||
&& (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){
|
||||
if(!FRAME_MBAFF)
|
||||
return 1;
|
||||
if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh)
|
||||
&& (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh))
|
||||
return 1;
|
||||
}
|
||||
|
||||
if(h->deblocking_filter == 2){
|
||||
h->top_type = top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
|
||||
h->left_type[0]= left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
|
||||
h->left_type[1]= left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
|
||||
}else{
|
||||
h->top_type = top_type = h->slice_table[top_xy ] < 0xFFFF ? s->current_picture.mb_type[top_xy] : 0;
|
||||
h->left_type[0]= left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;
|
||||
h->left_type[1]= left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;
|
||||
}
|
||||
if(IS_INTRA(mb_type))
|
||||
return 0;
|
||||
|
||||
AV_COPY64(&h->non_zero_count_cache[0+8*1], &h->non_zero_count[mb_xy][ 0]);
|
||||
AV_COPY64(&h->non_zero_count_cache[0+8*2], &h->non_zero_count[mb_xy][ 8]);
|
||||
*((uint32_t*)&h->non_zero_count_cache[0+8*5])= *((uint32_t*)&h->non_zero_count[mb_xy][16]);
|
||||
*((uint32_t*)&h->non_zero_count_cache[4+8*3])= *((uint32_t*)&h->non_zero_count[mb_xy][20]);
|
||||
AV_COPY64(&h->non_zero_count_cache[0+8*4], &h->non_zero_count[mb_xy][24]);
|
||||
|
||||
h->cbp= h->cbp_table[mb_xy];
|
||||
|
||||
{
|
||||
int list;
|
||||
for(list=0; list<h->list_count; list++){
|
||||
int8_t *ref;
|
||||
int y, b_stride;
|
||||
int16_t (*mv_dst)[2];
|
||||
int16_t (*mv_src)[2];
|
||||
|
||||
if(!USES_LIST(mb_type, list)){
|
||||
fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 2]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[10]] = ((LIST_NOT_USED)&0xFF)*0x01010101;
|
||||
continue;
|
||||
}
|
||||
|
||||
ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];
|
||||
{
|
||||
int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101;
|
||||
ref += h->b8_stride;
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101;
|
||||
}
|
||||
|
||||
b_stride = h->b_stride;
|
||||
mv_dst = &h->mv_cache[list][scan8[0]];
|
||||
mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
|
||||
for(y=0; y<4; y++){
|
||||
AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}else{
|
||||
topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
|
||||
top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
|
||||
topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
|
||||
@ -962,7 +875,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
@ -976,14 +888,12 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
|
||||
if(top_type){
|
||||
*(uint32_t*)&h->non_zero_count_cache[4+8*0]= *(uint32_t*)&h->non_zero_count[top_xy][4+3*8];
|
||||
if(!for_deblock){
|
||||
h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][1+1*8];
|
||||
h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][2+1*8];
|
||||
|
||||
h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][1+2*8];
|
||||
h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][2+2*8];
|
||||
}
|
||||
}else if(!for_deblock){
|
||||
}else {
|
||||
h->non_zero_count_cache[1+8*0]=
|
||||
h->non_zero_count_cache[2+8*0]=
|
||||
|
||||
@ -996,11 +906,9 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
if(left_type[i]){
|
||||
h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+0+2*i]];
|
||||
h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+1+2*i]];
|
||||
if(!for_deblock){
|
||||
h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[8+4+2*i]];
|
||||
h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[8+5+2*i]];
|
||||
}
|
||||
}else if(!for_deblock){
|
||||
}else{
|
||||
h->non_zero_count_cache[3+8*1 + 2*8*i]=
|
||||
h->non_zero_count_cache[3+8*2 + 2*8*i]=
|
||||
h->non_zero_count_cache[0+8*1 + 8*i]=
|
||||
@ -1008,39 +916,7 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
}
|
||||
}
|
||||
|
||||
// CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
|
||||
if(for_deblock && !CABAC && h->pps.transform_8x8_mode){
|
||||
if(IS_8x8DCT(top_type)){
|
||||
h->non_zero_count_cache[4+8*0]=
|
||||
h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4;
|
||||
h->non_zero_count_cache[6+8*0]=
|
||||
h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8;
|
||||
}
|
||||
if(IS_8x8DCT(left_type[0])){
|
||||
h->non_zero_count_cache[3+8*1]=
|
||||
h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF
|
||||
}
|
||||
if(IS_8x8DCT(left_type[1])){
|
||||
h->non_zero_count_cache[3+8*3]=
|
||||
h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF
|
||||
}
|
||||
|
||||
if(IS_8x8DCT(mb_type)){
|
||||
h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=
|
||||
h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp & 1;
|
||||
|
||||
h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
|
||||
h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
|
||||
|
||||
h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
|
||||
h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
|
||||
|
||||
h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
|
||||
h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
|
||||
}
|
||||
}
|
||||
|
||||
if( CABAC && !for_deblock) {
|
||||
if( CABAC ) {
|
||||
// top_cbp
|
||||
if(top_type) {
|
||||
h->top_cbp = h->cbp_table[top_xy];
|
||||
@ -1069,7 +945,7 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
|
||||
int list;
|
||||
for(list=0; list<h->list_count; list++){
|
||||
if(!for_deblock && !USES_LIST(mb_type, list) && !IS_DIRECT(mb_type)){
|
||||
if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type)){
|
||||
/*if(!h->mv_cache_clean[list]){
|
||||
memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
|
||||
memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
|
||||
@ -1083,50 +959,15 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
|
||||
const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
|
||||
AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
|
||||
if(for_deblock){
|
||||
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
|
||||
h->ref_cache[list][scan8[0] + 0 - 1*8]=
|
||||
h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
|
||||
h->ref_cache[list][scan8[0] + 2 - 1*8]=
|
||||
h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
|
||||
}else{
|
||||
h->ref_cache[list][scan8[0] + 0 - 1*8]=
|
||||
h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
|
||||
h->ref_cache[list][scan8[0] + 2 - 1*8]=
|
||||
h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
|
||||
}
|
||||
}else{
|
||||
AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= (((for_deblock||top_type) ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
|
||||
}
|
||||
|
||||
if(for_deblock){
|
||||
if(!IS_INTERLACED(mb_type^left_type[0])){
|
||||
if(USES_LIST(left_type[0], list)){
|
||||
const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
|
||||
const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
|
||||
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*0];
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 8 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*1];
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 +16 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*2];
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 +24 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*3];
|
||||
h->ref_cache[list][scan8[0] - 1 + 0 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + h->b8_stride*0]];
|
||||
h->ref_cache[list][scan8[0] - 1 +16 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + h->b8_stride*1]];
|
||||
}else{
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0 ]=
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 8 ]=
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 +16 ]=
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 +24 ]= 0;
|
||||
h->ref_cache[list][scan8[0] - 1 + 0 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 8 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 16 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}else{
|
||||
for(i=0; i<2; i++){
|
||||
int cache_idx = scan8[0] - 1 + i*2*8;
|
||||
if(USES_LIST(left_type[i], list)){
|
||||
@ -1143,7 +984,6 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
h->ref_cache[list][cache_idx+8]= (left_type[i]) ? LIST_NOT_USED : PART_NOT_AVAILABLE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF)
|
||||
continue;
|
||||
@ -1277,13 +1117,7 @@ static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deb
|
||||
}
|
||||
#endif
|
||||
|
||||
if(!for_deblock)
|
||||
h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void fill_decode_caches(H264Context *h, int mb_type){
|
||||
fill_caches(h, mb_type, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1291,7 +1125,213 @@ static void fill_decode_caches(H264Context *h, int mb_type){
|
||||
* @returns non zero if the loop filter can be skiped
|
||||
*/
|
||||
static int fill_filter_caches(H264Context *h, int mb_type){
|
||||
return fill_caches(h, mb_type, 1);
|
||||
MpegEncContext * const s = &h->s;
|
||||
const int mb_xy= h->mb_xy;
|
||||
int top_xy, left_xy[2];
|
||||
int top_type, left_type[2];
|
||||
int i;
|
||||
|
||||
top_xy = mb_xy - (s->mb_stride << MB_FIELD);
|
||||
|
||||
//FIXME deblocking could skip the intra and nnz parts.
|
||||
|
||||
/* Wow, what a mess, why didn't they simplify the interlacing & intra
|
||||
* stuff, I can't imagine that these complex rules are worth it. */
|
||||
|
||||
left_xy[1] = left_xy[0] = mb_xy-1;
|
||||
if(FRAME_MBAFF){
|
||||
const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
|
||||
const int curr_mb_field_flag = IS_INTERLACED(mb_type);
|
||||
if(s->mb_y&1){
|
||||
if (left_mb_field_flag != curr_mb_field_flag) {
|
||||
left_xy[0] = mb_xy - s->mb_stride - 1;
|
||||
left_xy[1] = mb_xy - 1;
|
||||
}
|
||||
}else{
|
||||
if(curr_mb_field_flag){
|
||||
top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1);
|
||||
}
|
||||
if (left_mb_field_flag != curr_mb_field_flag) {
|
||||
left_xy[0] = mb_xy - 1;
|
||||
left_xy[1] = mb_xy + s->mb_stride - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
h->top_mb_xy = top_xy;
|
||||
h->left_mb_xy[0] = left_xy[0];
|
||||
h->left_mb_xy[1] = left_xy[1];
|
||||
{
|
||||
//for sufficiently low qp, filtering wouldn't do anything
|
||||
//this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
|
||||
int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
|
||||
int qp = s->current_picture.qscale_table[mb_xy];
|
||||
if(qp <= qp_thresh
|
||||
&& (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
|
||||
&& (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){
|
||||
if(!FRAME_MBAFF)
|
||||
return 1;
|
||||
if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh)
|
||||
&& (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
if(h->deblocking_filter == 2){
|
||||
h->top_type = top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
|
||||
h->left_type[0]= left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
|
||||
h->left_type[1]= left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
|
||||
}else{
|
||||
h->top_type = top_type = h->slice_table[top_xy ] < 0xFFFF ? s->current_picture.mb_type[top_xy] : 0;
|
||||
h->left_type[0]= left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;
|
||||
h->left_type[1]= left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;
|
||||
}
|
||||
if(IS_INTRA(mb_type))
|
||||
return 0;
|
||||
|
||||
AV_COPY64(&h->non_zero_count_cache[0+8*1], &h->non_zero_count[mb_xy][ 0]);
|
||||
AV_COPY64(&h->non_zero_count_cache[0+8*2], &h->non_zero_count[mb_xy][ 8]);
|
||||
*((uint32_t*)&h->non_zero_count_cache[0+8*5])= *((uint32_t*)&h->non_zero_count[mb_xy][16]);
|
||||
*((uint32_t*)&h->non_zero_count_cache[4+8*3])= *((uint32_t*)&h->non_zero_count[mb_xy][20]);
|
||||
AV_COPY64(&h->non_zero_count_cache[0+8*4], &h->non_zero_count[mb_xy][24]);
|
||||
|
||||
h->cbp= h->cbp_table[mb_xy];
|
||||
|
||||
{
|
||||
int list;
|
||||
for(list=0; list<h->list_count; list++){
|
||||
int8_t *ref;
|
||||
int y, b_stride;
|
||||
int16_t (*mv_dst)[2];
|
||||
int16_t (*mv_src)[2];
|
||||
|
||||
if(!USES_LIST(mb_type, list)){
|
||||
fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 2]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[10]] = ((LIST_NOT_USED)&0xFF)*0x01010101;
|
||||
continue;
|
||||
}
|
||||
|
||||
ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];
|
||||
{
|
||||
int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101;
|
||||
ref += h->b8_stride;
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101;
|
||||
}
|
||||
|
||||
b_stride = h->b_stride;
|
||||
mv_dst = &h->mv_cache[list][scan8[0]];
|
||||
mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
|
||||
for(y=0; y<4; y++){
|
||||
AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
0 . T T. T T T T
|
||||
1 L . .L . . . .
|
||||
2 L . .L . . . .
|
||||
3 . T TL . . . .
|
||||
4 L . .L . . . .
|
||||
5 L . .. . . . .
|
||||
*/
|
||||
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
|
||||
if(top_type){
|
||||
*(uint32_t*)&h->non_zero_count_cache[4+8*0]= *(uint32_t*)&h->non_zero_count[top_xy][4+3*8];
|
||||
}
|
||||
|
||||
if(left_type[0]){
|
||||
h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][7+0*8];
|
||||
h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][7+1*8];
|
||||
h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][7+2*8];
|
||||
h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][7+3*8];
|
||||
}
|
||||
|
||||
// CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
|
||||
if(!CABAC && h->pps.transform_8x8_mode){
|
||||
if(IS_8x8DCT(top_type)){
|
||||
h->non_zero_count_cache[4+8*0]=
|
||||
h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4;
|
||||
h->non_zero_count_cache[6+8*0]=
|
||||
h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8;
|
||||
}
|
||||
if(IS_8x8DCT(left_type[0])){
|
||||
h->non_zero_count_cache[3+8*1]=
|
||||
h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF
|
||||
}
|
||||
if(IS_8x8DCT(left_type[1])){
|
||||
h->non_zero_count_cache[3+8*3]=
|
||||
h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF
|
||||
}
|
||||
|
||||
if(IS_8x8DCT(mb_type)){
|
||||
h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=
|
||||
h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp & 1;
|
||||
|
||||
h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
|
||||
h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
|
||||
|
||||
h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
|
||||
h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
|
||||
|
||||
h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
|
||||
h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
|
||||
}
|
||||
}
|
||||
|
||||
if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
|
||||
int list;
|
||||
for(list=0; list<h->list_count; list++){
|
||||
if(USES_LIST(top_type, list)){
|
||||
const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
|
||||
const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
|
||||
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
|
||||
AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
|
||||
h->ref_cache[list][scan8[0] + 0 - 1*8]=
|
||||
h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
|
||||
h->ref_cache[list][scan8[0] + 2 - 1*8]=
|
||||
h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
|
||||
}else{
|
||||
AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
|
||||
*(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((LIST_NOT_USED)&0xFF)*0x01010101;
|
||||
}
|
||||
|
||||
if(!IS_INTERLACED(mb_type^left_type[0])){
|
||||
if(USES_LIST(left_type[0], list)){
|
||||
const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
|
||||
const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
|
||||
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*0];
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 8 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*1];
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 +16 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*2];
|
||||
*(uint32_t*)h->mv_cache[list][scan8[0] - 1 +24 ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*3];
|
||||
h->ref_cache[list][scan8[0] - 1 + 0 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + h->b8_stride*0]];
|
||||
h->ref_cache[list][scan8[0] - 1 +16 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + h->b8_stride*1]];
|
||||
}else{
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0 ]=
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 8 ]=
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 +16 ]=
|
||||
*(uint32_t*)h->mv_cache [list][scan8[0] - 1 +24 ]= 0;
|
||||
h->ref_cache[list][scan8[0] - 1 + 0 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 8 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 16 ]=
|
||||
h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Loading…
Reference in New Issue
Block a user