Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

h264: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
Signed-off-by: Vittorio Giovara <vittorio.giovara@gmail.com>
pull/77/merge
Luca Barbato 11 years ago committed by Diego Biurrun
parent a11ef610ee
commit 2db953f846
3 changed files with 437 additions and 364 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 23
      libavcodec/h264.c
  2. 758
      libavcodec/h264_direct.c
  3. 20
      libavcodec/h264_slice.c

23
libavcodec/h264.c
Unescape View File

@ -501,8 +501,10 @@ int ff_h264_context_init(H264Context *h)
er->mb_stride = h->mb_stride; er->mb_stride = h->mb_stride;
er->b8_stride = h->mb_width * 2 + 1; er->b8_stride = h->mb_width * 2 + 1;
FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy, (h->mb_num + 1) * sizeof(int), // error resilience code looks cleaner with this
fail); // error ressilience code looks cleaner with this FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
(h->mb_num + 1) * sizeof(int), fail);
for (y = 0; y < h->mb_height; y++) for (y = 0; y < h->mb_height; y++)
for (x = 0; x < h->mb_width; x++) for (x = 0; x < h->mb_width; x++)
er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride; er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
@ -518,10 +520,11 @@ int ff_h264_context_init(H264Context *h)
FF_ALLOCZ_OR_GOTO(h->avctx, er->mbskip_table, mb_array_size + 2, fail); FF_ALLOCZ_OR_GOTO(h->avctx, er->mbskip_table, mb_array_size + 2, fail);
FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer, h->mb_height * h->mb_stride, FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
fail); h->mb_height * h->mb_stride, fail);
FF_ALLOCZ_OR_GOTO(h->avctx, h->dc_val_base, yc_size * sizeof(int16_t), fail); FF_ALLOCZ_OR_GOTO(h->avctx, h->dc_val_base,
yc_size * sizeof(int16_t), fail);
er->dc_val[0] = h->dc_val_base + h->mb_width * 2 + 2; er->dc_val[0] = h->dc_val_base + h->mb_width * 2 + 2;
er->dc_val[1] = h->dc_val_base + y_size + h->mb_stride + 1; er->dc_val[1] = h->dc_val_base + y_size + h->mb_stride + 1;
er->dc_val[2] = er->dc_val[1] + c_size; er->dc_val[2] = er->dc_val[1] + c_size;
@ -586,7 +589,7 @@ int ff_h264_decode_extradata(H264Context *h)
} }
p += nalsize; p += nalsize;
} }
// Now store right nal length size, that will be used to parse all other nals // Store right nal length size that will be used to parse all other nals
h->nal_length_size = (avctx->extradata[4] & 0x03) + 1; h->nal_length_size = (avctx->extradata[4] & 0x03) + 1;
} else { } else {
h->is_avc = 0; h->is_avc = 0;
@ -1037,8 +1040,8 @@ int ff_pred_weight_table(H264Context *h)
static void idr(H264Context *h) static void idr(H264Context *h)
{ {
ff_h264_remove_all_refs(h); ff_h264_remove_all_refs(h);
h->prev_frame_num = 0; h->prev_frame_num =
h->prev_frame_num_offset = 0; h->prev_frame_num_offset =
h->prev_poc_msb = h->prev_poc_msb =
h->prev_poc_lsb = 0; h->prev_poc_lsb = 0;
} }
@ -1692,9 +1695,9 @@ end:
static int get_consumed_bytes(int pos, int buf_size) static int get_consumed_bytes(int pos, int buf_size)
{ {
if (pos == 0) if (pos == 0)
pos = 1; // avoid infinite loops (i doubt that is needed but ...) pos = 1; // avoid infinite loops (I doubt that is needed but...)
if (pos + 10 > buf_size) if (pos + 10 > buf_size)
pos = buf_size; // oops ;) pos = buf_size; // oops ;)
return pos; return pos;
} }

758
libavcodec/h264_direct.c
Unescape View File

@ -34,63 +34,67 @@
#include <assert.h> #include <assert.h>
static int get_scale_factor(H264Context *const h, int poc, int poc1, int i)
static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){ {
int poc0 = h->ref_list[0][i].poc; int poc0 = h->ref_list[0][i].poc;
int td = av_clip(poc1 - poc0, -128, 127); int td = av_clip(poc1 - poc0, -128, 127);
if(td == 0 || h->ref_list[0][i].long_ref){ if (td == 0 || h->ref_list[0][i].long_ref) {
return 256; return 256;
}else{ } else {
int tb = av_clip(poc - poc0, -128, 127); int tb = av_clip(poc - poc0, -128, 127);
int tx = (16384 + (FFABS(td) >> 1)) / td; int tx = (16384 + (FFABS(td) >> 1)) / td;
return av_clip((tb*tx + 32) >> 6, -1024, 1023); return av_clip((tb * tx + 32) >> 6, -1024, 1023);
} }
} }
void ff_h264_direct_dist_scale_factor(H264Context * const h){ void ff_h264_direct_dist_scale_factor(H264Context *const h)
const int poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]; {
const int poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD];
const int poc1 = h->ref_list[1][0].poc; const int poc1 = h->ref_list[1][0].poc;
int i, field; int i, field;
if (FRAME_MBAFF(h)) if (FRAME_MBAFF(h))
for (field = 0; field < 2; field++){ for (field = 0; field < 2; field++) {
const int poc = h->cur_pic_ptr->field_poc[field]; const int poc = h->cur_pic_ptr->field_poc[field];
const int poc1 = h->ref_list[1][0].field_poc[field]; const int poc1 = h->ref_list[1][0].field_poc[field];
for (i = 0; i < 2 * h->ref_count[0]; i++) for (i = 0; i < 2 * h->ref_count[0]; i++)
h->dist_scale_factor_field[field][i^field] = h->dist_scale_factor_field[field][i ^ field] =
get_scale_factor(h, poc, poc1, i+16); get_scale_factor(h, poc, poc1, i + 16);
} }
for (i = 0; i < h->ref_count[0]; i++){ for (i = 0; i < h->ref_count[0]; i++)
h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i); h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i);
}
} }
static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){ static void fill_colmap(H264Context *h, int map[2][16 + 32], int list,
H264Picture * const ref1 = &h->ref_list[1][0]; int field, int colfield, int mbafi)
{
H264Picture *const ref1 = &h->ref_list[1][0];
int j, old_ref, rfield; int j, old_ref, rfield;
int start= mbafi ? 16 : 0; int start = mbafi ? 16 : 0;
int end = mbafi ? 16+2*h->ref_count[0] : h->ref_count[0]; int end = mbafi ? 16 + 2 * h->ref_count[0] : h->ref_count[0];
int interl= mbafi || h->picture_structure != PICT_FRAME; int interl = mbafi || h->picture_structure != PICT_FRAME;
/* bogus; fills in for missing frames */ /* bogus; fills in for missing frames */
memset(map[list], 0, sizeof(map[list])); memset(map[list], 0, sizeof(map[list]));
for(rfield=0; rfield<2; rfield++){ for (rfield = 0; rfield < 2; rfield++) {
for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){ for (old_ref = 0; old_ref < ref1->ref_count[colfield][list]; old_ref++) {
int poc = ref1->ref_poc[colfield][list][old_ref]; int poc = ref1->ref_poc[colfield][list][old_ref];
if (!interl) if (!interl)
poc |= 3; poc |= 3;
else if( interl && (poc&3) == 3) // FIXME: store all MBAFF references so this is not needed // FIXME: store all MBAFF references so this is not needed
poc= (poc&~3) + rfield + 1; else if (interl && (poc & 3) == 3)
poc = (poc & ~3) + rfield + 1;
for(j=start; j<end; j++){
if (4 * h->ref_list[0][j].frame_num + (h->ref_list[0][j].reference & 3) == poc) { for (j = start; j < end; j++) {
int cur_ref= mbafi ? (j-16)^field : j; if (4 * h->ref_list[0][j].frame_num +
(h->ref_list[0][j].reference & 3) == poc) {
int cur_ref = mbafi ? (j - 16) ^ field : j;
if (ref1->mbaff) if (ref1->mbaff)
map[list][2 * old_ref + (rfield^field) + 16] = cur_ref; map[list][2 * old_ref + (rfield ^ field) + 16] = cur_ref;
if(rfield == field || !interl) if (rfield == field || !interl)
map[list][old_ref] = cur_ref; map[list][old_ref] = cur_ref;
break; break;
} }
@ -99,65 +103,75 @@ static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field,
} }
} }
void ff_h264_direct_ref_list_init(H264Context * const h){ void ff_h264_direct_ref_list_init(H264Context *const h)
H264Picture * const ref1 = &h->ref_list[1][0]; {
H264Picture * const cur = h->cur_pic_ptr; H264Picture *const ref1 = &h->ref_list[1][0];
H264Picture *const cur = h->cur_pic_ptr;
int list, j, field; int list, j, field;
int sidx= (h->picture_structure&1)^1; int sidx = (h->picture_structure & 1) ^ 1;
int ref1sidx = (ref1->reference&1)^1; int ref1sidx = (ref1->reference & 1) ^ 1;
for(list=0; list<2; list++){ for (list = 0; list < 2; list++) {
cur->ref_count[sidx][list] = h->ref_count[list]; cur->ref_count[sidx][list] = h->ref_count[list];
for(j=0; j<h->ref_count[list]; j++) for (j = 0; j < h->ref_count[list]; j++)
cur->ref_poc[sidx][list][j] = 4 * h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference & 3); cur->ref_poc[sidx][list][j] = 4 * h->ref_list[list][j].frame_num +
(h->ref_list[list][j].reference & 3);
} }
if(h->picture_structure == PICT_FRAME){ if (h->picture_structure == PICT_FRAME) {
memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0])); memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));
memcpy(cur->ref_poc [1], cur->ref_poc [0], sizeof(cur->ref_poc [0])); memcpy(cur->ref_poc[1], cur->ref_poc[0], sizeof(cur->ref_poc[0]));
} }
cur->mbaff = FRAME_MBAFF(h); cur->mbaff = FRAME_MBAFF(h);
h->col_fieldoff= 0; h->col_fieldoff = 0;
if(h->picture_structure == PICT_FRAME){ if (h->picture_structure == PICT_FRAME) {
int cur_poc = h->cur_pic_ptr->poc; int cur_poc = h->cur_pic_ptr->poc;
int *col_poc = h->ref_list[1]->field_poc; int *col_poc = h->ref_list[1]->field_poc;
h->col_parity= (FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc)); h->col_parity = (FFABS(col_poc[0] - cur_poc) >=
ref1sidx=sidx= h->col_parity; FFABS(col_poc[1] - cur_poc));
} else if (!(h->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff) { // FL -> FL & differ parity ref1sidx =
sidx = h->col_parity;
// FL -> FL & differ parity
} else if (!(h->picture_structure & h->ref_list[1][0].reference) &&
!h->ref_list[1][0].mbaff) {
h->col_fieldoff = 2 * h->ref_list[1][0].reference - 3; h->col_fieldoff = 2 * h->ref_list[1][0].reference - 3;
} }
if (h->slice_type_nos != AV_PICTURE_TYPE_B || h->direct_spatial_mv_pred) if (h->slice_type_nos != AV_PICTURE_TYPE_B || h->direct_spatial_mv_pred)
return; return;
for(list=0; list<2; list++){ for (list = 0; list < 2; list++) {
fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0); fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);
if (FRAME_MBAFF(h)) if (FRAME_MBAFF(h))
for(field=0; field<2; field++) for (field = 0; field < 2; field++)
fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1); fill_colmap(h, h->map_col_to_list0_field[field], list, field,
field, 1);
} }
} }
static void await_reference_mb_row(H264Context * const h, H264Picture *ref, int mb_y) static void await_reference_mb_row(H264Context *const h, H264Picture *ref,
int mb_y)
{ {
int ref_field = ref->reference - 1; int ref_field = ref->reference - 1;
int ref_field_picture = ref->field_picture; int ref_field_picture = ref->field_picture;
int ref_height = 16*h->mb_height >> ref_field_picture; int ref_height = 16 * h->mb_height >> ref_field_picture;
if(!HAVE_THREADS || !(h->avctx->active_thread_type&FF_THREAD_FRAME)) if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_FRAME))
return; return;
//FIXME it can be safe to access mb stuff /* FIXME: It can be safe to access mb stuff
//even if pixels aren't deblocked yet * even if pixels aren't deblocked yet. */
ff_thread_await_progress(&ref->tf, ff_thread_await_progress(&ref->tf,
FFMIN(16 * mb_y >> ref_field_picture, ref_height - 1), FFMIN(16 * mb_y >> ref_field_picture,
ref_height - 1),
ref_field_picture && ref_field); ref_field_picture && ref_field);
} }
static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){ static void pred_spatial_direct_motion(H264Context *const h, int *mb_type)
{
int b8_stride = 2; int b8_stride = 2;
int b4_stride = h->b_stride; int b4_stride = h->b_stride;
int mb_xy = h->mb_xy, mb_y = h->mb_y; int mb_xy = h->mb_xy, mb_y = h->mb_y;
@ -165,7 +179,7 @@ static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){
const int16_t (*l1mv0)[2], (*l1mv1)[2]; const int16_t (*l1mv0)[2], (*l1mv1)[2];
const int8_t *l1ref0, *l1ref1; const int8_t *l1ref0, *l1ref1;
const int is_b8x8 = IS_8X8(*mb_type); const int is_b8x8 = IS_8X8(*mb_type);
unsigned int sub_mb_type= MB_TYPE_L0L1; unsigned int sub_mb_type = MB_TYPE_L0L1;
int i8, i4; int i8, i4;
int ref[2]; int ref[2];
int mv[2]; int mv[2];
@ -173,241 +187,276 @@ static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){
assert(h->ref_list[1][0].reference & 3); assert(h->ref_list[1][0].reference & 3);
await_reference_mb_row(h, &h->ref_list[1][0], h->mb_y + !!IS_INTERLACED(*mb_type)); await_reference_mb_row(h, &h->ref_list[1][0],
h->mb_y + !!IS_INTERLACED(*mb_type));
#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16 | MB_TYPE_INTRA4x4 | \
MB_TYPE_INTRA16x16 | MB_TYPE_INTRA_PCM)
/* ref = min(neighbors) */ /* ref = min(neighbors) */
for(list=0; list<2; list++){ for (list = 0; list < 2; list++) {
int left_ref = h->ref_cache[list][scan8[0] - 1]; int left_ref = h->ref_cache[list][scan8[0] - 1];
int top_ref = h->ref_cache[list][scan8[0] - 8]; int top_ref = h->ref_cache[list][scan8[0] - 8];
int refc = h->ref_cache[list][scan8[0] - 8 + 4]; int refc = h->ref_cache[list][scan8[0] - 8 + 4];
const int16_t *C= h->mv_cache[list][ scan8[0] - 8 + 4]; const int16_t *C = h->mv_cache[list][scan8[0] - 8 + 4];
if(refc == PART_NOT_AVAILABLE){ if (refc == PART_NOT_AVAILABLE) {
refc = h->ref_cache[list][scan8[0] - 8 - 1]; refc = h->ref_cache[list][scan8[0] - 8 - 1];
C = h-> mv_cache[list][scan8[0] - 8 - 1]; C = h->mv_cache[list][scan8[0] - 8 - 1];
} }
ref[list] = FFMIN3((unsigned)left_ref, (unsigned)top_ref, (unsigned)refc); ref[list] = FFMIN3((unsigned)left_ref,
if(ref[list] >= 0){ (unsigned)top_ref,
//this is just pred_motion() but with the cases removed that cannot happen for direct blocks (unsigned)refc);
const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; if (ref[list] >= 0) {
const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; /* This is just pred_motion() but with the cases removed that
* cannot happen for direct blocks. */
int match_count= (left_ref==ref[list]) + (top_ref==ref[list]) + (refc==ref[list]); const int16_t *const A = h->mv_cache[list][scan8[0] - 1];
if(match_count > 1){ //most common const int16_t *const B = h->mv_cache[list][scan8[0] - 8];
mv[list]= pack16to32(mid_pred(A[0], B[0], C[0]),
mid_pred(A[1], B[1], C[1]) ); int match_count = (left_ref == ref[list]) +
}else { (top_ref == ref[list]) +
assert(match_count==1); (refc == ref[list]);
if(left_ref==ref[list]){
mv[list]= AV_RN32A(A); if (match_count > 1) { // most common
}else if(top_ref==ref[list]){ mv[list] = pack16to32(mid_pred(A[0], B[0], C[0]),
mv[list]= AV_RN32A(B); mid_pred(A[1], B[1], C[1]));
}else{ } else {
mv[list]= AV_RN32A(C); assert(match_count == 1);
} if (left_ref == ref[list])
mv[list] = AV_RN32A(A);
else if (top_ref == ref[list])
mv[list] = AV_RN32A(B);
else
mv[list] = AV_RN32A(C);
} }
}else{ } else {
int mask= ~(MB_TYPE_L0 << (2*list)); int mask = ~(MB_TYPE_L0 << (2 * list));
mv[list] = 0; mv[list] = 0;
ref[list] = -1; ref[list] = -1;
if(!is_b8x8) if (!is_b8x8)
*mb_type &= mask; *mb_type &= mask;
sub_mb_type &= mask; sub_mb_type &= mask;
} }
} }
if(ref[0] < 0 && ref[1] < 0){ if (ref[0] < 0 && ref[1] < 0) {
ref[0] = ref[1] = 0; ref[0] = ref[1] = 0;
if(!is_b8x8) if (!is_b8x8)
*mb_type |= MB_TYPE_L0L1; *mb_type |= MB_TYPE_L0L1;
sub_mb_type |= MB_TYPE_L0L1; sub_mb_type |= MB_TYPE_L0L1;
} }
if(!(is_b8x8|mv[0]|mv[1])){ if (!(is_b8x8 | mv[0] | mv[1])) {
fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1); fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
*mb_type= (*mb_type & ~(MB_TYPE_8x8|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_P1L0|MB_TYPE_P1L1))|MB_TYPE_16x16|MB_TYPE_DIRECT2; *mb_type = (*mb_type & ~(MB_TYPE_8x8 | MB_TYPE_16x8 | MB_TYPE_8x16 |
MB_TYPE_P1L0 | MB_TYPE_P1L1)) |
MB_TYPE_16x16 | MB_TYPE_DIRECT2;
return; return;
} }
if (IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL if (IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL
if (!IS_INTERLACED(*mb_type)) { // AFR/FR -> AFL/FL if (!IS_INTERLACED(*mb_type)) { // AFR/FR -> AFL/FL
mb_y = (h->mb_y&~1) + h->col_parity; mb_y = (h->mb_y & ~1) + h->col_parity;
mb_xy= h->mb_x + ((h->mb_y&~1) + h->col_parity)*h->mb_stride; mb_xy = h->mb_x +
((h->mb_y & ~1) + h->col_parity) * h->mb_stride;
b8_stride = 0; b8_stride = 0;
}else{ } else {
mb_y += h->col_fieldoff; mb_y += h->col_fieldoff;
mb_xy += h->mb_stride*h->col_fieldoff; // non zero for FL -> FL & differ parity mb_xy += h->mb_stride * h->col_fieldoff; // non-zero for FL -> FL & differ parity
} }
goto single_col; goto single_col;
}else{ // AFL/AFR/FR/FL -> AFR/FR } else { // AFL/AFR/FR/FL -> AFR/FR
if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR if (IS_INTERLACED(*mb_type)) { // AFL /FL -> AFR/FR
mb_y = h->mb_y&~1; mb_y = h->mb_y & ~1;
mb_xy= h->mb_x + (h->mb_y&~1)*h->mb_stride; mb_xy = (h->mb_y & ~1) * h->mb_stride + h->mb_x;
mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy]; mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + h->mb_stride]; mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + h->mb_stride];
b8_stride = 2+4*h->mb_stride; b8_stride = 2 + 4 * h->mb_stride;
b4_stride *= 6; b4_stride *= 6;
if (IS_INTERLACED(mb_type_col[0]) != IS_INTERLACED(mb_type_col[1])) { if (IS_INTERLACED(mb_type_col[0]) !=
IS_INTERLACED(mb_type_col[1])) {
mb_type_col[0] &= ~MB_TYPE_INTERLACED; mb_type_col[0] &= ~MB_TYPE_INTERLACED;
mb_type_col[1] &= ~MB_TYPE_INTERLACED; mb_type_col[1] &= ~MB_TYPE_INTERLACED;
} }
sub_mb_type |= MB_TYPE_16x16|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ sub_mb_type |= MB_TYPE_16x16 | MB_TYPE_DIRECT2; /* B_SUB_8x8 */
if( (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) if ((mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) &&
&& (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) &&
&& !is_b8x8){ !is_b8x8) {
*mb_type |= MB_TYPE_16x8 |MB_TYPE_DIRECT2; /* B_16x8 */ *mb_type |= MB_TYPE_16x8 | MB_TYPE_DIRECT2; /* B_16x8 */
}else{ } else {
*mb_type |= MB_TYPE_8x8; *mb_type |= MB_TYPE_8x8;
} }
}else{ // AFR/FR -> AFR/FR } else { // AFR/FR -> AFR/FR
single_col: single_col:
mb_type_col[0] = mb_type_col[0] =
mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy]; mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];
sub_mb_type |= MB_TYPE_16x16|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ sub_mb_type |= MB_TYPE_16x16 | MB_TYPE_DIRECT2; /* B_SUB_8x8 */
if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){ if (!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)) {
*mb_type |= MB_TYPE_16x16|MB_TYPE_DIRECT2; /* B_16x16 */ *mb_type |= MB_TYPE_16x16 | MB_TYPE_DIRECT2; /* B_16x16 */
}else if(!is_b8x8 && (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16))){ } else if (!is_b8x8 &&
*mb_type |= MB_TYPE_DIRECT2 | (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16)); (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {
}else{ *mb_type |= MB_TYPE_DIRECT2 |
if(!h->sps.direct_8x8_inference_flag){ (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));
/* FIXME save sub mb types from previous frames (or derive from MVs) } else {
* so we know exactly what block size to use */ if (!h->sps.direct_8x8_inference_flag) {
sub_mb_type += (MB_TYPE_8x8-MB_TYPE_16x16); /* B_SUB_4x4 */ /* FIXME: Save sub mb types from previous frames (or derive
* from MVs) so we know exactly what block size to use. */
sub_mb_type += (MB_TYPE_8x8 - MB_TYPE_16x16); /* B_SUB_4x4 */
} }
*mb_type |= MB_TYPE_8x8; *mb_type |= MB_TYPE_8x8;
} }
} }
} }
await_reference_mb_row(h, &h->ref_list[1][0], mb_y); await_reference_mb_row(h, &h->ref_list[1][0], mb_y);
l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]]; l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy[mb_xy]];
l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]]; l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy[mb_xy]];
l1ref0 = &h->ref_list[1][0].ref_index [0][4 * mb_xy]; l1ref0 = &h->ref_list[1][0].ref_index[0][4 * mb_xy];
l1ref1 = &h->ref_list[1][0].ref_index [1][4 * mb_xy]; l1ref1 = &h->ref_list[1][0].ref_index[1][4 * mb_xy];
if(!b8_stride){ if (!b8_stride) {
if(h->mb_y&1){ if (h->mb_y & 1) {
l1ref0 += 2; l1ref0 += 2;
l1ref1 += 2; l1ref1 += 2;
l1mv0 += 2*b4_stride; l1mv0 += 2 * b4_stride;
l1mv1 += 2*b4_stride; l1mv1 += 2 * b4_stride;
} }
} }
if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {
if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){ int n = 0;
int n=0; for (i8 = 0; i8 < 4; i8++) {
for(i8=0; i8<4; i8++){ int x8 = i8 & 1;
int x8 = i8&1; int y8 = i8 >> 1;
int y8 = i8>>1; int xy8 = x8 + y8 * b8_stride;
int xy8 = x8+y8*b8_stride; int xy4 = x8 * 3 + y8 * b4_stride;
int xy4 = 3*x8+y8*b4_stride; int a, b;
int a,b;
if (is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) continue;
continue; h->sub_mb_type[i8] = sub_mb_type;
h->sub_mb_type[i8] = sub_mb_type;
fill_rectangle(&h->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1); (uint8_t)ref[0], 1);
fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); fill_rectangle(&h->ref_cache[1][scan8[i8 * 4]], 2, 2, 8,
if(!IS_INTRA(mb_type_col[y8]) && !h->ref_list[1][0].long_ref (uint8_t)ref[1], 1);
&& ( (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1) if (!IS_INTRA(mb_type_col[y8]) && !h->ref_list[1][0].long_ref &&
|| (l1ref0[xy8] < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){ ((l1ref0[xy8] == 0 &&
a=b=0; FFABS(l1mv0[xy4][0]) <= 1 &&
if(ref[0] > 0) FFABS(l1mv0[xy4][1]) <= 1) ||
a= mv[0]; (l1ref0[xy8] < 0 &&
if(ref[1] > 0) l1ref1[xy8] == 0 &&
b= mv[1]; FFABS(l1mv1[xy4][0]) <= 1 &&
n++; FFABS(l1mv1[xy4][1]) <= 1))) {
}else{ a =
a= mv[0]; b = 0;
b= mv[1]; if (ref[0] > 0)
} a = mv[0];
fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4); if (ref[1] > 0)
fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4); b = mv[1];
} n++;
if(!is_b8x8 && !(n&3)) } else {
*mb_type= (*mb_type & ~(MB_TYPE_8x8|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_P1L0|MB_TYPE_P1L1))|MB_TYPE_16x16|MB_TYPE_DIRECT2; a = mv[0];
}else if(IS_16X16(*mb_type)){ b = mv[1];
int a,b;
fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
if(!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref
&& ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)
|| (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1
&& h->x264_build>33U))){
a=b=0;
if(ref[0] > 0)
a= mv[0];
if(ref[1] > 0)
b= mv[1];
}else{
a= mv[0];
b= mv[1];
} }
fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4); fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, a, 4);
fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4); fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, b, 4);
}else{ }
int n=0; if (!is_b8x8 && !(n & 3))
for(i8=0; i8<4; i8++){ *mb_type = (*mb_type & ~(MB_TYPE_8x8 | MB_TYPE_16x8 | MB_TYPE_8x16 |
const int x8 = i8&1; MB_TYPE_P1L0 | MB_TYPE_P1L1)) |
const int y8 = i8>>1; MB_TYPE_16x16 | MB_TYPE_DIRECT2;
} else if (IS_16X16(*mb_type)) {
if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) int a, b;
continue;
h->sub_mb_type[i8] = sub_mb_type;
fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, mv[0], 4); fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, mv[1], 4); fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1); if (!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref &&
fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); ((l1ref0[0] == 0 &&
FFABS(l1mv0[0][0]) <= 1 &&
assert(b8_stride==2); FFABS(l1mv0[0][1]) <= 1) ||
/* col_zero_flag */ (l1ref0[0] < 0 && !l1ref1[0] &&
if(!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref && ( l1ref0[i8] == 0 FFABS(l1mv1[0][0]) <= 1 &&
|| (l1ref0[i8] < 0 && l1ref1[i8] == 0 FFABS(l1mv1[0][1]) <= 1 &&
&& h->x264_build>33U))){ h->x264_build > 33U))) {
const int16_t (*l1mv)[2]= l1ref0[i8] == 0 ? l1mv0 : l1mv1; a = b = 0;
if(IS_SUB_8X8(sub_mb_type)){ if (ref[0] > 0)
const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride]; a = mv[0];
if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ if (ref[1] > 0)
if(ref[0] == 0) b = mv[1];
fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); } else {
if(ref[1] == 0) a = mv[0];
fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); b = mv[1];
n+=4; }
} fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);
}else{ fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);
int m=0; } else {
for(i4=0; i4<4; i4++){ int n = 0;
const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride]; for (i8 = 0; i8 < 4; i8++) {
if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ const int x8 = i8 & 1;
if(ref[0] == 0) const int y8 = i8 >> 1;
AV_ZERO32(h->mv_cache[0][scan8[i8*4+i4]]);
if(ref[1] == 0) if (is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
AV_ZERO32(h->mv_cache[1][scan8[i8*4+i4]]); continue;
h->sub_mb_type[i8] = sub_mb_type;
fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, mv[0], 4);
fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, mv[1], 4);
fill_rectangle(&h->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
(uint8_t)ref[0], 1);
fill_rectangle(&h->ref_cache[1][scan8[i8 * 4]], 2, 2, 8,
(uint8_t)ref[1], 1);
assert(b8_stride == 2);
/* col_zero_flag */
if (!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref &&
(l1ref0[i8] == 0 ||
(l1ref0[i8] < 0 &&
l1ref1[i8] == 0 &&
h->x264_build > 33U))) {
const int16_t (*l1mv)[2] = l1ref0[i8] == 0 ? l1mv0 : l1mv1;
if (IS_SUB_8X8(sub_mb_type)) {
const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];
if (FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1) {
if (ref[0] == 0)
fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2,
8, 0, 4);
if (ref[1] == 0)
fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2,
8, 0, 4);
n += 4;
}
} else {
int m = 0;
for (i4 = 0; i4 < 4; i4++) {
const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +
(y8 * 2 + (i4 >> 1)) * b4_stride];
if (FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1) {
if (ref[0] == 0)
AV_ZERO32(h->mv_cache[0][scan8[i8 * 4 + i4]]);
if (ref[1] == 0)
AV_ZERO32(h->mv_cache[1][scan8[i8 * 4 + i4]]);
m++; m++;
} }
} }
if(!(m&3)) if (!(m & 3))
h->sub_mb_type[i8]+= MB_TYPE_16x16 - MB_TYPE_8x8; h->sub_mb_type[i8] += MB_TYPE_16x16 - MB_TYPE_8x8;
n+=m; n += m;
}
} }
} }
if(!is_b8x8 && !(n&15))
*mb_type= (*mb_type & ~(MB_TYPE_8x8|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_P1L0|MB_TYPE_P1L1))|MB_TYPE_16x16|MB_TYPE_DIRECT2;
} }
if (!is_b8x8 && !(n & 15))
*mb_type = (*mb_type & ~(MB_TYPE_8x8 | MB_TYPE_16x8 | MB_TYPE_8x16 |
MB_TYPE_P1L0 | MB_TYPE_P1L1)) |
MB_TYPE_16x16 | MB_TYPE_DIRECT2;
}
} }
static void pred_temp_direct_motion(H264Context * const h, int *mb_type){ static void pred_temp_direct_motion(H264Context *const h, int *mb_type)
{
int b8_stride = 2; int b8_stride = 2;
int b4_stride = h->b_stride; int b4_stride = h->b_stride;
int mb_xy = h->mb_xy, mb_y = h->mb_y; int mb_xy = h->mb_xy, mb_y = h->mb_y;
@ -420,127 +469,142 @@ static void pred_temp_direct_motion(H264Context * const h, int *mb_type){
assert(h->ref_list[1][0].reference & 3); assert(h->ref_list[1][0].reference & 3);
await_reference_mb_row(h, &h->ref_list[1][0], h->mb_y + !!IS_INTERLACED(*mb_type)); await_reference_mb_row(h, &h->ref_list[1][0],
h->mb_y + !!IS_INTERLACED(*mb_type));
if (IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL if (IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL
if (!IS_INTERLACED(*mb_type)) { // AFR/FR -> AFL/FL if (!IS_INTERLACED(*mb_type)) { // AFR/FR -> AFL/FL
mb_y = (h->mb_y&~1) + h->col_parity; mb_y = (h->mb_y & ~1) + h->col_parity;
mb_xy= h->mb_x + ((h->mb_y&~1) + h->col_parity)*h->mb_stride; mb_xy = h->mb_x +
((h->mb_y & ~1) + h->col_parity) * h->mb_stride;
b8_stride = 0; b8_stride = 0;
}else{ } else {
mb_y += h->col_fieldoff; mb_y += h->col_fieldoff;
mb_xy += h->mb_stride*h->col_fieldoff; // non zero for FL -> FL & differ parity mb_xy += h->mb_stride * h->col_fieldoff; // non-zero for FL -> FL & differ parity
} }
goto single_col; goto single_col;
}else{ // AFL/AFR/FR/FL -> AFR/FR } else { // AFL/AFR/FR/FL -> AFR/FR
if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR if (IS_INTERLACED(*mb_type)) { // AFL /FL -> AFR/FR
mb_y = h->mb_y&~1; mb_y = h->mb_y & ~1;
mb_xy= h->mb_x + (h->mb_y&~1)*h->mb_stride; mb_xy = h->mb_x + (h->mb_y & ~1) * h->mb_stride;
mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy]; mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + h->mb_stride]; mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + h->mb_stride];
b8_stride = 2+4*h->mb_stride; b8_stride = 2 + 4 * h->mb_stride;
b4_stride *= 6; b4_stride *= 6;
if (IS_INTERLACED(mb_type_col[0]) != IS_INTERLACED(mb_type_col[1])) { if (IS_INTERLACED(mb_type_col[0]) !=
IS_INTERLACED(mb_type_col[1])) {
mb_type_col[0] &= ~MB_TYPE_INTERLACED; mb_type_col[0] &= ~MB_TYPE_INTERLACED;
mb_type_col[1] &= ~MB_TYPE_INTERLACED; mb_type_col[1] &= ~MB_TYPE_INTERLACED;
} }
sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
MB_TYPE_DIRECT2; /* B_SUB_8x8 */
if( (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) if ((mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) &&
&& (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) &&
&& !is_b8x8){ !is_b8x8) {
*mb_type |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */ *mb_type |= MB_TYPE_16x8 | MB_TYPE_L0L1 |
}else{ MB_TYPE_DIRECT2; /* B_16x8 */
*mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1; } else {
*mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;
} }
}else{ // AFR/FR -> AFR/FR } else { // AFR/FR -> AFR/FR
single_col: single_col:
mb_type_col[0] = mb_type_col[0] =
mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy]; mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];
sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){ MB_TYPE_DIRECT2; /* B_SUB_8x8 */
*mb_type |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ if (!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)) {
}else if(!is_b8x8 && (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16))){ *mb_type |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
*mb_type |= MB_TYPE_L0L1|MB_TYPE_DIRECT2 | (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16)); MB_TYPE_DIRECT2; /* B_16x16 */
}else{ } else if (!is_b8x8 &&
if(!h->sps.direct_8x8_inference_flag){ (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {
/* FIXME save sub mb types from previous frames (or derive from MVs) *mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |
* so we know exactly what block size to use */ (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));
sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ } else {
if (!h->sps.direct_8x8_inference_flag) {
/* FIXME: save sub mb types from previous frames (or derive
* from MVs) so we know exactly what block size to use */
sub_mb_type = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
MB_TYPE_DIRECT2; /* B_SUB_4x4 */
} }
*mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1; *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;
} }
} }
} }
await_reference_mb_row(h, &h->ref_list[1][0], mb_y); await_reference_mb_row(h, &h->ref_list[1][0], mb_y);
l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]]; l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy[mb_xy]];
l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]]; l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy[mb_xy]];
l1ref0 = &h->ref_list[1][0].ref_index [0][4 * mb_xy]; l1ref0 = &h->ref_list[1][0].ref_index[0][4 * mb_xy];
l1ref1 = &h->ref_list[1][0].ref_index [1][4 * mb_xy]; l1ref1 = &h->ref_list[1][0].ref_index[1][4 * mb_xy];
if(!b8_stride){ if (!b8_stride) {
if(h->mb_y&1){ if (h->mb_y & 1) {
l1ref0 += 2; l1ref0 += 2;
l1ref1 += 2; l1ref1 += 2;
l1mv0 += 2*b4_stride; l1mv0 += 2 * b4_stride;
l1mv1 += 2*b4_stride; l1mv1 += 2 * b4_stride;
} }
} }
{ {
const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; const int *map_col_to_list0[2] = { h->map_col_to_list0[0],
h->map_col_to_list0[1] };
const int *dist_scale_factor = h->dist_scale_factor; const int *dist_scale_factor = h->dist_scale_factor;
int ref_offset; int ref_offset;
if (FRAME_MBAFF(h) && IS_INTERLACED(*mb_type)) { if (FRAME_MBAFF(h) && IS_INTERLACED(*mb_type)) {
map_col_to_list0[0] = h->map_col_to_list0_field[h->mb_y&1][0]; map_col_to_list0[0] = h->map_col_to_list0_field[h->mb_y & 1][0];
map_col_to_list0[1] = h->map_col_to_list0_field[h->mb_y&1][1]; map_col_to_list0[1] = h->map_col_to_list0_field[h->mb_y & 1][1];
dist_scale_factor =h->dist_scale_factor_field[h->mb_y&1]; dist_scale_factor = h->dist_scale_factor_field[h->mb_y & 1];
} }
ref_offset = (h->ref_list[1][0].mbaff<<4) & (mb_type_col[0]>>3); ref_offset = (h->ref_list[1][0].mbaff << 4) & (mb_type_col[0] >> 3);
if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){ if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {
int y_shift = 2*!IS_INTERLACED(*mb_type); int y_shift = 2 * !IS_INTERLACED(*mb_type);
assert(h->sps.direct_8x8_inference_flag); assert(h->sps.direct_8x8_inference_flag);
for(i8=0; i8<4; i8++){ for (i8 = 0; i8 < 4; i8++) {
const int x8 = i8&1; const int x8 = i8 & 1;
const int y8 = i8>>1; const int y8 = i8 >> 1;
int ref0, scale; int ref0, scale;
const int16_t (*l1mv)[2]= l1mv0; const int16_t (*l1mv)[2] = l1mv0;
if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) if (is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
continue; continue;
h->sub_mb_type[i8] = sub_mb_type; h->sub_mb_type[i8] = sub_mb_type;
fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); fill_rectangle(&h->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);
if(IS_INTRA(mb_type_col[y8])){ if (IS_INTRA(mb_type_col[y8])) {
fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); fill_rectangle(&h->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);
fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);
fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);
continue; continue;
} }
ref0 = l1ref0[x8 + y8*b8_stride]; ref0 = l1ref0[x8 + y8 * b8_stride];
if(ref0 >= 0) if (ref0 >= 0)
ref0 = map_col_to_list0[0][ref0 + ref_offset]; ref0 = map_col_to_list0[0][ref0 + ref_offset];
else{ else {
ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset]; ref0 = map_col_to_list0[1][l1ref1[x8 + y8 * b8_stride] +
l1mv= l1mv1; ref_offset];
l1mv = l1mv1;
} }
scale = dist_scale_factor[ref0]; scale = dist_scale_factor[ref0];
fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); fill_rectangle(&h->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
ref0, 1);
{ {
const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride]; const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];
int my_col = (mv_col[1]<<y_shift)/2; int my_col = (mv_col[1] << y_shift) / 2;
int mx = (scale * mv_col[0] + 128) >> 8; int mx = (scale * mv_col[0] + 128) >> 8;
int my = (scale * my_col + 128) >> 8; int my = (scale * my_col + 128) >> 8;
fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,
fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); pack16to32(mx, my), 4);
fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,
pack16to32(mx - mv_col[0], my - my_col), 4);
} }
} }
return; return;
@ -548,13 +612,13 @@ single_col:
/* one-to-one mv scaling */ /* one-to-one mv scaling */
if(IS_16X16(*mb_type)){ if (IS_16X16(*mb_type)) {
int ref, mv0, mv1; int ref, mv0, mv1;
fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
if(IS_INTRA(mb_type_col[0])){ if (IS_INTRA(mb_type_col[0])) {
ref=mv0=mv1=0; ref = mv0 = mv1 = 0;
}else{ } else {
const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset] const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]
: map_col_to_list0[1][l1ref1[0] + ref_offset]; : map_col_to_list0[1][l1ref1[0] + ref_offset];
const int scale = dist_scale_factor[ref0]; const int scale = dist_scale_factor[ref0];
@ -562,66 +626,72 @@ single_col:
int mv_l0[2]; int mv_l0[2];
mv_l0[0] = (scale * mv_col[0] + 128) >> 8; mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
mv_l0[1] = (scale * mv_col[1] + 128) >> 8; mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
ref= ref0; ref = ref0;
mv0= pack16to32(mv_l0[0],mv_l0[1]); mv0 = pack16to32(mv_l0[0], mv_l0[1]);
mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); mv1 = pack16to32(mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1]);
} }
fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4); fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);
fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4); fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);
}else{ } else {
for(i8=0; i8<4; i8++){ for (i8 = 0; i8 < 4; i8++) {
const int x8 = i8&1; const int x8 = i8 & 1;
const int y8 = i8>>1; const int y8 = i8 >> 1;
int ref0, scale; int ref0, scale;
const int16_t (*l1mv)[2]= l1mv0; const int16_t (*l1mv)[2] = l1mv0;
if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) if (is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
continue; continue;
h->sub_mb_type[i8] = sub_mb_type; h->sub_mb_type[i8] = sub_mb_type;
fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); fill_rectangle(&h->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);
if(IS_INTRA(mb_type_col[0])){ if (IS_INTRA(mb_type_col[0])) {
fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); fill_rectangle(&h->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);
fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);
fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);
continue; continue;
} }
assert(b8_stride == 2); assert(b8_stride == 2);
ref0 = l1ref0[i8]; ref0 = l1ref0[i8];
if(ref0 >= 0) if (ref0 >= 0)
ref0 = map_col_to_list0[0][ref0 + ref_offset]; ref0 = map_col_to_list0[0][ref0 + ref_offset];
else{ else {
ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset]; ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset];
l1mv= l1mv1; l1mv = l1mv1;
} }
scale = dist_scale_factor[ref0]; scale = dist_scale_factor[ref0];
fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); fill_rectangle(&h->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
if(IS_SUB_8X8(sub_mb_type)){ ref0, 1);
const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride]; if (IS_SUB_8X8(sub_mb_type)) {
int mx = (scale * mv_col[0] + 128) >> 8; const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];
int my = (scale * mv_col[1] + 128) >> 8; int mx = (scale * mv_col[0] + 128) >> 8;
fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); int my = (scale * mv_col[1] + 128) >> 8;
fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); fill_rectangle(&h->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,
}else pack16to32(mx, my), 4);
for(i4=0; i4<4; i4++){ fill_rectangle(&h->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,
const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride]; pack16to32(mx - mv_col[0], my - mv_col[1]), 4);
int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; } else {
mv_l0[0] = (scale * mv_col[0] + 128) >> 8; for (i4 = 0; i4 < 4; i4++) {
mv_l0[1] = (scale * mv_col[1] + 128) >> 8; const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +
AV_WN32A(h->mv_cache[1][scan8[i8*4+i4]], (y8 * 2 + (i4 >> 1)) * b4_stride];
pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1])); int16_t *mv_l0 = h->mv_cache[0][scan8[i8 * 4 + i4]];
mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
AV_WN32A(h->mv_cache[1][scan8[i8 * 4 + i4]],
pack16to32(mv_l0[0] - mv_col[0],
mv_l0[1] - mv_col[1]));
}
} }
} }
} }
} }
} }
void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){ void ff_h264_pred_direct_motion(H264Context *const h, int *mb_type)
if(h->direct_spatial_mv_pred){ {
if (h->direct_spatial_mv_pred)
pred_spatial_direct_motion(h, mb_type); pred_spatial_direct_motion(h, mb_type);
}else{ else
pred_temp_direct_motion(h, mb_type); pred_temp_direct_motion(h, mb_type);
}
} }

