FFmpeg  4.1.11
av1.c
Go to the documentation of this file.
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 #include "avio_internal.h"
30 
32 {
33  const uint8_t *end = buf + size;
34  int64_t obu_size;
35  int start_pos, type, temporal_id, spatial_id;
36 
37  size = 0;
38  while (buf < end) {
39  int len = parse_obu_header(buf, end - buf, &obu_size, &start_pos,
40  &type, &temporal_id, &spatial_id);
41  if (len < 0)
42  return len;
43 
44  switch (type) {
47  case AV1_OBU_TILE_LIST:
48  case AV1_OBU_PADDING:
49  break;
50  default:
51  avio_write(pb, buf, len);
52  size += len;
53  break;
54  }
55  buf += len;
56  }
57 
58  return size;
59 }
60 
62 {
63  AVIOContext *pb;
64  int ret;
65 
66  ret = avio_open_dyn_buf(&pb);
67  if (ret < 0)
68  return ret;
69 
70  ret = ff_av1_filter_obus(pb, buf, *size);
71  if (ret < 0) {
72  ffio_free_dyn_buf(&pb);
73  return ret;
74  }
75 
76  av_freep(out);
77  *size = avio_close_dyn_buf(pb, out);
78 
79  return ret;
80 }
81 
82 typedef struct AV1SequenceParameters {
93 
94 static inline void uvlc(GetBitContext *gb)
95 {
96  int leading_zeros = 0;
97 
98  while (get_bits_left(gb)) {
99  if (get_bits1(gb))
100  break;
101  leading_zeros++;
102  }
103 
104  if (leading_zeros >= 32)
105  return;
106 
107  skip_bits_long(gb, leading_zeros);
108 }
109 
111 {
112  int color_primaries, transfer_characteristics, matrix_coefficients;
113 
114  seq_params->high_bitdepth = get_bits1(gb);
115  if (seq_params->seq_profile == FF_PROFILE_AV1_PROFESSIONAL && seq_params->high_bitdepth)
116  seq_params->twelve_bit = get_bits1(gb);
117 
118  if (seq_params->seq_profile == FF_PROFILE_AV1_HIGH)
119  seq_params->monochrome = 0;
120  else
121  seq_params->monochrome = get_bits1(gb);
122 
123  if (get_bits1(gb)) { // color_description_present_flag
124  color_primaries = get_bits(gb, 8);
125  transfer_characteristics = get_bits(gb, 8);
126  matrix_coefficients = get_bits(gb, 8);
127  } else {
128  color_primaries = AVCOL_PRI_UNSPECIFIED;
129  transfer_characteristics = AVCOL_TRC_UNSPECIFIED;
130  matrix_coefficients = AVCOL_SPC_UNSPECIFIED;
131  }
132 
133  if (seq_params->monochrome) {
134  skip_bits1(gb); // color_range
135  seq_params->chroma_subsampling_x = 1;
136  seq_params->chroma_subsampling_y = 1;
137  seq_params->chroma_sample_position = 0;
138  return 0;
139  } else if (color_primaries == AVCOL_PRI_BT709 &&
140  transfer_characteristics == AVCOL_TRC_IEC61966_2_1 &&
141  matrix_coefficients == AVCOL_SPC_RGB) {
142  seq_params->chroma_subsampling_x = 0;
143  seq_params->chroma_subsampling_y = 0;
144  } else {
145  skip_bits1(gb); // color_range
146 
147  if (seq_params->seq_profile == FF_PROFILE_AV1_MAIN) {
148  seq_params->chroma_subsampling_x = 1;
149  seq_params->chroma_subsampling_y = 1;
150  } else if (seq_params->seq_profile == FF_PROFILE_AV1_HIGH) {
151  seq_params->chroma_subsampling_x = 0;
152  seq_params->chroma_subsampling_y = 0;
153  } else {
154  if (seq_params->twelve_bit) {
155  seq_params->chroma_subsampling_x = get_bits1(gb);
156  if (seq_params->chroma_subsampling_x)
157  seq_params->chroma_subsampling_y = get_bits1(gb);
158  else
159  seq_params->chroma_subsampling_y = 0;
160  } else {
161  seq_params->chroma_subsampling_x = 1;
162  seq_params->chroma_subsampling_y = 0;
163  }
164  }
165  if (seq_params->chroma_subsampling_x && seq_params->chroma_subsampling_y)
166  seq_params->chroma_sample_position = get_bits(gb, 2);
167  }
168 
169  skip_bits1(gb); // separate_uv_delta_q
170 
171  return 0;
172 }
173 
174 static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
175 {
176  GetBitContext gb;
177  int reduced_still_picture_header;
178  int frame_width_bits_minus_1, frame_height_bits_minus_1;
179  int size_bits, ret;
180 
181  size_bits = get_obu_bit_length(buf, size, AV1_OBU_SEQUENCE_HEADER);
182  if (size_bits < 0)
183  return size_bits;
184 
185  ret = init_get_bits(&gb, buf, size_bits);
186  if (ret < 0)
187  return ret;
188 
189  memset(seq_params, 0, sizeof(*seq_params));
190 
191  seq_params->seq_profile = get_bits(&gb, 3);
192 
193  skip_bits1(&gb); // still_picture
194  reduced_still_picture_header = get_bits1(&gb);
195 
196  if (reduced_still_picture_header) {
197  seq_params->seq_level_idx_0 = get_bits(&gb, 5);
198  seq_params->seq_tier_0 = 0;
199  } else {
200  int initial_display_delay_present_flag, operating_points_cnt_minus_1;
201  int decoder_model_info_present_flag, buffer_delay_length_minus_1;
202 
203  if (get_bits1(&gb)) { // timing_info_present_flag
204  skip_bits_long(&gb, 32); // num_units_in_display_tick
205  skip_bits_long(&gb, 32); // time_scale
206 
207  if (get_bits1(&gb)) // equal_picture_interval
208  uvlc(&gb); // num_ticks_per_picture_minus_1
209 
210  decoder_model_info_present_flag = get_bits1(&gb);
211  if (decoder_model_info_present_flag) {
212  buffer_delay_length_minus_1 = get_bits(&gb, 5);
213  skip_bits_long(&gb, 32); // num_units_in_decoding_tick
214  skip_bits(&gb, 10); // buffer_removal_time_length_minus_1 (5)
215  // frame_presentation_time_length_minus_1 (5)
216  }
217  } else
218  decoder_model_info_present_flag = 0;
219 
220  initial_display_delay_present_flag = get_bits1(&gb);
221 
222  operating_points_cnt_minus_1 = get_bits(&gb, 5);
223  for (int i = 0; i <= operating_points_cnt_minus_1; i++) {
224  int seq_level_idx, seq_tier;
225 
226  skip_bits(&gb, 12); // operating_point_idc
227  seq_level_idx = get_bits(&gb, 5);
228 
229  if (seq_level_idx > 7)
230  seq_tier = get_bits1(&gb);
231  else
232  seq_tier = 0;
233 
234  if (decoder_model_info_present_flag) {
235  if (get_bits1(&gb)) { // decoder_model_present_for_this_op
236  skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // decoder_buffer_delay
237  skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // encoder_buffer_delay
238  skip_bits1(&gb); // low_delay_mode_flag
239  }
240  }
241 
242  if (initial_display_delay_present_flag) {
243  if (get_bits1(&gb)) // initial_display_delay_present_for_this_op
244  skip_bits(&gb, 4); // initial_display_delay_minus_1
245  }
246 
247  if (i == 0) {
248  seq_params->seq_level_idx_0 = seq_level_idx;
249  seq_params->seq_tier_0 = seq_tier;
250  }
251  }
252  }
253 
254  frame_width_bits_minus_1 = get_bits(&gb, 4);
255  frame_height_bits_minus_1 = get_bits(&gb, 4);
256 
257  skip_bits(&gb, frame_width_bits_minus_1 + 1); // max_frame_width_minus_1
258  skip_bits(&gb, frame_height_bits_minus_1 + 1); // max_frame_height_minus_1
259 
260  if (!reduced_still_picture_header) {
261  if (get_bits1(&gb)) // frame_id_numbers_present_flag
262  skip_bits(&gb, 7); // delta_frame_id_length_minus_2 (4), additional_frame_id_length_minus_1 (3)
263  }
264 
265  skip_bits(&gb, 3); // use_128x128_superblock (1), enable_filter_intra (1), enable_intra_edge_filter (1)
266 
267  if (!reduced_still_picture_header) {
268  int enable_order_hint, seq_force_screen_content_tools;
269 
270  skip_bits(&gb, 4); // enable_intraintra_compound (1), enable_masked_compound (1)
271  // enable_warped_motion (1), enable_dual_filter (1)
272 
273  enable_order_hint = get_bits1(&gb);
274  if (enable_order_hint)
275  skip_bits(&gb, 2); // enable_jnt_comp (1), enable_ref_frame_mvs (1)
276 
277  if (get_bits1(&gb)) // seq_choose_screen_content_tools
278  seq_force_screen_content_tools = 2;
279  else
280  seq_force_screen_content_tools = get_bits1(&gb);
281 
282  if (seq_force_screen_content_tools) {
283  if (!get_bits1(&gb)) // seq_choose_integer_mv
284  skip_bits1(&gb); // seq_force_integer_mv
285  }
286 
287  if (enable_order_hint)
288  skip_bits(&gb, 3); // order_hint_bits_minus_1
289  }
290 
291  skip_bits(&gb, 3); // enable_superres (1), enable_cdef (1), enable_restoration (1)
292 
293  parse_color_config(seq_params, &gb);
294 
295  skip_bits1(&gb); // film_grain_params_present
296 
297  if (get_bits_left(&gb))
298  return AVERROR_INVALIDDATA;
299 
300  return 0;
301 }
302 
304 {
305  AVIOContext *seq_pb = NULL, *meta_pb = NULL;
306  AV1SequenceParameters seq_params;
307  PutBitContext pbc;
308  uint8_t header[4];
309  uint8_t *seq = NULL, *meta = NULL;
310  int64_t obu_size;
311  int start_pos, type, temporal_id, spatial_id;
312  int ret, nb_seq = 0, seq_size, meta_size;
313 
314  if (size <= 0)
315  return AVERROR_INVALIDDATA;
316 
317  ret = avio_open_dyn_buf(&seq_pb);
318  if (ret < 0)
319  return ret;
320  ret = avio_open_dyn_buf(&meta_pb);
321  if (ret < 0)
322  goto fail;
323 
324  while (size > 0) {
325  int len = parse_obu_header(buf, size, &obu_size, &start_pos,
326  &type, &temporal_id, &spatial_id);
327  if (len < 0) {
328  ret = len;
329  goto fail;
330  }
331 
332  switch (type) {
334  nb_seq++;
335  if (!obu_size || nb_seq > 1) {
336  ret = AVERROR_INVALIDDATA;
337  goto fail;
338  }
339  ret = parse_sequence_header(&seq_params, buf + start_pos, obu_size);
340  if (ret < 0)
341  goto fail;
342 
343  avio_write(seq_pb, buf, len);
344  break;
345  case AV1_OBU_METADATA:
346  if (!obu_size) {
347  ret = AVERROR_INVALIDDATA;
348  goto fail;
349  }
350  avio_write(meta_pb, buf, len);
351  break;
352  default:
353  break;
354  }
355  size -= len;
356  buf += len;
357  }
358 
359  seq_size = avio_close_dyn_buf(seq_pb, &seq);
360  if (!seq_size) {
361  ret = AVERROR_INVALIDDATA;
362  goto fail;
363  }
364 
365  init_put_bits(&pbc, header, sizeof(header));
366 
367  put_bits(&pbc, 1, 1); // marker
368  put_bits(&pbc, 7, 1); // version
369  put_bits(&pbc, 3, seq_params.seq_profile);
370  put_bits(&pbc, 5, seq_params.seq_level_idx_0);
371  put_bits(&pbc, 1, seq_params.seq_tier_0);
372  put_bits(&pbc, 1, seq_params.high_bitdepth);
373  put_bits(&pbc, 1, seq_params.twelve_bit);
374  put_bits(&pbc, 1, seq_params.monochrome);
375  put_bits(&pbc, 1, seq_params.chroma_subsampling_x);
376  put_bits(&pbc, 1, seq_params.chroma_subsampling_y);
377  put_bits(&pbc, 2, seq_params.chroma_sample_position);
378  put_bits(&pbc, 8, 0); // padding
379  flush_put_bits(&pbc);
380 
381  avio_write(pb, header, sizeof(header));
382  avio_write(pb, seq, seq_size);
383 
384  meta_size = avio_close_dyn_buf(meta_pb, &meta);
385  if (meta_size)
386  avio_write(pb, meta, meta_size);
387 
388 fail:
389  if (!seq)
390  avio_close_dyn_buf(seq_pb, &seq);
391  if (!meta)
392  avio_close_dyn_buf(meta_pb, &meta);
393  av_free(seq);
394  av_free(meta);
395 
396  return ret;
397 }
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
Buffered I/O operations.
int size
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1419
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
Memory handling functions.
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:293
int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and write the resulting bitstream ...
Definition: av1.c:31
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1390
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:487
uint8_t chroma_sample_position
Definition: av1.c:91
uint8_t monochrome
Definition: av1.c:88
uint8_t chroma_subsampling_x
Definition: av1.c:89
uint8_t seq_tier_0
Definition: av1.c:85
uint8_t
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
Definition: av1.c:303
static const uint8_t header[24]
Definition: sdr2.c:67
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:814
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:435
static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
Definition: av1.c:174
#define fail()
Definition: checkasm.h:117
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
static int parse_obu_header(const uint8_t *buf, int buf_size, int64_t *obu_size, int *start_pos, int *type, int *temporal_id, int *spatial_id)
Definition: av1_parse.h:99
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1449
uint8_t twelve_bit
Definition: av1.c:87
static void uvlc(GetBitContext *gb)
Definition: av1.c:94
int ff_av1_filter_obus_buf(const uint8_t *buf, uint8_t **out, int *size)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and write the resulting bitstream ...
Definition: av1.c:61
void * buf
Definition: avisynth_c.h:690
AV1 common definitions.
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:523
uint8_t seq_level_idx_0
Definition: av1.c:84
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:460
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:2954
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:2952
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:615
cl_device_type type
static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *gb)
Definition: av1.c:110
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:471
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static int get_obu_bit_length(const uint8_t *buf, int size, int type)
Definition: av1_parse.h:143
uint8_t chroma_subsampling_y
Definition: av1.c:90
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
#define av_free(p)
int len
uint8_t seq_profile
Definition: av1.c:83
FILE * out
Definition: movenc.c:54
#define av_freep(p)
uint8_t high_bitdepth
Definition: av1.c:86
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:2953
bitstream writer API