FFmpeg: libavformat/av1.c Source File

FFmpeg

[フレーム]

libavformat

av1.c

Go to the documentation of this file.

1 /*

2 * AV1 helper functions for muxers

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 */

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"

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;

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;

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 }

75 if (offset)

76 *offset = state != OFFSET_IMPOSSIBLE ? off : -1;

78 return size;

79 }

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 }

86 int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out,

87 int *size, int *offset)

88 {

89 FFIOContext pb;

90 uint8_t *buf;

91 int len, off, ret;

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.pub, 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

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

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

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

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

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 if (buf[0] & 0x80) {

379 // first bit is nonzero, the passed data does not consist purely of

380 // OBUs. Expect that the data is already in AV1CodecConfigurationRecord

381 // format.

382 int config_record_version = buf[0] & 0x7f;

383 if (config_record_version != 1 || size < 4) {

384 return AVERROR_INVALIDDATA;

385 }

386

387 avio_write(pb, buf, size);

388

389 return 0;

390 }

391

392 ret = avio_open_dyn_buf(&meta_pb);

393 if (ret < 0)

394 return ret;

395

396 while (size > 0) {

397 int len = parse_obu_header(buf, size, &obu_size, &start_pos,

398 &type, &temporal_id, &spatial_id);

399 if (len < 0) {

400 ret = len;

401 goto fail;

402 }

403

404 switch (type) {

405 case AV1_OBU_SEQUENCE_HEADER:

406 nb_seq++;

407 if (!obu_size || nb_seq > 1) {

408 ret = AVERROR_INVALIDDATA;

409 goto fail;

410 }

411 ret = parse_sequence_header(&seq_params, buf + start_pos, obu_size);

412 if (ret < 0)

413 goto fail;

414

415 seq = buf;

416 seq_size = len;

417 break;

418 case AV1_OBU_METADATA:

419 if (!obu_size) {

420 ret = AVERROR_INVALIDDATA;

421 goto fail;

422 }

423 avio_write(meta_pb, buf, len);

424 break;

425 default:

426 break;

427 }

428 size -= len;

429 buf += len;

430 }

431

432 if (!nb_seq) {

433 ret = AVERROR_INVALIDDATA;

434 goto fail;

435 }

436

437 init_put_bits(&pbc, header, sizeof(header));

438

439 put_bits(&pbc, 1, 1); // marker

440 put_bits(&pbc, 7, 1); // version

441 put_bits(&pbc, 3, seq_params.profile);

442 put_bits(&pbc, 5, seq_params.level);

443 put_bits(&pbc, 1, seq_params.tier);

444 put_bits(&pbc, 1, seq_params.bitdepth > 8);

445 put_bits(&pbc, 1, seq_params.bitdepth == 12);

446 put_bits(&pbc, 1, seq_params.monochrome);

447 put_bits(&pbc, 1, seq_params.chroma_subsampling_x);

448 put_bits(&pbc, 1, seq_params.chroma_subsampling_y);

449 put_bits(&pbc, 2, seq_params.chroma_sample_position);

450 put_bits(&pbc, 8, 0); // padding

451 flush_put_bits(&pbc);

452

453 avio_write(pb, header, sizeof(header));

454 avio_write(pb, seq, seq_size);

455

456 meta_size = avio_get_dyn_buf(meta_pb, &meta);

457 if (meta_size)

458 avio_write(pb, meta, meta_size);

459

460 fail:

461 ffio_free_dyn_buf(&meta_pb);

462

463 return ret;

464 }

parse_sequence_header

static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)

Definition: av1.c:205

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:292

AV1_OBU_REDUNDANT_FRAME_HEADER

@ AV1_OBU_REDUNDANT_FRAME_HEADER

Definition: av1.h:36

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:850

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

out

FILE * out

Definition: movenc.c:54

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:61

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:220

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:497

AVCOL_SPC_RGB

