blob: 249cced2d3da2a4aefa38fda5191e415ddd2c499
1 | /* |
2 | * H.26L/H.264/AVC/JVT/14496-10/... decoder |
3 | * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> |
4 | * |
5 | * This file is part of FFmpeg. |
6 | * |
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. |
11 | * |
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. |
16 | * |
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 |
20 | */ |
21 | |
22 | /** |
23 | * @file |
24 | * H.264 / AVC / MPEG-4 part10 codec. |
25 | * @author Michael Niedermayer <michaelni@gmx.at> |
26 | */ |
27 | |
28 | #define UNCHECKED_BITSTREAM_READER 1 |
29 | |
30 | #include "libavutil/avassert.h" |
31 | #include "libavutil/display.h" |
32 | #include "libavutil/imgutils.h" |
33 | #include "libavutil/opt.h" |
34 | #include "libavutil/stereo3d.h" |
35 | #include "libavutil/timer.h" |
36 | #include "internal.h" |
37 | #include "bytestream.h" |
38 | #include "cabac.h" |
39 | #include "cabac_functions.h" |
40 | #include "error_resilience.h" |
41 | #include "avcodec.h" |
42 | #include "h264.h" |
43 | #include "h264dec.h" |
44 | #include "h2645_parse.h" |
45 | #include "h264data.h" |
46 | #include "h264chroma.h" |
47 | #include "h264_mvpred.h" |
48 | #include "h264_ps.h" |
49 | #include "golomb.h" |
50 | #include "mathops.h" |
51 | #include "me_cmp.h" |
52 | #include "mpegutils.h" |
53 | #include "profiles.h" |
54 | #include "rectangle.h" |
55 | #include "thread.h" |
56 | #include "vdpau_compat.h" |
57 | |
58 | static int h264_decode_end(AVCodecContext *avctx); |
59 | |
60 | const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 }; |
61 | |
62 | int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx) |
63 | { |
64 | H264Context *h = avctx->priv_data; |
65 | return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0; |
66 | } |
67 | |
68 | static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, |
69 | int (*mv)[2][4][2], |
70 | int mb_x, int mb_y, int mb_intra, int mb_skipped) |
71 | { |
72 | H264Context *h = opaque; |
73 | H264SliceContext *sl = &h->slice_ctx[0]; |
74 | |
75 | sl->mb_x = mb_x; |
76 | sl->mb_y = mb_y; |
77 | sl->mb_xy = mb_x + mb_y * h->mb_stride; |
78 | memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache)); |
79 | av_assert1(ref >= 0); |
80 | /* FIXME: It is possible albeit uncommon that slice references |
81 | * differ between slices. We take the easy approach and ignore |
82 | * it for now. If this turns out to have any relevance in |
83 | * practice then correct remapping should be added. */ |
84 | if (ref >= sl->ref_count[0]) |
85 | ref = 0; |
86 | if (!sl->ref_list[0][ref].data[0]) { |
87 | av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n"); |
88 | ref = 0; |
89 | } |
90 | if ((sl->ref_list[0][ref].reference&3) != 3) { |
91 | av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n"); |
92 | return; |
93 | } |
94 | fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy], |
95 | 2, 2, 2, ref, 1); |
96 | fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); |
97 | fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8, |
98 | pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4); |
99 | sl->mb_mbaff = |
100 | sl->mb_field_decoding_flag = 0; |
101 | ff_h264_hl_decode_mb(h, &h->slice_ctx[0]); |
102 | } |
103 | |
104 | void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, |
105 | int y, int height) |
106 | { |
107 | AVCodecContext *avctx = h->avctx; |
108 | const AVFrame *src = h->cur_pic.f; |
109 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); |
110 | int vshift = desc->log2_chroma_h; |
111 | const int field_pic = h->picture_structure != PICT_FRAME; |
112 | if (field_pic) { |
113 | height <<= 1; |
114 | y <<= 1; |
115 | } |
116 | |
117 | height = FFMIN(height, avctx->height - y); |
118 | |
119 | if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) |
120 | return; |
121 | |
122 | if (avctx->draw_horiz_band) { |
123 | int offset[AV_NUM_DATA_POINTERS]; |
124 | int i; |
125 | |
126 | offset[0] = y * src->linesize[0]; |
127 | offset[1] = |
128 | offset[2] = (y >> vshift) * src->linesize[1]; |
129 | for (i = 3; i < AV_NUM_DATA_POINTERS; i++) |
130 | offset[i] = 0; |
131 | |
132 | emms_c(); |
133 | |
134 | avctx->draw_horiz_band(avctx, src, offset, |
135 | y, h->picture_structure, height); |
136 | } |
137 | } |
138 | |
139 | void ff_h264_free_tables(H264Context *h) |
140 | { |
141 | int i; |
142 | |
143 | av_freep(&h->intra4x4_pred_mode); |
144 | av_freep(&h->chroma_pred_mode_table); |
145 | av_freep(&h->cbp_table); |
146 | av_freep(&h->mvd_table[0]); |
147 | av_freep(&h->mvd_table[1]); |
148 | av_freep(&h->direct_table); |
149 | av_freep(&h->non_zero_count); |
150 | av_freep(&h->slice_table_base); |
151 | h->slice_table = NULL; |
152 | av_freep(&h->list_counts); |
153 | |
154 | av_freep(&h->mb2b_xy); |
155 | av_freep(&h->mb2br_xy); |
156 | |
157 | av_buffer_pool_uninit(&h->qscale_table_pool); |
158 | av_buffer_pool_uninit(&h->mb_type_pool); |
159 | av_buffer_pool_uninit(&h->motion_val_pool); |
160 | av_buffer_pool_uninit(&h->ref_index_pool); |
161 | |
162 | for (i = 0; i < h->nb_slice_ctx; i++) { |
163 | H264SliceContext *sl = &h->slice_ctx[i]; |
164 | |
165 | av_freep(&sl->dc_val_base); |
166 | av_freep(&sl->er.mb_index2xy); |
167 | av_freep(&sl->er.error_status_table); |
168 | av_freep(&sl->er.er_temp_buffer); |
169 | |
170 | av_freep(&sl->bipred_scratchpad); |
171 | av_freep(&sl->edge_emu_buffer); |
172 | av_freep(&sl->top_borders[0]); |
173 | av_freep(&sl->top_borders[1]); |
174 | |
175 | sl->bipred_scratchpad_allocated = 0; |
176 | sl->edge_emu_buffer_allocated = 0; |
177 | sl->top_borders_allocated[0] = 0; |
178 | sl->top_borders_allocated[1] = 0; |
179 | } |
180 | } |
181 | |
182 | int ff_h264_alloc_tables(H264Context *h) |
183 | { |
184 | const int big_mb_num = h->mb_stride * (h->mb_height + 1); |
185 | const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1); |
186 | int x, y; |
187 | |
188 | FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode, |
189 | row_mb_num, 8 * sizeof(uint8_t), fail) |
190 | h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode; |
191 | |
192 | FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count, |
193 | big_mb_num * 48 * sizeof(uint8_t), fail) |
194 | FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base, |
195 | (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail) |
196 | FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table, |
197 | big_mb_num * sizeof(uint16_t), fail) |
198 | FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table, |
199 | big_mb_num * sizeof(uint8_t), fail) |
200 | FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0], |
201 | row_mb_num, 16 * sizeof(uint8_t), fail); |
202 | FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1], |
203 | row_mb_num, 16 * sizeof(uint8_t), fail); |
204 | h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; |
205 | h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; |
206 | |
207 | FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table, |
208 | 4 * big_mb_num * sizeof(uint8_t), fail); |
209 | FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts, |
210 | big_mb_num * sizeof(uint8_t), fail) |
211 | |
212 | memset(h->slice_table_base, -1, |
213 | (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base)); |
214 | h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1; |
215 | |
216 | FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy, |
217 | big_mb_num * sizeof(uint32_t), fail); |
218 | FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy, |
219 | big_mb_num * sizeof(uint32_t), fail); |
220 | for (y = 0; y < h->mb_height; y++) |
221 | for (x = 0; x < h->mb_width; x++) { |
222 | const int mb_xy = x + y * h->mb_stride; |
223 | const int b_xy = 4 * x + 4 * y * h->b_stride; |
224 | |
225 | h->mb2b_xy[mb_xy] = b_xy; |
226 | h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride))); |
227 | } |
228 | |
229 | return 0; |
230 | |
231 | fail: |
232 | ff_h264_free_tables(h); |
233 | return AVERROR(ENOMEM); |
234 | } |
235 | |
236 | /** |
237 | * Init context |
238 | * Allocate buffers which are not shared amongst multiple threads. |
239 | */ |
240 | int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) |
241 | { |
242 | ERContext *er = &sl->er; |
243 | int mb_array_size = h->mb_height * h->mb_stride; |
244 | int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1); |
245 | int c_size = h->mb_stride * (h->mb_height + 1); |
246 | int yc_size = y_size + 2 * c_size; |
247 | int x, y, i; |
248 | |
249 | sl->ref_cache[0][scan8[5] + 1] = |
250 | sl->ref_cache[0][scan8[7] + 1] = |
251 | sl->ref_cache[0][scan8[13] + 1] = |
252 | sl->ref_cache[1][scan8[5] + 1] = |
253 | sl->ref_cache[1][scan8[7] + 1] = |
254 | sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; |
255 | |
256 | if (sl != h->slice_ctx) { |
257 | memset(er, 0, sizeof(*er)); |
258 | } else |
259 | if (CONFIG_ERROR_RESILIENCE) { |
260 | |
261 | /* init ER */ |
262 | er->avctx = h->avctx; |
263 | er->decode_mb = h264_er_decode_mb; |
264 | er->opaque = h; |
265 | er->quarter_sample = 1; |
266 | |
267 | er->mb_num = h->mb_num; |
268 | er->mb_width = h->mb_width; |
269 | er->mb_height = h->mb_height; |
270 | er->mb_stride = h->mb_stride; |
271 | er->b8_stride = h->mb_width * 2 + 1; |
272 | |
273 | // error resilience code looks cleaner with this |
274 | FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy, |
275 | (h->mb_num + 1) * sizeof(int), fail); |
276 | |
277 | for (y = 0; y < h->mb_height; y++) |
278 | for (x = 0; x < h->mb_width; x++) |
279 | er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride; |
280 | |
281 | er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) * |
282 | h->mb_stride + h->mb_width; |
283 | |
284 | FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table, |
285 | mb_array_size * sizeof(uint8_t), fail); |
286 | |
287 | FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer, |
288 | h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail); |
289 | |
290 | FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base, |
291 | yc_size * sizeof(int16_t), fail); |
292 | er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2; |
293 | er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1; |
294 | er->dc_val[2] = er->dc_val[1] + c_size; |
295 | for (i = 0; i < yc_size; i++) |
296 | sl->dc_val_base[i] = 1024; |
297 | } |
298 | |
299 | return 0; |
300 | |
301 | fail: |
302 | return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us |
303 | } |
304 | |
305 | static int h264_init_context(AVCodecContext *avctx, H264Context *h) |
306 | { |
307 | int i; |
308 | |
309 | h->avctx = avctx; |
310 | h->cur_chroma_format_idc = -1; |
311 | |
312 | h->picture_structure = PICT_FRAME; |
313 | h->workaround_bugs = avctx->workaround_bugs; |
314 | h->flags = avctx->flags; |
315 | h->poc.prev_poc_msb = 1 << 16; |
316 | h->recovery_frame = -1; |
317 | h->frame_recovered = 0; |
318 | h->poc.prev_frame_num = -1; |
319 | h->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1; |
320 | h->sei.unregistered.x264_build = -1; |
321 | |
322 | h->next_outputed_poc = INT_MIN; |
323 | for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) |
324 | h->last_pocs[i] = INT_MIN; |
325 | |
326 | ff_h264_sei_uninit(&h->sei); |
327 | |
328 | avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; |
329 | |
330 | h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1; |
331 | h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx)); |
332 | if (!h->slice_ctx) { |
333 | h->nb_slice_ctx = 0; |
334 | return AVERROR(ENOMEM); |
335 | } |
336 | |
337 | for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) { |
338 | h->DPB[i].f = av_frame_alloc(); |
339 | if (!h->DPB[i].f) |
340 | return AVERROR(ENOMEM); |
341 | } |
342 | |
343 | h->cur_pic.f = av_frame_alloc(); |
344 | if (!h->cur_pic.f) |
345 | return AVERROR(ENOMEM); |
346 | |
347 | h->last_pic_for_ec.f = av_frame_alloc(); |
348 | if (!h->last_pic_for_ec.f) |
349 | return AVERROR(ENOMEM); |
350 | |
351 | for (i = 0; i < h->nb_slice_ctx; i++) |
352 | h->slice_ctx[i].h264 = h; |
353 | |
354 | return 0; |
355 | } |
356 | |
357 | static av_cold int h264_decode_end(AVCodecContext *avctx) |
358 | { |
359 | H264Context *h = avctx->priv_data; |
360 | int i; |
361 | |
362 | ff_h264_remove_all_refs(h); |
363 | ff_h264_free_tables(h); |
364 | |
365 | for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) { |
366 | ff_h264_unref_picture(h, &h->DPB[i]); |
367 | av_frame_free(&h->DPB[i].f); |
368 | } |
369 | memset(h->delayed_pic, 0, sizeof(h->delayed_pic)); |
370 | |
371 | h->cur_pic_ptr = NULL; |
372 | |
373 | av_freep(&h->slice_ctx); |
374 | h->nb_slice_ctx = 0; |
375 | |
376 | ff_h264_sei_uninit(&h->sei); |
377 | ff_h264_ps_uninit(&h->ps); |
378 | |
379 | ff_h2645_packet_uninit(&h->pkt); |
380 | |
381 | ff_h264_unref_picture(h, &h->cur_pic); |
382 | av_frame_free(&h->cur_pic.f); |
383 | ff_h264_unref_picture(h, &h->last_pic_for_ec); |
384 | av_frame_free(&h->last_pic_for_ec.f); |
385 | |
386 | return 0; |
387 | } |
388 | |
389 | static AVOnce h264_vlc_init = AV_ONCE_INIT; |
390 | |
391 | av_cold int ff_h264_decode_init(AVCodecContext *avctx) |
392 | { |
393 | H264Context *h = avctx->priv_data; |
394 | int ret; |
395 | |
396 | ret = h264_init_context(avctx, h); |
397 | if (ret < 0) |
398 | return ret; |
399 | |
400 | ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc); |
401 | if (ret != 0) { |
402 | av_log(avctx, AV_LOG_ERROR, "pthread_once has failed."); |
403 | return AVERROR_UNKNOWN; |
404 | } |
405 | |
406 | if (avctx->ticks_per_frame == 1) { |
407 | if(h->avctx->time_base.den < INT_MAX/2) { |
408 | h->avctx->time_base.den *= 2; |
409 | } else |
410 | h->avctx->time_base.num /= 2; |
411 | } |
412 | avctx->ticks_per_frame = 2; |
413 | |
414 | if (avctx->extradata_size > 0 && avctx->extradata) { |
415 | ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size, |
416 | &h->ps, &h->is_avc, &h->nal_length_size, |
417 | avctx->err_recognition, avctx); |
418 | if (ret < 0) { |
419 | h264_decode_end(avctx); |
420 | return ret; |
421 | } |
422 | } |
423 | |
424 | if (h->ps.sps && h->ps.sps->bitstream_restriction_flag && |
425 | h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) { |
426 | h->avctx->has_b_frames = h->ps.sps->num_reorder_frames; |
427 | } |
428 | |
429 | avctx->internal->allocate_progress = 1; |
430 | |
431 | ff_h264_flush_change(h); |
432 | |
433 | if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE)) |
434 | h->enable_er = 0; |
435 | |
436 | if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) { |
437 | av_log(avctx, AV_LOG_WARNING, |
438 | "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. " |
439 | "Use it at your own risk\n"); |
440 | } |
441 | |
442 | return 0; |
443 | } |
444 | |
445 | #if HAVE_THREADS |
446 | static int decode_init_thread_copy(AVCodecContext *avctx) |
447 | { |
448 | H264Context *h = avctx->priv_data; |
449 | int ret; |
450 | |
451 | if (!avctx->internal->is_copy) |
452 | return 0; |
453 | |
454 | memset(h, 0, sizeof(*h)); |
455 | |
456 | ret = h264_init_context(avctx, h); |
457 | if (ret < 0) |
458 | return ret; |
459 | |
460 | h->context_initialized = 0; |
461 | |
462 | return 0; |
463 | } |
464 | #endif |
465 | |
466 | /** |
467 | * instantaneous decoder refresh. |
468 | */ |
469 | static void idr(H264Context *h) |
470 | { |
471 | int i; |
472 | ff_h264_remove_all_refs(h); |
473 | h->poc.prev_frame_num = |
474 | h->poc.prev_frame_num_offset = 0; |
475 | h->poc.prev_poc_msb = 1<<16; |
476 | h->poc.prev_poc_lsb = 0; |
477 | for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) |
478 | h->last_pocs[i] = INT_MIN; |
479 | } |
480 | |
481 | /* forget old pics after a seek */ |
482 | void ff_h264_flush_change(H264Context *h) |
483 | { |
484 | int i, j; |
485 | |
486 | h->next_outputed_poc = INT_MIN; |
487 | h->prev_interlaced_frame = 1; |
488 | idr(h); |
489 | |
490 | h->poc.prev_frame_num = -1; |
491 | if (h->cur_pic_ptr) { |
492 | h->cur_pic_ptr->reference = 0; |
493 | for (j=i=0; h->delayed_pic[i]; i++) |
494 | if (h->delayed_pic[i] != h->cur_pic_ptr) |
495 | h->delayed_pic[j++] = h->delayed_pic[i]; |
496 | h->delayed_pic[j] = NULL; |
497 | } |
498 | ff_h264_unref_picture(h, &h->last_pic_for_ec); |
499 | |
500 | h->first_field = 0; |
501 | ff_h264_sei_uninit(&h->sei); |
502 | h->recovery_frame = -1; |
503 | h->frame_recovered = 0; |
504 | h->current_slice = 0; |
505 | h->mmco_reset = 1; |
506 | } |
507 | |
508 | /* forget old pics after a seek */ |
509 | static void flush_dpb(AVCodecContext *avctx) |
510 | { |
511 | H264Context *h = avctx->priv_data; |
512 | int i; |
513 | |
514 | memset(h->delayed_pic, 0, sizeof(h->delayed_pic)); |
515 | |
516 | ff_h264_flush_change(h); |
517 | |
518 | for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) |
519 | ff_h264_unref_picture(h, &h->DPB[i]); |
520 | h->cur_pic_ptr = NULL; |
521 | ff_h264_unref_picture(h, &h->cur_pic); |
522 | |
523 | h->mb_y = 0; |
524 | |
525 | ff_h264_free_tables(h); |
526 | h->context_initialized = 0; |
527 | } |
528 | |
529 | #if FF_API_CAP_VDPAU |
530 | static const uint8_t start_code[] = { 0x00, 0x00, 0x01 }; |
531 | #endif |
532 | |
533 | static int get_last_needed_nal(H264Context *h) |
534 | { |
535 | int nals_needed = 0; |
536 | int first_slice = 0; |
537 | int i, ret; |
538 | |
539 | for (i = 0; i < h->pkt.nb_nals; i++) { |
540 | H2645NAL *nal = &h->pkt.nals[i]; |
541 | GetBitContext gb; |
542 | |
543 | /* packets can sometimes contain multiple PPS/SPS, |
544 | * e.g. two PAFF field pictures in one packet, or a demuxer |
545 | * which splits NALs strangely if so, when frame threading we |
546 | * can't start the next thread until we've read all of them */ |
547 | switch (nal->type) { |
548 | case H264_NAL_SPS: |
549 | case H264_NAL_PPS: |
550 | nals_needed = i; |
551 | break; |
552 | case H264_NAL_DPA: |
553 | case H264_NAL_IDR_SLICE: |
554 | case H264_NAL_SLICE: |
555 | ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1); |
556 | if (ret < 0) { |
557 | av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n"); |
558 | if (h->avctx->err_recognition & AV_EF_EXPLODE) |
559 | return ret; |
560 | |
561 | break; |
562 | } |
563 | if (!get_ue_golomb_long(&gb) || // first_mb_in_slice |
564 | !first_slice || |
565 | first_slice != nal->type) |
566 | nals_needed = i; |
567 | if (!first_slice) |
568 | first_slice = nal->type; |
569 | } |
570 | } |
571 | |
572 | return nals_needed; |
573 | } |
574 | |
575 | static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx) |
576 | { |
577 | av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n"); |
578 | av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type); |
579 | |
580 | if (gm->green_metadata_type == 0) { |
581 | av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type); |
582 | |
583 | if (gm->period_type == 2) |
584 | av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds); |
585 | else if (gm->period_type == 3) |
586 | av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures); |
587 | |
588 | av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n", |
589 | (float)gm->percent_non_zero_macroblocks/255, |
590 | (float)gm->percent_intra_coded_macroblocks/255, |
591 | (float)gm->percent_six_tap_filtering/255, |
592 | (float)gm->percent_alpha_point_deblocking_instance/255); |
593 | |
594 | } else if (gm->green_metadata_type == 1) { |
595 | av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type); |
596 | |
597 | if (gm->xsd_metric_type == 0) |
598 | av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n", |
599 | (float)gm->xsd_metric_value/100); |
600 | } |
601 | } |
602 | |
603 | static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size) |
604 | { |
605 | AVCodecContext *const avctx = h->avctx; |
606 | int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts |
607 | int idr_cleared=0; |
608 | int i, ret = 0; |
609 | |
610 | h->has_slice = 0; |
611 | h->nal_unit_type= 0; |
612 | |
613 | if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { |
614 | h->current_slice = 0; |
615 | if (!h->first_field) |
616 | h->cur_pic_ptr = NULL; |
617 | ff_h264_sei_uninit(&h->sei); |
618 | } |
619 | |
620 | if (h->nal_length_size == 4) { |
621 | if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) { |
622 | h->is_avc = 0; |
623 | }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size) |
624 | h->is_avc = 1; |
625 | } |
626 | |
627 | ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc, |
628 | h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST); |
629 | if (ret < 0) { |
630 | av_log(avctx, AV_LOG_ERROR, |
631 | "Error splitting the input into NAL units.\n"); |
632 | return ret; |
633 | } |
634 | |
635 | if (avctx->active_thread_type & FF_THREAD_FRAME) |
636 | nals_needed = get_last_needed_nal(h); |
637 | if (nals_needed < 0) |
638 | return nals_needed; |
639 | |
640 | for (i = 0; i < h->pkt.nb_nals; i++) { |
641 | H2645NAL *nal = &h->pkt.nals[i]; |
642 | int max_slice_ctx, err; |
643 | |
644 | if (avctx->skip_frame >= AVDISCARD_NONREF && |
645 | nal->ref_idc == 0 && nal->type != H264_NAL_SEI) |
646 | continue; |
647 | |
648 | // FIXME these should stop being context-global variables |
649 | h->nal_ref_idc = nal->ref_idc; |
650 | h->nal_unit_type = nal->type; |
651 | |
652 | err = 0; |
653 | switch (nal->type) { |
654 | case H264_NAL_IDR_SLICE: |
655 | if ((nal->data[1] & 0xFC) == 0x98) { |
656 | av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n"); |
657 | h->next_outputed_poc = INT_MIN; |
658 | ret = -1; |
659 | goto end; |
660 | } |
661 | if(!idr_cleared) { |
662 | if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) { |
663 | av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n"); |
664 | ret = AVERROR_INVALIDDATA; |
665 | goto end; |
666 | } |
667 | idr(h); // FIXME ensure we don't lose some frames if there is reordering |
668 | } |
669 | idr_cleared = 1; |
670 | h->has_recovery_point = 1; |
671 | case H264_NAL_SLICE: |
672 | h->has_slice = 1; |
673 | |
674 | if ((err = ff_h264_queue_decode_slice(h, nal))) { |
675 | H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued; |
676 | sl->ref_count[0] = sl->ref_count[1] = 0; |
677 | break; |
678 | } |
679 | |
680 | if (h->current_slice == 1) { |
681 | if (avctx->active_thread_type & FF_THREAD_FRAME && |
682 | i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) { |
683 | ff_thread_finish_setup(avctx); |
684 | h->setup_finished = 1; |
685 | } |
686 | |
687 | if (h->avctx->hwaccel && |
688 | (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0) |
689 | goto end; |
690 | #if FF_API_CAP_VDPAU |
691 | if (CONFIG_H264_VDPAU_DECODER && |
692 | h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU) |
693 | ff_vdpau_h264_picture_start(h); |
694 | #endif |
695 | } |
696 | |
697 | max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx; |
698 | if (h->nb_slice_ctx_queued == max_slice_ctx) { |
699 | if (h->avctx->hwaccel) { |
700 | ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size); |
701 | h->nb_slice_ctx_queued = 0; |
702 | } else |
703 | #if FF_API_CAP_VDPAU |
704 | if (CONFIG_H264_VDPAU_DECODER && |
705 | h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU) { |
706 | ff_vdpau_add_data_chunk(h->cur_pic_ptr->f->data[0], |
707 | start_code, |
708 | sizeof(start_code)); |
709 | ff_vdpau_add_data_chunk(h->cur_pic_ptr->f->data[0], |
710 | nal->raw_data, |
711 | nal->raw_size); |
712 | ret = 0; |
713 | } else |
714 | #endif |
715 | ret = ff_h264_execute_decode_slices(h); |
716 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
717 | goto end; |
718 | } |
719 | break; |
720 | case H264_NAL_DPA: |
721 | case H264_NAL_DPB: |
722 | case H264_NAL_DPC: |
723 | avpriv_request_sample(avctx, "data partitioning"); |
724 | break; |
725 | case H264_NAL_SEI: |
726 | ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx); |
727 | h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1; |
728 | if (avctx->debug & FF_DEBUG_GREEN_MD) |
729 | debug_green_metadata(&h->sei.green_metadata, h->avctx); |
730 | #if FF_API_AFD |
731 | FF_DISABLE_DEPRECATION_WARNINGS |
732 | h->avctx->dtg_active_format = h->sei.afd.active_format_description; |
733 | FF_ENABLE_DEPRECATION_WARNINGS |
734 | #endif /* FF_API_AFD */ |
735 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
736 | goto end; |
737 | break; |
738 | case H264_NAL_SPS: { |
739 | GetBitContext tmp_gb = nal->gb; |
740 | if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0) |
741 | break; |
742 | av_log(h->avctx, AV_LOG_DEBUG, |
743 | "SPS decoding failure, trying again with the complete NAL\n"); |
744 | init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1); |
745 | if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0) |
746 | break; |
747 | ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1); |
748 | break; |
749 | } |
750 | case H264_NAL_PPS: |
751 | ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps, |
752 | nal->size_bits); |
753 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
754 | goto end; |
755 | break; |
756 | case H264_NAL_AUD: |
757 | case H264_NAL_END_SEQUENCE: |
758 | case H264_NAL_END_STREAM: |
759 | case H264_NAL_FILLER_DATA: |
760 | case H264_NAL_SPS_EXT: |
761 | case H264_NAL_AUXILIARY_SLICE: |
762 | break; |
763 | case H264_NAL_PREFIX: |
764 | case H264_NAL_SUB_SPS: |
765 | case H264_NAL_SLC_EXT: |
766 | /*0x1b is ts avc stream type set mvc once*/ |
767 | if (avctx->codec_tag == 0x1b) { |
768 | avctx->codec_tag = MKTAG('M', 'V', 'C', ' '); |
769 | } |
770 | break; |
771 | default: |
772 | av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", |
773 | nal->type, nal->size_bits); |
774 | } |
775 | |
776 | if (err < 0) { |
777 | av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n"); |
778 | } |
779 | } |
780 | |
781 | ret = ff_h264_execute_decode_slices(h); |
782 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
783 | goto end; |
784 | |
785 | ret = 0; |
786 | end: |
787 | |
788 | #if CONFIG_ERROR_RESILIENCE |
789 | /* |
790 | * FIXME: Error handling code does not seem to support interlaced |
791 | * when slices span multiple rows |
792 | * The ff_er_add_slice calls don't work right for bottom |
793 | * fields; they cause massive erroneous error concealing |
794 | * Error marking covers both fields (top and bottom). |
795 | * This causes a mismatched s->error_count |
796 | * and a bad error table. Further, the error count goes to |
797 | * INT_MAX when called for bottom field, because mb_y is |
798 | * past end by one (callers fault) and resync_mb_y != 0 |
799 | * causes problems for the first MB line, too. |
800 | */ |
801 | if (!FIELD_PICTURE(h) && h->current_slice && |
802 | h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data && |
803 | h->enable_er) { |
804 | |
805 | H264SliceContext *sl = h->slice_ctx; |
806 | int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0]; |
807 | |
808 | ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr); |
809 | |
810 | if (use_last_pic) { |
811 | ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec); |
812 | sl->ref_list[0][0].parent = &h->last_pic_for_ec; |
813 | memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data)); |
814 | memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize)); |
815 | sl->ref_list[0][0].reference = h->last_pic_for_ec.reference; |
816 | } else if (sl->ref_count[0]) { |
817 | ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent); |
818 | } else |
819 | ff_h264_set_erpic(&sl->er.last_pic, NULL); |
820 | |
821 | if (sl->ref_count[1]) |
822 | ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent); |
823 | |
824 | sl->er.ref_count = sl->ref_count[0]; |
825 | |
826 | ff_er_frame_end(&sl->er); |
827 | if (use_last_pic) |
828 | memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0])); |
829 | } |
830 | #endif /* CONFIG_ERROR_RESILIENCE */ |
831 | /* clean up */ |
832 | if (h->cur_pic_ptr && !h->droppable && h->has_slice) { |
833 | ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, |
834 | h->picture_structure == PICT_BOTTOM_FIELD); |
835 | } |
836 | |
837 | return (ret < 0) ? ret : buf_size; |
838 | } |
839 | |
840 | /** |
841 | * Return the number of bytes consumed for building the current frame. |
842 | */ |
843 | static int get_consumed_bytes(int pos, int buf_size) |
844 | { |
845 | if (pos == 0) |
846 | pos = 1; // avoid infinite loops (I doubt that is needed but...) |
847 | if (pos + 10 > buf_size) |
848 | pos = buf_size; // oops ;) |
849 | |
850 | return pos; |
851 | } |
852 | |
853 | static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp) |
854 | { |
855 | AVFrame *src = srcp->f; |
856 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format); |
857 | int i; |
858 | int ret; |
859 | |
860 | if (src->format == AV_PIX_FMT_VIDEOTOOLBOX && src->buf[0]->size == 1) |
861 | return AVERROR_EXTERNAL; |
862 | |
863 | ret = av_frame_ref(dst, src); |
864 | if (ret < 0) |
865 | return ret; |
866 | |
867 | av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0); |
868 | |
869 | if (srcp->sei_recovery_frame_cnt == 0) |
870 | dst->key_frame = 1; |
871 | if (!srcp->crop) |
872 | return 0; |
873 | |
874 | for (i = 0; i < desc->nb_components; i++) { |
875 | int hshift = (i > 0) ? desc->log2_chroma_w : 0; |
876 | int vshift = (i > 0) ? desc->log2_chroma_h : 0; |
877 | int off = ((srcp->crop_left >> hshift) << h->pixel_shift) + |
878 | (srcp->crop_top >> vshift) * dst->linesize[i]; |
879 | dst->data[i] += off; |
880 | } |
881 | return 0; |
882 | } |
883 | |
884 | static int is_extra(const uint8_t *buf, int buf_size) |
885 | { |
886 | int cnt= buf[5]&0x1f; |
887 | const uint8_t *p= buf+6; |
888 | while(cnt--){ |
889 | int nalsize= AV_RB16(p) + 2; |
890 | if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7) |
891 | return 0; |
892 | p += nalsize; |
893 | } |
894 | cnt = *(p++); |
895 | if(!cnt) |
896 | return 0; |
897 | while(cnt--){ |
898 | int nalsize= AV_RB16(p) + 2; |
899 | if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8) |
900 | return 0; |
901 | p += nalsize; |
902 | } |
903 | return 1; |
904 | } |
905 | |
906 | static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame) |
907 | { |
908 | int ret; |
909 | |
910 | if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) || |
911 | (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) || |
912 | out->recovered)) { |
913 | |
914 | if (!h->avctx->hwaccel && |
915 | (out->field_poc[0] == INT_MAX || |
916 | out->field_poc[1] == INT_MAX) |
917 | ) { |
918 | int p; |
919 | AVFrame *f = out->f; |
920 | int field = out->field_poc[0] == INT_MAX; |
921 | uint8_t *dst_data[4]; |
922 | int linesizes[4]; |
923 | const uint8_t *src_data[4]; |
924 | |
925 | av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field); |
926 | |
927 | for (p = 0; p<4; p++) { |
928 | dst_data[p] = f->data[p] + (field^1)*f->linesize[p]; |
929 | src_data[p] = f->data[p] + field *f->linesize[p]; |
930 | linesizes[p] = 2*f->linesize[p]; |
931 | } |
932 | |
933 | av_image_copy(dst_data, linesizes, src_data, linesizes, |
934 | f->format, f->width, f->height>>1); |
935 | } |
936 | |
937 | ret = output_frame(h, dst, out); |
938 | if (ret < 0) |
939 | return ret; |
940 | |
941 | *got_frame = 1; |
942 | |
943 | if (CONFIG_MPEGVIDEO) { |
944 | ff_print_debug_info2(h->avctx, dst, NULL, |
945 | out->mb_type, |
946 | out->qscale_table, |
947 | out->motion_val, |
948 | NULL, |
949 | h->mb_width, h->mb_height, h->mb_stride, 1); |
950 | } |
951 | } |
952 | |
953 | return 0; |
954 | } |
955 | |
956 | static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, |
957 | int *got_frame, int buf_index) |
958 | { |
959 | int ret, i, out_idx; |
960 | H264Picture *out = h->delayed_pic[0]; |
961 | |
962 | h->cur_pic_ptr = NULL; |
963 | h->first_field = 0; |
964 | |
965 | out_idx = 0; |
966 | for (i = 1; |
967 | h->delayed_pic[i] && |
968 | !h->delayed_pic[i]->f->key_frame && |
969 | !h->delayed_pic[i]->mmco_reset; |
970 | i++) |
971 | if (h->delayed_pic[i]->poc < out->poc) { |
972 | out = h->delayed_pic[i]; |
973 | out_idx = i; |
974 | } |
975 | |
976 | for (i = out_idx; h->delayed_pic[i]; i++) |
977 | h->delayed_pic[i] = h->delayed_pic[i + 1]; |
978 | |
979 | if (out) { |
980 | out->reference &= ~DELAYED_PIC_REF; |
981 | ret = finalize_frame(h, dst_frame, out, got_frame); |
982 | if (ret < 0) |
983 | return ret; |
984 | } |
985 | |
986 | return buf_index; |
987 | } |
988 | |
989 | static int h264_decode_frame(AVCodecContext *avctx, void *data, |
990 | int *got_frame, AVPacket *avpkt) |
991 | { |
992 | const uint8_t *buf = avpkt->data; |
993 | int buf_size = avpkt->size; |
994 | H264Context *h = avctx->priv_data; |
995 | AVFrame *pict = data; |
996 | int buf_index; |
997 | int ret; |
998 | |
999 | h->flags = avctx->flags; |
1000 | h->setup_finished = 0; |
1001 | h->nb_slice_ctx_queued = 0; |
1002 | |
1003 | ff_h264_unref_picture(h, &h->last_pic_for_ec); |
1004 | |
1005 | /* end of stream, output what is still in the buffers */ |
1006 | if (buf_size == 0) |
1007 | return send_next_delayed_frame(h, pict, got_frame, 0); |
1008 | |
1009 | if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) { |
1010 | int side_size; |
1011 | uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size); |
1012 | if (is_extra(side, side_size)) |
1013 | ff_h264_decode_extradata(side, side_size, |
1014 | &h->ps, &h->is_avc, &h->nal_length_size, |
1015 | avctx->err_recognition, avctx); |
1016 | } |
1017 | if(h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){ |
1018 | if (is_extra(buf, buf_size)) |
1019 | return ff_h264_decode_extradata(buf, buf_size, |
1020 | &h->ps, &h->is_avc, &h->nal_length_size, |
1021 | avctx->err_recognition, avctx); |
1022 | } |
1023 | |
1024 | buf_index = decode_nal_units(h, buf, buf_size); |
1025 | if (buf_index < 0) |
1026 | return AVERROR_INVALIDDATA; |
1027 | |
1028 | if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) { |
1029 | av_assert0(buf_index <= buf_size); |
1030 | return send_next_delayed_frame(h, pict, got_frame, buf_index); |
1031 | } |
1032 | |
1033 | if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) { |
1034 | if (avctx->skip_frame >= AVDISCARD_NONREF || |
1035 | buf_size >= 4 && !memcmp("Q264", buf, 4)) |
1036 | return buf_size; |
1037 | av_log(avctx, AV_LOG_ERROR, "no frame!\n"); |
1038 | return AVERROR_INVALIDDATA; |
1039 | } |
1040 | |
1041 | if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) || |
1042 | (h->mb_y >= h->mb_height && h->mb_height)) { |
1043 | if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0) |
1044 | return ret; |
1045 | |
1046 | /* Wait for second field. */ |
1047 | if (h->next_output_pic) { |
1048 | ret = finalize_frame(h, pict, h->next_output_pic, got_frame); |
1049 | if (ret < 0) |
1050 | return ret; |
1051 | } |
1052 | } |
1053 | |
1054 | av_assert0(pict->buf[0] || !*got_frame); |
1055 | |
1056 | ff_h264_unref_picture(h, &h->last_pic_for_ec); |
1057 | |
1058 | return get_consumed_bytes(buf_index, buf_size); |
1059 | } |
1060 | |
1061 | #define OFFSET(x) offsetof(H264Context, x) |
1062 | #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM |
1063 | static const AVOption h264_options[] = { |
1064 | { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 }, |
1065 | { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 }, |
1066 | { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD }, |
1067 | { NULL }, |
1068 | }; |
1069 | |
1070 | static const AVClass h264_class = { |
1071 | .class_name = "H264 Decoder", |
1072 | .item_name = av_default_item_name, |
1073 | .option = h264_options, |
1074 | .version = LIBAVUTIL_VERSION_INT, |
1075 | }; |
1076 | |
1077 | AVCodec ff_h264_decoder = { |
1078 | .name = "h264", |
1079 | .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), |
1080 | .type = AVMEDIA_TYPE_VIDEO, |
1081 | .id = AV_CODEC_ID_H264, |
1082 | .priv_data_size = sizeof(H264Context), |
1083 | .init = ff_h264_decode_init, |
1084 | .close = h264_decode_end, |
1085 | .decode = h264_decode_frame, |
1086 | .capabilities = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 | |
1087 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | |
1088 | AV_CODEC_CAP_FRAME_THREADS, |
1089 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, |
1090 | .flush = flush_dpb, |
1091 | .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy), |
1092 | .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context), |
1093 | .profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles), |
1094 | .priv_class = &h264_class, |
1095 | }; |
1096 | |
1097 | #if CONFIG_H264_VDPAU_DECODER && FF_API_VDPAU |
1098 | static const AVClass h264_vdpau_class = { |
1099 | .class_name = "H264 VDPAU Decoder", |
1100 | .item_name = av_default_item_name, |
1101 | .option = h264_options, |
1102 | .version = LIBAVUTIL_VERSION_INT, |
1103 | }; |
1104 | |
1105 | AVCodec ff_h264_vdpau_decoder = { |
1106 | .name = "h264_vdpau", |
1107 | .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"), |
1108 | .type = AVMEDIA_TYPE_VIDEO, |
1109 | .id = AV_CODEC_ID_H264, |
1110 | .priv_data_size = sizeof(H264Context), |
1111 | .init = ff_h264_decode_init, |
1112 | .close = h264_decode_end, |
1113 | .decode = h264_decode_frame, |
1114 | .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU, |
1115 | .flush = flush_dpb, |
1116 | .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_H264, |
1117 | AV_PIX_FMT_NONE}, |
1118 | .profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles), |
1119 | .priv_class = &h264_vdpau_class, |
1120 | }; |
1121 | #endif |
1122 |