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