1 /*
2 * AV1 helper functions for muxers
3 * Copyright (c) 2018 James Almer <jamrial@gmail.com>
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 #include "libavutil/avassert.h"
23 #include "libavutil/mem.h"
24 #include "libavcodec/av1.h"
25 #include "libavcodec/av1_parse.h"
26 #include "libavcodec/avcodec.h"
27 #include "libavcodec/put_bits.h"
28 #include "av1.h"
29 #include "avio.h"
30 #include "avio_internal.h"
31
av1_filter_obus(AVIOContext * pb,const uint8_t * buf,int size,int * offset)32 static int av1_filter_obus(AVIOContext *pb, const uint8_t *buf,
33 int size, int *offset)
34 {
35 const uint8_t *start = buf, *end = buf + size;
36 int off;
37 enum {
38 START_NOT_FOUND,
39 START_FOUND,
40 END_FOUND,
41 OFFSET_IMPOSSIBLE,
42 } state = START_NOT_FOUND;
43
44 off = size = 0;
45 while (buf < end) {
46 int64_t obu_size;
47 int start_pos, type, temporal_id, spatial_id;
48 int len = parse_obu_header(buf, end - buf, &obu_size, &start_pos,
49 &type, &temporal_id, &spatial_id);
50 if (len < 0)
51 return len;
52
53 switch (type) {
54 case AV1_OBU_TEMPORAL_DELIMITER:
55 case AV1_OBU_REDUNDANT_FRAME_HEADER:
56 case AV1_OBU_TILE_LIST:
57 case AV1_OBU_PADDING:
58 if (state == START_FOUND)
59 state = END_FOUND;
60 break;
61 default:
62 if (state == START_NOT_FOUND) {
63 off = buf - start;
64 state = START_FOUND;
65 } else if (state == END_FOUND) {
66 state = OFFSET_IMPOSSIBLE;
67 }
68 if (pb)
69 avio_write(pb, buf, len);
70 size += len;
71 break;
72 }
73 buf += len;
74 }
75
76 if (offset)
77 *offset = state != OFFSET_IMPOSSIBLE ? off : -1;
78
79 return size;
80 }
81
ff_av1_filter_obus(AVIOContext * pb,const uint8_t * buf,int size)82 int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
83 {
84 return av1_filter_obus(pb, buf, size, NULL);
85 }
86
ff_av1_filter_obus_buf(const uint8_t * in,uint8_t ** out,int * size,int * offset)87 int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out,
88 int *size, int *offset)
89 {
90 FFIOContext pb;
91 uint8_t *buf;
92 int len, off, ret;
93
94 len = ret = av1_filter_obus(NULL, in, *size, &off);
95 if (ret < 0) {
96 return ret;
97 }
98 if (off >= 0) {
99 *out = (uint8_t *)in;
100 *size = len;
101 *offset = off;
102
103 return 0;
104 }
105
106 buf = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE);
107 if (!buf)
108 return AVERROR(ENOMEM);
109
110 ffio_init_context(&pb, buf, len, 1, NULL, NULL, NULL, NULL);
111
112 ret = av1_filter_obus(&pb.pub, in, *size, NULL);
113 av_assert1(ret == len);
114
115 memset(buf + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
116
117 *out = buf;
118 *size = len;
119 *offset = 0;
120
121 return 0;
122 }
123
uvlc(GetBitContext * gb)124 static inline void uvlc(GetBitContext *gb)
125 {
126 int leading_zeros = 0;
127
128 while (get_bits_left(gb)) {
129 if (get_bits1(gb))
130 break;
131 leading_zeros++;
132 }
133
134 if (leading_zeros >= 32)
135 return;
136
137 skip_bits_long(gb, leading_zeros);
138 }
139
parse_color_config(AV1SequenceParameters * seq_params,GetBitContext * gb)140 static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *gb)
141 {
142 int twelve_bit = 0;
143 int high_bitdepth = get_bits1(gb);
144 if (seq_params->profile == FF_PROFILE_AV1_PROFESSIONAL && high_bitdepth)
145 twelve_bit = get_bits1(gb);
146
147 seq_params->bitdepth = 8 + (high_bitdepth * 2) + (twelve_bit * 2);
148
149 if (seq_params->profile == FF_PROFILE_AV1_HIGH)
150 seq_params->monochrome = 0;
151 else
152 seq_params->monochrome = get_bits1(gb);
153
154 seq_params->color_description_present_flag = get_bits1(gb);
155 if (seq_params->color_description_present_flag) {
156 seq_params->color_primaries = get_bits(gb, 8);
157 seq_params->transfer_characteristics = get_bits(gb, 8);
158 seq_params->matrix_coefficients = get_bits(gb, 8);
159 } else {
160 seq_params->color_primaries = AVCOL_PRI_UNSPECIFIED;
161 seq_params->transfer_characteristics = AVCOL_TRC_UNSPECIFIED;
162 seq_params->matrix_coefficients = AVCOL_SPC_UNSPECIFIED;
163 }
164
165 if (seq_params->monochrome) {
166 seq_params->color_range = get_bits1(gb);
167 seq_params->chroma_subsampling_x = 1;
168 seq_params->chroma_subsampling_y = 1;
169 seq_params->chroma_sample_position = 0;
170 return 0;
171 } else if (seq_params->color_primaries == AVCOL_PRI_BT709 &&
172 seq_params->transfer_characteristics == AVCOL_TRC_IEC61966_2_1 &&
173 seq_params->matrix_coefficients == AVCOL_SPC_RGB) {
174 seq_params->chroma_subsampling_x = 0;
175 seq_params->chroma_subsampling_y = 0;
176 } else {
177 seq_params->color_range = get_bits1(gb);
178
179 if (seq_params->profile == FF_PROFILE_AV1_MAIN) {
180 seq_params->chroma_subsampling_x = 1;
181 seq_params->chroma_subsampling_y = 1;
182 } else if (seq_params->profile == FF_PROFILE_AV1_HIGH) {
183 seq_params->chroma_subsampling_x = 0;
184 seq_params->chroma_subsampling_y = 0;
185 } else {
186 if (twelve_bit) {
187 seq_params->chroma_subsampling_x = get_bits1(gb);
188 if (seq_params->chroma_subsampling_x)
189 seq_params->chroma_subsampling_y = get_bits1(gb);
190 else
191 seq_params->chroma_subsampling_y = 0;
192 } else {
193 seq_params->chroma_subsampling_x = 1;
194 seq_params->chroma_subsampling_y = 0;
195 }
196 }
197 if (seq_params->chroma_subsampling_x && seq_params->chroma_subsampling_y)
198 seq_params->chroma_sample_position = get_bits(gb, 2);
199 }
200
201 skip_bits1(gb); // separate_uv_delta_q
202
203 return 0;
204 }
205
parse_sequence_header(AV1SequenceParameters * seq_params,const uint8_t * buf,int size)206 static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
207 {
208 GetBitContext gb;
209 int reduced_still_picture_header;
210 int frame_width_bits_minus_1, frame_height_bits_minus_1;
211 int size_bits, ret;
212
213 size_bits = get_obu_bit_length(buf, size, AV1_OBU_SEQUENCE_HEADER);
214 if (size_bits < 0)
215 return size_bits;
216
217 ret = init_get_bits(&gb, buf, size_bits);
218 if (ret < 0)
219 return ret;
220
221 memset(seq_params, 0, sizeof(*seq_params));
222
223 seq_params->profile = get_bits(&gb, 3);
224
225 skip_bits1(&gb); // still_picture
226 reduced_still_picture_header = get_bits1(&gb);
227
228 if (reduced_still_picture_header) {
229 seq_params->level = get_bits(&gb, 5);
230 seq_params->tier = 0;
231 } else {
232 int initial_display_delay_present_flag, operating_points_cnt_minus_1;
233 int decoder_model_info_present_flag, buffer_delay_length_minus_1;
234
235 if (get_bits1(&gb)) { // timing_info_present_flag
236 skip_bits_long(&gb, 32); // num_units_in_display_tick
237 skip_bits_long(&gb, 32); // time_scale
238
239 if (get_bits1(&gb)) // equal_picture_interval
240 uvlc(&gb); // num_ticks_per_picture_minus_1
241
242 decoder_model_info_present_flag = get_bits1(&gb);
243 if (decoder_model_info_present_flag) {
244 buffer_delay_length_minus_1 = get_bits(&gb, 5);
245 skip_bits_long(&gb, 32); // num_units_in_decoding_tick
246 skip_bits(&gb, 10); // buffer_removal_time_length_minus_1 (5)
247 // frame_presentation_time_length_minus_1 (5)
248 }
249 } else
250 decoder_model_info_present_flag = 0;
251
252 initial_display_delay_present_flag = get_bits1(&gb);
253
254 operating_points_cnt_minus_1 = get_bits(&gb, 5);
255 for (int i = 0; i <= operating_points_cnt_minus_1; i++) {
256 int seq_level_idx, seq_tier;
257
258 skip_bits(&gb, 12); // operating_point_idc
259 seq_level_idx = get_bits(&gb, 5);
260
261 if (seq_level_idx > 7)
262 seq_tier = get_bits1(&gb);
263 else
264 seq_tier = 0;
265
266 if (decoder_model_info_present_flag) {
267 if (get_bits1(&gb)) { // decoder_model_present_for_this_op
268 skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // decoder_buffer_delay
269 skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // encoder_buffer_delay
270 skip_bits1(&gb); // low_delay_mode_flag
271 }
272 }
273
274 if (initial_display_delay_present_flag) {
275 if (get_bits1(&gb)) // initial_display_delay_present_for_this_op
276 skip_bits(&gb, 4); // initial_display_delay_minus_1
277 }
278
279 if (i == 0) {
280 seq_params->level = seq_level_idx;
281 seq_params->tier = seq_tier;
282 }
283 }
284 }
285
286 frame_width_bits_minus_1 = get_bits(&gb, 4);
287 frame_height_bits_minus_1 = get_bits(&gb, 4);
288
289 skip_bits(&gb, frame_width_bits_minus_1 + 1); // max_frame_width_minus_1
290 skip_bits(&gb, frame_height_bits_minus_1 + 1); // max_frame_height_minus_1
291
292 if (!reduced_still_picture_header) {
293 if (get_bits1(&gb)) // frame_id_numbers_present_flag
294 skip_bits(&gb, 7); // delta_frame_id_length_minus_2 (4), additional_frame_id_length_minus_1 (3)
295 }
296
297 skip_bits(&gb, 3); // use_128x128_superblock (1), enable_filter_intra (1), enable_intra_edge_filter (1)
298
299 if (!reduced_still_picture_header) {
300 int enable_order_hint, seq_force_screen_content_tools;
301
302 skip_bits(&gb, 4); // enable_interintra_compound (1), enable_masked_compound (1)
303 // enable_warped_motion (1), enable_dual_filter (1)
304
305 enable_order_hint = get_bits1(&gb);
306 if (enable_order_hint)
307 skip_bits(&gb, 2); // enable_jnt_comp (1), enable_ref_frame_mvs (1)
308
309 if (get_bits1(&gb)) // seq_choose_screen_content_tools
310 seq_force_screen_content_tools = 2;
311 else
312 seq_force_screen_content_tools = get_bits1(&gb);
313
314 if (seq_force_screen_content_tools) {
315 if (!get_bits1(&gb)) // seq_choose_integer_mv
316 skip_bits1(&gb); // seq_force_integer_mv
317 }
318
319 if (enable_order_hint)
320 skip_bits(&gb, 3); // order_hint_bits_minus_1
321 }
322
323 skip_bits(&gb, 3); // enable_superres (1), enable_cdef (1), enable_restoration (1)
324
325 parse_color_config(seq_params, &gb);
326
327 skip_bits1(&gb); // film_grain_params_present
328
329 if (get_bits_left(&gb))
330 return AVERROR_INVALIDDATA;
331
332 return 0;
333 }
334
ff_av1_parse_seq_header(AV1SequenceParameters * seq,const uint8_t * buf,int size)335 int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
336 {
337 int is_av1c;
338
339 if (size <= 0)
340 return AVERROR_INVALIDDATA;
341
342 is_av1c = !!(buf[0] & 0x80);
343 if (is_av1c) {
344 GetBitContext gb;
345 int ret, version = buf[0] & 0x7F;
346
347 if (version != 1 || size < 4)
348 return AVERROR_INVALIDDATA;
349
350 ret = init_get_bits8(&gb, buf, 4);
351 if (ret < 0)
352 return ret;
353
354 memset(seq, 0, sizeof(*seq));
355
356 skip_bits(&gb, 8);
357 seq->profile = get_bits(&gb, 3);
358 seq->level = get_bits(&gb, 5);
359 seq->tier = get_bits(&gb, 1);
360 seq->bitdepth = get_bits(&gb, 1) * 2 + 8;
361 seq->bitdepth += get_bits(&gb, 1) * 2;
362 seq->monochrome = get_bits(&gb, 1);
363 seq->chroma_subsampling_x = get_bits(&gb, 1);
364 seq->chroma_subsampling_y = get_bits(&gb, 1);
365 seq->chroma_sample_position = get_bits(&gb, 2);
366 seq->color_primaries = AVCOL_PRI_UNSPECIFIED;
367 seq->transfer_characteristics = AVCOL_TRC_UNSPECIFIED;
368 seq->matrix_coefficients = AVCOL_SPC_UNSPECIFIED;
369
370 size -= 4;
371 buf += 4;
372 }
373
374 while (size > 0) {
375 int64_t obu_size;
376 int start_pos, type, temporal_id, spatial_id;
377 int len = parse_obu_header(buf, size, &obu_size, &start_pos,
378 &type, &temporal_id, &spatial_id);
379 if (len < 0)
380 return len;
381
382 switch (type) {
383 case AV1_OBU_SEQUENCE_HEADER:
384 if (!obu_size)
385 return AVERROR_INVALIDDATA;
386
387 return parse_sequence_header(seq, buf + start_pos, obu_size);
388 default:
389 break;
390 }
391 size -= len;
392 buf += len;
393 }
394
395 return is_av1c ? 0 : AVERROR_INVALIDDATA;
396 }
397
ff_isom_write_av1c(AVIOContext * pb,const uint8_t * buf,int size,int write_seq_header)398 int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size,
399 int write_seq_header)
400 {
401 AVIOContext *meta_pb;
402 AV1SequenceParameters seq_params;
403 PutBitContext pbc;
404 uint8_t header[4], *meta;
405 const uint8_t *seq;
406 int ret, nb_seq = 0, seq_size, meta_size;
407
408 if (size <= 0)
409 return AVERROR_INVALIDDATA;
410
411 if (buf[0] & 0x80) {
412 // first bit is nonzero, the passed data does not consist purely of
413 // OBUs. Expect that the data is already in AV1CodecConfigurationRecord
414 // format.
415 int config_record_version = buf[0] & 0x7f;
416 if (config_record_version != 1 || size < 4) {
417 return AVERROR_INVALIDDATA;
418 }
419
420 avio_write(pb, buf, size);
421
422 return 0;
423 }
424
425 ret = avio_open_dyn_buf(&meta_pb);
426 if (ret < 0)
427 return ret;
428
429 while (size > 0) {
430 int64_t obu_size;
431 int start_pos, type, temporal_id, spatial_id;
432 int len = parse_obu_header(buf, size, &obu_size, &start_pos,
433 &type, &temporal_id, &spatial_id);
434 if (len < 0) {
435 ret = len;
436 goto fail;
437 }
438
439 switch (type) {
440 case AV1_OBU_SEQUENCE_HEADER:
441 nb_seq++;
442 if (!obu_size || nb_seq > 1) {
443 ret = AVERROR_INVALIDDATA;
444 goto fail;
445 }
446 ret = parse_sequence_header(&seq_params, buf + start_pos, obu_size);
447 if (ret < 0)
448 goto fail;
449
450 seq = buf;
451 seq_size = len;
452 break;
453 case AV1_OBU_METADATA:
454 if (!obu_size) {
455 ret = AVERROR_INVALIDDATA;
456 goto fail;
457 }
458 avio_write(meta_pb, buf, len);
459 break;
460 default:
461 break;
462 }
463 size -= len;
464 buf += len;
465 }
466
467 if (!nb_seq) {
468 ret = AVERROR_INVALIDDATA;
469 goto fail;
470 }
471
472 init_put_bits(&pbc, header, sizeof(header));
473
474 put_bits(&pbc, 1, 1); // marker
475 put_bits(&pbc, 7, 1); // version
476 put_bits(&pbc, 3, seq_params.profile);
477 put_bits(&pbc, 5, seq_params.level);
478 put_bits(&pbc, 1, seq_params.tier);
479 put_bits(&pbc, 1, seq_params.bitdepth > 8);
480 put_bits(&pbc, 1, seq_params.bitdepth == 12);
481 put_bits(&pbc, 1, seq_params.monochrome);
482 put_bits(&pbc, 1, seq_params.chroma_subsampling_x);
483 put_bits(&pbc, 1, seq_params.chroma_subsampling_y);
484 put_bits(&pbc, 2, seq_params.chroma_sample_position);
485 put_bits(&pbc, 8, 0); // padding
486 flush_put_bits(&pbc);
487
488 avio_write(pb, header, sizeof(header));
489 if (write_seq_header) {
490 avio_write(pb, seq, seq_size);
491 }
492
493 meta_size = avio_get_dyn_buf(meta_pb, &meta);
494 if (meta_size)
495 avio_write(pb, meta, meta_size);
496
497 fail:
498 ffio_free_dyn_buf(&meta_pb);
499
500 return ret;
501 }
502