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