@ AVCOL_SPC_RGB

order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1

Definition: pixfmt.h:524

ff_isom_write_av1c

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:364

AV1_OBU_TEMPORAL_DELIMITER

@ AV1_OBU_TEMPORAL_DELIMITER

Definition: av1.h:31

avio_get_dyn_buf

int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)

Return the written size and a pointer to the buffer.

Definition: aviobuf.c:1483

FFIOContext

Definition: avio_internal.h:29

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:660

AV1SequenceParameters::chroma_subsampling_y

uint8_t chroma_subsampling_y

Definition: av1.h:35

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:468

av1_filter_obus

static int av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size, int *offset)

Definition: av1.c:32

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:380

av1_parse.h

AVCOL_TRC_IEC61966_2_1

@ AVCOL_TRC_IEC61966_2_1

IEC 61966-2-1 (sRGB or sYCC)

Definition: pixfmt.h:508

fail

#define fail()

Definition: checkasm.h:127

GetBitContext

Definition: get_bits.h:62

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

AV1SequenceParameters::color_description_present_flag

uint8_t color_description_present_flag

Definition: av1.h:37

avassert.h

avio_open_dyn_buf

int avio_open_dyn_buf(AVIOContext **s)

Open a write only memory stream.

Definition: aviobuf.c:1471

parse_obu_header

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:107

ff_av1_filter_obus_buf

int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out, int *size, int *offset)

Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and return the result in a data bu...

Definition: av1.c:86

AV1SequenceParameters::color_range

uint8_t color_range

Definition: av1.h:41

AVCOL_PRI_UNSPECIFIED

@ AVCOL_PRI_UNSPECIFIED

Definition: pixfmt.h:472

PutBitContext

Definition: put_bits.h:49

AV1SequenceParameters::chroma_sample_position

uint8_t chroma_sample_position

Definition: av1.h:36

uvlc

static void uvlc(GetBitContext *gb)

Definition: av1.c:123

NULL

#define NULL

Definition: coverity.c:32

AVCOL_PRI_BT709

@ AVCOL_PRI_BT709

also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B

Definition: pixfmt.h:471

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

AV1SequenceParameters::transfer_characteristics

uint8_t transfer_characteristics

Definition: av1.h:39

profiles.h

AV1SequenceParameters::tier

uint8_t tier

Definition: av1.h:31

AV1SequenceParameters::monochrome

uint8_t monochrome

Definition: av1.h:33

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

FF_PROFILE_AV1_MAIN

#define FF_PROFILE_AV1_MAIN

Definition: avcodec.h:1621

state

static struct @320 state

AV1SequenceParameters::matrix_coefficients

uint8_t matrix_coefficients

Definition: av1.h:40

get_obu_bit_length

static int get_obu_bit_length(const uint8_t *buf, int size, int type)

Definition: av1_parse.h:151

FFIOContext::pub

AVIOContext pub

Definition: avio_internal.h:30

size

int size

Definition: twinvq_data.h:10344

avio.h

AV1_OBU_SEQUENCE_HEADER

@ AV1_OBU_SEQUENCE_HEADER

Definition: av1.h:30

av1.h

header

static const uint8_t header[24]

Definition: sdr2.c:67

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:232

parse_color_config

static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *gb)

Definition: av1.c:139

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:539

AV1SequenceParameters::profile

uint8_t profile

Definition: av1.h:29

AV1SequenceParameters::color_primaries

uint8_t color_primaries

Definition: av1.h:38

AV1_OBU_PADDING

@ AV1_OBU_PADDING

Definition: av1.h:39

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271

avio_internal.h

ffio_init_context

void ffio_init_context(FFIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))

Definition: aviobuf.c:81

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:53

AV1SequenceParameters::level

uint8_t level

Definition: av1.h:30

len

int len

Definition: vorbis_enc_data.h:426

AVCOL_SPC_UNSPECIFIED