2 * H.26L/H.264/AVC/JVT/14496-10/... decoder
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * H.264 / AVC / MPEG4 part10 codec.
25 * @author Michael Niedermayer <michaelni@gmx.at>
28 #include "libavutil/avassert.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/timer.h"
33 #include "cabac_functions.h"
34 #include "error_resilience.h"
38 #include "h264chroma.h"
39 #include "h264_mvpred.h"
42 #include "mpegutils.h"
43 #include "rectangle.h"
47 static const uint8_t rem6
[QP_MAX_NUM
+ 1] = {
48 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
49 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
50 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
51 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
55 static const uint8_t div6
[QP_MAX_NUM
+ 1] = {
56 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
57 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
58 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10,
59 10,10,10,11,11,11,11,11,11,12,12,12,12,12,12,13,13,13, 13, 13, 13,
63 static const uint8_t field_scan
[16+1] = {
64 0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
65 0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
66 2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
67 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
70 static const uint8_t field_scan8x8
[64+1] = {
71 0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
72 1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
73 2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
74 0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
75 2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
76 2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
77 2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
78 3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
79 3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
80 4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
81 4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
82 5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
83 5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
84 7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
85 6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
86 7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
89 static const uint8_t field_scan8x8_cavlc
[64+1] = {
90 0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
91 2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
92 3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
93 5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
94 0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
95 1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
96 3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
97 5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
98 0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
99 1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
100 3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
101 5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
102 1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
103 1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
104 3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
105 6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
108 // zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
109 static const uint8_t zigzag_scan8x8_cavlc
[64+1] = {
110 0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
111 4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
112 3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
113 2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
114 1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
115 3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
116 2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
117 3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
118 0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
119 2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
120 1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
121 4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
122 0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
123 1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
124 0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
125 5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
128 static const uint8_t dequant4_coeff_init
[6][3] = {
137 static const uint8_t dequant8_coeff_init_scan
[16] = {
138 0, 3, 4, 3, 3, 1, 5, 1, 4, 5, 2, 5, 3, 1, 5, 1
141 static const uint8_t dequant8_coeff_init
[6][6] = {
142 { 20, 18, 32, 19, 25, 24 },
143 { 22, 19, 35, 21, 28, 26 },
144 { 26, 23, 42, 24, 33, 31 },
145 { 28, 25, 45, 26, 35, 33 },
146 { 32, 28, 51, 30, 40, 38 },
147 { 36, 32, 58, 34, 46, 43 },
150 static const enum AVPixelFormat h264_hwaccel_pixfmt_list_420
[] = {
151 #if CONFIG_H264_DXVA2_HWACCEL
152 AV_PIX_FMT_DXVA2_VLD
,
154 #if CONFIG_H264_VAAPI_HWACCEL
155 AV_PIX_FMT_VAAPI_VLD
,
157 #if CONFIG_H264_VDA_HWACCEL
161 #if CONFIG_H264_VDPAU_HWACCEL
168 static const enum AVPixelFormat h264_hwaccel_pixfmt_list_jpeg_420
[] = {
169 #if CONFIG_H264_DXVA2_HWACCEL
170 AV_PIX_FMT_DXVA2_VLD
,
172 #if CONFIG_H264_VAAPI_HWACCEL
173 AV_PIX_FMT_VAAPI_VLD
,
175 #if CONFIG_H264_VDA_HWACCEL
179 #if CONFIG_H264_VDPAU_HWACCEL
187 static void release_unused_pictures(H264Context
*h
, int remove_current
)
191 /* release non reference frames */
192 for (i
= 0; i
< H264_MAX_PICTURE_COUNT
; i
++) {
193 if (h
->DPB
[i
].f
.buf
[0] && !h
->DPB
[i
].reference
&&
194 (remove_current
|| &h
->DPB
[i
] != h
->cur_pic_ptr
)) {
195 ff_h264_unref_picture(h
, &h
->DPB
[i
]);
200 static int alloc_scratch_buffers(H264Context
*h
, int linesize
)
202 int alloc_size
= FFALIGN(FFABS(linesize
) + 32, 32);
204 if (h
->bipred_scratchpad
)
207 h
->bipred_scratchpad
= av_malloc(16 * 6 * alloc_size
);
208 // edge emu needs blocksize + filter length - 1
209 // (= 21x21 for h264)
210 h
->edge_emu_buffer
= av_mallocz(alloc_size
* 2 * 21);
212 if (!h
->bipred_scratchpad
|| !h
->edge_emu_buffer
) {
213 av_freep(&h
->bipred_scratchpad
);
214 av_freep(&h
->edge_emu_buffer
);
215 return AVERROR(ENOMEM
);
221 static int init_table_pools(H264Context
*h
)
223 const int big_mb_num
= h
->mb_stride
* (h
->mb_height
+ 1) + 1;
224 const int mb_array_size
= h
->mb_stride
* h
->mb_height
;
225 const int b4_stride
= h
->mb_width
* 4 + 1;
226 const int b4_array_size
= b4_stride
* h
->mb_height
* 4;
228 h
->qscale_table_pool
= av_buffer_pool_init(big_mb_num
+ h
->mb_stride
,
230 h
->mb_type_pool
= av_buffer_pool_init((big_mb_num
+ h
->mb_stride
) *
231 sizeof(uint32_t), av_buffer_allocz
);
232 h
->motion_val_pool
= av_buffer_pool_init(2 * (b4_array_size
+ 4) *
233 sizeof(int16_t), av_buffer_allocz
);
234 h
->ref_index_pool
= av_buffer_pool_init(4 * mb_array_size
, av_buffer_allocz
);
236 if (!h
->qscale_table_pool
|| !h
->mb_type_pool
|| !h
->motion_val_pool
||
237 !h
->ref_index_pool
) {
238 av_buffer_pool_uninit(&h
->qscale_table_pool
);
239 av_buffer_pool_uninit(&h
->mb_type_pool
);
240 av_buffer_pool_uninit(&h
->motion_val_pool
);
241 av_buffer_pool_uninit(&h
->ref_index_pool
);
242 return AVERROR(ENOMEM
);
248 static int alloc_picture(H264Context
*h
, H264Picture
*pic
)
252 av_assert0(!pic
->f
.data
[0]);
255 ret
= ff_thread_get_buffer(h
->avctx
, &pic
->tf
, pic
->reference
?
256 AV_GET_BUFFER_FLAG_REF
: 0);
260 h
->linesize
= pic
->f
.linesize
[0];
261 h
->uvlinesize
= pic
->f
.linesize
[1];
262 pic
->crop
= h
->sps
.crop
;
263 pic
->crop_top
= h
->sps
.crop_top
;
264 pic
->crop_left
= h
->sps
.crop_left
;
266 if (h
->avctx
->hwaccel
) {
267 const AVHWAccel
*hwaccel
= h
->avctx
->hwaccel
;
268 av_assert0(!pic
->hwaccel_picture_private
);
269 if (hwaccel
->frame_priv_data_size
) {
270 pic
->hwaccel_priv_buf
= av_buffer_allocz(hwaccel
->frame_priv_data_size
);
271 if (!pic
->hwaccel_priv_buf
)
272 return AVERROR(ENOMEM
);
273 pic
->hwaccel_picture_private
= pic
->hwaccel_priv_buf
->data
;
276 if (!h
->avctx
->hwaccel
&& CONFIG_GRAY
&& h
->flags
& CODEC_FLAG_GRAY
&& pic
->f
.data
[2]) {
277 int h_chroma_shift
, v_chroma_shift
;
278 av_pix_fmt_get_chroma_sub_sample(pic
->f
.format
,
279 &h_chroma_shift
, &v_chroma_shift
);
281 for(i
=0; i
<FF_CEIL_RSHIFT(h
->avctx
->height
, v_chroma_shift
); i
++) {
282 memset(pic
->f
.data
[1] + pic
->f
.linesize
[1]*i
,
283 0x80, FF_CEIL_RSHIFT(h
->avctx
->width
, h_chroma_shift
));
284 memset(pic
->f
.data
[2] + pic
->f
.linesize
[2]*i
,
285 0x80, FF_CEIL_RSHIFT(h
->avctx
->width
, h_chroma_shift
));
289 if (!h
->qscale_table_pool
) {
290 ret
= init_table_pools(h
);
295 pic
->qscale_table_buf
= av_buffer_pool_get(h
->qscale_table_pool
);
296 pic
->mb_type_buf
= av_buffer_pool_get(h
->mb_type_pool
);
297 if (!pic
->qscale_table_buf
|| !pic
->mb_type_buf
)
300 pic
->mb_type
= (uint32_t*)pic
->mb_type_buf
->data
+ 2 * h
->mb_stride
+ 1;
301 pic
->qscale_table
= pic
->qscale_table_buf
->data
+ 2 * h
->mb_stride
+ 1;
303 for (i
= 0; i
< 2; i
++) {
304 pic
->motion_val_buf
[i
] = av_buffer_pool_get(h
->motion_val_pool
);
305 pic
->ref_index_buf
[i
] = av_buffer_pool_get(h
->ref_index_pool
);
306 if (!pic
->motion_val_buf
[i
] || !pic
->ref_index_buf
[i
])
309 pic
->motion_val
[i
] = (int16_t (*)[2])pic
->motion_val_buf
[i
]->data
+ 4;
310 pic
->ref_index
[i
] = pic
->ref_index_buf
[i
]->data
;
315 ff_h264_unref_picture(h
, pic
);
316 return (ret
< 0) ? ret
: AVERROR(ENOMEM
);
319 static inline int pic_is_unused(H264Context
*h
, H264Picture
*pic
)
323 if (pic
->needs_realloc
&& !(pic
->reference
& DELAYED_PIC_REF
))
328 static int find_unused_picture(H264Context
*h
)
332 for (i
= 0; i
< H264_MAX_PICTURE_COUNT
; i
++) {
333 if (pic_is_unused(h
, &h
->DPB
[i
]))
336 if (i
== H264_MAX_PICTURE_COUNT
)
337 return AVERROR_INVALIDDATA
;
339 if (h
->DPB
[i
].needs_realloc
) {
340 h
->DPB
[i
].needs_realloc
= 0;
341 ff_h264_unref_picture(h
, &h
->DPB
[i
]);
348 static void init_dequant8_coeff_table(H264Context
*h
)
351 const int max_qp
= 51 + 6 * (h
->sps
.bit_depth_luma
- 8);
353 for (i
= 0; i
< 6; i
++) {
354 h
->dequant8_coeff
[i
] = h
->dequant8_buffer
[i
];
355 for (j
= 0; j
< i
; j
++)
356 if (!memcmp(h
->pps
.scaling_matrix8
[j
], h
->pps
.scaling_matrix8
[i
],
357 64 * sizeof(uint8_t))) {
358 h
->dequant8_coeff
[i
] = h
->dequant8_buffer
[j
];
364 for (q
= 0; q
< max_qp
+ 1; q
++) {
367 for (x
= 0; x
< 64; x
++)
368 h
->dequant8_coeff
[i
][q
][(x
>> 3) | ((x
& 7) << 3)] =
369 ((uint32_t)dequant8_coeff_init
[idx
][dequant8_coeff_init_scan
[((x
>> 1) & 12) | (x
& 3)]] *
370 h
->pps
.scaling_matrix8
[i
][x
]) << shift
;
375 static void init_dequant4_coeff_table(H264Context
*h
)
378 const int max_qp
= 51 + 6 * (h
->sps
.bit_depth_luma
- 8);
379 for (i
= 0; i
< 6; i
++) {
380 h
->dequant4_coeff
[i
] = h
->dequant4_buffer
[i
];
381 for (j
= 0; j
< i
; j
++)
382 if (!memcmp(h
->pps
.scaling_matrix4
[j
], h
->pps
.scaling_matrix4
[i
],
383 16 * sizeof(uint8_t))) {
384 h
->dequant4_coeff
[i
] = h
->dequant4_buffer
[j
];
390 for (q
= 0; q
< max_qp
+ 1; q
++) {
391 int shift
= div6
[q
] + 2;
393 for (x
= 0; x
< 16; x
++)
394 h
->dequant4_coeff
[i
][q
][(x
>> 2) | ((x
<< 2) & 0xF)] =
395 ((uint32_t)dequant4_coeff_init
[idx
][(x
& 1) + ((x
>> 2) & 1)] *
396 h
->pps
.scaling_matrix4
[i
][x
]) << shift
;
401 void h264_init_dequant_tables(H264Context
*h
)
404 init_dequant4_coeff_table(h
);
405 memset(h
->dequant8_coeff
, 0, sizeof(h
->dequant8_coeff
));
407 if (h
->pps
.transform_8x8_mode
)
408 init_dequant8_coeff_table(h
);
409 if (h
->sps
.transform_bypass
) {
410 for (i
= 0; i
< 6; i
++)
411 for (x
= 0; x
< 16; x
++)
412 h
->dequant4_coeff
[i
][0][x
] = 1 << 6;
413 if (h
->pps
.transform_8x8_mode
)
414 for (i
= 0; i
< 6; i
++)
415 for (x
= 0; x
< 64; x
++)
416 h
->dequant8_coeff
[i
][0][x
] = 1 << 6;
421 * Mimic alloc_tables(), but for every context thread.
423 static void clone_tables(H264Context
*dst
, H264Context
*src
, int i
)
425 dst
->intra4x4_pred_mode
= src
->intra4x4_pred_mode
+ i
* 8 * 2 * src
->mb_stride
;
426 dst
->non_zero_count
= src
->non_zero_count
;
427 dst
->slice_table
= src
->slice_table
;
428 dst
->cbp_table
= src
->cbp_table
;
429 dst
->mb2b_xy
= src
->mb2b_xy
;
430 dst
->mb2br_xy
= src
->mb2br_xy
;
431 dst
->chroma_pred_mode_table
= src
->chroma_pred_mode_table
;
432 dst
->mvd_table
[0] = src
->mvd_table
[0] + i
* 8 * 2 * src
->mb_stride
;
433 dst
->mvd_table
[1] = src
->mvd_table
[1] + i
* 8 * 2 * src
->mb_stride
;
434 dst
->direct_table
= src
->direct_table
;
435 dst
->list_counts
= src
->list_counts
;
437 dst
->cur_pic_ptr
= src
->cur_pic_ptr
;
438 dst
->cur_pic
= src
->cur_pic
;
439 dst
->bipred_scratchpad
= NULL
;
440 dst
->edge_emu_buffer
= NULL
;
441 ff_h264_pred_init(&dst
->hpc
, src
->avctx
->codec_id
, src
->sps
.bit_depth_luma
,
442 src
->sps
.chroma_format_idc
);
445 #define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b) + (size))))
446 #undef REBASE_PICTURE
447 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
448 (((pic) && (pic) >= (old_ctx)->DPB && \
449 (pic) < (old_ctx)->DPB + H264_MAX_PICTURE_COUNT) ? \
450 &(new_ctx)->DPB[(pic) - (old_ctx)->DPB] : NULL)
452 static void copy_picture_range(H264Picture
**to
, H264Picture
**from
, int count
,
453 H264Context
*new_base
,
454 H264Context
*old_base
)
458 for (i
= 0; i
< count
; i
++) {
459 assert((IN_RANGE(from
[i
], old_base
, sizeof(*old_base
)) ||
460 IN_RANGE(from
[i
], old_base
->DPB
,
461 sizeof(H264Picture
) * H264_MAX_PICTURE_COUNT
) ||
463 to
[i
] = REBASE_PICTURE(from
[i
], new_base
, old_base
);
467 static int copy_parameter_set(void **to
, void **from
, int count
, int size
)
471 for (i
= 0; i
< count
; i
++) {
472 if (to
[i
] && !from
[i
]) {
474 } else if (from
[i
] && !to
[i
]) {
475 to
[i
] = av_malloc(size
);
477 return AVERROR(ENOMEM
);
481 memcpy(to
[i
], from
[i
], size
);
487 #define copy_fields(to, from, start_field, end_field) \
488 memcpy(&(to)->start_field, &(from)->start_field, \
489 (char *)&(to)->end_field - (char *)&(to)->start_field)
491 static int h264_slice_header_init(H264Context
*h
, int reinit
);
493 int ff_h264_update_thread_context(AVCodecContext
*dst
,
494 const AVCodecContext
*src
)
496 H264Context
*h
= dst
->priv_data
, *h1
= src
->priv_data
;
497 int inited
= h
->context_initialized
, err
= 0;
498 int context_reinitialized
= 0;
505 (h
->width
!= h1
->width
||
506 h
->height
!= h1
->height
||
507 h
->mb_width
!= h1
->mb_width
||
508 h
->mb_height
!= h1
->mb_height
||
509 h
->sps
.bit_depth_luma
!= h1
->sps
.bit_depth_luma
||
510 h
->sps
.chroma_format_idc
!= h1
->sps
.chroma_format_idc
||
511 h
->sps
.colorspace
!= h1
->sps
.colorspace
)) {
513 /* set bits_per_raw_sample to the previous value. the check for changed
514 * bit depth in h264_set_parameter_from_sps() uses it and sets it to
515 * the current value */
516 h
->avctx
->bits_per_raw_sample
= h
->sps
.bit_depth_luma
;
518 av_freep(&h
->bipred_scratchpad
);
520 h
->width
= h1
->width
;
521 h
->height
= h1
->height
;
522 h
->mb_height
= h1
->mb_height
;
523 h
->mb_width
= h1
->mb_width
;
524 h
->mb_num
= h1
->mb_num
;
525 h
->mb_stride
= h1
->mb_stride
;
526 h
->b_stride
= h1
->b_stride
;
528 if ((ret
= copy_parameter_set((void **)h
->sps_buffers
,
529 (void **)h1
->sps_buffers
,
530 MAX_SPS_COUNT
, sizeof(SPS
))) < 0)
533 if ((ret
= copy_parameter_set((void **)h
->pps_buffers
,
534 (void **)h1
->pps_buffers
,
535 MAX_PPS_COUNT
, sizeof(PPS
))) < 0)
539 if ((err
= h264_slice_header_init(h
, 1)) < 0) {
540 av_log(h
->avctx
, AV_LOG_ERROR
, "h264_slice_header_init() failed\n");
543 context_reinitialized
= 1;
546 h264_set_parameter_from_sps(h
);
547 //Note we set context_reinitialized which will cause h264_set_parameter_from_sps to be reexecuted
548 h
->cur_chroma_format_idc
= h1
->cur_chroma_format_idc
;
551 /* update linesize on resize for h264. The h264 decoder doesn't
552 * necessarily call ff_mpv_frame_start in the new thread */
553 h
->linesize
= h1
->linesize
;
554 h
->uvlinesize
= h1
->uvlinesize
;
556 /* copy block_offset since frame_start may not be called */
557 memcpy(h
->block_offset
, h1
->block_offset
, sizeof(h
->block_offset
));
560 for (i
= 0; i
< MAX_SPS_COUNT
; i
++)
561 av_freep(h
->sps_buffers
+ i
);
563 for (i
= 0; i
< MAX_PPS_COUNT
; i
++)
564 av_freep(h
->pps_buffers
+ i
);
566 av_freep(&h
->rbsp_buffer
[0]);
567 av_freep(&h
->rbsp_buffer
[1]);
568 memcpy(h
, h1
, offsetof(H264Context
, intra_pcm_ptr
));
569 memcpy(&h
->cabac
, &h1
->cabac
,
570 sizeof(H264Context
) - offsetof(H264Context
, cabac
));
571 av_assert0((void*)&h
->cabac
== &h
->mb_padding
+ 1);
573 memset(h
->sps_buffers
, 0, sizeof(h
->sps_buffers
));
574 memset(h
->pps_buffers
, 0, sizeof(h
->pps_buffers
));
576 memset(&h
->er
, 0, sizeof(h
->er
));
577 memset(&h
->mb
, 0, sizeof(h
->mb
));
578 memset(&h
->mb_luma_dc
, 0, sizeof(h
->mb_luma_dc
));
579 memset(&h
->mb_padding
, 0, sizeof(h
->mb_padding
));
580 memset(&h
->cur_pic
, 0, sizeof(h
->cur_pic
));
584 h
->qscale_table_pool
= NULL
;
585 h
->mb_type_pool
= NULL
;
586 h
->ref_index_pool
= NULL
;
587 h
->motion_val_pool
= NULL
;
588 h
->intra4x4_pred_mode
= NULL
;
589 h
->non_zero_count
= NULL
;
590 h
->slice_table_base
= NULL
;
591 h
->slice_table
= NULL
;
593 h
->chroma_pred_mode_table
= NULL
;
594 memset(h
->mvd_table
, 0, sizeof(h
->mvd_table
));
595 h
->direct_table
= NULL
;
596 h
->list_counts
= NULL
;
599 for (i
= 0; i
< 2; i
++) {
600 h
->rbsp_buffer
[i
] = NULL
;
601 h
->rbsp_buffer_size
[i
] = 0;
604 if (h1
->context_initialized
) {
605 h
->context_initialized
= 0;
607 memset(&h
->cur_pic
, 0, sizeof(h
->cur_pic
));
608 av_frame_unref(&h
->cur_pic
.f
);
609 h
->cur_pic
.tf
.f
= &h
->cur_pic
.f
;
611 ret
= ff_h264_alloc_tables(h
);
613 av_log(dst
, AV_LOG_ERROR
, "Could not allocate memory\n");
616 ret
= ff_h264_context_init(h
);
618 av_log(dst
, AV_LOG_ERROR
, "context_init() failed.\n");
623 h
->bipred_scratchpad
= NULL
;
624 h
->edge_emu_buffer
= NULL
;
626 h
->thread_context
[0] = h
;
627 h
->context_initialized
= h1
->context_initialized
;
630 h
->avctx
->coded_height
= h1
->avctx
->coded_height
;
631 h
->avctx
->coded_width
= h1
->avctx
->coded_width
;
632 h
->avctx
->width
= h1
->avctx
->width
;
633 h
->avctx
->height
= h1
->avctx
->height
;
634 h
->coded_picture_number
= h1
->coded_picture_number
;
635 h
->first_field
= h1
->first_field
;
636 h
->picture_structure
= h1
->picture_structure
;
637 h
->qscale
= h1
->qscale
;
638 h
->droppable
= h1
->droppable
;
639 h
->low_delay
= h1
->low_delay
;
641 for (i
= 0; h
->DPB
&& i
< H264_MAX_PICTURE_COUNT
; i
++) {
642 ff_h264_unref_picture(h
, &h
->DPB
[i
]);
643 if (h1
->DPB
&& h1
->DPB
[i
].f
.buf
[0] &&
644 (ret
= ff_h264_ref_picture(h
, &h
->DPB
[i
], &h1
->DPB
[i
])) < 0)
648 h
->cur_pic_ptr
= REBASE_PICTURE(h1
->cur_pic_ptr
, h
, h1
);
649 ff_h264_unref_picture(h
, &h
->cur_pic
);
650 if (h1
->cur_pic
.f
.buf
[0] && (ret
= ff_h264_ref_picture(h
, &h
->cur_pic
, &h1
->cur_pic
)) < 0)
653 h
->workaround_bugs
= h1
->workaround_bugs
;
654 h
->low_delay
= h1
->low_delay
;
655 h
->droppable
= h1
->droppable
;
657 // extradata/NAL handling
658 h
->is_avc
= h1
->is_avc
;
661 if ((ret
= copy_parameter_set((void **)h
->sps_buffers
,
662 (void **)h1
->sps_buffers
,
663 MAX_SPS_COUNT
, sizeof(SPS
))) < 0)
666 if ((ret
= copy_parameter_set((void **)h
->pps_buffers
,
667 (void **)h1
->pps_buffers
,
668 MAX_PPS_COUNT
, sizeof(PPS
))) < 0)
672 // Dequantization matrices
673 // FIXME these are big - can they be only copied when PPS changes?
674 copy_fields(h
, h1
, dequant4_buffer
, dequant4_coeff
);
676 for (i
= 0; i
< 6; i
++)
677 h
->dequant4_coeff
[i
] = h
->dequant4_buffer
[0] +
678 (h1
->dequant4_coeff
[i
] - h1
->dequant4_buffer
[0]);
680 for (i
= 0; i
< 6; i
++)
681 h
->dequant8_coeff
[i
] = h
->dequant8_buffer
[0] +
682 (h1
->dequant8_coeff
[i
] - h1
->dequant8_buffer
[0]);
684 h
->dequant_coeff_pps
= h1
->dequant_coeff_pps
;
687 copy_fields(h
, h1
, poc_lsb
, redundant_pic_count
);
690 copy_fields(h
, h1
, short_ref
, cabac_init_idc
);
692 copy_picture_range(h
->short_ref
, h1
->short_ref
, 32, h
, h1
);
693 copy_picture_range(h
->long_ref
, h1
->long_ref
, 32, h
, h1
);
694 copy_picture_range(h
->delayed_pic
, h1
->delayed_pic
,
695 MAX_DELAYED_PIC_COUNT
+ 2, h
, h1
);
697 h
->frame_recovered
= h1
->frame_recovered
;
699 if (context_reinitialized
)
700 ff_h264_set_parameter_from_sps(h
);
706 err
= ff_h264_execute_ref_pic_marking(h
, h
->mmco
, h
->mmco_index
);
707 h
->prev_poc_msb
= h
->poc_msb
;
708 h
->prev_poc_lsb
= h
->poc_lsb
;
710 h
->prev_frame_num_offset
= h
->frame_num_offset
;
711 h
->prev_frame_num
= h
->frame_num
;
712 h
->outputed_poc
= h
->next_outputed_poc
;
714 h
->recovery_frame
= h1
->recovery_frame
;
719 static int h264_frame_start(H264Context
*h
)
723 const int pixel_shift
= h
->pixel_shift
;
725 1<<(h
->sps
.bit_depth_luma
-1),
726 1<<(h
->sps
.bit_depth_chroma
-1),
727 1<<(h
->sps
.bit_depth_chroma
-1),
731 if (!ff_thread_can_start_frame(h
->avctx
)) {
732 av_log(h
->avctx
, AV_LOG_ERROR
, "Attempt to start a frame outside SETUP state\n");
736 release_unused_pictures(h
, 1);
737 h
->cur_pic_ptr
= NULL
;
739 i
= find_unused_picture(h
);
741 av_log(h
->avctx
, AV_LOG_ERROR
, "no frame buffer available\n");
746 pic
->reference
= h
->droppable
? 0 : h
->picture_structure
;
747 pic
->f
.coded_picture_number
= h
->coded_picture_number
++;
748 pic
->field_picture
= h
->picture_structure
!= PICT_FRAME
;
751 * Zero key_frame here; IDR markings per slice in frame or fields are ORed
753 * See decode_nal_units().
755 pic
->f
.key_frame
= 0;
758 pic
->invalid_gap
= 0;
759 pic
->sei_recovery_frame_cnt
= h
->sei_recovery_frame_cnt
;
761 if ((ret
= alloc_picture(h
, pic
)) < 0)
763 if(!h
->frame_recovered
&& !h
->avctx
->hwaccel
&&
764 !(h
->avctx
->codec
->capabilities
& CODEC_CAP_HWACCEL_VDPAU
))
765 avpriv_color_frame(&pic
->f
, c
);
767 h
->cur_pic_ptr
= pic
;
768 ff_h264_unref_picture(h
, &h
->cur_pic
);
769 if (CONFIG_ERROR_RESILIENCE
) {
770 ff_h264_set_erpic(&h
->er
.cur_pic
, NULL
);
773 if ((ret
= ff_h264_ref_picture(h
, &h
->cur_pic
, h
->cur_pic_ptr
)) < 0)
776 if (CONFIG_ERROR_RESILIENCE
) {
777 ff_er_frame_start(&h
->er
);
778 ff_h264_set_erpic(&h
->er
.last_pic
, NULL
);
779 ff_h264_set_erpic(&h
->er
.next_pic
, NULL
);
782 assert(h
->linesize
&& h
->uvlinesize
);
784 for (i
= 0; i
< 16; i
++) {
785 h
->block_offset
[i
] = (4 * ((scan8
[i
] - scan8
[0]) & 7) << pixel_shift
) + 4 * h
->linesize
* ((scan8
[i
] - scan8
[0]) >> 3);
786 h
->block_offset
[48 + i
] = (4 * ((scan8
[i
] - scan8
[0]) & 7) << pixel_shift
) + 8 * h
->linesize
* ((scan8
[i
] - scan8
[0]) >> 3);
788 for (i
= 0; i
< 16; i
++) {
789 h
->block_offset
[16 + i
] =
790 h
->block_offset
[32 + i
] = (4 * ((scan8
[i
] - scan8
[0]) & 7) << pixel_shift
) + 4 * h
->uvlinesize
* ((scan8
[i
] - scan8
[0]) >> 3);
791 h
->block_offset
[48 + 16 + i
] =
792 h
->block_offset
[48 + 32 + i
] = (4 * ((scan8
[i
] - scan8
[0]) & 7) << pixel_shift
) + 8 * h
->uvlinesize
* ((scan8
[i
] - scan8
[0]) >> 3);
795 /* We mark the current picture as non-reference after allocating it, so
796 * that if we break out due to an error it can be released automatically
797 * in the next ff_mpv_frame_start().
799 h
->cur_pic_ptr
->reference
= 0;
801 h
->cur_pic_ptr
->field_poc
[0] = h
->cur_pic_ptr
->field_poc
[1] = INT_MAX
;
803 h
->next_output_pic
= NULL
;
805 assert(h
->cur_pic_ptr
->long_ref
== 0);
810 static av_always_inline
void backup_mb_border(H264Context
*h
, uint8_t *src_y
,
811 uint8_t *src_cb
, uint8_t *src_cr
,
812 int linesize
, int uvlinesize
,
817 const int pixel_shift
= h
->pixel_shift
;
818 int chroma444
= CHROMA444(h
);
819 int chroma422
= CHROMA422(h
);
822 src_cb
-= uvlinesize
;
823 src_cr
-= uvlinesize
;
825 if (!simple
&& FRAME_MBAFF(h
)) {
828 top_border
= h
->top_borders
[0][h
->mb_x
];
829 AV_COPY128(top_border
, src_y
+ 15 * linesize
);
831 AV_COPY128(top_border
+ 16, src_y
+ 15 * linesize
+ 16);
832 if (simple
|| !CONFIG_GRAY
|| !(h
->flags
& CODEC_FLAG_GRAY
)) {
835 AV_COPY128(top_border
+ 32, src_cb
+ 15 * uvlinesize
);
836 AV_COPY128(top_border
+ 48, src_cb
+ 15 * uvlinesize
+ 16);
837 AV_COPY128(top_border
+ 64, src_cr
+ 15 * uvlinesize
);
838 AV_COPY128(top_border
+ 80, src_cr
+ 15 * uvlinesize
+ 16);
840 AV_COPY128(top_border
+ 16, src_cb
+ 15 * uvlinesize
);
841 AV_COPY128(top_border
+ 32, src_cr
+ 15 * uvlinesize
);
843 } else if (chroma422
) {
845 AV_COPY128(top_border
+ 32, src_cb
+ 15 * uvlinesize
);
846 AV_COPY128(top_border
+ 48, src_cr
+ 15 * uvlinesize
);
848 AV_COPY64(top_border
+ 16, src_cb
+ 15 * uvlinesize
);
849 AV_COPY64(top_border
+ 24, src_cr
+ 15 * uvlinesize
);
853 AV_COPY128(top_border
+ 32, src_cb
+ 7 * uvlinesize
);
854 AV_COPY128(top_border
+ 48, src_cr
+ 7 * uvlinesize
);
856 AV_COPY64(top_border
+ 16, src_cb
+ 7 * uvlinesize
);
857 AV_COPY64(top_border
+ 24, src_cr
+ 7 * uvlinesize
);
862 } else if (MB_MBAFF(h
)) {
868 top_border
= h
->top_borders
[top_idx
][h
->mb_x
];
869 /* There are two lines saved, the line above the top macroblock
870 * of a pair, and the line above the bottom macroblock. */
871 AV_COPY128(top_border
, src_y
+ 16 * linesize
);
873 AV_COPY128(top_border
+ 16, src_y
+ 16 * linesize
+ 16);
875 if (simple
|| !CONFIG_GRAY
|| !(h
->flags
& CODEC_FLAG_GRAY
)) {
878 AV_COPY128(top_border
+ 32, src_cb
+ 16 * linesize
);
879 AV_COPY128(top_border
+ 48, src_cb
+ 16 * linesize
+ 16);
880 AV_COPY128(top_border
+ 64, src_cr
+ 16 * linesize
);
881 AV_COPY128(top_border
+ 80, src_cr
+ 16 * linesize
+ 16);
883 AV_COPY128(top_border
+ 16, src_cb
+ 16 * linesize
);
884 AV_COPY128(top_border
+ 32, src_cr
+ 16 * linesize
);
886 } else if (chroma422
) {
888 AV_COPY128(top_border
+ 32, src_cb
+ 16 * uvlinesize
);
889 AV_COPY128(top_border
+ 48, src_cr
+ 16 * uvlinesize
);
891 AV_COPY64(top_border
+ 16, src_cb
+ 16 * uvlinesize
);
892 AV_COPY64(top_border
+ 24, src_cr
+ 16 * uvlinesize
);
896 AV_COPY128(top_border
+ 32, src_cb
+ 8 * uvlinesize
);
897 AV_COPY128(top_border
+ 48, src_cr
+ 8 * uvlinesize
);
899 AV_COPY64(top_border
+ 16, src_cb
+ 8 * uvlinesize
);
900 AV_COPY64(top_border
+ 24, src_cr
+ 8 * uvlinesize
);
907 * Initialize implicit_weight table.
908 * @param field 0/1 initialize the weight for interlaced MBAFF
909 * -1 initializes the rest
911 static void implicit_weight_table(H264Context
*h
, int field
)
913 int ref0
, ref1
, i
, cur_poc
, ref_start
, ref_count0
, ref_count1
;
915 for (i
= 0; i
< 2; i
++) {
916 h
->luma_weight_flag
[i
] = 0;
917 h
->chroma_weight_flag
[i
] = 0;
921 if (h
->picture_structure
== PICT_FRAME
) {
922 cur_poc
= h
->cur_pic_ptr
->poc
;
924 cur_poc
= h
->cur_pic_ptr
->field_poc
[h
->picture_structure
- 1];
926 if (h
->ref_count
[0] == 1 && h
->ref_count
[1] == 1 && !FRAME_MBAFF(h
) &&
927 h
->ref_list
[0][0].poc
+ h
->ref_list
[1][0].poc
== 2 * cur_poc
) {
929 h
->use_weight_chroma
= 0;
933 ref_count0
= h
->ref_count
[0];
934 ref_count1
= h
->ref_count
[1];
936 cur_poc
= h
->cur_pic_ptr
->field_poc
[field
];
938 ref_count0
= 16 + 2 * h
->ref_count
[0];
939 ref_count1
= 16 + 2 * h
->ref_count
[1];
943 h
->use_weight_chroma
= 2;
944 h
->luma_log2_weight_denom
= 5;
945 h
->chroma_log2_weight_denom
= 5;
947 for (ref0
= ref_start
; ref0
< ref_count0
; ref0
++) {
948 int poc0
= h
->ref_list
[0][ref0
].poc
;
949 for (ref1
= ref_start
; ref1
< ref_count1
; ref1
++) {
951 if (!h
->ref_list
[0][ref0
].long_ref
&& !h
->ref_list
[1][ref1
].long_ref
) {
952 int poc1
= h
->ref_list
[1][ref1
].poc
;
953 int td
= av_clip(poc1
- poc0
, -128, 127);
955 int tb
= av_clip(cur_poc
- poc0
, -128, 127);
956 int tx
= (16384 + (FFABS(td
) >> 1)) / td
;
957 int dist_scale_factor
= (tb
* tx
+ 32) >> 8;
958 if (dist_scale_factor
>= -64 && dist_scale_factor
<= 128)
959 w
= 64 - dist_scale_factor
;
963 h
->implicit_weight
[ref0
][ref1
][0] =
964 h
->implicit_weight
[ref0
][ref1
][1] = w
;
966 h
->implicit_weight
[ref0
][ref1
][field
] = w
;
973 * initialize scan tables
975 static void init_scan_tables(H264Context
*h
)
978 for (i
= 0; i
< 16; i
++) {
979 #define TRANSPOSE(x) ((x) >> 2) | (((x) << 2) & 0xF)
980 h
->zigzag_scan
[i
] = TRANSPOSE(zigzag_scan
[i
]);
981 h
->field_scan
[i
] = TRANSPOSE(field_scan
[i
]);
984 for (i
= 0; i
< 64; i
++) {
985 #define TRANSPOSE(x) ((x) >> 3) | (((x) & 7) << 3)
986 h
->zigzag_scan8x8
[i
] = TRANSPOSE(ff_zigzag_direct
[i
]);
987 h
->zigzag_scan8x8_cavlc
[i
] = TRANSPOSE(zigzag_scan8x8_cavlc
[i
]);
988 h
->field_scan8x8
[i
] = TRANSPOSE(field_scan8x8
[i
]);
989 h
->field_scan8x8_cavlc
[i
] = TRANSPOSE(field_scan8x8_cavlc
[i
]);
992 if (h
->sps
.transform_bypass
) { // FIXME same ugly
993 memcpy(h
->zigzag_scan_q0
, zigzag_scan
, sizeof(h
->zigzag_scan_q0
));
994 memcpy(h
->zigzag_scan8x8_q0
, ff_zigzag_direct
, sizeof(h
->zigzag_scan8x8_q0
));
995 memcpy(h
->zigzag_scan8x8_cavlc_q0
, zigzag_scan8x8_cavlc
, sizeof(h
->zigzag_scan8x8_cavlc_q0
));
996 memcpy(h
->field_scan_q0
, field_scan
, sizeof(h
->field_scan_q0
));
997 memcpy(h
->field_scan8x8_q0
, field_scan8x8
, sizeof(h
->field_scan8x8_q0
));
998 memcpy(h
->field_scan8x8_cavlc_q0
, field_scan8x8_cavlc
, sizeof(h
->field_scan8x8_cavlc_q0
));
1000 memcpy(h
->zigzag_scan_q0
, h
->zigzag_scan
, sizeof(h
->zigzag_scan_q0
));
1001 memcpy(h
->zigzag_scan8x8_q0
, h
->zigzag_scan8x8
, sizeof(h
->zigzag_scan8x8_q0
));
1002 memcpy(h
->zigzag_scan8x8_cavlc_q0
, h
->zigzag_scan8x8_cavlc
, sizeof(h
->zigzag_scan8x8_cavlc_q0
));
1003 memcpy(h
->field_scan_q0
, h
->field_scan
, sizeof(h
->field_scan_q0
));
1004 memcpy(h
->field_scan8x8_q0
, h
->field_scan8x8
, sizeof(h
->field_scan8x8_q0
));
1005 memcpy(h
->field_scan8x8_cavlc_q0
, h
->field_scan8x8_cavlc
, sizeof(h
->field_scan8x8_cavlc_q0
));
1010 * Replicate H264 "master" context to thread contexts.
1012 static int clone_slice(H264Context
*dst
, H264Context
*src
)
1014 memcpy(dst
->block_offset
, src
->block_offset
, sizeof(dst
->block_offset
));
1015 dst
->cur_pic_ptr
= src
->cur_pic_ptr
;
1016 dst
->cur_pic
= src
->cur_pic
;
1017 dst
->linesize
= src
->linesize
;
1018 dst
->uvlinesize
= src
->uvlinesize
;
1019 dst
->first_field
= src
->first_field
;
1021 dst
->prev_poc_msb
= src
->prev_poc_msb
;
1022 dst
->prev_poc_lsb
= src
->prev_poc_lsb
;
1023 dst
->prev_frame_num_offset
= src
->prev_frame_num_offset
;
1024 dst
->prev_frame_num
= src
->prev_frame_num
;
1025 dst
->short_ref_count
= src
->short_ref_count
;
1027 memcpy(dst
->short_ref
, src
->short_ref
, sizeof(dst
->short_ref
));
1028 memcpy(dst
->long_ref
, src
->long_ref
, sizeof(dst
->long_ref
));
1029 memcpy(dst
->default_ref_list
, src
->default_ref_list
, sizeof(dst
->default_ref_list
));
1031 memcpy(dst
->dequant4_coeff
, src
->dequant4_coeff
, sizeof(src
->dequant4_coeff
));
1032 memcpy(dst
->dequant8_coeff
, src
->dequant8_coeff
, sizeof(src
->dequant8_coeff
));
1037 static enum AVPixelFormat
get_pixel_format(H264Context
*h
, int force_callback
)
1039 enum AVPixelFormat pix_fmts
[2];
1040 const enum AVPixelFormat
*choices
= pix_fmts
;
1043 pix_fmts
[1] = AV_PIX_FMT_NONE
;
1045 switch (h
->sps
.bit_depth_luma
) {
1048 if (h
->avctx
->colorspace
== AVCOL_SPC_RGB
) {
1049 pix_fmts
[0] = AV_PIX_FMT_GBRP9
;
1051 pix_fmts
[0] = AV_PIX_FMT_YUV444P9
;
1052 } else if (CHROMA422(h
))
1053 pix_fmts
[0] = AV_PIX_FMT_YUV422P9
;
1055 pix_fmts
[0] = AV_PIX_FMT_YUV420P9
;
1059 if (h
->avctx
->colorspace
== AVCOL_SPC_RGB
) {
1060 pix_fmts
[0] = AV_PIX_FMT_GBRP10
;
1062 pix_fmts
[0] = AV_PIX_FMT_YUV444P10
;
1063 } else if (CHROMA422(h
))
1064 pix_fmts
[0] = AV_PIX_FMT_YUV422P10
;
1066 pix_fmts
[0] = AV_PIX_FMT_YUV420P10
;
1070 if (h
->avctx
->colorspace
== AVCOL_SPC_RGB
) {
1071 pix_fmts
[0] = AV_PIX_FMT_GBRP12
;
1073 pix_fmts
[0] = AV_PIX_FMT_YUV444P12
;
1074 } else if (CHROMA422(h
))
1075 pix_fmts
[0] = AV_PIX_FMT_YUV422P12
;
1077 pix_fmts
[0] = AV_PIX_FMT_YUV420P12
;
1081 if (h
->avctx
->colorspace
== AVCOL_SPC_RGB
) {
1082 pix_fmts
[0] = AV_PIX_FMT_GBRP14
;
1084 pix_fmts
[0] = AV_PIX_FMT_YUV444P14
;
1085 } else if (CHROMA422(h
))
1086 pix_fmts
[0] = AV_PIX_FMT_YUV422P14
;
1088 pix_fmts
[0] = AV_PIX_FMT_YUV420P14
;
1092 if (h
->avctx
->colorspace
== AVCOL_SPC_YCGCO
)
1093 av_log(h
->avctx
, AV_LOG_WARNING
, "Detected unsupported YCgCo colorspace.\n");
1094 if (h
->avctx
->colorspace
== AVCOL_SPC_RGB
)
1095 pix_fmts
[0] = AV_PIX_FMT_GBRP
;
1096 else if (h
->avctx
->color_range
== AVCOL_RANGE_JPEG
)
1097 pix_fmts
[0] = AV_PIX_FMT_YUVJ444P
;
1099 pix_fmts
[0] = AV_PIX_FMT_YUV444P
;
1100 } else if (CHROMA422(h
)) {
1101 if (h
->avctx
->color_range
== AVCOL_RANGE_JPEG
)
1102 pix_fmts
[0] = AV_PIX_FMT_YUVJ422P
;
1104 pix_fmts
[0] = AV_PIX_FMT_YUV422P
;
1106 if (h
->avctx
->codec
->pix_fmts
)
1107 choices
= h
->avctx
->codec
->pix_fmts
;
1108 else if (h
->avctx
->color_range
== AVCOL_RANGE_JPEG
)
1109 choices
= h264_hwaccel_pixfmt_list_jpeg_420
;
1111 choices
= h264_hwaccel_pixfmt_list_420
;
1115 av_log(h
->avctx
, AV_LOG_ERROR
,
1116 "Unsupported bit depth %d\n", h
->sps
.bit_depth_luma
);
1117 return AVERROR_INVALIDDATA
;
1120 for (i
=0; choices
[i
] != AV_PIX_FMT_NONE
; i
++)
1121 if (choices
[i
] == h
->avctx
->pix_fmt
&& !force_callback
)
1123 return ff_thread_get_format(h
->avctx
, choices
);
1126 /* export coded and cropped frame dimensions to AVCodecContext */
1127 static int init_dimensions(H264Context
*h
)
1129 int width
= h
->width
- (h
->sps
.crop_right
+ h
->sps
.crop_left
);
1130 int height
= h
->height
- (h
->sps
.crop_top
+ h
->sps
.crop_bottom
);
1131 int crop_present
= h
->sps
.crop_left
|| h
->sps
.crop_top
||
1132 h
->sps
.crop_right
|| h
->sps
.crop_bottom
;
1133 av_assert0(h
->sps
.crop_right
+ h
->sps
.crop_left
< (unsigned)h
->width
);
1134 av_assert0(h
->sps
.crop_top
+ h
->sps
.crop_bottom
< (unsigned)h
->height
);
1136 /* handle container cropping */
1137 if (!crop_present
&&
1138 FFALIGN(h
->avctx
->width
, 16) == h
->width
&&
1139 FFALIGN(h
->avctx
->height
, 16) == h
->height
) {
1140 width
= h
->avctx
->width
;
1141 height
= h
->avctx
->height
;
1144 if (width
<= 0 || height
<= 0) {
1145 av_log(h
->avctx
, AV_LOG_ERROR
, "Invalid cropped dimensions: %dx%d.\n",
1147 if (h
->avctx
->err_recognition
& AV_EF_EXPLODE
)
1148 return AVERROR_INVALIDDATA
;
1150 av_log(h
->avctx
, AV_LOG_WARNING
, "Ignoring cropping information.\n");
1151 h
->sps
.crop_bottom
=
1161 h
->avctx
->coded_width
= h
->width
;
1162 h
->avctx
->coded_height
= h
->height
;
1163 h
->avctx
->width
= width
;
1164 h
->avctx
->height
= height
;
1169 static int h264_slice_header_init(H264Context
*h
, int reinit
)
1171 int nb_slices
= (HAVE_THREADS
&&
1172 h
->avctx
->active_thread_type
& FF_THREAD_SLICE
) ?
1173 h
->avctx
->thread_count
: 1;
1176 ff_set_sar(h
->avctx
, h
->sps
.sar
);
1177 av_pix_fmt_get_chroma_sub_sample(h
->avctx
->pix_fmt
,
1178 &h
->chroma_x_shift
, &h
->chroma_y_shift
);
1180 if (h
->sps
.timing_info_present_flag
) {
1181 int64_t den
= h
->sps
.time_scale
;
1182 if (h
->x264_build
< 44U)
1184 av_reduce(&h
->avctx
->framerate
.den
, &h
->avctx
->framerate
.num
,
1185 h
->sps
.num_units_in_tick
* h
->avctx
->ticks_per_frame
, den
, 1 << 30);
1189 ff_h264_free_tables(h
, 0);
1191 h
->prev_interlaced_frame
= 1;
1193 init_scan_tables(h
);
1194 ret
= ff_h264_alloc_tables(h
);
1196 av_log(h
->avctx
, AV_LOG_ERROR
, "Could not allocate memory\n");
1200 if (nb_slices
> H264_MAX_THREADS
|| (nb_slices
> h
->mb_height
&& h
->mb_height
)) {
1203 max_slices
= FFMIN(H264_MAX_THREADS
, h
->mb_height
);
1205 max_slices
= H264_MAX_THREADS
;
1206 av_log(h
->avctx
, AV_LOG_WARNING
, "too many threads/slices %d,"
1207 " reducing to %d\n", nb_slices
, max_slices
);
1208 nb_slices
= max_slices
;
1210 h
->slice_context_count
= nb_slices
;
1212 if (!HAVE_THREADS
|| !(h
->avctx
->active_thread_type
& FF_THREAD_SLICE
)) {
1213 ret
= ff_h264_context_init(h
);
1215 av_log(h
->avctx
, AV_LOG_ERROR
, "context_init() failed.\n");
1219 for (i
= 1; i
< h
->slice_context_count
; i
++) {
1221 c
= h
->thread_context
[i
] = av_mallocz(sizeof(H264Context
));
1223 ret
= AVERROR(ENOMEM
);
1226 c
->avctx
= h
->avctx
;
1227 if (CONFIG_ERROR_RESILIENCE
) {
1231 c
->h264dsp
= h
->h264dsp
;
1232 c
->h264qpel
= h
->h264qpel
;
1233 c
->h264chroma
= h
->h264chroma
;
1236 c
->pixel_shift
= h
->pixel_shift
;
1237 c
->cur_chroma_format_idc
= h
->cur_chroma_format_idc
;
1238 c
->width
= h
->width
;
1239 c
->height
= h
->height
;
1240 c
->linesize
= h
->linesize
;
1241 c
->uvlinesize
= h
->uvlinesize
;
1242 c
->chroma_x_shift
= h
->chroma_x_shift
;
1243 c
->chroma_y_shift
= h
->chroma_y_shift
;
1244 c
->qscale
= h
->qscale
;
1245 c
->droppable
= h
->droppable
;
1246 c
->data_partitioning
= h
->data_partitioning
;
1247 c
->low_delay
= h
->low_delay
;
1248 c
->mb_width
= h
->mb_width
;
1249 c
->mb_height
= h
->mb_height
;
1250 c
->mb_stride
= h
->mb_stride
;
1251 c
->mb_num
= h
->mb_num
;
1252 c
->flags
= h
->flags
;
1253 c
->workaround_bugs
= h
->workaround_bugs
;
1254 c
->pict_type
= h
->pict_type
;
1256 init_scan_tables(c
);
1257 clone_tables(c
, h
, i
);
1258 c
->context_initialized
= 1;
1261 for (i
= 0; i
< h
->slice_context_count
; i
++)
1262 if ((ret
= ff_h264_context_init(h
->thread_context
[i
])) < 0) {
1263 av_log(h
->avctx
, AV_LOG_ERROR
, "context_init() failed.\n");
1268 h
->context_initialized
= 1;
1272 ff_h264_free_tables(h
, 0);
1273 h
->context_initialized
= 0;
1277 static enum AVPixelFormat
non_j_pixfmt(enum AVPixelFormat a
)
1280 case AV_PIX_FMT_YUVJ420P
: return AV_PIX_FMT_YUV420P
;
1281 case AV_PIX_FMT_YUVJ422P
: return AV_PIX_FMT_YUV422P
;
1282 case AV_PIX_FMT_YUVJ444P
: return AV_PIX_FMT_YUV444P
;
1289 * Decode a slice header.
1290 * This will (re)intialize the decoder and call h264_frame_start() as needed.
1292 * @param h h264context
1293 * @param h0 h264 master context (differs from 'h' when doing sliced based
1294 * parallel decoding)
1296 * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
1298 int ff_h264_decode_slice_header(H264Context
*h
, H264Context
*h0
)
1300 unsigned int first_mb_in_slice
;
1301 unsigned int pps_id
;
1303 unsigned int slice_type
, tmp
, i
, j
;
1304 int last_pic_structure
, last_pic_droppable
;
1306 int needs_reinit
= 0;
1307 int field_pic_flag
, bottom_field_flag
;
1309 h
->qpel_put
= h
->h264qpel
.put_h264_qpel_pixels_tab
;
1310 h
->qpel_avg
= h
->h264qpel
.avg_h264_qpel_pixels_tab
;
1312 first_mb_in_slice
= get_ue_golomb_long(&h
->gb
);
1314 if (first_mb_in_slice
== 0) { // FIXME better field boundary detection
1315 if (h0
->current_slice
&& h
->cur_pic_ptr
&& FIELD_PICTURE(h
)) {
1316 ff_h264_field_end(h
, 1);
1319 h0
->current_slice
= 0;
1320 if (!h0
->first_field
) {
1321 if (h
->cur_pic_ptr
&& !h
->droppable
) {
1322 ff_thread_report_progress(&h
->cur_pic_ptr
->tf
, INT_MAX
,
1323 h
->picture_structure
== PICT_BOTTOM_FIELD
);
1325 h
->cur_pic_ptr
= NULL
;
1329 slice_type
= get_ue_golomb_31(&h
->gb
);
1330 if (slice_type
> 9) {
1331 av_log(h
->avctx
, AV_LOG_ERROR
,
1332 "slice type %d too large at %d %d\n",
1333 slice_type
, h
->mb_x
, h
->mb_y
);
1334 return AVERROR_INVALIDDATA
;
1336 if (slice_type
> 4) {
1338 h
->slice_type_fixed
= 1;
1340 h
->slice_type_fixed
= 0;
1342 slice_type
= golomb_to_pict_type
[slice_type
];
1343 h
->slice_type
= slice_type
;
1344 h
->slice_type_nos
= slice_type
& 3;
1346 if (h
->nal_unit_type
== NAL_IDR_SLICE
&&
1347 h
->slice_type_nos
!= AV_PICTURE_TYPE_I
) {
1348 av_log(h
->avctx
, AV_LOG_ERROR
, "A non-intra slice in an IDR NAL unit.\n");
1349 return AVERROR_INVALIDDATA
;
1353 (h
->avctx
->skip_frame
>= AVDISCARD_NONREF
&& !h
->nal_ref_idc
) ||
1354 (h
->avctx
->skip_frame
>= AVDISCARD_BIDIR
&& h
->slice_type_nos
== AV_PICTURE_TYPE_B
) ||
1355 (h
->avctx
->skip_frame
>= AVDISCARD_NONINTRA
&& h
->slice_type_nos
!= AV_PICTURE_TYPE_I
) ||
1356 (h
->avctx
->skip_frame
>= AVDISCARD_NONKEY
&& h
->nal_unit_type
!= NAL_IDR_SLICE
) ||
1357 h
->avctx
->skip_frame
>= AVDISCARD_ALL
) {
1358 return SLICE_SKIPED
;
1361 // to make a few old functions happy, it's wrong though
1362 h
->pict_type
= h
->slice_type
;
1364 pps_id
= get_ue_golomb(&h
->gb
);
1365 if (pps_id
>= MAX_PPS_COUNT
) {
1366 av_log(h
->avctx
, AV_LOG_ERROR
, "pps_id %u out of range\n", pps_id
);
1367 return AVERROR_INVALIDDATA
;
1369 if (!h0
->pps_buffers
[pps_id
]) {
1370 av_log(h
->avctx
, AV_LOG_ERROR
,
1371 "non-existing PPS %u referenced\n",
1373 return AVERROR_INVALIDDATA
;
1375 if (h0
->au_pps_id
>= 0 && pps_id
!= h0
->au_pps_id
) {
1376 av_log(h
->avctx
, AV_LOG_ERROR
,
1377 "PPS change from %d to %d forbidden\n",
1378 h0
->au_pps_id
, pps_id
);
1379 return AVERROR_INVALIDDATA
;
1381 h
->pps
= *h0
->pps_buffers
[pps_id
];
1383 if (!h0
->sps_buffers
[h
->pps
.sps_id
]) {
1384 av_log(h
->avctx
, AV_LOG_ERROR
,
1385 "non-existing SPS %u referenced\n",
1387 return AVERROR_INVALIDDATA
;
1390 if (h
->pps
.sps_id
!= h
->sps
.sps_id
||
1391 h
->pps
.sps_id
!= h
->current_sps_id
||
1392 h0
->sps_buffers
[h
->pps
.sps_id
]->new) {
1394 h
->sps
= *h0
->sps_buffers
[h
->pps
.sps_id
];
1396 if (h
->mb_width
!= h
->sps
.mb_width
||
1397 h
->mb_height
!= h
->sps
.mb_height
* (2 - h
->sps
.frame_mbs_only_flag
) ||
1398 h
->avctx
->bits_per_raw_sample
!= h
->sps
.bit_depth_luma
||
1399 h
->cur_chroma_format_idc
!= h
->sps
.chroma_format_idc
1403 if (h
->bit_depth_luma
!= h
->sps
.bit_depth_luma
||
1404 h
->chroma_format_idc
!= h
->sps
.chroma_format_idc
) {
1405 h
->bit_depth_luma
= h
->sps
.bit_depth_luma
;
1406 h
->chroma_format_idc
= h
->sps
.chroma_format_idc
;
1409 if ((ret
= ff_h264_set_parameter_from_sps(h
)) < 0)
1413 h
->avctx
->profile
= ff_h264_get_profile(&h
->sps
);
1414 h
->avctx
->level
= h
->sps
.level_idc
;
1415 h
->avctx
->refs
= h
->sps
.ref_frame_count
;
1417 must_reinit
= (h
->context_initialized
&&
1418 ( 16*h
->sps
.mb_width
!= h
->avctx
->coded_width
1419 || 16*h
->sps
.mb_height
* (2 - h
->sps
.frame_mbs_only_flag
) != h
->avctx
->coded_height
1420 || h
->avctx
->bits_per_raw_sample
!= h
->sps
.bit_depth_luma
1421 || h
->cur_chroma_format_idc
!= h
->sps
.chroma_format_idc
1422 || av_cmp_q(h
->sps
.sar
, h
->avctx
->sample_aspect_ratio
)
1423 || h
->mb_width
!= h
->sps
.mb_width
1424 || h
->mb_height
!= h
->sps
.mb_height
* (2 - h
->sps
.frame_mbs_only_flag
)
1426 if (non_j_pixfmt(h0
->avctx
->pix_fmt
) != non_j_pixfmt(get_pixel_format(h0
, 0)))
1429 h
->mb_width
= h
->sps
.mb_width
;
1430 h
->mb_height
= h
->sps
.mb_height
* (2 - h
->sps
.frame_mbs_only_flag
);
1431 h
->mb_num
= h
->mb_width
* h
->mb_height
;
1432 h
->mb_stride
= h
->mb_width
+ 1;
1434 h
->b_stride
= h
->mb_width
* 4;
1436 h
->chroma_y_shift
= h
->sps
.chroma_format_idc
<= 1; // 400 uses yuv420p
1438 h
->width
= 16 * h
->mb_width
;
1439 h
->height
= 16 * h
->mb_height
;
1441 ret
= init_dimensions(h
);
1445 if (h
->sps
.video_signal_type_present_flag
) {
1446 h
->avctx
->color_range
= h
->sps
.full_range
>0 ? AVCOL_RANGE_JPEG
1448 if (h
->sps
.colour_description_present_flag
) {
1449 if (h
->avctx
->colorspace
!= h
->sps
.colorspace
)
1451 h
->avctx
->color_primaries
= h
->sps
.color_primaries
;
1452 h
->avctx
->color_trc
= h
->sps
.color_trc
;
1453 h
->avctx
->colorspace
= h
->sps
.colorspace
;
1457 if (h
->context_initialized
&&
1458 (must_reinit
|| needs_reinit
)) {
1460 av_log(h
->avctx
, AV_LOG_ERROR
,
1461 "changing width %d -> %d / height %d -> %d on "
1463 h
->width
, h
->avctx
->coded_width
,
1464 h
->height
, h
->avctx
->coded_height
,
1465 h0
->current_slice
+ 1);
1466 return AVERROR_INVALIDDATA
;
1469 ff_h264_flush_change(h
);
1471 if ((ret
= get_pixel_format(h
, 1)) < 0)
1473 h
->avctx
->pix_fmt
= ret
;
1475 av_log(h
->avctx
, AV_LOG_INFO
, "Reinit context to %dx%d, "
1476 "pix_fmt: %s\n", h
->width
, h
->height
, av_get_pix_fmt_name(h
->avctx
->pix_fmt
));
1478 if ((ret
= h264_slice_header_init(h
, 1)) < 0) {
1479 av_log(h
->avctx
, AV_LOG_ERROR
,
1480 "h264_slice_header_init() failed\n");
1484 if (!h
->context_initialized
) {
1486 av_log(h
->avctx
, AV_LOG_ERROR
,
1487 "Cannot (re-)initialize context during parallel decoding.\n");
1488 return AVERROR_PATCHWELCOME
;
1491 if ((ret
= get_pixel_format(h
, 1)) < 0)
1493 h
->avctx
->pix_fmt
= ret
;
1495 if ((ret
= h264_slice_header_init(h
, 0)) < 0) {
1496 av_log(h
->avctx
, AV_LOG_ERROR
,
1497 "h264_slice_header_init() failed\n");
1502 if (h
== h0
&& h
->dequant_coeff_pps
!= pps_id
) {
1503 h
->dequant_coeff_pps
= pps_id
;
1504 h264_init_dequant_tables(h
);
1507 h
->frame_num
= get_bits(&h
->gb
, h
->sps
.log2_max_frame_num
);
1510 h
->mb_aff_frame
= 0;
1511 last_pic_structure
= h0
->picture_structure
;
1512 last_pic_droppable
= h0
->droppable
;
1513 h
->droppable
= h
->nal_ref_idc
== 0;
1514 if (h
->sps
.frame_mbs_only_flag
) {
1515 h
->picture_structure
= PICT_FRAME
;
1517 if (!h
->sps
.direct_8x8_inference_flag
&& slice_type
== AV_PICTURE_TYPE_B
) {
1518 av_log(h
->avctx
, AV_LOG_ERROR
, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
1521 field_pic_flag
= get_bits1(&h
->gb
);
1522 if (field_pic_flag
) {
1523 bottom_field_flag
= get_bits1(&h
->gb
);
1524 h
->picture_structure
= PICT_TOP_FIELD
+ bottom_field_flag
;
1526 h
->picture_structure
= PICT_FRAME
;
1527 h
->mb_aff_frame
= h
->sps
.mb_aff
;
1530 h
->mb_field_decoding_flag
= h
->picture_structure
!= PICT_FRAME
;
1532 if (h0
->current_slice
!= 0) {
1533 if (last_pic_structure
!= h
->picture_structure
||
1534 last_pic_droppable
!= h
->droppable
) {
1535 av_log(h
->avctx
, AV_LOG_ERROR
,
1536 "Changing field mode (%d -> %d) between slices is not allowed\n",
1537 last_pic_structure
, h
->picture_structure
);
1538 h
->picture_structure
= last_pic_structure
;
1539 h
->droppable
= last_pic_droppable
;
1540 return AVERROR_INVALIDDATA
;
1541 } else if (!h0
->cur_pic_ptr
) {
1542 av_log(h
->avctx
, AV_LOG_ERROR
,
1543 "unset cur_pic_ptr on slice %d\n",
1544 h0
->current_slice
+ 1);
1545 return AVERROR_INVALIDDATA
;
1548 /* Shorten frame num gaps so we don't have to allocate reference
1549 * frames just to throw them away */
1550 if (h
->frame_num
!= h
->prev_frame_num
) {
1551 int unwrap_prev_frame_num
= h
->prev_frame_num
;
1552 int max_frame_num
= 1 << h
->sps
.log2_max_frame_num
;
1554 if (unwrap_prev_frame_num
> h
->frame_num
)
1555 unwrap_prev_frame_num
-= max_frame_num
;
1557 if ((h
->frame_num
- unwrap_prev_frame_num
) > h
->sps
.ref_frame_count
) {
1558 unwrap_prev_frame_num
= (h
->frame_num
- h
->sps
.ref_frame_count
) - 1;
1559 if (unwrap_prev_frame_num
< 0)
1560 unwrap_prev_frame_num
+= max_frame_num
;
1562 h
->prev_frame_num
= unwrap_prev_frame_num
;
1566 /* See if we have a decoded first field looking for a pair...
1567 * Here, we're using that to see if we should mark previously
1568 * decode frames as "finished".
1569 * We have to do that before the "dummy" in-between frame allocation,
1570 * since that can modify h->cur_pic_ptr. */
1571 if (h0
->first_field
) {
1572 assert(h0
->cur_pic_ptr
);
1573 assert(h0
->cur_pic_ptr
->f
.buf
[0]);
1574 assert(h0
->cur_pic_ptr
->reference
!= DELAYED_PIC_REF
);
1576 /* Mark old field/frame as completed */
1577 if (h0
->cur_pic_ptr
->tf
.owner
== h0
->avctx
) {
1578 ff_thread_report_progress(&h0
->cur_pic_ptr
->tf
, INT_MAX
,
1579 last_pic_structure
== PICT_BOTTOM_FIELD
);
1582 /* figure out if we have a complementary field pair */
1583 if (!FIELD_PICTURE(h
) || h
->picture_structure
== last_pic_structure
) {
1584 /* Previous field is unmatched. Don't display it, but let it
1585 * remain for reference if marked as such. */
1586 if (last_pic_structure
!= PICT_FRAME
) {
1587 ff_thread_report_progress(&h0
->cur_pic_ptr
->tf
, INT_MAX
,
1588 last_pic_structure
== PICT_TOP_FIELD
);
1591 if (h0
->cur_pic_ptr
->frame_num
!= h
->frame_num
) {
1592 /* This and previous field were reference, but had
1593 * different frame_nums. Consider this field first in
1594 * pair. Throw away previous field except for reference
1596 if (last_pic_structure
!= PICT_FRAME
) {
1597 ff_thread_report_progress(&h0
->cur_pic_ptr
->tf
, INT_MAX
,
1598 last_pic_structure
== PICT_TOP_FIELD
);
1601 /* Second field in complementary pair */
1602 if (!((last_pic_structure
== PICT_TOP_FIELD
&&
1603 h
->picture_structure
== PICT_BOTTOM_FIELD
) ||
1604 (last_pic_structure
== PICT_BOTTOM_FIELD
&&
1605 h
->picture_structure
== PICT_TOP_FIELD
))) {
1606 av_log(h
->avctx
, AV_LOG_ERROR
,
1607 "Invalid field mode combination %d/%d\n",
1608 last_pic_structure
, h
->picture_structure
);
1609 h
->picture_structure
= last_pic_structure
;
1610 h
->droppable
= last_pic_droppable
;
1611 return AVERROR_INVALIDDATA
;
1612 } else if (last_pic_droppable
!= h
->droppable
) {
1613 avpriv_request_sample(h
->avctx
,
1614 "Found reference and non-reference fields in the same frame, which");
1615 h
->picture_structure
= last_pic_structure
;
1616 h
->droppable
= last_pic_droppable
;
1617 return AVERROR_PATCHWELCOME
;
1623 while (h
->frame_num
!= h
->prev_frame_num
&& !h0
->first_field
&&
1624 h
->frame_num
!= (h
->prev_frame_num
+ 1) % (1 << h
->sps
.log2_max_frame_num
)) {
1625 H264Picture
*prev
= h
->short_ref_count
? h
->short_ref
[0] : NULL
;
1626 av_log(h
->avctx
, AV_LOG_DEBUG
, "Frame num gap %d %d\n",
1627 h
->frame_num
, h
->prev_frame_num
);
1628 if (!h
->sps
.gaps_in_frame_num_allowed_flag
)
1629 for(i
=0; i
<FF_ARRAY_ELEMS(h
->last_pocs
); i
++)
1630 h
->last_pocs
[i
] = INT_MIN
;
1631 ret
= h264_frame_start(h
);
1633 h0
->first_field
= 0;
1637 h
->prev_frame_num
++;
1638 h
->prev_frame_num
%= 1 << h
->sps
.log2_max_frame_num
;
1639 h
->cur_pic_ptr
->frame_num
= h
->prev_frame_num
;
1640 h
->cur_pic_ptr
->invalid_gap
= !h
->sps
.gaps_in_frame_num_allowed_flag
;
1641 ff_thread_report_progress(&h
->cur_pic_ptr
->tf
, INT_MAX
, 0);
1642 ff_thread_report_progress(&h
->cur_pic_ptr
->tf
, INT_MAX
, 1);
1643 ret
= ff_generate_sliding_window_mmcos(h
, 1);
1644 if (ret
< 0 && (h
->avctx
->err_recognition
& AV_EF_EXPLODE
))
1646 ret
= ff_h264_execute_ref_pic_marking(h
, h
->mmco
, h
->mmco_index
);
1647 if (ret
< 0 && (h
->avctx
->err_recognition
& AV_EF_EXPLODE
))
1649 /* Error concealment: If a ref is missing, copy the previous ref
1651 * FIXME: Avoiding a memcpy would be nice, but ref handling makes
1652 * many assumptions about there being no actual duplicates.
1653 * FIXME: This does not copy padding for out-of-frame motion
1654 * vectors. Given we are concealing a lost frame, this probably
1655 * is not noticeable by comparison, but it should be fixed. */
1656 if (h
->short_ref_count
) {
1658 av_image_copy(h
->short_ref
[0]->f
.data
,
1659 h
->short_ref
[0]->f
.linesize
,
1660 (const uint8_t **)prev
->f
.data
,
1665 h
->short_ref
[0]->poc
= prev
->poc
+ 2;
1667 h
->short_ref
[0]->frame_num
= h
->prev_frame_num
;
1671 /* See if we have a decoded first field looking for a pair...
1672 * We're using that to see whether to continue decoding in that
1673 * frame, or to allocate a new one. */
1674 if (h0
->first_field
) {
1675 assert(h0
->cur_pic_ptr
);
1676 assert(h0
->cur_pic_ptr
->f
.buf
[0]);
1677 assert(h0
->cur_pic_ptr
->reference
!= DELAYED_PIC_REF
);
1679 /* figure out if we have a complementary field pair */
1680 if (!FIELD_PICTURE(h
) || h
->picture_structure
== last_pic_structure
) {
1681 /* Previous field is unmatched. Don't display it, but let it
1682 * remain for reference if marked as such. */
1683 h0
->cur_pic_ptr
= NULL
;
1684 h0
->first_field
= FIELD_PICTURE(h
);
1686 if (h0
->cur_pic_ptr
->frame_num
!= h
->frame_num
) {
1687 ff_thread_report_progress(&h0
->cur_pic_ptr
->tf
, INT_MAX
,
1688 h0
->picture_structure
==PICT_BOTTOM_FIELD
);
1689 /* This and the previous field had different frame_nums.
1690 * Consider this field first in pair. Throw away previous
1691 * one except for reference purposes. */
1692 h0
->first_field
= 1;
1693 h0
->cur_pic_ptr
= NULL
;
1695 /* Second field in complementary pair */
1696 h0
->first_field
= 0;
1700 /* Frame or first field in a potentially complementary pair */
1701 h0
->first_field
= FIELD_PICTURE(h
);
1704 if (!FIELD_PICTURE(h
) || h0
->first_field
) {
1705 if (h264_frame_start(h
) < 0) {
1706 h0
->first_field
= 0;
1707 return AVERROR_INVALIDDATA
;
1710 release_unused_pictures(h
, 0);
1712 /* Some macroblocks can be accessed before they're available in case
1713 * of lost slices, MBAFF or threading. */
1714 if (FIELD_PICTURE(h
)) {
1715 for(i
= (h
->picture_structure
== PICT_BOTTOM_FIELD
); i
<h
->mb_height
; i
++)
1716 memset(h
->slice_table
+ i
*h
->mb_stride
, -1, (h
->mb_stride
- (i
+1==h
->mb_height
)) * sizeof(*h
->slice_table
));
1718 memset(h
->slice_table
, -1,
1719 (h
->mb_height
* h
->mb_stride
- 1) * sizeof(*h
->slice_table
));
1721 h0
->last_slice_type
= -1;
1723 if (h
!= h0
&& (ret
= clone_slice(h
, h0
)) < 0)
1726 /* can't be in alloc_tables because linesize isn't known there.
1727 * FIXME: redo bipred weight to not require extra buffer? */
1728 for (i
= 0; i
< h
->slice_context_count
; i
++)
1729 if (h
->thread_context
[i
]) {
1730 ret
= alloc_scratch_buffers(h
->thread_context
[i
], h
->linesize
);
1735 h
->cur_pic_ptr
->frame_num
= h
->frame_num
; // FIXME frame_num cleanup
1737 av_assert1(h
->mb_num
== h
->mb_width
* h
->mb_height
);
1738 if (first_mb_in_slice
<< FIELD_OR_MBAFF_PICTURE(h
) >= h
->mb_num
||
1739 first_mb_in_slice
>= h
->mb_num
) {
1740 av_log(h
->avctx
, AV_LOG_ERROR
, "first_mb_in_slice overflow\n");
1741 return AVERROR_INVALIDDATA
;
1743 h
->resync_mb_x
= h
->mb_x
= first_mb_in_slice
% h
->mb_width
;
1744 h
->resync_mb_y
= h
->mb_y
= (first_mb_in_slice
/ h
->mb_width
) <<
1745 FIELD_OR_MBAFF_PICTURE(h
);
1746 if (h
->picture_structure
== PICT_BOTTOM_FIELD
)
1747 h
->resync_mb_y
= h
->mb_y
= h
->mb_y
+ 1;
1748 av_assert1(h
->mb_y
< h
->mb_height
);
1750 if (h
->picture_structure
== PICT_FRAME
) {
1751 h
->curr_pic_num
= h
->frame_num
;
1752 h
->max_pic_num
= 1 << h
->sps
.log2_max_frame_num
;
1754 h
->curr_pic_num
= 2 * h
->frame_num
+ 1;
1755 h
->max_pic_num
= 1 << (h
->sps
.log2_max_frame_num
+ 1);
1758 if (h
->nal_unit_type
== NAL_IDR_SLICE
)
1759 get_ue_golomb(&h
->gb
); /* idr_pic_id */
1761 if (h
->sps
.poc_type
== 0) {
1762 h
->poc_lsb
= get_bits(&h
->gb
, h
->sps
.log2_max_poc_lsb
);
1764 if (h
->pps
.pic_order_present
== 1 && h
->picture_structure
== PICT_FRAME
)
1765 h
->delta_poc_bottom
= get_se_golomb(&h
->gb
);
1768 if (h
->sps
.poc_type
== 1 && !h
->sps
.delta_pic_order_always_zero_flag
) {
1769 h
->delta_poc
[0] = get_se_golomb(&h
->gb
);
1771 if (h
->pps
.pic_order_present
== 1 && h
->picture_structure
== PICT_FRAME
)
1772 h
->delta_poc
[1] = get_se_golomb(&h
->gb
);
1775 ff_init_poc(h
, h
->cur_pic_ptr
->field_poc
, &h
->cur_pic_ptr
->poc
);
1777 if (h
->pps
.redundant_pic_cnt_present
)
1778 h
->redundant_pic_count
= get_ue_golomb(&h
->gb
);
1780 ret
= ff_set_ref_count(h
);
1784 if (slice_type
!= AV_PICTURE_TYPE_I
&&
1785 (h0
->current_slice
== 0 ||
1786 slice_type
!= h0
->last_slice_type
||
1787 memcmp(h0
->last_ref_count
, h0
->ref_count
, sizeof(h0
->ref_count
)))) {
1789 ff_h264_fill_default_ref_list(h
);
1792 if (h
->slice_type_nos
!= AV_PICTURE_TYPE_I
) {
1793 ret
= ff_h264_decode_ref_pic_list_reordering(h
);
1795 h
->ref_count
[1] = h
->ref_count
[0] = 0;
1800 if ((h
->pps
.weighted_pred
&& h
->slice_type_nos
== AV_PICTURE_TYPE_P
) ||
1801 (h
->pps
.weighted_bipred_idc
== 1 &&
1802 h
->slice_type_nos
== AV_PICTURE_TYPE_B
))
1803 ff_pred_weight_table(h
);
1804 else if (h
->pps
.weighted_bipred_idc
== 2 &&
1805 h
->slice_type_nos
== AV_PICTURE_TYPE_B
) {
1806 implicit_weight_table(h
, -1);
1809 for (i
= 0; i
< 2; i
++) {
1810 h
->luma_weight_flag
[i
] = 0;
1811 h
->chroma_weight_flag
[i
] = 0;
1815 // If frame-mt is enabled, only update mmco tables for the first slice
1816 // in a field. Subsequent slices can temporarily clobber h->mmco_index
1817 // or h->mmco, which will cause ref list mix-ups and decoding errors
1818 // further down the line. This may break decoding if the first slice is
1819 // corrupt, thus we only do this if frame-mt is enabled.
1820 if (h
->nal_ref_idc
) {
1821 ret
= ff_h264_decode_ref_pic_marking(h0
, &h
->gb
,
1822 !(h
->avctx
->active_thread_type
& FF_THREAD_FRAME
) ||
1823 h0
->current_slice
== 0);
1824 if (ret
< 0 && (h
->avctx
->err_recognition
& AV_EF_EXPLODE
))
1825 return AVERROR_INVALIDDATA
;
1828 if (FRAME_MBAFF(h
)) {
1829 ff_h264_fill_mbaff_ref_list(h
);
1831 if (h
->pps
.weighted_bipred_idc
== 2 && h
->slice_type_nos
== AV_PICTURE_TYPE_B
) {
1832 implicit_weight_table(h
, 0);
1833 implicit_weight_table(h
, 1);
1837 if (h
->slice_type_nos
== AV_PICTURE_TYPE_B
&& !h
->direct_spatial_mv_pred
)
1838 ff_h264_direct_dist_scale_factor(h
);
1839 ff_h264_direct_ref_list_init(h
);
1841 if (h
->slice_type_nos
!= AV_PICTURE_TYPE_I
&& h
->pps
.cabac
) {
1842 tmp
= get_ue_golomb_31(&h
->gb
);
1844 av_log(h
->avctx
, AV_LOG_ERROR
, "cabac_init_idc %u overflow\n", tmp
);
1845 return AVERROR_INVALIDDATA
;
1847 h
->cabac_init_idc
= tmp
;
1850 h
->last_qscale_diff
= 0;
1851 tmp
= h
->pps
.init_qp
+ get_se_golomb(&h
->gb
);
1852 if (tmp
> 51 + 6 * (h
->sps
.bit_depth_luma
- 8)) {
1853 av_log(h
->avctx
, AV_LOG_ERROR
, "QP %u out of range\n", tmp
);
1854 return AVERROR_INVALIDDATA
;
1857 h
->chroma_qp
[0] = get_chroma_qp(h
, 0, h
->qscale
);
1858 h
->chroma_qp
[1] = get_chroma_qp(h
, 1, h
->qscale
);
1859 // FIXME qscale / qp ... stuff
1860 if (h
->slice_type
== AV_PICTURE_TYPE_SP
)
1861 get_bits1(&h
->gb
); /* sp_for_switch_flag */
1862 if (h
->slice_type
== AV_PICTURE_TYPE_SP
||
1863 h
->slice_type
== AV_PICTURE_TYPE_SI
)
1864 get_se_golomb(&h
->gb
); /* slice_qs_delta */
1866 h
->deblocking_filter
= 1;
1867 h
->slice_alpha_c0_offset
= 0;
1868 h
->slice_beta_offset
= 0;
1869 if (h
->pps
.deblocking_filter_parameters_present
) {
1870 tmp
= get_ue_golomb_31(&h
->gb
);
1872 av_log(h
->avctx
, AV_LOG_ERROR
,
1873 "deblocking_filter_idc %u out of range\n", tmp
);
1874 return AVERROR_INVALIDDATA
;
1876 h
->deblocking_filter
= tmp
;
1877 if (h
->deblocking_filter
< 2)
1878 h
->deblocking_filter
^= 1; // 1<->0
1880 if (h
->deblocking_filter
) {
1881 h
->slice_alpha_c0_offset
= get_se_golomb(&h
->gb
) * 2;
1882 h
->slice_beta_offset
= get_se_golomb(&h
->gb
) * 2;
1883 if (h
->slice_alpha_c0_offset
> 12 ||
1884 h
->slice_alpha_c0_offset
< -12 ||
1885 h
->slice_beta_offset
> 12 ||
1886 h
->slice_beta_offset
< -12) {
1887 av_log(h
->avctx
, AV_LOG_ERROR
,
1888 "deblocking filter parameters %d %d out of range\n",
1889 h
->slice_alpha_c0_offset
, h
->slice_beta_offset
);
1890 return AVERROR_INVALIDDATA
;
1895 if (h
->avctx
->skip_loop_filter
>= AVDISCARD_ALL
||
1896 (h
->avctx
->skip_loop_filter
>= AVDISCARD_NONKEY
&&
1897 h
->nal_unit_type
!= NAL_IDR_SLICE
) ||
1898 (h
->avctx
->skip_loop_filter
>= AVDISCARD_NONINTRA
&&
1899 h
->slice_type_nos
!= AV_PICTURE_TYPE_I
) ||
1900 (h
->avctx
->skip_loop_filter
>= AVDISCARD_BIDIR
&&
1901 h
->slice_type_nos
== AV_PICTURE_TYPE_B
) ||
1902 (h
->avctx
->skip_loop_filter
>= AVDISCARD_NONREF
&&
1903 h
->nal_ref_idc
== 0))
1904 h
->deblocking_filter
= 0;
1906 if (h
->deblocking_filter
== 1 && h0
->max_contexts
> 1) {
1907 if (h
->avctx
->flags2
& CODEC_FLAG2_FAST
) {
1908 /* Cheat slightly for speed:
1909 * Do not bother to deblock across slices. */
1910 h
->deblocking_filter
= 2;
1912 h0
->max_contexts
= 1;
1913 if (!h0
->single_decode_warning
) {
1914 av_log(h
->avctx
, AV_LOG_INFO
,
1915 "Cannot parallelize slice decoding with deblocking filter type 1, decoding such frames in sequential order\n"
1916 "To parallelize slice decoding you need video encoded with disable_deblocking_filter_idc set to 2 (deblock only edges that do not cross slices).\n"
1917 "Setting the flags2 libavcodec option to +fast (-flags2 +fast) will disable deblocking across slices and enable parallel slice decoding "
1918 "but will generate non-standard-compliant output.\n");
1919 h0
->single_decode_warning
= 1;
1922 av_log(h
->avctx
, AV_LOG_ERROR
,
1923 "Deblocking switched inside frame.\n");
1924 return SLICE_SINGLETHREAD
;
1929 FFMIN(h
->slice_alpha_c0_offset
, h
->slice_beta_offset
) -
1931 h
->pps
.chroma_qp_index_offset
[0],
1932 h
->pps
.chroma_qp_index_offset
[1]) +
1933 6 * (h
->sps
.bit_depth_luma
- 8);
1935 h0
->last_slice_type
= slice_type
;
1936 memcpy(h0
->last_ref_count
, h0
->ref_count
, sizeof(h0
->last_ref_count
));
1937 h
->slice_num
= ++h0
->current_slice
;
1940 h0
->slice_row
[(h
->slice_num
-1)&(MAX_SLICES
-1)]= h
->resync_mb_y
;
1941 if ( h0
->slice_row
[h
->slice_num
&(MAX_SLICES
-1)] + 3 >= h
->resync_mb_y
1942 && h0
->slice_row
[h
->slice_num
&(MAX_SLICES
-1)] <= h
->resync_mb_y
1943 && h
->slice_num
>= MAX_SLICES
) {
1944 //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
1945 av_log(h
->avctx
, AV_LOG_WARNING
, "Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", h
->slice_num
, MAX_SLICES
);
1948 for (j
= 0; j
< 2; j
++) {
1950 int *ref2frm
= h
->ref2frm
[h
->slice_num
& (MAX_SLICES
- 1)][j
];
1951 for (i
= 0; i
< 16; i
++) {
1953 if (j
< h
->list_count
&& i
< h
->ref_count
[j
] &&
1954 h
->ref_list
[j
][i
].f
.buf
[0]) {
1956 AVBuffer
*buf
= h
->ref_list
[j
][i
].f
.buf
[0]->buffer
;
1957 for (k
= 0; k
< h
->short_ref_count
; k
++)
1958 if (h
->short_ref
[k
]->f
.buf
[0]->buffer
== buf
) {
1962 for (k
= 0; k
< h
->long_ref_count
; k
++)
1963 if (h
->long_ref
[k
] && h
->long_ref
[k
]->f
.buf
[0]->buffer
== buf
) {
1964 id_list
[i
] = h
->short_ref_count
+ k
;
1972 for (i
= 0; i
< 16; i
++)
1973 ref2frm
[i
+ 2] = 4 * id_list
[i
] + (h
->ref_list
[j
][i
].reference
& 3);
1975 ref2frm
[18 + 1] = -1;
1976 for (i
= 16; i
< 48; i
++)
1977 ref2frm
[i
+ 4] = 4 * id_list
[(i
- 16) >> 1] +
1978 (h
->ref_list
[j
][i
].reference
& 3);
1981 if (h
->ref_count
[0]) ff_h264_set_erpic(&h
->er
.last_pic
, &h
->ref_list
[0][0]);
1982 if (h
->ref_count
[1]) ff_h264_set_erpic(&h
->er
.next_pic
, &h
->ref_list
[1][0]);
1984 h
->er
.ref_count
= h
->ref_count
[0];
1985 h0
->au_pps_id
= pps_id
;
1987 h0
->sps_buffers
[h
->pps
.sps_id
]->new = 0;
1988 h
->current_sps_id
= h
->pps
.sps_id
;
1990 if (h
->avctx
->debug
& FF_DEBUG_PICT_INFO
) {
1991 av_log(h
->avctx
, AV_LOG_DEBUG
,
1992 "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
1994 (h
->picture_structure
== PICT_FRAME
? "F" : h
->picture_structure
== PICT_TOP_FIELD
? "T" : "B"),
1996 av_get_picture_type_char(h
->slice_type
),
1997 h
->slice_type_fixed
? " fix" : "",
1998 h
->nal_unit_type
== NAL_IDR_SLICE
? " IDR" : "",
1999 pps_id
, h
->frame_num
,
2000 h
->cur_pic_ptr
->field_poc
[0],
2001 h
->cur_pic_ptr
->field_poc
[1],
2002 h
->ref_count
[0], h
->ref_count
[1],
2004 h
->deblocking_filter
,
2005 h
->slice_alpha_c0_offset
, h
->slice_beta_offset
,
2007 h
->use_weight
== 1 && h
->use_weight_chroma
? "c" : "",
2008 h
->slice_type
== AV_PICTURE_TYPE_B
? (h
->direct_spatial_mv_pred
? "SPAT" : "TEMP") : "");
2014 int ff_h264_get_slice_type(const H264Context
*h
)
2016 switch (h
->slice_type
) {
2017 case AV_PICTURE_TYPE_P
:
2019 case AV_PICTURE_TYPE_B
:
2021 case AV_PICTURE_TYPE_I
:
2023 case AV_PICTURE_TYPE_SP
:
2025 case AV_PICTURE_TYPE_SI
:
2028 return AVERROR_INVALIDDATA
;
2032 static av_always_inline
void fill_filter_caches_inter(H264Context
*h
,
2033 int mb_type
, int top_xy
,
2034 int left_xy
[LEFT_MBS
],
2036 int left_type
[LEFT_MBS
],
2037 int mb_xy
, int list
)
2039 int b_stride
= h
->b_stride
;
2040 int16_t(*mv_dst
)[2] = &h
->mv_cache
[list
][scan8
[0]];
2041 int8_t *ref_cache
= &h
->ref_cache
[list
][scan8
[0]];
2042 if (IS_INTER(mb_type
) || IS_DIRECT(mb_type
)) {
2043 if (USES_LIST(top_type
, list
)) {
2044 const int b_xy
= h
->mb2b_xy
[top_xy
] + 3 * b_stride
;
2045 const int b8_xy
= 4 * top_xy
+ 2;
2046 int (*ref2frm
)[64] = (void*)(h
->ref2frm
[h
->slice_table
[top_xy
] & (MAX_SLICES
- 1)][0] + (MB_MBAFF(h
) ? 20 : 2));
2047 AV_COPY128(mv_dst
- 1 * 8, h
->cur_pic
.motion_val
[list
][b_xy
+ 0]);
2048 ref_cache
[0 - 1 * 8] =
2049 ref_cache
[1 - 1 * 8] = ref2frm
[list
][h
->cur_pic
.ref_index
[list
][b8_xy
+ 0]];
2050 ref_cache
[2 - 1 * 8] =
2051 ref_cache
[3 - 1 * 8] = ref2frm
[list
][h
->cur_pic
.ref_index
[list
][b8_xy
+ 1]];
2053 AV_ZERO128(mv_dst
- 1 * 8);
2054 AV_WN32A(&ref_cache
[0 - 1 * 8], ((LIST_NOT_USED
) & 0xFF) * 0x01010101u
);
2057 if (!IS_INTERLACED(mb_type
^ left_type
[LTOP
])) {
2058 if (USES_LIST(left_type
[LTOP
], list
)) {
2059 const int b_xy
= h
->mb2b_xy
[left_xy
[LTOP
]] + 3;
2060 const int b8_xy
= 4 * left_xy
[LTOP
] + 1;
2061 int (*ref2frm
)[64] =(void*)( h
->ref2frm
[h
->slice_table
[left_xy
[LTOP
]] & (MAX_SLICES
- 1)][0] + (MB_MBAFF(h
) ? 20 : 2));
2062 AV_COPY32(mv_dst
- 1 + 0, h
->cur_pic
.motion_val
[list
][b_xy
+ b_stride
* 0]);
2063 AV_COPY32(mv_dst
- 1 + 8, h
->cur_pic
.motion_val
[list
][b_xy
+ b_stride
* 1]);
2064 AV_COPY32(mv_dst
- 1 + 16, h
->cur_pic
.motion_val
[list
][b_xy
+ b_stride
* 2]);
2065 AV_COPY32(mv_dst
- 1 + 24, h
->cur_pic
.motion_val
[list
][b_xy
+ b_stride
* 3]);
2067 ref_cache
[-1 + 8] = ref2frm
[list
][h
->cur_pic
.ref_index
[list
][b8_xy
+ 2 * 0]];
2068 ref_cache
[-1 + 16] =
2069 ref_cache
[-1 + 24] = ref2frm
[list
][h
->cur_pic
.ref_index
[list
][b8_xy
+ 2 * 1]];
2071 AV_ZERO32(mv_dst
- 1 + 0);
2072 AV_ZERO32(mv_dst
- 1 + 8);
2073 AV_ZERO32(mv_dst
- 1 + 16);
2074 AV_ZERO32(mv_dst
- 1 + 24);
2077 ref_cache
[-1 + 16] =
2078 ref_cache
[-1 + 24] = LIST_NOT_USED
;
2083 if (!USES_LIST(mb_type
, list
)) {
2084 fill_rectangle(mv_dst
, 4, 4, 8, pack16to32(0, 0), 4);
2085 AV_WN32A(&ref_cache
[0 * 8], ((LIST_NOT_USED
) & 0xFF) * 0x01010101u
);
2086 AV_WN32A(&ref_cache
[1 * 8], ((LIST_NOT_USED
) & 0xFF) * 0x01010101u
);
2087 AV_WN32A(&ref_cache
[2 * 8], ((LIST_NOT_USED
) & 0xFF) * 0x01010101u
);
2088 AV_WN32A(&ref_cache
[3 * 8], ((LIST_NOT_USED
) & 0xFF) * 0x01010101u
);
2093 int8_t *ref
= &h
->cur_pic
.ref_index
[list
][4 * mb_xy
];
2094 int (*ref2frm
)[64] = (void*)(h
->ref2frm
[h
->slice_num
& (MAX_SLICES
- 1)][0] + (MB_MBAFF(h
) ? 20 : 2));
2095 uint32_t ref01
= (pack16to32(ref2frm
[list
][ref
[0]], ref2frm
[list
][ref
[1]]) & 0x00FF00FF) * 0x0101;
2096 uint32_t ref23
= (pack16to32(ref2frm
[list
][ref
[2]], ref2frm
[list
][ref
[3]]) & 0x00FF00FF) * 0x0101;
2097 AV_WN32A(&ref_cache
[0 * 8], ref01
);
2098 AV_WN32A(&ref_cache
[1 * 8], ref01
);
2099 AV_WN32A(&ref_cache
[2 * 8], ref23
);
2100 AV_WN32A(&ref_cache
[3 * 8], ref23
);
2104 int16_t(*mv_src
)[2] = &h
->cur_pic
.motion_val
[list
][4 * h
->mb_x
+ 4 * h
->mb_y
* b_stride
];
2105 AV_COPY128(mv_dst
+ 8 * 0, mv_src
+ 0 * b_stride
);
2106 AV_COPY128(mv_dst
+ 8 * 1, mv_src
+ 1 * b_stride
);
2107 AV_COPY128(mv_dst
+ 8 * 2, mv_src
+ 2 * b_stride
);
2108 AV_COPY128(mv_dst
+ 8 * 3, mv_src
+ 3 * b_stride
);
2114 * @return non zero if the loop filter can be skipped
2116 static int fill_filter_caches(H264Context
*h
, int mb_type
)
2118 const int mb_xy
= h
->mb_xy
;
2119 int top_xy
, left_xy
[LEFT_MBS
];
2120 int top_type
, left_type
[LEFT_MBS
];
2124 top_xy
= mb_xy
- (h
->mb_stride
<< MB_FIELD(h
));
2126 /* Wow, what a mess, why didn't they simplify the interlacing & intra
2127 * stuff, I can't imagine that these complex rules are worth it. */
2129 left_xy
[LBOT
] = left_xy
[LTOP
] = mb_xy
- 1;
2130 if (FRAME_MBAFF(h
)) {
2131 const int left_mb_field_flag
= IS_INTERLACED(h
->cur_pic
.mb_type
[mb_xy
- 1]);
2132 const int curr_mb_field_flag
= IS_INTERLACED(mb_type
);
2134 if (left_mb_field_flag
!= curr_mb_field_flag
)
2135 left_xy
[LTOP
] -= h
->mb_stride
;
2137 if (curr_mb_field_flag
)
2138 top_xy
+= h
->mb_stride
&
2139 (((h
->cur_pic
.mb_type
[top_xy
] >> 7) & 1) - 1);
2140 if (left_mb_field_flag
!= curr_mb_field_flag
)
2141 left_xy
[LBOT
] += h
->mb_stride
;
2145 h
->top_mb_xy
= top_xy
;
2146 h
->left_mb_xy
[LTOP
] = left_xy
[LTOP
];
2147 h
->left_mb_xy
[LBOT
] = left_xy
[LBOT
];
2149 /* For sufficiently low qp, filtering wouldn't do anything.
2150 * This is a conservative estimate: could also check beta_offset
2151 * and more accurate chroma_qp. */
2152 int qp_thresh
= h
->qp_thresh
; // FIXME strictly we should store qp_thresh for each mb of a slice
2153 int qp
= h
->cur_pic
.qscale_table
[mb_xy
];
2154 if (qp
<= qp_thresh
&&
2155 (left_xy
[LTOP
] < 0 ||
2156 ((qp
+ h
->cur_pic
.qscale_table
[left_xy
[LTOP
]] + 1) >> 1) <= qp_thresh
) &&
2158 ((qp
+ h
->cur_pic
.qscale_table
[top_xy
] + 1) >> 1) <= qp_thresh
)) {
2159 if (!FRAME_MBAFF(h
))
2161 if ((left_xy
[LTOP
] < 0 ||
2162 ((qp
+ h
->cur_pic
.qscale_table
[left_xy
[LBOT
]] + 1) >> 1) <= qp_thresh
) &&
2163 (top_xy
< h
->mb_stride
||
2164 ((qp
+ h
->cur_pic
.qscale_table
[top_xy
- h
->mb_stride
] + 1) >> 1) <= qp_thresh
))
2169 top_type
= h
->cur_pic
.mb_type
[top_xy
];
2170 left_type
[LTOP
] = h
->cur_pic
.mb_type
[left_xy
[LTOP
]];
2171 left_type
[LBOT
] = h
->cur_pic
.mb_type
[left_xy
[LBOT
]];
2172 if (h
->deblocking_filter
== 2) {
2173 if (h
->slice_table
[top_xy
] != h
->slice_num
)
2175 if (h
->slice_table
[left_xy
[LBOT
]] != h
->slice_num
)
2176 left_type
[LTOP
] = left_type
[LBOT
] = 0;
2178 if (h
->slice_table
[top_xy
] == 0xFFFF)
2180 if (h
->slice_table
[left_xy
[LBOT
]] == 0xFFFF)
2181 left_type
[LTOP
] = left_type
[LBOT
] = 0;
2183 h
->top_type
= top_type
;
2184 h
->left_type
[LTOP
] = left_type
[LTOP
];
2185 h
->left_type
[LBOT
] = left_type
[LBOT
];
2187 if (IS_INTRA(mb_type
))
2190 fill_filter_caches_inter(h
, mb_type
, top_xy
, left_xy
,
2191 top_type
, left_type
, mb_xy
, 0);
2192 if (h
->list_count
== 2)
2193 fill_filter_caches_inter(h
, mb_type
, top_xy
, left_xy
,
2194 top_type
, left_type
, mb_xy
, 1);
2196 nnz
= h
->non_zero_count
[mb_xy
];
2197 nnz_cache
= h
->non_zero_count_cache
;
2198 AV_COPY32(&nnz_cache
[4 + 8 * 1], &nnz
[0]);
2199 AV_COPY32(&nnz_cache
[4 + 8 * 2], &nnz
[4]);
2200 AV_COPY32(&nnz_cache
[4 + 8 * 3], &nnz
[8]);
2201 AV_COPY32(&nnz_cache
[4 + 8 * 4], &nnz
[12]);
2202 h
->cbp
= h
->cbp_table
[mb_xy
];
2205 nnz
= h
->non_zero_count
[top_xy
];
2206 AV_COPY32(&nnz_cache
[4 + 8 * 0], &nnz
[3 * 4]);
2209 if (left_type
[LTOP
]) {
2210 nnz
= h
->non_zero_count
[left_xy
[LTOP
]];
2211 nnz_cache
[3 + 8 * 1] = nnz
[3 + 0 * 4];
2212 nnz_cache
[3 + 8 * 2] = nnz
[3 + 1 * 4];
2213 nnz_cache
[3 + 8 * 3] = nnz
[3 + 2 * 4];
2214 nnz_cache
[3 + 8 * 4] = nnz
[3 + 3 * 4];
2217 /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
2218 * from what the loop filter needs */
2219 if (!CABAC(h
) && h
->pps
.transform_8x8_mode
) {
2220 if (IS_8x8DCT(top_type
)) {
2221 nnz_cache
[4 + 8 * 0] =
2222 nnz_cache
[5 + 8 * 0] = (h
->cbp_table
[top_xy
] & 0x4000) >> 12;
2223 nnz_cache
[6 + 8 * 0] =
2224 nnz_cache
[7 + 8 * 0] = (h
->cbp_table
[top_xy
] & 0x8000) >> 12;
2226 if (IS_8x8DCT(left_type
[LTOP
])) {
2227 nnz_cache
[3 + 8 * 1] =
2228 nnz_cache
[3 + 8 * 2] = (h
->cbp_table
[left_xy
[LTOP
]] & 0x2000) >> 12; // FIXME check MBAFF
2230 if (IS_8x8DCT(left_type
[LBOT
])) {
2231 nnz_cache
[3 + 8 * 3] =
2232 nnz_cache
[3 + 8 * 4] = (h
->cbp_table
[left_xy
[LBOT
]] & 0x8000) >> 12; // FIXME check MBAFF
2235 if (IS_8x8DCT(mb_type
)) {
2236 nnz_cache
[scan8
[0]] =
2237 nnz_cache
[scan8
[1]] =
2238 nnz_cache
[scan8
[2]] =
2239 nnz_cache
[scan8
[3]] = (h
->cbp
& 0x1000) >> 12;
2241 nnz_cache
[scan8
[0 + 4]] =
2242 nnz_cache
[scan8
[1 + 4]] =
2243 nnz_cache
[scan8
[2 + 4]] =
2244 nnz_cache
[scan8
[3 + 4]] = (h
->cbp
& 0x2000) >> 12;
2246 nnz_cache
[scan8
[0 + 8]] =
2247 nnz_cache
[scan8
[1 + 8]] =
2248 nnz_cache
[scan8
[2 + 8]] =
2249 nnz_cache
[scan8
[3 + 8]] = (h
->cbp
& 0x4000) >> 12;
2251 nnz_cache
[scan8
[0 + 12]] =
2252 nnz_cache
[scan8
[1 + 12]] =
2253 nnz_cache
[scan8
[2 + 12]] =
2254 nnz_cache
[scan8
[3 + 12]] = (h
->cbp
& 0x8000) >> 12;
2261 static void loop_filter(H264Context
*h
, int start_x
, int end_x
)
2263 uint8_t *dest_y
, *dest_cb
, *dest_cr
;
2264 int linesize
, uvlinesize
, mb_x
, mb_y
;
2265 const int end_mb_y
= h
->mb_y
+ FRAME_MBAFF(h
);
2266 const int old_slice_type
= h
->slice_type
;
2267 const int pixel_shift
= h
->pixel_shift
;
2268 const int block_h
= 16 >> h
->chroma_y_shift
;
2270 if (h
->deblocking_filter
) {
2271 for (mb_x
= start_x
; mb_x
< end_x
; mb_x
++)
2272 for (mb_y
= end_mb_y
- FRAME_MBAFF(h
); mb_y
<= end_mb_y
; mb_y
++) {
2274 mb_xy
= h
->mb_xy
= mb_x
+ mb_y
* h
->mb_stride
;
2275 h
->slice_num
= h
->slice_table
[mb_xy
];
2276 mb_type
= h
->cur_pic
.mb_type
[mb_xy
];
2277 h
->list_count
= h
->list_counts
[mb_xy
];
2281 h
->mb_field_decoding_flag
= !!IS_INTERLACED(mb_type
);
2285 dest_y
= h
->cur_pic
.f
.data
[0] +
2286 ((mb_x
<< pixel_shift
) + mb_y
* h
->linesize
) * 16;
2287 dest_cb
= h
->cur_pic
.f
.data
[1] +
2288 (mb_x
<< pixel_shift
) * (8 << CHROMA444(h
)) +
2289 mb_y
* h
->uvlinesize
* block_h
;
2290 dest_cr
= h
->cur_pic
.f
.data
[2] +
2291 (mb_x
<< pixel_shift
) * (8 << CHROMA444(h
)) +
2292 mb_y
* h
->uvlinesize
* block_h
;
2293 // FIXME simplify above
2296 linesize
= h
->mb_linesize
= h
->linesize
* 2;
2297 uvlinesize
= h
->mb_uvlinesize
= h
->uvlinesize
* 2;
2298 if (mb_y
& 1) { // FIXME move out of this function?
2299 dest_y
-= h
->linesize
* 15;
2300 dest_cb
-= h
->uvlinesize
* (block_h
- 1);
2301 dest_cr
-= h
->uvlinesize
* (block_h
- 1);
2304 linesize
= h
->mb_linesize
= h
->linesize
;
2305 uvlinesize
= h
->mb_uvlinesize
= h
->uvlinesize
;
2307 backup_mb_border(h
, dest_y
, dest_cb
, dest_cr
, linesize
,
2309 if (fill_filter_caches(h
, mb_type
))
2311 h
->chroma_qp
[0] = get_chroma_qp(h
, 0, h
->cur_pic
.qscale_table
[mb_xy
]);
2312 h
->chroma_qp
[1] = get_chroma_qp(h
, 1, h
->cur_pic
.qscale_table
[mb_xy
]);
2314 if (FRAME_MBAFF(h
)) {
2315 ff_h264_filter_mb(h
, mb_x
, mb_y
, dest_y
, dest_cb
, dest_cr
,
2316 linesize
, uvlinesize
);
2318 ff_h264_filter_mb_fast(h
, mb_x
, mb_y
, dest_y
, dest_cb
,
2319 dest_cr
, linesize
, uvlinesize
);
2323 h
->slice_type
= old_slice_type
;
2325 h
->mb_y
= end_mb_y
- FRAME_MBAFF(h
);
2326 h
->chroma_qp
[0] = get_chroma_qp(h
, 0, h
->qscale
);
2327 h
->chroma_qp
[1] = get_chroma_qp(h
, 1, h
->qscale
);
2330 static void predict_field_decoding_flag(H264Context
*h
)
2332 const int mb_xy
= h
->mb_x
+ h
->mb_y
* h
->mb_stride
;
2333 int mb_type
= (h
->slice_table
[mb_xy
- 1] == h
->slice_num
) ?
2334 h
->cur_pic
.mb_type
[mb_xy
- 1] :
2335 (h
->slice_table
[mb_xy
- h
->mb_stride
] == h
->slice_num
) ?
2336 h
->cur_pic
.mb_type
[mb_xy
- h
->mb_stride
] : 0;
2337 h
->mb_mbaff
= h
->mb_field_decoding_flag
= IS_INTERLACED(mb_type
) ? 1 : 0;
2341 * Draw edges and report progress for the last MB row.
2343 static void decode_finish_row(H264Context
*h
)
2345 int top
= 16 * (h
->mb_y
>> FIELD_PICTURE(h
));
2346 int pic_height
= 16 * h
->mb_height
>> FIELD_PICTURE(h
);
2347 int height
= 16 << FRAME_MBAFF(h
);
2348 int deblock_border
= (16 + 4) << FRAME_MBAFF(h
);
2350 if (h
->deblocking_filter
) {
2351 if ((top
+ height
) >= pic_height
)
2352 height
+= deblock_border
;
2353 top
-= deblock_border
;
2356 if (top
>= pic_height
|| (top
+ height
) < 0)
2359 height
= FFMIN(height
, pic_height
- top
);
2361 height
= top
+ height
;
2365 ff_h264_draw_horiz_band(h
, top
, height
);
2367 if (h
->droppable
|| h
->er
.error_occurred
)
2370 ff_thread_report_progress(&h
->cur_pic_ptr
->tf
, top
+ height
- 1,
2371 h
->picture_structure
== PICT_BOTTOM_FIELD
);
2374 static void er_add_slice(H264Context
*h
, int startx
, int starty
,
2375 int endx
, int endy
, int status
)
2377 if (CONFIG_ERROR_RESILIENCE
) {
2378 ERContext
*er
= &h
->er
;
2380 ff_er_add_slice(er
, startx
, starty
, endx
, endy
, status
);
2384 static int decode_slice(struct AVCodecContext
*avctx
, void *arg
)
2386 H264Context
*h
= *(void **)arg
;
2387 int lf_x_start
= h
->mb_x
;
2389 h
->mb_skip_run
= -1;
2391 av_assert0(h
->block_offset
[15] == (4 * ((scan8
[15] - scan8
[0]) & 7) << h
->pixel_shift
) + 4 * h
->linesize
* ((scan8
[15] - scan8
[0]) >> 3));
2393 h
->is_complex
= FRAME_MBAFF(h
) || h
->picture_structure
!= PICT_FRAME
||
2394 avctx
->codec_id
!= AV_CODEC_ID_H264
||
2395 (CONFIG_GRAY
&& (h
->flags
& CODEC_FLAG_GRAY
));
2397 if (!(h
->avctx
->active_thread_type
& FF_THREAD_SLICE
) && h
->picture_structure
== PICT_FRAME
&& h
->er
.error_status_table
) {
2398 const int start_i
= av_clip(h
->resync_mb_x
+ h
->resync_mb_y
* h
->mb_width
, 0, h
->mb_num
- 1);
2400 int prev_status
= h
->er
.error_status_table
[h
->er
.mb_index2xy
[start_i
- 1]];
2401 prev_status
&= ~ VP_START
;
2402 if (prev_status
!= (ER_MV_END
| ER_DC_END
| ER_AC_END
))
2403 h
->er
.error_occurred
= 1;
2409 align_get_bits(&h
->gb
);
2412 ff_init_cabac_decoder(&h
->cabac
,
2413 h
->gb
.buffer
+ get_bits_count(&h
->gb
) / 8,
2414 (get_bits_left(&h
->gb
) + 7) / 8);
2416 ff_h264_init_cabac_states(h
);
2420 int ret
= ff_h264_decode_mb_cabac(h
);
2422 // STOP_TIMER("decode_mb_cabac")
2425 ff_h264_hl_decode_mb(h
);
2427 // FIXME optimal? or let mb_decode decode 16x32 ?
2428 if (ret
>= 0 && FRAME_MBAFF(h
)) {
2431 ret
= ff_h264_decode_mb_cabac(h
);
2434 ff_h264_hl_decode_mb(h
);
2437 eos
= get_cabac_terminate(&h
->cabac
);
2439 if ((h
->workaround_bugs
& FF_BUG_TRUNCATED
) &&
2440 h
->cabac
.bytestream
> h
->cabac
.bytestream_end
+ 2) {
2441 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
, h
->mb_x
- 1,
2442 h
->mb_y
, ER_MB_END
);
2443 if (h
->mb_x
>= lf_x_start
)
2444 loop_filter(h
, lf_x_start
, h
->mb_x
+ 1);
2447 if (h
->cabac
.bytestream
> h
->cabac
.bytestream_end
+ 2 )
2448 av_log(h
->avctx
, AV_LOG_DEBUG
, "bytestream overread %"PTRDIFF_SPECIFIER
"\n", h
->cabac
.bytestream_end
- h
->cabac
.bytestream
);
2449 if (ret
< 0 || h
->cabac
.bytestream
> h
->cabac
.bytestream_end
+ 4) {
2450 av_log(h
->avctx
, AV_LOG_ERROR
,
2451 "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER
"\n",
2453 h
->cabac
.bytestream_end
- h
->cabac
.bytestream
);
2454 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
, h
->mb_x
,
2455 h
->mb_y
, ER_MB_ERROR
);
2456 return AVERROR_INVALIDDATA
;
2459 if (++h
->mb_x
>= h
->mb_width
) {
2460 loop_filter(h
, lf_x_start
, h
->mb_x
);
2461 h
->mb_x
= lf_x_start
= 0;
2462 decode_finish_row(h
);
2464 if (FIELD_OR_MBAFF_PICTURE(h
)) {
2466 if (FRAME_MBAFF(h
) && h
->mb_y
< h
->mb_height
)
2467 predict_field_decoding_flag(h
);
2471 if (eos
|| h
->mb_y
>= h
->mb_height
) {
2472 tprintf(h
->avctx
, "slice end %d %d\n",
2473 get_bits_count(&h
->gb
), h
->gb
.size_in_bits
);
2474 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
, h
->mb_x
- 1,
2475 h
->mb_y
, ER_MB_END
);
2476 if (h
->mb_x
> lf_x_start
)
2477 loop_filter(h
, lf_x_start
, h
->mb_x
);
2483 int ret
= ff_h264_decode_mb_cavlc(h
);
2486 ff_h264_hl_decode_mb(h
);
2488 // FIXME optimal? or let mb_decode decode 16x32 ?
2489 if (ret
>= 0 && FRAME_MBAFF(h
)) {
2491 ret
= ff_h264_decode_mb_cavlc(h
);
2494 ff_h264_hl_decode_mb(h
);
2499 av_log(h
->avctx
, AV_LOG_ERROR
,
2500 "error while decoding MB %d %d\n", h
->mb_x
, h
->mb_y
);
2501 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
, h
->mb_x
,
2502 h
->mb_y
, ER_MB_ERROR
);
2506 if (++h
->mb_x
>= h
->mb_width
) {
2507 loop_filter(h
, lf_x_start
, h
->mb_x
);
2508 h
->mb_x
= lf_x_start
= 0;
2509 decode_finish_row(h
);
2511 if (FIELD_OR_MBAFF_PICTURE(h
)) {
2513 if (FRAME_MBAFF(h
) && h
->mb_y
< h
->mb_height
)
2514 predict_field_decoding_flag(h
);
2516 if (h
->mb_y
>= h
->mb_height
) {
2517 tprintf(h
->avctx
, "slice end %d %d\n",
2518 get_bits_count(&h
->gb
), h
->gb
.size_in_bits
);
2520 if ( get_bits_left(&h
->gb
) == 0
2521 || get_bits_left(&h
->gb
) > 0 && !(h
->avctx
->err_recognition
& AV_EF_AGGRESSIVE
)) {
2522 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
,
2523 h
->mb_x
- 1, h
->mb_y
, ER_MB_END
);
2527 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
,
2528 h
->mb_x
, h
->mb_y
, ER_MB_END
);
2530 return AVERROR_INVALIDDATA
;
2535 if (get_bits_left(&h
->gb
) <= 0 && h
->mb_skip_run
<= 0) {
2536 tprintf(h
->avctx
, "slice end %d %d\n",
2537 get_bits_count(&h
->gb
), h
->gb
.size_in_bits
);
2539 if (get_bits_left(&h
->gb
) == 0) {
2540 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
,
2541 h
->mb_x
- 1, h
->mb_y
, ER_MB_END
);
2542 if (h
->mb_x
> lf_x_start
)
2543 loop_filter(h
, lf_x_start
, h
->mb_x
);
2547 er_add_slice(h
, h
->resync_mb_x
, h
->resync_mb_y
, h
->mb_x
,
2548 h
->mb_y
, ER_MB_ERROR
);
2550 return AVERROR_INVALIDDATA
;
2558 * Call decode_slice() for each context.
2560 * @param h h264 master context
2561 * @param context_count number of contexts to execute
2563 int ff_h264_execute_decode_slices(H264Context
*h
, unsigned context_count
)
2565 AVCodecContext
*const avctx
= h
->avctx
;
2569 av_assert0(h
->mb_y
< h
->mb_height
);
2571 if (h
->avctx
->hwaccel
||
2572 h
->avctx
->codec
->capabilities
& CODEC_CAP_HWACCEL_VDPAU
)
2574 if (context_count
== 1) {
2575 return decode_slice(avctx
, &h
);
2577 av_assert0(context_count
> 0);
2578 for (i
= 1; i
< context_count
; i
++) {
2579 hx
= h
->thread_context
[i
];
2580 if (CONFIG_ERROR_RESILIENCE
) {
2581 hx
->er
.error_count
= 0;
2583 hx
->x264_build
= h
->x264_build
;
2586 avctx
->execute(avctx
, decode_slice
, h
->thread_context
,
2587 NULL
, context_count
, sizeof(void *));
2589 /* pull back stuff from slices to master context */
2590 hx
= h
->thread_context
[context_count
- 1];
2593 h
->droppable
= hx
->droppable
;
2594 h
->picture_structure
= hx
->picture_structure
;
2595 if (CONFIG_ERROR_RESILIENCE
) {
2596 for (i
= 1; i
< context_count
; i
++)
2597 h
->er
.error_count
+= h
->thread_context
[i
]->er
.error_count
;