X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fh264_refs.c;h=9536c4beaa957989a4e7a04da6cdcbd2e6c5b769;hb=a2ca8ed903b435446031a8a0792ca535e6ee2913;hp=370b5c312d802688d4fa2b89d2d7197ea9ed3b98;hpb=9abc98737fe12ee67ddb7d52e9d497d4de2bac6c;p=ffmpeg diff --git a/libavcodec/h264_refs.c b/libavcodec/h264_refs.c index 370b5c312d8..9536c4beaa9 100644 --- a/libavcodec/h264_refs.c +++ b/libavcodec/h264_refs.c @@ -21,38 +21,50 @@ /** * @file - * H.264 / AVC / MPEG4 part10 reference picture handling. + * H.264 / AVC / MPEG-4 part10 reference picture handling. * @author Michael Niedermayer */ +#include + +#include "golomb_legacy.h" #include "internal.h" -#include "dsputil.h" #include "avcodec.h" #include "h264.h" -#include "golomb.h" +#include "h264dec.h" +#include "mpegutils.h" -//#undef NDEBUG #include - -static void pic_as_field(Picture *pic, const int parity){ +static void pic_as_field(H264Ref *pic, const int parity) +{ int i; - for (i = 0; i < 4; ++i) { + for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) { if (parity == PICT_BOTTOM_FIELD) - pic->f.data[i] += pic->f.linesize[i]; - pic->f.reference = parity; - pic->f.linesize[i] *= 2; + pic->data[i] += pic->linesize[i]; + pic->reference = parity; + pic->linesize[i] *= 2; } - pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD]; + pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD]; +} + +static void ref_from_h264pic(H264Ref *dst, H264Picture *src) +{ + memcpy(dst->data, src->f->data, sizeof(dst->data)); + memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize)); + dst->reference = src->reference; + dst->poc = src->poc; + dst->pic_id = src->pic_id; + dst->parent = src; } -static int split_field_copy(Picture *dest, Picture *src, - int parity, int id_add){ - int match = !!(src->f.reference & parity); +static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add) +{ + int match = !!(src->reference & parity); if (match) { - *dest = *src; - if(parity != PICT_FRAME){ + ref_from_h264pic(dest, src); + if (parity != PICT_FRAME) { pic_as_field(dest, parity); dest->pic_id *= 2; dest->pic_id += id_add; @@ -62,103 +74,136 @@ static int split_field_copy(Picture *dest, Picture *src, return match; } -static int build_def_list(Picture *def, Picture **in, int len, int is_long, int sel){ - int i[2]={0}; - int index=0; +static int build_def_list(H264Ref *def, int def_len, + H264Picture * const *in, int len, int is_long, int sel) +{ + int i[2] = { 0 }; + int index = 0; - while(i[0]f.reference & sel))) + while ((i[0] < len || i[1] < len) && index < def_len) { + while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel))) i[0]++; - while (i[1] < len && !(in[ i[1] ] && (in[ i[1] ]->f.reference & (sel^3)))) + while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3)))) i[1]++; - if(i[0] < len){ - in[ i[0] ]->pic_id= is_long ? i[0] : in[ i[0] ]->frame_num; - split_field_copy(&def[index++], in[ i[0]++ ], sel , 1); + if (i[0] < len && index < def_len) { + in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num; + split_field_copy(&def[index++], in[i[0]++], sel, 1); } - if(i[1] < len){ - in[ i[1] ]->pic_id= is_long ? i[1] : in[ i[1] ]->frame_num; - split_field_copy(&def[index++], in[ i[1]++ ], sel^3, 0); + if (i[1] < len && index < def_len) { + in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num; + split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0); } } return index; } -static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir){ +static int add_sorted(H264Picture **sorted, H264Picture * const *src, + int len, int limit, int dir) +{ int i, best_poc; - int out_i= 0; + int out_i = 0; - for(;;){ - best_poc= dir ? INT_MIN : INT_MAX; + for (;;) { + best_poc = dir ? INT_MIN : INT_MAX; - for(i=0; ipoc; - if(((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)){ - best_poc= poc; - sorted[out_i]= src[i]; + for (i = 0; i < len; i++) { + const int poc = src[i]->poc; + if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) { + best_poc = poc; + sorted[out_i] = src[i]; } } - if(best_poc == (dir ? INT_MIN : INT_MAX)) + if (best_poc == (dir ? INT_MIN : INT_MAX)) break; - limit= sorted[out_i++]->poc - dir; + limit = sorted[out_i++]->poc - dir; } return out_i; } -int ff_h264_fill_default_ref_list(H264Context *h){ - MpegEncContext * const s = &h->s; +static void h264_initialise_ref_list(const H264Context *h, H264SliceContext *sl) +{ int i, len; - if(h->slice_type_nos==AV_PICTURE_TYPE_B){ - Picture *sorted[32]; + if (sl->slice_type_nos == AV_PICTURE_TYPE_B) { + H264Picture *sorted[32]; int cur_poc, list; int lens[2]; - if(FIELD_PICTURE) - cur_poc= s->current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ]; + if (FIELD_PICTURE(h)) + cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]; else - cur_poc= s->current_picture_ptr->poc; - - for(list= 0; list<2; list++){ - len= add_sorted(sorted , h->short_ref, h->short_ref_count, cur_poc, 1^list); - len+=add_sorted(sorted+len, h->short_ref, h->short_ref_count, cur_poc, 0^list); - assert(len<=32); - len= build_def_list(h->default_ref_list[list] , sorted , len, 0, s->picture_structure); - len+=build_def_list(h->default_ref_list[list]+len, h->long_ref, 16 , 1, s->picture_structure); - assert(len<=32); - - if(len < h->ref_count[list]) - memset(&h->default_ref_list[list][len], 0, sizeof(Picture)*(h->ref_count[list] - len)); - lens[list]= len; + cur_poc = h->cur_pic_ptr->poc; + + for (list = 0; list < 2; list++) { + len = add_sorted(sorted, h->short_ref, h->short_ref_count, cur_poc, 1 ^ list); + len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list); + assert(len <= 32); + + len = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]), + sorted, len, 0, h->picture_structure); + len += build_def_list(sl->ref_list[list] + len, + FF_ARRAY_ELEMS(sl->ref_list[0]) - len, + h->long_ref, 16, 1, h->picture_structure); + + if (len < sl->ref_count[list]) + memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len)); + lens[list] = len; } - if(lens[0] == lens[1] && lens[1] > 1){ - for (i = 0; h->default_ref_list[0][i].f.data[0] == h->default_ref_list[1][i].f.data[0] && i < lens[0]; i++); - if(i == lens[0]) - FFSWAP(Picture, h->default_ref_list[1][0], h->default_ref_list[1][1]); + if (lens[0] == lens[1] && lens[1] > 1) { + for (i = 0; i < lens[0] && + sl->ref_list[0][i].parent->f->buf[0]->buffer == + sl->ref_list[1][i].parent->f->buf[0]->buffer; i++); + if (i == lens[0]) { + FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]); + } } - }else{ - len = build_def_list(h->default_ref_list[0] , h->short_ref, h->short_ref_count, 0, s->picture_structure); - len+= build_def_list(h->default_ref_list[0]+len, h-> long_ref, 16 , 1, s->picture_structure); - assert(len <= 32); - if(len < h->ref_count[0]) - memset(&h->default_ref_list[0][len], 0, sizeof(Picture)*(h->ref_count[0] - len)); - } -#ifdef TRACE - for (i=0; iref_count[0]; i++) { - tprintf(h->s.avctx, "List0: %s fn:%d 0x%p\n", (h->default_ref_list[0][i].long_ref ? "LT" : "ST"), h->default_ref_list[0][i].pic_id, h->default_ref_list[0][i].data[0]); + } else { + 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); + len += build_def_list(sl->ref_list[0] + len, + FF_ARRAY_ELEMS(sl->ref_list[0]) - len, + h-> long_ref, 16, 1, h->picture_structure); + + if (len < sl->ref_count[0]) + memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len)); } - if(h->slice_type_nos==AV_PICTURE_TYPE_B){ - for (i=0; iref_count[1]; i++) { - tprintf(h->s.avctx, "List1: %s fn:%d 0x%p\n", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[1][i].data[0]); +} + +/** + * print short term list + */ +static void print_short_term(const H264Context *h) +{ + uint32_t i; + if (h->avctx->debug & FF_DEBUG_MMCO) { + av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n"); + for (i = 0; i < h->short_ref_count; i++) { + H264Picture *pic = h->short_ref[i]; + av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n", + i, pic->frame_num, pic->poc, pic->f->data[0]); } } -#endif - return 0; } -static void print_short_term(H264Context *h); -static void print_long_term(H264Context *h); +/** + * print long term list + */ +static void print_long_term(const H264Context *h) +{ + uint32_t i; + if (h->avctx->debug & FF_DEBUG_MMCO) { + av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n"); + for (i = 0; i < 16; i++) { + H264Picture *pic = h->long_ref[i]; + if (pic) { + av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n", + i, pic->frame_num, pic->poc, pic->f->data[0]); + } + } + } +} /** * Extract structure information about the picture described by pic_num in @@ -170,11 +215,10 @@ static void print_long_term(H264Context *h); * @return frame number (short term) or long term index of picture * described by pic_num */ -static int pic_num_extract(H264Context *h, int pic_num, int *structure){ - MpegEncContext * const s = &h->s; - - *structure = s->picture_structure; - if(FIELD_PICTURE){ +static int pic_num_extract(const H264Context *h, int pic_num, int *structure) +{ + *structure = h->picture_structure; + if (FIELD_PICTURE(h)) { if (!(pic_num & 1)) /* opposite field */ *structure ^= PICT_FRAME; @@ -184,145 +228,178 @@ static int pic_num_extract(H264Context *h, int pic_num, int *structure){ return pic_num; } -int ff_h264_decode_ref_pic_list_reordering(H264Context *h){ - MpegEncContext * const s = &h->s; +static void h264_fill_mbaff_ref_list(H264SliceContext *sl) +{ + int list, i, j; + for (list = 0; list < sl->list_count; list++) { + for (i = 0; i < sl->ref_count[list]; i++) { + H264Ref *frame = &sl->ref_list[list][i]; + H264Ref *field = &sl->ref_list[list][16 + 2 * i]; + + field[0] = *frame; + + for (j = 0; j < 3; j++) + field[0].linesize[j] <<= 1; + field[0].reference = PICT_TOP_FIELD; + field[0].poc = field[0].parent->field_poc[0]; + + field[1] = field[0]; + + for (j = 0; j < 3; j++) + field[1].data[j] += frame->parent->f->linesize[j]; + field[1].reference = PICT_BOTTOM_FIELD; + field[1].poc = field[1].parent->field_poc[1]; + } + } +} + +int ff_h264_build_ref_list(const H264Context *h, H264SliceContext *sl) +{ int list, index, pic_structure; print_short_term(h); print_long_term(h); - for(list=0; listlist_count; list++){ - memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); + h264_initialise_ref_list(h, sl); - if(get_bits1(&s->gb)){ - int pred= h->curr_pic_num; + for (list = 0; list < sl->list_count; list++) { + int pred = sl->curr_pic_num; - for(index=0; ; index++){ - unsigned int reordering_of_pic_nums_idc= get_ue_golomb_31(&s->gb); - unsigned int pic_id; - int i; - Picture *ref = NULL; + for (index = 0; index < sl->nb_ref_modifications[list]; index++) { + unsigned int modification_of_pic_nums_idc = sl->ref_modifications[list][index].op; + unsigned int val = sl->ref_modifications[list][index].val; + unsigned int pic_id; + int i; + H264Picture *ref = NULL; - if(reordering_of_pic_nums_idc==3) - break; + switch (modification_of_pic_nums_idc) { + case 0: + case 1: { + const unsigned int abs_diff_pic_num = val + 1; + int frame_num; - if(index >= h->ref_count[list]){ - av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); - return -1; + if (abs_diff_pic_num > sl->max_pic_num) { + av_log(h->avctx, AV_LOG_ERROR, + "abs_diff_pic_num overflow\n"); + return AVERROR_INVALIDDATA; } - if(reordering_of_pic_nums_idc<3){ - if(reordering_of_pic_nums_idc<2){ - const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; - int frame_num; - - if(abs_diff_pic_num > h->max_pic_num){ - av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); - return -1; - } - - if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; - else pred+= abs_diff_pic_num; - pred &= h->max_pic_num - 1; - - frame_num = pic_num_extract(h, pred, &pic_structure); - - for(i= h->short_ref_count-1; i>=0; i--){ - ref = h->short_ref[i]; - assert(ref->f.reference); - assert(!ref->long_ref); - if( - ref->frame_num == frame_num && - (ref->f.reference & pic_structure) - ) - break; - } - if(i>=0) - ref->pic_id= pred; - }else{ - int long_idx; - pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx - - long_idx= pic_num_extract(h, pic_id, &pic_structure); - - if(long_idx>31){ - av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflow\n"); - return -1; - } - ref = h->long_ref[long_idx]; - assert(!(ref && !ref->f.reference)); - if (ref && (ref->f.reference & pic_structure)) { - ref->pic_id= pic_id; - assert(ref->long_ref); - i=0; - }else{ - i=-1; - } - } + if (modification_of_pic_nums_idc == 0) + pred -= abs_diff_pic_num; + else + pred += abs_diff_pic_num; + pred &= sl->max_pic_num - 1; + + frame_num = pic_num_extract(h, pred, &pic_structure); + + for (i = h->short_ref_count - 1; i >= 0; i--) { + ref = h->short_ref[i]; + assert(ref->reference); + assert(!ref->long_ref); + if (ref->frame_num == frame_num && + (ref->reference & pic_structure)) + break; + } + if (i >= 0) + ref->pic_id = pred; + break; + } + case 2: { + int long_idx; + pic_id = val; // long_term_pic_idx - if (i < 0) { - av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); - memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME - } else { - for(i=index; i+1ref_count[list]; i++){ - if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) - break; - } - for(; i > index; i--){ - h->ref_list[list][i]= h->ref_list[list][i-1]; - } - h->ref_list[list][index]= *ref; - if (FIELD_PICTURE){ - pic_as_field(&h->ref_list[list][index], pic_structure); - } - } - }else{ - av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); - return -1; + long_idx = pic_num_extract(h, pic_id, &pic_structure); + + if (long_idx > 31) { + av_log(h->avctx, AV_LOG_ERROR, + "long_term_pic_idx overflow\n"); + return AVERROR_INVALIDDATA; + } + ref = h->long_ref[long_idx]; + assert(!(ref && !ref->reference)); + if (ref && (ref->reference & pic_structure)) { + ref->pic_id = pic_id; + assert(ref->long_ref); + i = 0; + } else { + i = -1; + } + break; + } + } + + if (i < 0) { + av_log(h->avctx, AV_LOG_ERROR, + "reference picture missing during reorder\n"); + memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME + } else { + for (i = index; i + 1 < sl->ref_count[list]; i++) { + if (sl->ref_list[list][i].parent && + ref->long_ref == sl->ref_list[list][i].parent->long_ref && + ref->pic_id == sl->ref_list[list][i].pic_id) + break; + } + for (; i > index; i--) { + sl->ref_list[list][i] = sl->ref_list[list][i - 1]; + } + ref_from_h264pic(&sl->ref_list[list][index], ref); + if (FIELD_PICTURE(h)) { + pic_as_field(&sl->ref_list[list][index], pic_structure); } } } } - for(list=0; listlist_count; list++){ - for(index= 0; index < h->ref_count[list]; index++){ - if (!h->ref_list[list][index].f.data[0]) { - av_log(h->s.avctx, AV_LOG_ERROR, "Missing reference picture\n"); - if (h->default_ref_list[list][0].f.data[0]) - h->ref_list[list][index]= h->default_ref_list[list][0]; + for (list = 0; list < sl->list_count; list++) { + for (index = 0; index < sl->ref_count[list]; index++) { + if (!sl->ref_list[list][index].parent) { + av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture\n"); + if (index == 0 || h->avctx->err_recognition & AV_EF_EXPLODE) + return AVERROR_INVALIDDATA; else - return -1; + sl->ref_list[list][index] = sl->ref_list[list][index - 1]; } } } + if (FRAME_MBAFF(h)) + h264_fill_mbaff_ref_list(sl); + return 0; } -void ff_h264_fill_mbaff_ref_list(H264Context *h){ - int list, i, j; - for(list=0; list<2; list++){ //FIXME try list_count - for(i=0; iref_count[list]; i++){ - Picture *frame = &h->ref_list[list][i]; - Picture *field = &h->ref_list[list][16+2*i]; - field[0] = *frame; - for(j=0; j<3; j++) - field[0].f.linesize[j] <<= 1; - field[0].f.reference = PICT_TOP_FIELD; - field[0].poc= field[0].field_poc[0]; - field[1] = field[0]; - for(j=0; j<3; j++) - field[1].f.data[j] += frame->f.linesize[j]; - field[1].f.reference = PICT_BOTTOM_FIELD; - field[1].poc= field[1].field_poc[1]; - - h->luma_weight[16+2*i][list][0] = h->luma_weight[16+2*i+1][list][0] = h->luma_weight[i][list][0]; - h->luma_weight[16+2*i][list][1] = h->luma_weight[16+2*i+1][list][1] = h->luma_weight[i][list][1]; - for(j=0; j<2; j++){ - h->chroma_weight[16+2*i][list][j][0] = h->chroma_weight[16+2*i+1][list][j][0] = h->chroma_weight[i][list][j][0]; - h->chroma_weight[16+2*i][list][j][1] = h->chroma_weight[16+2*i+1][list][j][1] = h->chroma_weight[i][list][j][1]; +int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx) +{ + int list, index; + + sl->nb_ref_modifications[0] = 0; + sl->nb_ref_modifications[1] = 0; + + for (list = 0; list < sl->list_count; list++) { + if (!get_bits1(&sl->gb)) // ref_pic_list_modification_flag_l[01] + continue; + + for (index = 0; ; index++) { + unsigned int op = get_ue_golomb_31(&sl->gb); + + if (op == 3) + break; + + if (index >= sl->ref_count[list]) { + av_log(logctx, AV_LOG_ERROR, "reference count overflow\n"); + return AVERROR_INVALIDDATA; + } else if (op > 2) { + av_log(logctx, AV_LOG_ERROR, + "illegal modification_of_pic_nums_idc %u\n", + op); + return AVERROR_INVALIDDATA; } + sl->ref_modifications[list][index].val = get_ue_golomb(&sl->gb); + sl->ref_modifications[list][index].op = op; + sl->nb_ref_modifications[list]++; } } + + return 0; } /** @@ -336,14 +413,15 @@ void ff_h264_fill_mbaff_ref_list(H264Context *h){ * for display purposes) zero if one of the fields remains in * reference */ -static inline int unreference_pic(H264Context *h, Picture *pic, int refmask){ +static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask) +{ int i; - if (pic->f.reference &= refmask) { + if (pic->reference &= refmask) { return 0; } else { for(i = 0; h->delayed_pic[i]; i++) if(pic == h->delayed_pic[i]){ - pic->f.reference = DELAYED_PIC_REF; + pic->reference = DELAYED_PIC_REF; break; } return 1; @@ -351,22 +429,22 @@ static inline int unreference_pic(H264Context *h, Picture *pic, int refmask){ } /** - * Find a Picture in the short term reference list by frame number. + * Find a H264Picture in the short term reference list by frame number. * @param frame_num frame number to search for * @param idx the index into h->short_ref where returned picture is found * undefined if no picture found. * @return pointer to the found picture, or NULL if no pic with the provided * frame number is found */ -static Picture * find_short(H264Context *h, int frame_num, int *idx){ - MpegEncContext * const s = &h->s; +static H264Picture *find_short(H264Context *h, int frame_num, int *idx) +{ int i; - for(i=0; ishort_ref_count; i++){ - Picture *pic= h->short_ref[i]; - if(s->avctx->debug&FF_DEBUG_MMCO) - av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); - if(pic->frame_num == frame_num) { + for (i = 0; i < h->short_ref_count; i++) { + H264Picture *pic = h->short_ref[i]; + if (h->avctx->debug & FF_DEBUG_MMCO) + av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); + if (pic->frame_num == frame_num) { *idx = i; return pic; } @@ -380,29 +458,30 @@ static Picture * find_short(H264Context *h, int frame_num, int *idx){ * to be valid. Other list entries are shifted down. * @param i index into h->short_ref of picture to remove. */ -static void remove_short_at_index(H264Context *h, int i){ +static void remove_short_at_index(H264Context *h, int i) +{ assert(i >= 0 && i < h->short_ref_count); - h->short_ref[i]= NULL; + h->short_ref[i] = NULL; if (--h->short_ref_count) - memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i)*sizeof(Picture*)); + memmove(&h->short_ref[i], &h->short_ref[i + 1], + (h->short_ref_count - i) * sizeof(H264Picture*)); } /** - * * @return the removed picture or NULL if an error occurs */ -static Picture * remove_short(H264Context *h, int frame_num, int ref_mask){ - MpegEncContext * const s = &h->s; - Picture *pic; +static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask) +{ + H264Picture *pic; int i; - if(s->avctx->debug&FF_DEBUG_MMCO) - av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); + if (h->avctx->debug & FF_DEBUG_MMCO) + av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); pic = find_short(h, frame_num, &i); - if (pic){ - if(unreference_pic(h, pic, ref_mask)) - remove_short_at_index(h, i); + if (pic) { + if (unreference_pic(h, pic, ref_mask)) + remove_short_at_index(h, i); } return pic; @@ -413,15 +492,16 @@ static Picture * remove_short(H264Context *h, int frame_num, int ref_mask){ * that list. * @return the removed picture or NULL if an error occurs */ -static Picture * remove_long(H264Context *h, int i, int ref_mask){ - Picture *pic; +static H264Picture *remove_long(H264Context *h, int i, int ref_mask) +{ + H264Picture *pic; - pic= h->long_ref[i]; - if (pic){ - if(unreference_pic(h, pic, ref_mask)){ + pic = h->long_ref[i]; + if (pic) { + if (unreference_pic(h, pic, ref_mask)) { assert(h->long_ref[i]->long_ref == 1); - h->long_ref[i]->long_ref= 0; - h->long_ref[i]= NULL; + h->long_ref[i]->long_ref = 0; + h->long_ref[i] = NULL; h->long_ref_count--; } } @@ -429,104 +509,93 @@ static Picture * remove_long(H264Context *h, int i, int ref_mask){ return pic; } -void ff_h264_remove_all_refs(H264Context *h){ +void ff_h264_remove_all_refs(H264Context *h) +{ int i; - for(i=0; i<16; i++){ + for (i = 0; i < 16; i++) { remove_long(h, i, 0); } - assert(h->long_ref_count==0); + assert(h->long_ref_count == 0); - for(i=0; ishort_ref_count; i++){ + for (i = 0; i < h->short_ref_count; i++) { unreference_pic(h, h->short_ref[i], 0); - h->short_ref[i]= NULL; + h->short_ref[i] = NULL; } - h->short_ref_count=0; + h->short_ref_count = 0; } -/** - * print short term list - */ -static void print_short_term(H264Context *h) { - uint32_t i; - if(h->s.avctx->debug&FF_DEBUG_MMCO) { - av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n"); - for(i=0; ishort_ref_count; i++){ - Picture *pic= h->short_ref[i]; - av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", - i, pic->frame_num, pic->poc, pic->f.data[0]); +static void generate_sliding_window_mmcos(H264Context *h) +{ + MMCO *mmco = h->mmco; + int nb_mmco = 0; + + assert(h->long_ref_count + h->short_ref_count <= h->ps.sps->ref_frame_count); + + if (h->short_ref_count && + h->long_ref_count + h->short_ref_count == h->ps.sps->ref_frame_count && + !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) { + mmco[0].opcode = MMCO_SHORT2UNUSED; + mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num; + nb_mmco = 1; + if (FIELD_PICTURE(h)) { + mmco[0].short_pic_num *= 2; + mmco[1].opcode = MMCO_SHORT2UNUSED; + mmco[1].short_pic_num = mmco[0].short_pic_num + 1; + nb_mmco = 2; } } -} -/** - * print long term list - */ -static void print_long_term(H264Context *h) { - uint32_t i; - if(h->s.avctx->debug&FF_DEBUG_MMCO) { - av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n"); - for(i = 0; i < 16; i++){ - Picture *pic= h->long_ref[i]; - if (pic) { - av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", - i, pic->frame_num, pic->poc, pic->f.data[0]); - } - } - } + h->nb_mmco = nb_mmco; } -void ff_generate_sliding_window_mmcos(H264Context *h) { - MpegEncContext * const s = &h->s; - assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); - - h->mmco_index= 0; - if(h->short_ref_count && h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count && - !(FIELD_PICTURE && !s->first_field && s->current_picture_ptr->f.reference)) { - h->mmco[0].opcode= MMCO_SHORT2UNUSED; - h->mmco[0].short_pic_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; - h->mmco_index= 1; - if (FIELD_PICTURE) { - h->mmco[0].short_pic_num *= 2; - h->mmco[1].opcode= MMCO_SHORT2UNUSED; - h->mmco[1].short_pic_num= h->mmco[0].short_pic_num + 1; - h->mmco_index= 2; - } +int ff_h264_execute_ref_pic_marking(H264Context *h) +{ + MMCO *mmco = h->mmco; + int mmco_count; + int i, av_uninit(j); + int current_ref_assigned = 0, err = 0; + H264Picture *av_uninit(pic); + + if (!h->ps.sps) { + av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n"); + err = AVERROR_INVALIDDATA; + goto out; } -} -int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ - MpegEncContext * const s = &h->s; - int i, av_uninit(j); - int current_ref_assigned=0, err=0; - Picture *av_uninit(pic); + if (!h->explicit_ref_marking) + generate_sliding_window_mmcos(h); + mmco_count = h->nb_mmco; - if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0) - av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); + if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0) + av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n"); - for(i=0; iavctx->debug&FF_DEBUG_MMCO) - av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_pic_num, h->mmco[i].long_arg); + if (h->avctx->debug & FF_DEBUG_MMCO) + av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, + h->mmco[i].short_pic_num, h->mmco[i].long_arg); - if( mmco[i].opcode == MMCO_SHORT2UNUSED - || mmco[i].opcode == MMCO_SHORT2LONG){ + if (mmco[i].opcode == MMCO_SHORT2UNUSED || + mmco[i].opcode == MMCO_SHORT2LONG) { frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure); - pic = find_short(h, frame_num, &j); - if(!pic){ - if(mmco[i].opcode != MMCO_SHORT2LONG || !h->long_ref[mmco[i].long_arg] - || h->long_ref[mmco[i].long_arg]->frame_num != frame_num) { - av_log(h->s.avctx, AV_LOG_ERROR, "mmco: unref short failure\n"); + pic = find_short(h, frame_num, &j); + if (!pic) { + if (mmco[i].opcode != MMCO_SHORT2LONG || + !h->long_ref[mmco[i].long_arg] || + h->long_ref[mmco[i].long_arg]->frame_num != frame_num) { + av_log(h->avctx, AV_LOG_ERROR, "mmco: unref short failure\n"); err = AVERROR_INVALIDDATA; } continue; } } - switch(mmco[i].opcode){ + switch (mmco[i].opcode) { case MMCO_SHORT2UNUSED: - if(s->avctx->debug&FF_DEBUG_MMCO) - av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n", h->mmco[i].short_pic_num, h->short_ref_count); + if (h->avctx->debug & FF_DEBUG_MMCO) + av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n", + h->mmco[i].short_pic_num, h->short_ref_count); remove_short(h, frame_num, structure ^ PICT_FRAME); break; case MMCO_SHORT2LONG: @@ -534,62 +603,68 @@ int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ remove_long(h, mmco[i].long_arg, 0); remove_short_at_index(h, j); - h->long_ref[ mmco[i].long_arg ]= pic; - if (h->long_ref[ mmco[i].long_arg ]){ - h->long_ref[ mmco[i].long_arg ]->long_ref=1; + h->long_ref[ mmco[i].long_arg ] = pic; + if (h->long_ref[mmco[i].long_arg]) { + h->long_ref[mmco[i].long_arg]->long_ref = 1; h->long_ref_count++; } break; case MMCO_LONG2UNUSED: - j = pic_num_extract(h, mmco[i].long_arg, &structure); + j = pic_num_extract(h, mmco[i].long_arg, &structure); pic = h->long_ref[j]; if (pic) { remove_long(h, j, structure ^ PICT_FRAME); - } else if(s->avctx->debug&FF_DEBUG_MMCO) - av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: unref long failure\n"); + } else if (h->avctx->debug & FF_DEBUG_MMCO) + av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n"); break; case MMCO_LONG: - // Comment below left from previous code as it is an interresting note. + // Comment below left from previous code as it is an interesting note. /* First field in pair is in short term list or * at a different long term index. * This is not allowed; see 7.4.3.3, notes 2 and 3. * Report the problem and keep the pair where it is, * and mark this field valid. */ + if (h->short_ref[0] == h->cur_pic_ptr) + remove_short_at_index(h, 0); + + /* make sure the current picture is not already assigned as a long ref */ + if (h->cur_pic_ptr->long_ref) { + for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) { + if (h->long_ref[j] == h->cur_pic_ptr) + remove_long(h, j, 0); + } + } + - if (h->long_ref[mmco[i].long_arg] != s->current_picture_ptr) { + if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) { remove_long(h, mmco[i].long_arg, 0); - h->long_ref[ mmco[i].long_arg ]= s->current_picture_ptr; - h->long_ref[ mmco[i].long_arg ]->long_ref=1; + h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr; + h->long_ref[mmco[i].long_arg]->long_ref = 1; h->long_ref_count++; } - s->current_picture_ptr->f.reference |= s->picture_structure; - current_ref_assigned=1; + h->cur_pic_ptr->reference |= h->picture_structure; + current_ref_assigned = 1; break; case MMCO_SET_MAX_LONG: assert(mmco[i].long_arg <= 16); // just remove the long term which index is greater than new max - for(j = mmco[i].long_arg; j<16; j++){ + for (j = mmco[i].long_arg; j < 16; j++) { remove_long(h, j, 0); } break; case MMCO_RESET: - while(h->short_ref_count){ + while (h->short_ref_count) { remove_short(h, h->short_ref[0]->frame_num, 0); } - for(j = 0; j < 16; j++) { + for (j = 0; j < 16; j++) { remove_long(h, j, 0); } - s->current_picture_ptr->poc= - s->current_picture_ptr->field_poc[0]= - s->current_picture_ptr->field_poc[1]= - h->poc_lsb= - h->poc_msb= - h->frame_num= - s->current_picture_ptr->frame_num= 0; - s->current_picture_ptr->mmco_reset=1; + h->poc.frame_num = h->cur_pic_ptr->frame_num = 0; + h->mmco_reset = 1; + h->cur_pic_ptr->mmco_reset = 1; break; default: assert(0); } @@ -602,42 +677,43 @@ int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ * in long_ref; trying to put it on the short list here is an * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3). */ - if (h->short_ref_count && h->short_ref[0] == s->current_picture_ptr) { + if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) { /* Just mark the second field valid */ - s->current_picture_ptr->f.reference = PICT_FRAME; - } else if (s->current_picture_ptr->long_ref) { - av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term reference " - "assignment for second field " - "in complementary field pair " - "(first field is long term)\n"); + h->cur_pic_ptr->reference = PICT_FRAME; + } else if (h->cur_pic_ptr->long_ref) { + av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference " + "assignment for second field " + "in complementary field pair " + "(first field is long term)\n"); err = AVERROR_INVALIDDATA; } else { - pic= remove_short(h, s->current_picture_ptr->frame_num, 0); - if(pic){ - av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); + pic = remove_short(h, h->cur_pic_ptr->frame_num, 0); + if (pic) { + av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); err = AVERROR_INVALIDDATA; } - if(h->short_ref_count) - memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); + if (h->short_ref_count) + memmove(&h->short_ref[1], &h->short_ref[0], + h->short_ref_count * sizeof(H264Picture*)); - h->short_ref[0]= s->current_picture_ptr; + h->short_ref[0] = h->cur_pic_ptr; h->short_ref_count++; - s->current_picture_ptr->f.reference |= s->picture_structure; + h->cur_pic_ptr->reference |= h->picture_structure; } } if (h->long_ref_count + h->short_ref_count - - (h->short_ref[0] == s->current_picture_ptr) > h->sps.ref_frame_count){ + (h->short_ref[0] == h->cur_pic_ptr) > h->ps.sps->ref_frame_count) { /* We have too many reference frames, probably due to corrupted * stream. Need to discard one frame. Prevents overrun of the * short_ref and long_ref buffers. */ - av_log(h->s.avctx, AV_LOG_ERROR, + av_log(h->avctx, AV_LOG_ERROR, "number of reference frames (%d+%d) exceeds max (%d; probably " "corrupt input), discarding one\n", - h->long_ref_count, h->short_ref_count, h->sps.ref_frame_count); + h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count); err = AVERROR_INVALIDDATA; if (h->long_ref_count && !h->short_ref_count) { @@ -655,55 +731,66 @@ int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ print_short_term(h); print_long_term(h); - return (h->s.avctx->err_recognition & AV_EF_EXPLODE) ? err : 0; +out: + return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0; } -int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb){ - MpegEncContext * const s = &h->s; +int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, + const H2645NAL *nal, void *logctx) +{ int i; - - h->mmco_index= 0; - if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields - s->broken_link= get_bits1(gb) -1; - if(get_bits1(gb)){ - h->mmco[0].opcode= MMCO_LONG; - h->mmco[0].long_arg= 0; - h->mmco_index= 1; + MMCO *mmco = sl->mmco; + int nb_mmco = 0; + + if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields + skip_bits1(gb); // broken_link + if (get_bits1(gb)) { + mmco[0].opcode = MMCO_LONG; + mmco[0].long_arg = 0; + nb_mmco = 1; } - }else{ - if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag - for(i= 0; immco[i].opcode= opcode; - if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ - h->mmco[i].short_pic_num= (h->curr_pic_num - get_ue_golomb(gb) - 1) & (h->max_pic_num - 1); -/* if(h->mmco[i].short_pic_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_pic_num ] == NULL){ - av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); - return -1; - }*/ + sl->explicit_ref_marking = 1; + } else { + sl->explicit_ref_marking = get_bits1(gb); + if (sl->explicit_ref_marking) { + for (i = 0; i < MAX_MMCO_COUNT; i++) { + MMCOOpcode opcode = get_ue_golomb_31(gb); + + mmco[i].opcode = opcode; + if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) { + mmco[i].short_pic_num = + (sl->curr_pic_num - get_ue_golomb(gb) - 1) & + (sl->max_pic_num - 1); } - if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ - unsigned int long_arg= get_ue_golomb_31(gb); - if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG && long_arg == 16) && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){ - av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); + if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED || + opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) { + unsigned int long_arg = get_ue_golomb_31(gb); + if (long_arg >= 32 || + (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG && + long_arg == 16) && + !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) { + av_log(logctx, AV_LOG_ERROR, + "illegal long ref in memory management control " + "operation %d\n", opcode); return -1; } - h->mmco[i].long_arg= long_arg; + mmco[i].long_arg = long_arg; } - if(opcode > (unsigned)MMCO_LONG){ - av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); + if (opcode > (unsigned) MMCO_LONG) { + av_log(logctx, AV_LOG_ERROR, + "illegal memory management control operation %d\n", + opcode); return -1; } - if(opcode == MMCO_END) + if (opcode == MMCO_END) break; } - h->mmco_index= i; - }else{ - ff_generate_sliding_window_mmcos(h); + nb_mmco = i; } } + sl->nb_mmco = nb_mmco; + return 0; }