X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fh264_mb.c;h=2487b96ceb851a0b185f1a14e3510cb1fbd3b3e2;hb=99404597201911de90cff2ef85f2d44176d39147;hp=31e372bc25477382022244f12c780b9438c736b1;hpb=e9b2383bf86b38ad18a001801aee20c8182e29bd;p=ffmpeg diff --git a/libavcodec/h264_mb.c b/libavcodec/h264_mb.c index 31e372bc254..2487b96ceb8 100644 --- a/libavcodec/h264_mb.c +++ b/libavcodec/h264_mb.c @@ -37,8 +37,7 @@ #include "thread.h" static inline int get_lowest_part_list_y(H264SliceContext *sl, - H264Picture *pic, int n, - int height, int y_offset, int list) + int n, int height, int y_offset, int list) { int raw_my = sl->mv_cache[list][scan8[n]][1]; int filter_height_up = (raw_my & 3) ? 2 : 0; @@ -61,14 +60,14 @@ static inline void get_lowest_part_y(const H264Context *h, H264SliceContext *sl, if (list0) { int ref_n = sl->ref_cache[0][scan8[n]]; - H264Picture *ref = &sl->ref_list[0][ref_n]; + H264Ref *ref = &sl->ref_list[0][ref_n]; // Error resilience puts the current picture in the ref list. // Don't try to wait on these as it will cause a deadlock. // Fields can wait on each other, though. - if (ref->tf.progress->data != h->cur_pic.tf.progress->data || + if (ref->parent->tf.progress->data != h->cur_pic.tf.progress->data || (ref->reference & 3) != h->picture_structure) { - my = get_lowest_part_list_y(sl, ref, n, height, y_offset, 0); + my = get_lowest_part_list_y(sl, n, height, y_offset, 0); if (refs[0][ref_n] < 0) nrefs[0] += 1; refs[0][ref_n] = FFMAX(refs[0][ref_n], my); @@ -77,11 +76,11 @@ static inline void get_lowest_part_y(const H264Context *h, H264SliceContext *sl, if (list1) { int ref_n = sl->ref_cache[1][scan8[n]]; - H264Picture *ref = &sl->ref_list[1][ref_n]; + H264Ref *ref = &sl->ref_list[1][ref_n]; - if (ref->tf.progress->data != h->cur_pic.tf.progress->data || + if (ref->parent->tf.progress->data != h->cur_pic.tf.progress->data || (ref->reference & 3) != h->picture_structure) { - my = get_lowest_part_list_y(sl, ref, n, height, y_offset, 1); + my = get_lowest_part_list_y(sl, n, height, y_offset, 1); if (refs[1][ref_n] < 0) nrefs[1] += 1; refs[1][ref_n] = FFMAX(refs[1][ref_n], my); @@ -168,33 +167,33 @@ static void await_references(const H264Context *h, H264SliceContext *sl) for (ref = 0; ref < 48 && nrefs[list]; ref++) { int row = refs[list][ref]; if (row >= 0) { - H264Picture *ref_pic = &sl->ref_list[list][ref]; + H264Ref *ref_pic = &sl->ref_list[list][ref]; int ref_field = ref_pic->reference - 1; - int ref_field_picture = ref_pic->field_picture; + int ref_field_picture = ref_pic->parent->field_picture; int pic_height = 16 * h->mb_height >> ref_field_picture; row <<= MB_MBAFF(sl); nrefs[list]--; if (!FIELD_PICTURE(h) && ref_field_picture) { // frame referencing two fields - ff_thread_await_progress(&ref_pic->tf, + ff_thread_await_progress(&ref_pic->parent->tf, FFMIN((row >> 1) - !(row & 1), pic_height - 1), 1); - ff_thread_await_progress(&ref_pic->tf, + ff_thread_await_progress(&ref_pic->parent->tf, FFMIN((row >> 1), pic_height - 1), 0); } else if (FIELD_PICTURE(h) && !ref_field_picture) { // field referencing one field of a frame - ff_thread_await_progress(&ref_pic->tf, + ff_thread_await_progress(&ref_pic->parent->tf, FFMIN(row * 2 + ref_field, pic_height - 1), 0); } else if (FIELD_PICTURE(h)) { - ff_thread_await_progress(&ref_pic->tf, + ff_thread_await_progress(&ref_pic->parent->tf, FFMIN(row, pic_height - 1), ref_field); } else { - ff_thread_await_progress(&ref_pic->tf, + ff_thread_await_progress(&ref_pic->parent->tf, FFMIN(row, pic_height - 1), 0); } @@ -203,7 +202,7 @@ static void await_references(const H264Context *h, H264SliceContext *sl) } static av_always_inline void mc_dir_part(const H264Context *h, H264SliceContext *sl, - H264Picture *pic, + H264Ref *pic, int n, int square, int height, int delta, int list, uint8_t *dest_y, uint8_t *dest_cb, @@ -217,7 +216,7 @@ static av_always_inline void mc_dir_part(const H264Context *h, H264SliceContext int my = sl->mv_cache[list][scan8[n]][1] + src_y_offset * 8; const int luma_xy = (mx & 3) + ((my & 3) << 2); ptrdiff_t offset = ((mx >> 2) << pixel_shift) + (my >> 2) * sl->mb_linesize; - uint8_t *src_y = pic->f.data[0] + offset; + uint8_t *src_y = pic->data[0] + offset; uint8_t *src_cb, *src_cr; int extra_width = 0; int extra_height = 0; @@ -237,12 +236,12 @@ static av_always_inline void mc_dir_part(const H264Context *h, H264SliceContext full_my < 0 - extra_height || full_mx + 16 /*FIXME*/ > pic_width + extra_width || full_my + 16 /*FIXME*/ > pic_height + extra_height) { - h->vdsp.emulated_edge_mc(h->edge_emu_buffer, + h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src_y - (2 << pixel_shift) - 2 * sl->mb_linesize, sl->mb_linesize, sl->mb_linesize, 16 + 5, 16 + 5 /*FIXME*/, full_mx - 2, full_my - 2, pic_width, pic_height); - src_y = h->edge_emu_buffer + (2 << pixel_shift) + 2 * sl->mb_linesize; + src_y = sl->edge_emu_buffer + (2 << pixel_shift) + 2 * sl->mb_linesize; emu = 1; } @@ -250,33 +249,33 @@ static av_always_inline void mc_dir_part(const H264Context *h, H264SliceContext if (!square) qpix_op[luma_xy](dest_y + delta, src_y + delta, sl->mb_linesize); - if (CONFIG_GRAY && h->flags & CODEC_FLAG_GRAY) + if (CONFIG_GRAY && h->flags & AV_CODEC_FLAG_GRAY) return; if (chroma_idc == 3 /* yuv444 */) { - src_cb = pic->f.data[1] + offset; + src_cb = pic->data[1] + offset; if (emu) { - h->vdsp.emulated_edge_mc(h->edge_emu_buffer, + h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src_cb - (2 << pixel_shift) - 2 * sl->mb_linesize, sl->mb_linesize, sl->mb_linesize, 16 + 5, 16 + 5 /*FIXME*/, full_mx - 2, full_my - 2, pic_width, pic_height); - src_cb = h->edge_emu_buffer + (2 << pixel_shift) + 2 * sl->mb_linesize; + src_cb = sl->edge_emu_buffer + (2 << pixel_shift) + 2 * sl->mb_linesize; } qpix_op[luma_xy](dest_cb, src_cb, sl->mb_linesize); // FIXME try variable height perhaps? if (!square) qpix_op[luma_xy](dest_cb + delta, src_cb + delta, sl->mb_linesize); - src_cr = pic->f.data[2] + offset; + src_cr = pic->data[2] + offset; if (emu) { - h->vdsp.emulated_edge_mc(h->edge_emu_buffer, + h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src_cr - (2 << pixel_shift) - 2 * sl->mb_linesize, sl->mb_linesize, sl->mb_linesize, 16 + 5, 16 + 5 /*FIXME*/, full_mx - 2, full_my - 2, pic_width, pic_height); - src_cr = h->edge_emu_buffer + (2 << pixel_shift) + 2 * sl->mb_linesize; + src_cr = sl->edge_emu_buffer + (2 << pixel_shift) + 2 * sl->mb_linesize; } qpix_op[luma_xy](dest_cr, src_cr, sl->mb_linesize); // FIXME try variable height perhaps? if (!square) @@ -291,28 +290,28 @@ static av_always_inline void mc_dir_part(const H264Context *h, H264SliceContext emu |= (my >> 3) < 0 || (my >> 3) + 8 >= (pic_height >> 1); } - src_cb = pic->f.data[1] + ((mx >> 3) << pixel_shift) + + src_cb = pic->data[1] + ((mx >> 3) << pixel_shift) + (my >> ysh) * sl->mb_uvlinesize; - src_cr = pic->f.data[2] + ((mx >> 3) << pixel_shift) + + src_cr = pic->data[2] + ((mx >> 3) << pixel_shift) + (my >> ysh) * sl->mb_uvlinesize; if (emu) { - h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cb, + h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src_cb, sl->mb_uvlinesize, sl->mb_uvlinesize, 9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh), pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */)); - src_cb = h->edge_emu_buffer; + src_cb = sl->edge_emu_buffer; } chroma_op(dest_cb, src_cb, sl->mb_uvlinesize, height >> (chroma_idc == 1 /* yuv420 */), mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7); if (emu) { - h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cr, + h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src_cr, sl->mb_uvlinesize, sl->mb_uvlinesize, 9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh), pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */)); - src_cr = h->edge_emu_buffer; + src_cr = sl->edge_emu_buffer; } chroma_op(dest_cr, src_cr, sl->mb_uvlinesize, height >> (chroma_idc == 1 /* yuv420 */), mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7); @@ -349,7 +348,7 @@ static av_always_inline void mc_part_std(const H264Context *h, H264SliceContext y_offset += 8 * (sl->mb_y >> MB_FIELD(sl)); if (list0) { - H264Picture *ref = &sl->ref_list[0][sl->ref_cache[0][scan8[n]]]; + H264Ref *ref = &sl->ref_list[0][sl->ref_cache[0][scan8[n]]]; mc_dir_part(h, sl, ref, n, square, height, delta, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, qpix_op, chroma_op, pixel_shift, chroma_idc); @@ -359,7 +358,7 @@ static av_always_inline void mc_part_std(const H264Context *h, H264SliceContext } if (list1) { - H264Picture *ref = &sl->ref_list[1][sl->ref_cache[1][scan8[n]]]; + H264Ref *ref = &sl->ref_list[1][sl->ref_cache[1][scan8[n]]]; mc_dir_part(h, sl, ref, n, square, height, delta, 1, dest_y, dest_cb, dest_cr, x_offset, y_offset, qpix_op, chroma_op, pixel_shift, chroma_idc); @@ -405,9 +404,9 @@ static av_always_inline void mc_part_weighted(const H264Context *h, H264SliceCon if (list0 && list1) { /* don't optimize for luma-only case, since B-frames usually * use implicit weights => chroma too. */ - uint8_t *tmp_cb = h->bipred_scratchpad; - uint8_t *tmp_cr = h->bipred_scratchpad + (16 << pixel_shift); - uint8_t *tmp_y = h->bipred_scratchpad + 16 * sl->mb_uvlinesize; + uint8_t *tmp_cb = sl->bipred_scratchpad; + uint8_t *tmp_cr = sl->bipred_scratchpad + (16 << pixel_shift); + uint8_t *tmp_y = sl->bipred_scratchpad + 16 * sl->mb_uvlinesize; int refn0 = sl->ref_cache[0][scan8[n]]; int refn1 = sl->ref_cache[1][scan8[n]]; @@ -452,7 +451,7 @@ static av_always_inline void mc_part_weighted(const H264Context *h, H264SliceCon } else { int list = list1 ? 1 : 0; int refn = sl->ref_cache[list][scan8[n]]; - H264Picture *ref = &sl->ref_list[list][refn]; + H264Ref *ref = &sl->ref_list[list][refn]; mc_dir_part(h, sl, ref, n, square, height, delta, list, dest_y, dest_cb, dest_cr, x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma_idc); @@ -484,17 +483,17 @@ static av_always_inline void prefetch_motion(const H264Context *h, H264SliceCont if (refn >= 0) { const int mx = (sl->mv_cache[list][scan8[0]][0] >> 2) + 16 * sl->mb_x + 8; const int my = (sl->mv_cache[list][scan8[0]][1] >> 2) + 16 * sl->mb_y; - uint8_t **src = sl->ref_list[list][refn].f.data; + uint8_t **src = sl->ref_list[list][refn].data; int off = (mx << pixel_shift) + (my + (sl->mb_x & 3) * 4) * sl->mb_linesize + (64 << pixel_shift); - h->vdsp.prefetch(src[0] + off, h->linesize, 4); + h->vdsp.prefetch(src[0] + off, sl->linesize, 4); if (chroma_idc == 3 /* yuv444 */) { - h->vdsp.prefetch(src[1] + off, h->linesize, 4); - h->vdsp.prefetch(src[2] + off, h->linesize, 4); + h->vdsp.prefetch(src[1] + off, sl->linesize, 4); + h->vdsp.prefetch(src[2] + off, sl->linesize, 4); } else { off = ((mx >> 1) << pixel_shift) + - ((my >> 1) + (sl->mb_x & 7)) * h->uvlinesize + + ((my >> 1) + (sl->mb_x & 7)) * sl->uvlinesize + (64 << pixel_shift); h->vdsp.prefetch(src[1] + off, src[2] - src[1], 2); } @@ -535,8 +534,8 @@ static av_always_inline void xchg_mb_border(const H264Context *h, H264SliceConte src_cb -= uvlinesize + 1 + pixel_shift; src_cr -= uvlinesize + 1 + pixel_shift; - top_border_m1 = h->top_borders[top_idx][sl->mb_x - 1]; - top_border = h->top_borders[top_idx][sl->mb_x]; + top_border_m1 = sl->top_borders[top_idx][sl->mb_x - 1]; + top_border = sl->top_borders[top_idx][sl->mb_x]; #define XCHG(a, b, xchg) \ if (pixel_shift) { \ @@ -559,11 +558,11 @@ static av_always_inline void xchg_mb_border(const H264Context *h, H264SliceConte XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg); XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1); if (sl->mb_x + 1 < h->mb_width) { - XCHG(h->top_borders[top_idx][sl->mb_x + 1], + XCHG(sl->top_borders[top_idx][sl->mb_x + 1], src_y + (17 << pixel_shift), 1); } } - if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) { + if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) { if (chroma444) { if (deblock_top) { if (deblock_topleft) { @@ -575,8 +574,8 @@ static av_always_inline void xchg_mb_border(const H264Context *h, H264SliceConte XCHG(top_border + (32 << pixel_shift), src_cr + (1 << pixel_shift), xchg); XCHG(top_border + (40 << pixel_shift), src_cr + (9 << pixel_shift), 1); if (sl->mb_x + 1 < h->mb_width) { - XCHG(h->top_borders[top_idx][sl->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1); - XCHG(h->top_borders[top_idx][sl->mb_x + 1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1); + XCHG(sl->top_borders[top_idx][sl->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1); + XCHG(sl->top_borders[top_idx][sl->mb_x + 1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1); } } } else {