virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-11-26 19:01:44 +02:00
Code Issues Releases Activity

Merge commit '741b494fa8cd28a7d096349bac183893c236e3f9'

Browse Source 
* commit '741b494fa8cd28a7d096349bac183893c236e3f9':
  h264: eliminate default_ref_list

Merged-by: Hendrik Leppkes <h.leppkes@gmail.com>
This commit is contained in:
Hendrik Leppkes 2015-12-17 12:45:28 +01:00
commit bc66451e5e
3 changed files with 26 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libavcodec/h264.h
View File

@ -669,7 +669,6 @@ typedef struct H264Context {
*/ */
int max_pic_num; int max_pic_num;
H264Ref default_ref_list[2][32]; ///< base reference list for all slices of a coded picture
H264Picture *short_ref[32]; H264Picture *short_ref[32];
H264Picture *long_ref[32]; H264Picture *long_ref[32];
H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size? H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
@ -714,8 +713,6 @@ typedef struct H264Context {
enum AVPictureType pict_type; enum AVPictureType pict_type;
int last_slice_type;
unsigned int last_ref_count[2];
/** @} */ /** @} */
/** /**
@ -897,11 +894,6 @@ int ff_h264_get_slice_type(const H264SliceContext *sl);
*/ */
int ff_h264_alloc_tables(H264Context *h); int ff_h264_alloc_tables(H264Context *h);
/**
* Fill the default_ref_list.
*/
int ff_h264_fill_default_ref_list(H264Context *h, H264SliceContext *sl);
int ff_h264_decode_ref_pic_list_reordering(H264Context *h, H264SliceContext *sl); int ff_h264_decode_ref_pic_list_reordering(H264Context *h, H264SliceContext *sl);
void ff_h264_fill_mbaff_ref_list(H264Context *h, H264SliceContext *sl); void ff_h264_fill_mbaff_ref_list(H264Context *h, H264SliceContext *sl);
void ff_h264_remove_all_refs(H264Context *h); void ff_h264_remove_all_refs(H264Context *h);

57
libavcodec/h264_refs.c
View File

@ -130,7 +130,7 @@ static int mismatches_ref(H264Context *h, H264Picture *pic)
h->cur_pic_ptr->f->format != f->format); h->cur_pic_ptr->f->format != f->format);
} }
int ff_h264_fill_default_ref_list(H264Context *h, H264SliceContext *sl) static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
{ {
int i, len; int i, len;
int j; int j;
@ -150,66 +150,64 @@ int ff_h264_fill_default_ref_list(H264Context *h, H264SliceContext *sl)
len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list); len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
av_assert0(len <= 32); av_assert0(len <= 32);
len = build_def_list(h->default_ref_list[list], FF_ARRAY_ELEMS(h->default_ref_list[0]), len = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]),
sorted, len, 0, h->picture_structure); sorted, len, 0, h->picture_structure);
len += build_def_list(h->default_ref_list[list] + len, len += build_def_list(sl->ref_list[list] + len,
FF_ARRAY_ELEMS(h->default_ref_list[0]) - len, FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
h->long_ref, 16, 1, h->picture_structure); h->long_ref, 16, 1, h->picture_structure);
av_assert0(len <= 32); av_assert0(len <= 32);
if (len < sl->ref_count[list]) if (len < sl->ref_count[list])
memset(&h->default_ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len)); memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len));
lens[list] = len; lens[list] = len;
} }
if (lens[0] == lens[1] && lens[1] > 1) { if (lens[0] == lens[1] && lens[1] > 1) {
for (i = 0; i < lens[0] && for (i = 0; i < lens[0] &&
h->default_ref_list[0][i].parent->f->buf[0]->buffer == sl->ref_list[0][i].parent->f->buf[0]->buffer ==
h->default_ref_list[1][i].parent->f->buf[0]->buffer; i++); sl->ref_list[1][i].parent->f->buf[0]->buffer; i++);
if (i == lens[0]) { if (i == lens[0]) {
FFSWAP(H264Ref, h->default_ref_list[1][0], h->default_ref_list[1][1]); FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]);
} }
} }
} else { } else {
len = build_def_list(h->default_ref_list[0], FF_ARRAY_ELEMS(h->default_ref_list[0]), len = build_def_list(sl->ref_list[0], FF_ARRAY_ELEMS(sl->ref_list[0]),
h->short_ref, h->short_ref_count, 0, h->picture_structure); h->short_ref, h->short_ref_count, 0, h->picture_structure);
len += build_def_list(h->default_ref_list[0] + len, len += build_def_list(sl->ref_list[0] + len,
FF_ARRAY_ELEMS(h->default_ref_list[0]) - len, FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
h-> long_ref, 16, 1, h->picture_structure); h-> long_ref, 16, 1, h->picture_structure);
av_assert0(len <= 32); av_assert0(len <= 32);
if (len < sl->ref_count[0]) if (len < sl->ref_count[0])
memset(&h->default_ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len)); memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len));
} }
#ifdef TRACE #ifdef TRACE
for (i = 0; i < sl->ref_count[0]; i++) { for (i = 0; i < sl->ref_count[0]; i++) {
ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n", ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n",
h->default_ref_list[0][i].parent ? (h->default_ref_list[0][i].parent->long_ref ? "LT" : "ST") : "NULL", (sl->ref_list[0][i].long_ref ? "LT" : "ST"),
h->default_ref_list[0][i].pic_id, sl->ref_list[0][i].pic_id,
h->default_ref_list[0][i].parent ? h->default_ref_list[0][i].parent->f->data[0] : 0); sl->ref_list[0][i].f->data[0]);
} }
if (sl->slice_type_nos == AV_PICTURE_TYPE_B) { if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
for (i = 0; i < sl->ref_count[1]; i++) { for (i = 0; i < sl->ref_count[1]; i++) {
ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n", ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n",
h->default_ref_list[1][i].parent ? (h->default_ref_list[1][i].parent->long_ref ? "LT" : "ST") : "NULL", (sl->ref_list[1][i].long_ref ? "LT" : "ST"),
h->default_ref_list[1][i].pic_id, sl->ref_list[1][i].pic_id,
h->default_ref_list[1][i].parent ? h->default_ref_list[1][i].parent->f->data[0] : 0); sl->ref_list[1][i].f->data[0]);
} }
} }
#endif #endif
for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) { for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) {
for (i = 0; i < sl->ref_count[j]; i++) { for (i = 0; i < sl->ref_count[j]; i++) {
if (h->default_ref_list[j][i].parent) { if (sl->ref_list[j][i].parent) {
if (mismatches_ref(h, h->default_ref_list[j][i].parent)) { if (mismatches_ref(h, sl->ref_list[j][i].parent)) {
av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n"); av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n");
memset(&h->default_ref_list[j][i], 0, sizeof(h->default_ref_list[j][i])); memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i]));
} }
} }
} }
} }
return 0;
} }
static void print_short_term(H264Context *h); static void print_short_term(H264Context *h);
@ -245,9 +243,9 @@ int ff_h264_decode_ref_pic_list_reordering(H264Context *h, H264SliceContext *sl)
print_short_term(h); print_short_term(h);
print_long_term(h); print_long_term(h);
for (list = 0; list < sl->list_count; list++) { h264_initialise_ref_list(h, sl);
memcpy(sl->ref_list[list], h->default_ref_list[list], sl->ref_count[list] * sizeof(sl->ref_list[0][0]));
for (list = 0; list < sl->list_count; list++) {
if (get_bits1(&sl->gb)) { // ref_pic_list_modification_flag_l[01] if (get_bits1(&sl->gb)) { // ref_pic_list_modification_flag_l[01]
int pred = h->curr_pic_num; int pred = h->curr_pic_num;
@ -353,14 +351,10 @@ int ff_h264_decode_ref_pic_list_reordering(H264Context *h, H264SliceContext *sl)
if ( !sl->ref_list[list][index].parent if ( !sl->ref_list[list][index].parent
|| (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) { || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {
int i; int i;
av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref_list[list][0].poc); av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture\n");
for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++) for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
h->last_pocs[i] = INT_MIN; h->last_pocs[i] = INT_MIN;
if (h->default_ref_list[list][0].parent return -1;
&& !(!FIELD_PICTURE(h) && (h->default_ref_list[list][0].reference&3) != 3))
sl->ref_list[list][index] = h->default_ref_list[list][0];
else
return -1;
} }
av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0); av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
} }
@ -530,7 +524,6 @@ void ff_h264_remove_all_refs(H264Context *h)
} }
h->short_ref_count = 0; h->short_ref_count = 0;
memset(h->default_ref_list, 0, sizeof(h->default_ref_list));
for (i = 0; i < h->nb_slice_ctx; i++) { for (i = 0; i < h->nb_slice_ctx; i++) {
H264SliceContext *sl = &h->slice_ctx[i]; H264SliceContext *sl = &h->slice_ctx[i];
sl->list_count = sl->ref_count[0] = sl->ref_count[1] = 0; sl->list_count = sl->ref_count[0] = sl->ref_count[1] = 0;

17
libavcodec/h264_slice.c
View File

@ -540,10 +540,7 @@ int ff_h264_update_thread_context(AVCodecContext *dst,
h->dequant_coeff_pps = h1->dequant_coeff_pps; h->dequant_coeff_pps = h1->dequant_coeff_pps;
// POC timing // POC timing
copy_fields(h, h1, poc_lsb, default_ref_list); copy_fields(h, h1, poc_lsb, current_slice);
// reference lists
copy_fields(h, h1, short_ref, current_slice);
copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1); copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);
copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1); copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);
@ -1228,7 +1225,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
sl->slice_type_fixed = 0; sl->slice_type_fixed = 0;
slice_type = golomb_to_pict_type[slice_type]; slice_type = golomb_to_pict_type[slice_type];
sl->slice_type = slice_type; sl->slice_type = slice_type;
sl->slice_type_nos = slice_type & 3; sl->slice_type_nos = slice_type & 3;
@ -1667,7 +1663,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
memset(h->slice_table, -1, memset(h->slice_table, -1,
(h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table)); (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
} }
h->last_slice_type = -1;
} }
if (!h->setup_finished) if (!h->setup_finished)
@ -1734,14 +1729,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
if (ret < 0) if (ret < 0)
return ret; return ret;
if (slice_type != AV_PICTURE_TYPE_I &&
(h->current_slice == 0 ||
slice_type != h->last_slice_type ||
memcmp(h->last_ref_count, sl->ref_count, sizeof(sl->ref_count)))) {
ff_h264_fill_default_ref_list(h, sl);
}
if (sl->slice_type_nos != AV_PICTURE_TYPE_I) { if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
ret = ff_h264_decode_ref_pic_list_reordering(h, sl); ret = ff_h264_decode_ref_pic_list_reordering(h, sl);
if (ret < 0) { if (ret < 0) {
@ -1885,8 +1872,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
h->pps.chroma_qp_index_offset[1]) + h->pps.chroma_qp_index_offset[1]) +
6 * (h->sps.bit_depth_luma - 8); 6 * (h->sps.bit_depth_luma - 8);
h->last_slice_type = slice_type;
memcpy(h->last_ref_count, sl->ref_count, sizeof(h->last_ref_count));
sl->slice_num = ++h->current_slice; sl->slice_num = ++h->current_slice;
if (sl->slice_num) if (sl->slice_num)