20
libavcodec/h264_slice.c
Unescape View File

@ -226,9 +226,9 @@ static int init_table_pools(H264Context *h)
av_buffer_allocz); av_buffer_allocz);
h->mb_type_pool = av_buffer_pool_init((big_mb_num + h->mb_stride) * h->mb_type_pool = av_buffer_pool_init((big_mb_num + h->mb_stride) *
sizeof(uint32_t), av_buffer_allocz); sizeof(uint32_t), av_buffer_allocz);
h->motion_val_pool = av_buffer_pool_init(2 * (b4_array_size + 4) * h->motion_val_pool = av_buffer_pool_init(2 * (b4_array_size + 4) *
sizeof(int16_t), av_buffer_allocz); sizeof(int16_t), av_buffer_allocz);
h->ref_index_pool = av_buffer_pool_init(4 * mb_array_size, av_buffer_allocz); h->ref_index_pool = av_buffer_pool_init(4 * mb_array_size, av_buffer_allocz);
if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool || if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
!h->ref_index_pool) { !h->ref_index_pool) {
@ -1045,7 +1045,10 @@ static int init_dimensions(H264Context *h)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
av_log(h->avctx, AV_LOG_WARNING, "Ignoring cropping information.\n"); av_log(h->avctx, AV_LOG_WARNING, "Ignoring cropping information.\n");
h->sps.crop_bottom = h->sps.crop_top = h->sps.crop_right = h->sps.crop_left = 0; h->sps.crop_bottom =
h->sps.crop_top =
h->sps.crop_right =
h->sps.crop_left =
h->sps.crop = 0; h->sps.crop = 0;
width = h->width; width = h->width;
@ -2295,14 +2298,12 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
if (get_bits_left(&h->gb) == 0) { if (get_bits_left(&h->gb) == 0) {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
h->mb_x - 1, h->mb_y, h->mb_x - 1, h->mb_y, ER_MB_END);
ER_MB_END);
return 0; return 0;
} else { } else {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
h->mb_x - 1, h->mb_y, h->mb_x - 1, h->mb_y, ER_MB_END);
ER_MB_END);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -2315,8 +2316,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
if (get_bits_left(&h->gb) == 0) { if (get_bits_left(&h->gb) == 0) {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
h->mb_x - 1, h->mb_y, h->mb_x - 1, h->mb_y, ER_MB_END);
ER_MB_END);
if (h->mb_x > lf_x_start) if (h->mb_x > lf_x_start)
loop_filter(h, lf_x_start, h->mb_x); loop_filter(h, lf_x_start, h->mb_x);

Write Preview
Loading…
Cancel
Save