51 0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
52 0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
53 2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
54 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
58 0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
59 1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
60 2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
61 0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
62 2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
63 2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
64 2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
65 3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
66 3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
67 4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
68 4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
69 5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
70 5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
71 7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
72 6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
73 7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
77 0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
78 2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
79 3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
80 5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
81 0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
82 1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
83 3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
84 5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
85 0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
86 1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
87 3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
88 5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
89 1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
90 1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
91 3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
92 6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
97 0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
98 4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
99 3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
100 2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
101 1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
102 3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
103 2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
104 3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
105 0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
106 2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
107 1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
108 4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
109 0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
110 1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
111 0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
112 5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
164 const int b4_stride = h->
mb_width * 4 + 1;
165 const int b4_array_size = b4_stride * h->
mb_height * 4;
224 for (i = 0; i < 2; i++) {
237 return (ret < 0) ? ret :
AVERROR(ENOMEM);
255 if (i == H264_MAX_PICTURE_COUNT)
289 #define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b) + (size)))) 291 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \ 292 ((pic && pic >= old_ctx->DPB && \ 293 pic < old_ctx->DPB + H264_MAX_PICTURE_COUNT) ? \ 294 &new_ctx->DPB[pic - old_ctx->DPB] : NULL) 302 for (i = 0; i < count; i++) {
303 assert((
IN_RANGE(from[i], old_base,
sizeof(*old_base)) ||
321 if (dst == src || !h1->context_initialized)
328 (h->
width != h1->width ||
329 h->
height != h1->height ||
342 if (h1->ps.sps_list[i]) {
350 if (h1->ps.pps_list[i]) {
357 h->
ps.
sps = h1->ps.sps;
359 if (need_reinit || !inited) {
360 h->
width = h1->width;
389 if (h1->DPB[i].f->buf[0] &&
396 if (h1->cur_pic.f->buf[0]) {
411 memcpy(&h->
poc, &h1->poc,
sizeof(h->
poc));
420 memcpy(h->
mmco, h1->mmco,
sizeof(h->
mmco));
478 for (i = 0; i < 16; i++) {
482 for (i = 0; i < 16; i++) {
517 int linesize,
int uvlinesize,
527 src_cb -= uvlinesize;
528 src_cr -= uvlinesize;
534 AV_COPY128(top_border, src_y + 15 * linesize);
536 AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
540 AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
541 AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
542 AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
543 AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
545 AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
546 AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
548 }
else if (chroma422) {
550 AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
551 AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
553 AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
554 AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
558 AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
559 AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
561 AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
562 AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
576 AV_COPY128(top_border, src_y + 16 * linesize);
578 AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
583 AV_COPY128(top_border + 32, src_cb + 16 * linesize);
584 AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
585 AV_COPY128(top_border + 64, src_cr + 16 * linesize);
586 AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
588 AV_COPY128(top_border + 16, src_cb + 16 * linesize);
589 AV_COPY128(top_border + 32, src_cr + 16 * linesize);
591 }
else if (chroma422) {
593 AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
594 AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
596 AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
597 AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
601 AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
602 AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
604 AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
605 AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
618 int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
620 for (i = 0; i < 2; i++) {
652 for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
654 for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
658 int td = av_clip_int8(poc1 - poc0);
660 int tb = av_clip_int8(cur_poc - poc0);
661 int tx = (16384 + (
FFABS(td) >> 1)) / td;
662 int dist_scale_factor = (tb * tx + 32) >> 8;
663 if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
664 w = 64 - dist_scale_factor;
683 for (i = 0; i < 16; i++) {
684 #define TRANSPOSE(x) (x >> 2) | ((x << 2) & 0xF) 689 for (i = 0; i < 64; i++) {
690 #define TRANSPOSE(x) (x >> 3) | ((x & 7) << 3) 716 #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \ 717 CONFIG_H264_D3D11VA_HWACCEL + \ 718 CONFIG_H264_VAAPI_HWACCEL + \ 719 (CONFIG_H264_VDA_HWACCEL * 2) + \ 720 CONFIG_H264_VDPAU_HWACCEL) 748 #if CONFIG_H264_VDPAU_HWACCEL 764 #if CONFIG_H264_DXVA2_HWACCEL 767 #if CONFIG_H264_D3D11VA_HWACCEL 770 #if CONFIG_H264_VAAPI_HWACCEL 773 #if CONFIG_H264_VDA_HWACCEL 810 if (width <= 0 || height <= 0) {
913 int needs_reinit = 0, ret;
965 "changing width %d -> %d / height %d -> %d on " 984 "h264_slice_header_init() failed\n");
1152 int i, pics, out_of_order, out_idx;
1153 int invalid = 0, cnt = 0;
1186 invalid += out->
poc == INT_MIN;
1189 cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
1198 invalid = MAX_DELAYED_PIC_COUNT;
1202 for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
1221 if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
1237 sizeof(*h->
last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
1290 int last_pic_structure, last_pic_droppable, ret;
1316 unwrap_prev_frame_num -= max_frame_num;
1320 if (unwrap_prev_frame_num < 0)
1321 unwrap_prev_frame_num += max_frame_num;
1341 if (!last_pic_droppable && last_pic_structure !=
PICT_FRAME) {
1351 if (!last_pic_droppable && last_pic_structure !=
PICT_FRAME) {
1362 "Invalid field mode combination %d/%d\n",
1367 }
else if (last_pic_droppable != h->
droppable) {
1369 "Found reference and non-reference fields in the same frame, which");
1522 unsigned int slice_type,
tmp, i;
1523 int field_pic_flag, bottom_field_flag, picture_structure;
1528 if (slice_type > 9) {
1530 "slice type %d too large at %d\n",
1534 if (slice_type > 4) {
1557 "non-existing PPS %u referenced\n",
1565 "non-existing SPS %u referenced\n", pps->
sps_id);
1578 if (field_pic_flag) {
1635 for (i = 0; i < 2; i++) {
1684 "deblocking_filter_idc %u out of range\n", tmp);
1699 "deblocking filter parameters %d %d out of range\n",
1725 "Changing field mode (%d -> %d) between slices is not allowed\n",
1730 "unset cur_pic_ptr on slice %d\n",
1799 "Too many slices, increase MAX_SLICES and recompile\n");
1802 for (j = 0; j < 2; j++) {
1805 for (i = 0; i < 16; i++) {
1807 if (j < sl->list_count && i < sl->ref_count[j] &&
1826 for (i = 0; i < 16; i++)
1829 ref2frm[18 + 1] = -1;
1830 for (i = 16; i < 48; i++)
1831 ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
1837 "slice:%d %s mb:%d %c%s%s frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
1885 memcpy(&tmp_ctx, h->
slice_ctx,
sizeof(tmp_ctx));
1886 memcpy(h->
slice_ctx, sl,
sizeof(tmp_ctx));
1887 memcpy(sl, &tmp_ctx,
sizeof(tmp_ctx));
1948 int mb_type,
int top_xy,
1951 int left_type[LEFT_MBS],
1952 int mb_xy,
int list)
1959 const int b_xy = h->
mb2b_xy[top_xy] + 3 * b_stride;
1960 const int b8_xy = 4 * top_xy + 2;
1963 ref_cache[0 - 1 * 8] =
1965 ref_cache[2 - 1 * 8] =
1975 const int b8_xy = 4 * left_xy[
LTOP] + 1;
1983 ref_cache[-1 + 16] =
1992 ref_cache[-1 + 16] =
2010 uint32_t ref01 = (
pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
2011 uint32_t ref23 = (
pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
2012 AV_WN32A(&ref_cache[0 * 8], ref01);
2013 AV_WN32A(&ref_cache[1 * 8], ref01);
2014 AV_WN32A(&ref_cache[2 * 8], ref23);
2015 AV_WN32A(&ref_cache[3 * 8], ref23);
2020 AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
2021 AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
2022 AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
2023 AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
2032 const int mb_xy = sl->
mb_xy;
2040 left_xy[
LBOT] = left_xy[
LTOP] = mb_xy - 1;
2045 if (left_mb_field_flag != curr_mb_field_flag)
2048 if (curr_mb_field_flag)
2051 if (left_mb_field_flag != curr_mb_field_flag)
2065 if (qp <= qp_thresh &&
2066 (left_xy[
LTOP] < 0 ||
2072 if ((left_xy[
LTOP] < 0 ||
2087 left_type[
LTOP] = left_type[
LBOT] = 0;
2092 left_type[
LTOP] = left_type[
LBOT] = 0;
2102 top_type, left_type, mb_xy, 0);
2105 top_type, left_type, mb_xy, 1);
2109 AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
2110 AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
2111 AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
2112 AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
2117 AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
2120 if (left_type[
LTOP]) {
2122 nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
2123 nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
2124 nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
2125 nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
2132 nnz_cache[4 + 8 * 0] =
2133 nnz_cache[5 + 8 * 0] = (h->
cbp_table[top_xy] & 0x4000) >> 12;
2134 nnz_cache[6 + 8 * 0] =
2135 nnz_cache[7 + 8 * 0] = (h->
cbp_table[top_xy] & 0x8000) >> 12;
2138 nnz_cache[3 + 8 * 1] =
2139 nnz_cache[3 + 8 * 2] = (h->
cbp_table[left_xy[
LTOP]] & 0x2000) >> 12;
2142 nnz_cache[3 + 8 * 3] =
2143 nnz_cache[3 + 8 * 4] = (h->
cbp_table[left_xy[
LBOT]] & 0x8000) >> 12;
2147 nnz_cache[
scan8[0]] =
2148 nnz_cache[scan8[1]] =
2149 nnz_cache[scan8[2]] =
2150 nnz_cache[scan8[3]] = (sl->
cbp & 0x1000) >> 12;
2152 nnz_cache[scan8[0 + 4]] =
2153 nnz_cache[scan8[1 + 4]] =
2154 nnz_cache[scan8[2 + 4]] =
2155 nnz_cache[scan8[3 + 4]] = (sl->
cbp & 0x2000) >> 12;
2157 nnz_cache[scan8[0 + 8]] =
2158 nnz_cache[scan8[1 + 8]] =
2159 nnz_cache[scan8[2 + 8]] =
2160 nnz_cache[scan8[3 + 8]] = (sl->
cbp & 0x4000) >> 12;
2162 nnz_cache[scan8[0 + 12]] =
2163 nnz_cache[scan8[1 + 12]] =
2164 nnz_cache[scan8[2 + 12]] =
2165 nnz_cache[scan8[3 + 12]] = (sl->
cbp & 0x8000) >> 12;
2174 uint8_t *dest_y, *dest_cb, *dest_cr;
2175 int linesize, uvlinesize, mb_x, mb_y;
2185 for (mb_x = start_x; mb_x < end_x; mb_x++)
2186 for (mb_y = end_mb_y -
FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
2198 ((mb_x << pixel_shift) + mb_y * sl->
linesize) * 16;
2200 (mb_x << pixel_shift) * (8 <<
CHROMA444(h)) +
2203 (mb_x << pixel_shift) * (8 <<
CHROMA444(h)) +
2228 linesize, uvlinesize);
2231 dest_cr, linesize, uvlinesize);
2263 if ((top + height) >= pic_height)
2264 height += deblock_border;
2265 top -= deblock_border;
2268 if (top >= pic_height || (top + height) < 0)
2271 height =
FFMIN(height, pic_height - top);
2287 int startx,
int starty,
2288 int endx,
int endy,
int status)
2290 #if CONFIG_ERROR_RESILIENCE 2305 int lf_x_start = sl->
mb_x;
2367 if (sl->
mb_x >= lf_x_start)
2373 "error while decoding MB %d %d, bytestream %td\n",
2383 sl->
mb_x = lf_x_start = 0;
2398 if (sl->
mb_x > lf_x_start)
2430 "error while decoding MB %d %d\n", sl->
mb_x, sl->
mb_y);
2438 sl->
mb_x = lf_x_start = 0;
2471 if (sl->
mb_x > lf_x_start)
2505 if (context_count == 1) {
2515 for (i = 0; i < context_count; i++) {
2524 for (j = 0; j < context_count; j++) {
2528 if (i == j || slice_idx2 < slice_idx)
2530 next_slice_idx =
FFMIN(next_slice_idx, slice_idx2);
2541 for (i = 1; i < context_count; i++)
2547 for (i = 0; i < context_count; i++) {
2557 j == y_end - 1 ? x_end : h->
mb_width);
int video_signal_type_present_flag
struct H264Context * h264
const struct AVCodec * codec
discard all frames except keyframes
int long_ref
1->long term reference 0->short term reference
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Views are packed per line, as if interlaced.
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
static int h264_slice_header_parse(H264SliceContext *sl, const H2645NAL *nal, const H264ParamSets *ps, AVCodecContext *avctx)
int recovery_frame_cnt
recovery_frame_cnt
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Views are alternated temporally.
static int initialize_cur_frame(H264Context *h)
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
int edge_emu_buffer_allocated
int coded_width
Bitstream width / height, may be different from width/height e.g.
static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
Draw edges and report progress for the last MB row.
const uint8_t ff_zigzag_scan[16]
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Views are next to each other, but when upscaling apply a checkerboard pattern.
#define AV_LOG_WARNING
Something somehow does not look correct.
int chroma_qp_index_offset[2]
AVBufferRef * sps_list[MAX_SPS_COUNT]
const uint8_t * bytestream_end
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
static const uint8_t zigzag_scan8x8_cavlc[64]
H264ChromaContext h264chroma
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
MMCO mmco[MAX_MMCO_COUNT]
memory management control operations buffer.
static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
Initialize implicit_weight table.
int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int bitstream_restriction_flag
AVBufferRef * mb_type_buf
int repeat_pict
When decoding, this signals how much the picture must be delayed.
int bipred_scratchpad_allocated
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
#define AV_PIX_FMT_GBRP10
AVBufferPool * mb_type_pool
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
int16_t(*[2] motion_val)[2]
void ff_h264_flush_change(H264Context *h)
const uint8_t * field_scan8x8_q0
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]
int is_avc
Used to parse AVC variant of H.264.
3: top field, bottom field, in that order
AVBufferPool * ref_index_pool
uint8_t zigzag_scan8x8_cavlc[64]
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
H264SEIDisplayOrientation display_orientation
#define FF_ARRAY_ELEMS(a)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
uint32_t num_units_in_tick
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
H264Picture * long_ref[32]
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
#define IN_RANGE(a, b, size)
static const uint8_t field_scan8x8_cavlc[64]
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
MMCO mmco[MAX_MMCO_COUNT]
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
enum AVDiscard skip_frame
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
struct AVHWAccel * hwaccel
Hardware accelerator in use.
unsigned int crop_top
frame_cropping_rect_top_offset
#define USES_LIST(a, list)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
const uint8_t * bytestream
int ref2frm[MAX_SLICES][2][64]
reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 ...
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
unsigned int crop_left
frame_cropping_rect_left_offset
int slice_alpha_c0_offset
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
int field_picture
whether or not picture was encoded in separate fields
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
#define FF_DEBUG_PICT_INFO
enum AVColorPrimaries color_primaries
int frame_num_offset
for POC type 2
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
Multithreading support functions.
int cabac
entropy_coding_mode_flag
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
unsigned int crop_right
frame_cropping_rect_right_offset
int frame_recovered
Initial frame has been completely recovered.
#define PICT_BOTTOM_FIELD
int transform_bypass
qpprime_y_zero_transform_bypass_flag
static int get_bits_count(const GetBitContext *s)
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
#define AV_LOG_VERBOSE
Detailed information.
int interlaced_frame
The content of the picture is interlaced.
AVBufferRef * qscale_table_buf
static int h264_export_frame_props(H264Context *h)
#define FRAME_RECOVERED_SEI
Sufficient number of frames have been decoded since a SEI recovery point, so all the following frames...
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
high precision timer, useful to profile code
int recovered
picture at IDR or recovery point + recovery count
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using enum...
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
int last_pocs[MAX_DELAYED_PIC_COUNT]
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
static int h264_frame_start(H264Context *h)
const uint8_t * zigzag_scan8x8_cavlc_q0
H.264 common definitions.
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
static int get_bits_left(GetBitContext *gb)
H.264 parameter set handling.
H264Picture DPB[H264_MAX_PICTURE_COUNT]
enum AVColorTransferCharacteristic color_trc
int mb_aff
mb_adaptive_frame_field_flag
int chroma_log2_weight_denom
int width
width and height of the video frame
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
int flags
Additional information about the frame packing.
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
const uint8_t * zigzag_scan_q0
static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
int poc_type
pic_order_cnt_type
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
discard all bidirectional frames
void * hwaccel_picture_private
hardware accelerator private data
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
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.
ATSC A53 Part 4 Closed Captions.
static int init_dimensions(H264Context *h)
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
uint8_t(*[2] mvd_table)[2]
int prev_interlaced_frame
Complement sei_pic_struct SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced...
int flags
AV_CODEC_FLAG_*.
static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
simple assert() macros that are a bit more flexible than ISO C assert().
uint8_t(*[2] top_borders)[(16 *3) *2]
int weighted_pred
weighted_pred_flag
#define AV_PIX_FMT_YUV444P10
int direct_spatial_mv_pred
H264SEIUnregistered unregistered
HW acceleration through VDA, data[3] contains a CVPixelBufferRef.
int frame_num
frame_num (raw frame_num from slice header)
const uint8_t ff_h264_golomb_to_pict_type[5]
static const uint8_t field_scan8x8[64]
Video is not stereoscopic (and metadata has to be there).
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
uint8_t active_format_description
int delta_pic_order_always_zero_flag
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
uint8_t zigzag_scan8x8[64]
AVBufferRef * hwaccel_priv_buf
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int crop
frame_cropping_flag
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
useful rectangle filling function
#define AV_PIX_FMT_YUV422P9
int refs
number of reference frames
static const uint8_t field_scan[16]
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
AVBufferRef * motion_val_buf[2]
int ref_frame_count
num_ref_frames
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
enum AVPictureType pict_type
Picture type of the frame.
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
int ct_type
Bit set of clock types for fields/frames in picture timing SEI message.
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
static void copy_picture_range(H264Picture **to, H264Picture **from, int count, H264Context *new_base, H264Context *old_base)
uint8_t field_scan8x8_cavlc[64]
int colour_description_present_flag
unsigned int first_mb_addr
static void er_add_slice(H264SliceContext *sl, int startx, int starty, int endx, int endy, int status)
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
int width
picture width / height.
int long_ref_count
number of actual long term references
#define AV_FRAME_FLAG_CORRUPT
The frame data may be corrupted, e.g.
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
int luma_log2_weight_denom
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
int ff_h264_build_ref_list(const H264Context *h, H264SliceContext *sl)
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color)
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Context Adaptive Binary Arithmetic Coder inline functions.
int init_qp
pic_init_qp_minus26 + 26
H.264 / AVC / MPEG-4 part10 codec.
H264SliceContext * slice_ctx
static int h264_select_output_frame(H264Context *h)
int top_borders_allocated[2]
static int pic_is_unused(H264Context *h, H264Picture *pic)
#define FIELD_OR_MBAFF_PICTURE(h)
const uint8_t * zigzag_scan8x8_q0
int ref_idc
H.264 only, nal_ref_idc.
static void init_scan_tables(H264Context *h)
initialize scan tables
static int h264_init_ps(H264Context *h, const H264SliceContext *sl)
static int av_unused get_cabac_terminate(CABACContext *c)
#define AV_PIX_FMT_YUV444P9
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output...
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure counterclockwise rotation by the specified angle...
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, const int chroma_format_idc)
Set the intra prediction function pointers.
the normal 2^n-1 "JPEG" YUV ranges
static int init_table_pools(H264Context *h)
uint8_t * edge_emu_buffer
if(ac->has_optimized_func)
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
int pic_order_present
pic_order_present_flag
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
int bit_depth_luma
luma bit depth from sps to detect changes
int chroma_format_idc
chroma format from sps to detect changes
int timing_info_present_flag
int coded_picture_number
picture number in bitstream order
enum AVStereo3DType type
How views are packed within the video.
Libavcodec external API header.
#define MAX_DELAYED_PIC_COUNT
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
AVBufferRef * pps_list[MAX_PPS_COUNT]
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
H264Picture * short_ref[32]
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
int field_poc[2]
top/bottom POC
SEI_PicStructType pic_struct
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
int recovery_frame
recovery_frame is the frame_num at which the next frame should be fully constructed.
main external API structure.
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
int qp_thresh
QP threshold to skip loopfilter.
uint8_t * data
The data buffer.
static av_always_inline uint32_t pack16to32(int a, int b)
H264SEIA53Caption a53_caption
int implicit_weight[48][48][2]
static const uint8_t scan8[16 *3+3]
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
static unsigned int get_bits1(GetBitContext *s)
#define AV_PIX_FMT_YUV420P10
int prev_frame_num
frame_num of the last pic for POC type 1/2
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
#define FF_COMPLIANCE_NORMAL
const uint8_t * field_scan8x8_cavlc_q0
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
5: top field, bottom field, top field repeated, in that order
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
A reference counted buffer type.
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
int mmco_reset
MMCO_RESET set this 1.
int content_interpretation_type
H264Picture * cur_pic_ptr
const uint8_t ff_zigzag_direct[64]
static int h264_slice_header_init(H264Context *h)
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
#define AV_PIX_FMT_YUV420P9
H264SEIPictureTiming picture_timing
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
H264SEIRecoveryPoint recovery_point
ptrdiff_t mb_linesize
may be equal to s->linesize or s->linesize * 2, for mbaff
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
static enum AVPixelFormat pix_fmts[]
static int alloc_picture(H264Context *h, H264Picture *pic)
Views are on top of each other.
int block_offset[2 *(16 *3)]
block_offset[ 0..23] for frame macroblocks block_offset[24..47] for field macroblocks ...
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int transform_8x8_mode
transform_8x8_mode_flag
#define AV_PIX_FMT_YUV422P10
static int h264_slice_init(H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
int pic_struct_present_flag
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
static void release_unused_pictures(H264Context *h, int remove_current)
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
static int h264_field_start(H264Context *h, const H264SliceContext *sl, const H2645NAL *nal)
the normal 219*2^(n-8) "MPEG" YUV ranges
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Views are next to each other.
#define CONFIG_ERROR_RESILIENCE
hardware decoding through VDA
discard all non reference
int anticlockwise_rotation
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
AVBufferPool * qscale_table_pool
AVBufferPool * motion_val_pool
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
H264SEIFramePacking frame_packing
H.264 / AVC / MPEG-4 part10 motion vector prediction.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
int8_t * intra4x4_pred_mode
enum AVDiscard skip_loop_filter
static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
int bit_depth_luma
bit_depth_luma_minus8 + 8
void ff_h264_free_tables(H264Context *h)
4: bottom field, top field, in that order
static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple)
int8_t ref_cache[2][5 *8]
void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
#define AV_CODEC_FLAG_OUTPUT_CORRUPT
Output even those frames that might be corrupted.
int top_field_first
If the content is interlaced, is top field displayed first.
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Views are packed in a checkerboard-like structure per pixel.
int key_frame
1 -> keyframe, 0-> not
Views are packed per column.
static int find_unused_picture(H264Context *h)
int current_slice
current slice number, used to initialize slice_num of each thread/context
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
static const uint8_t * align_get_bits(GetBitContext *s)
int mb_width
pic_width_in_mbs_minus1 + 1
int flags2
AV_CODEC_FLAG2_*.
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
AVBufferRef * ref_index_buf[2]
const uint8_t * field_scan_q0
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
void ff_er_frame_start(ERContext *s)
uint8_t(*[2] mvd_table)[2]
uint8_t field_scan8x8[64]
static av_always_inline void fill_filter_caches_inter(const H264Context *h, H264SliceContext *sl, int mb_type, int top_xy, int left_xy[LEFT_MBS], int top_type, int left_type[LEFT_MBS], int mb_xy, int list)
int prev_frame_num_offset
for POC type 2
HW decoding through Direct3D11, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer...
int8_t * intra4x4_pred_mode
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
static int decode_slice(struct AVCodecContext *avctx, void *arg)
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)
int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
Init context Allocate buffers which are not shared amongst multiple threads.
int mb_field_decoding_flag
static enum AVPixelFormat get_pixel_format(H264Context *h)
uint8_t(* non_zero_count)[48]
static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
uint8_t * bipred_scratchpad
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
AVPixelFormat
Pixel format.
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure)
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
#define FRAME_RECOVERED_IDR
We have seen an IDR, so all the following frames in coded order are correctly decodable.
6: bottom field, top field, bottom field repeated, in that order
Context Adaptive Binary Arithmetic Coder.
#define H264_MAX_PICTURE_COUNT
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl)
int short_ref_count
number of actual short term references
enum AVColorSpace colorspace