39 int poc,
int poc1,
int i)
42 int64_t pocdiff = poc1 - (int64_t)poc0;
43 int td = av_clip_int8(pocdiff);
45 if (pocdiff != (
int)pocdiff)
51 int64_t pocdiff0 = poc - (int64_t)poc0;
52 int tb = av_clip_int8(pocdiff0);
53 int tx = (16384 + (
FFABS(td) >> 1)) /
td;
55 if (pocdiff0 != (
int)pocdiff0)
58 return av_clip_intp2((tb * tx + 32) >> 6, 10);
71 for (field = 0; field < 2; field++) {
74 for (i = 0; i < 2 * sl->
ref_count[0]; i++)
85 int field,
int colfield,
int mbafi)
88 int j, old_ref, rfield;
89 int start = mbafi ? 16 : 0;
94 memset(
map[list], 0,
sizeof(
map[list]));
96 for (rfield = 0; rfield < 2; rfield++) {
97 for (old_ref = 0; old_ref < ref1->
ref_count[colfield][
list]; old_ref++) {
103 else if (interl && (poc & 3) == 3)
104 poc = (poc & ~3) + rfield + 1;
106 for (j = start; j <
end; j++) {
109 int cur_ref = mbafi ? (j - 16) ^ field : j;
111 map[
list][2 * old_ref + (rfield ^
field) + 16] = cur_ref;
112 if (rfield == field || !interl)
127 int ref1sidx = (ref1->
reference & 1) ^ 1;
129 for (list = 0; list < sl->
list_count; list++) {
155 if (col_poc[0] == INT_MAX && col_poc[1] == INT_MAX) {
160 FFABS(col_poc[1] - (int64_t)cur_poc));
172 for (list = 0; list < 2; list++) {
175 for (field = 0; field < 2; field++)
186 int ref_height = 16 * h->
mb_height >> ref_field_picture;
195 FFMIN(16 * mb_y >> ref_field_picture,
197 ref_field_picture && ref_field);
207 const int16_t (*l1mv0)[2], (*l1mv1)[2];
208 const int8_t *l1ref0, *l1ref1;
209 const int is_b8x8 =
IS_8X8(*mb_type);
221 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16 | MB_TYPE_INTRA4x4 | \ 222 MB_TYPE_INTRA16x16 | MB_TYPE_INTRA_PCM) 225 for (list = 0; list < 2; list++) {
237 if (ref[list] >= 0) {
243 int match_count = (left_ref == ref[
list]) +
244 (top_ref == ref[list]) +
247 if (match_count > 1) {
251 assert(match_count == 1);
252 if (left_ref == ref[list])
254 else if (top_ref == ref[list])
269 if (ref[0] < 0 && ref[1] < 0) {
276 if (!(is_b8x8 | mv[0] | mv[1])) {
300 mb_y = sl->
mb_y & ~1;
328 }
else if (!is_b8x8 &&
353 l1mv0 += 2 * b4_stride;
354 l1mv1 += 2 * b4_stride;
360 for (i8 = 0; i8 < 4; i8++) {
363 int xy8 = x8 + y8 * b8_stride;
364 int xy4 = x8 * 3 + y8 * b4_stride;
376 ((l1ref0[xy8] == 0 &&
377 FFABS(l1mv0[xy4][0]) <= 1 &&
378 FFABS(l1mv0[xy4][1]) <= 1) ||
381 FFABS(l1mv1[xy4][0]) <= 1 &&
382 FFABS(l1mv1[xy4][1]) <= 1))) {
397 if (!is_b8x8 && !(n & 3))
408 FFABS(l1mv0[0][0]) <= 1 &&
409 FFABS(l1mv0[0][1]) <= 1) ||
410 (l1ref0[0] < 0 && !l1ref1[0] &&
411 FFABS(l1mv1[0][0]) <= 1 &&
412 FFABS(l1mv1[0][1]) <= 1 &&
427 for (i8 = 0; i8 < 4; i8++) {
428 const int x8 = i8 & 1;
429 const int y8 = i8 >> 1;
442 assert(b8_stride == 2);
449 const int16_t (*l1mv)[2] = l1ref0[i8] == 0 ? l1mv0 : l1mv1;
451 const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];
452 if (
FFABS(mv_col[0]) <= 1 &&
FFABS(mv_col[1]) <= 1) {
463 for (i4 = 0; i4 < 4; i4++) {
464 const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +
465 (y8 * 2 + (i4 >> 1)) * b4_stride];
466 if (
FFABS(mv_col[0]) <= 1 &&
FFABS(mv_col[1]) <= 1) {
480 if (!is_b8x8 && !(n & 15))
494 const int16_t (*l1mv0)[2], (*l1mv1)[2];
495 const int8_t *l1ref0, *l1ref1;
496 const int is_b8x8 =
IS_8X8(*mb_type);
497 unsigned int sub_mb_type;
518 mb_y = sl->
mb_y & ~1;
551 }
else if (!is_b8x8 &&
577 l1mv0 += 2 * b4_stride;
578 l1mv1 += 2 * b4_stride;
599 for (i8 = 0; i8 < 4; i8++) {
600 const int x8 = i8 & 1;
601 const int y8 = i8 >> 1;
603 const int16_t (*l1mv)[2] = l1mv0;
617 ref0 = l1ref0[x8 + y8 * b8_stride];
619 ref0 = map_col_to_list0[0][ref0 + ref_offset];
621 ref0 = map_col_to_list0[1][l1ref1[x8 + y8 * b8_stride] +
625 scale = dist_scale_factor[ref0];
630 const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];
631 int my_col = (mv_col[1] * (1 << y_shift)) / 2;
632 int mx = (scale * mv_col[0] + 128) >> 8;
633 int my = (scale * my_col + 128) >> 8;
652 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]
653 : map_col_to_list0[1][l1ref1[0] + ref_offset];
654 const int scale = dist_scale_factor[ref0];
655 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
657 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
658 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
661 mv1 =
pack16to32(mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1]);
667 for (i8 = 0; i8 < 4; i8++) {
668 const int x8 = i8 & 1;
669 const int y8 = i8 >> 1;
671 const int16_t (*l1mv)[2] = l1mv0;
684 assert(b8_stride == 2);
687 ref0 = map_col_to_list0[0][ref0 + ref_offset];
689 ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset];
692 scale = dist_scale_factor[ref0];
697 const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];
698 int mx = (scale * mv_col[0] + 128) >> 8;
699 int my = (scale * mv_col[1] + 128) >> 8;
703 pack16to32(mx - mv_col[0], my - mv_col[1]), 4);
705 for (i4 = 0; i4 < 4; i4++) {
706 const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +
707 (y8 * 2 + (i4 >> 1)) * b4_stride];
709 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
710 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
713 mv_l0[1] - mv_col[1]));
static void pred_spatial_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
struct H264Context * h264
int long_ref
1->long term reference 0->short term reference
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
int dist_scale_factor[32]
#define avpriv_request_sample(...)
int16_t(*[2] motion_val)[2]
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them.reget_buffer() and buffer age optimizations no longer work.*The contents of buffers must not be written to after ff_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
#define av_assert0(cond)
assert() equivalent, that is always enabled.
uint16_t sub_mb_type[4]
as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
int field_picture
whether or not picture was encoded in separate fields
static av_cold int end(AVCodecContext *avctx)
Multithreading support functions.
int map_col_to_list0_field[2][2][16+32]
#define PICT_BOTTOM_FIELD
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
static void await_reference_mb_row(const H264Context *const h, H264Ref *ref, int mb_y)
H.264 parameter set handling.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint16_t mask[17]
int map_col_to_list0[2][16+32]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
int active_thread_type
Which multithreading methods are in use by the codec.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int ref_poc[2][2][32]
POCs of the frames/fields used as reference (FIXME need per slice)
int direct_spatial_mv_pred
int frame_num
frame_num (raw frame_num from slice header)
#define MB_TYPE_16x16_OR_INTRA
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
useful rectangle filling function
#define FF_THREAD_FRAME
Decode more than one frame at once.
static void pred_temp_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
H.264 / AVC / MPEG-4 part10 codec.
int direct_8x8_inference_flag
static void fill_rectangle(int x, int y, int w, int h)
#define MB_TYPE_INTERLACED
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
static int get_scale_factor(H264SliceContext *sl, int poc, int poc1, int i)
static const int8_t mv[256][2]
Libavcodec external API header.
int field_poc[2]
top/bottom POC
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
static const uint8_t scan8[16 *3+3]
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
H264Picture * cur_pic_ptr
const VDPAUPixFmtMap * map
static void fill_colmap(const H264Context *h, H264SliceContext *sl, int map[2][16+32], int list, int field, int colfield, int mbafi)
int mbaff
1 -> MBAFF frame 0-> not MBAFF
common internal api header.
static int ref[MAX_W *MAX_W]
int8_t ref_cache[2][5 *8]
#define PART_NOT_AVAILABLE
int current_slice
current slice number, used to initialize slice_num of each thread/context
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
int ref_count[2][2]
number of entries in ref_poc (FIXME need per slice)
int dist_scale_factor_field[2][32]
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)