#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;
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);
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);
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);
}
}
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,
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;
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;
}
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)
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);
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);
}
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);
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]];
} 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);
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);
}
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) { \
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) {
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 {