FFmpeg: libavcodec/bsf/extract_extradata.c Source File

FFmpeg

[フレーム]

extract_extradata.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

4 * FFmpeg is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU Lesser General Public

6 * License as published by the Free Software Foundation; either

7 * version 2.1 of the License, or (at your option) any later version.

8 *

9 * FFmpeg is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12 * Lesser General Public License for more details.

13 *

14 * You should have received a copy of the GNU Lesser General Public

15 * License along with FFmpeg; if not, write to the Free Software

16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

17 */

19 #include <stdint.h>

21 #include "libavutil/log.h"

22 #include "libavutil/mem.h"

23 #include "libavutil/opt.h"

25 #include "av1.h"

26 #include "av1_parse.h"

27 #include "bsf.h"

28 #include "bsf_internal.h"

29 #include "bytestream.h"

30 #include "h2645_parse.h"

31 #include "h264.h"

32 #include "startcode.h"

33 #include "vc1_common.h"

34 #include "vvc.h"

36 #include "hevc/hevc.h"

38 typedef struct ExtractExtradataContext {

39 const AVClass *class;

41 int (*extract)(AVBSFContext *ctx, AVPacket *pkt,

42 uint8_t **data, int *size);

44 /* AV1 specific fields */

45 AV1Packet av1_pkt;

47 /* H264/HEVC specific fields */

48 H2645Packet h2645_pkt;

50 /* AVOptions */

51 int remove;

52 } ExtractExtradataContext;

54 static int val_in_array(const int *arr, size_t len, int val)

55 {

56 for (size_t i = 0; i < len; i++)

57 if (arr[i] == val)

58 return 1;

59 return 0;

60 }

62 static int metadata_is_global(const AV1OBU *obu)

63 {

64 static const int metadata_obu_types[] = {

65 AV1_METADATA_TYPE_HDR_CLL, AV1_METADATA_TYPE_HDR_MDCV,

66 };

67 GetBitContext gb;

68 int metadata_type;

70 if (init_get_bits(&gb, obu->data, obu->size_bits) < 0)

71 return 0;

73 metadata_type = get_leb(&gb);

75 return val_in_array(metadata_obu_types, FF_ARRAY_ELEMS(metadata_obu_types),

76 metadata_type);

77 }

79 static int obu_is_global(const AV1OBU *obu)

80 {

81 static const int extradata_obu_types[] = {

82 AV1_OBU_SEQUENCE_HEADER, AV1_OBU_METADATA,

83 };

85 if (!val_in_array(extradata_obu_types, FF_ARRAY_ELEMS(extradata_obu_types),

86 obu->type))

87 return 0;

88 if (obu->type != AV1_OBU_METADATA)

89 return 1;

91 return metadata_is_global(obu);

92 }

94 static int extract_extradata_av1(AVBSFContext *ctx, AVPacket *pkt,

95 uint8_t **data, int *size)

96 {

98 ExtractExtradataContext *s = ctx->priv_data;

100 int extradata_size = 0, filtered_size = 0;

101 int i, has_seq = 0, ret = 0;

102

103 ret = ff_av1_packet_split(&s->av1_pkt, pkt->data, pkt->size, ctx);

104 if (ret < 0)

105 return ret;

106

107 for (i = 0; i < s->av1_pkt.nb_obus; i++) {

108 AV1OBU *obu = &s->av1_pkt.obus[i];

109 if (obu_is_global(obu)) {

110 extradata_size += obu->raw_size;

111 if (obu->type == AV1_OBU_SEQUENCE_HEADER)

112 has_seq = 1;

113 } else if (s->remove) {

114 filtered_size += obu->raw_size;

115 }

116 }

117

118 if (extradata_size && has_seq) {

119 AVBufferRef *filtered_buf = NULL;

120 PutByteContext pb_filtered_data, pb_extradata;

121 uint8_t *extradata;

122

123 if (s->remove) {

124 filtered_buf = av_buffer_alloc(filtered_size + AV_INPUT_BUFFER_PADDING_SIZE);

125 if (!filtered_buf) {

126 return AVERROR(ENOMEM);

127 }

128 memset(filtered_buf->data + filtered_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

129 }

130

131 extradata = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

132 if (!extradata) {

133 av_buffer_unref(&filtered_buf);

134 return AVERROR(ENOMEM);

135 }

136

137 *data = extradata;

138 *size = extradata_size;

139

140 bytestream2_init_writer(&pb_extradata, extradata, extradata_size);

141 if (s->remove)

142 bytestream2_init_writer(&pb_filtered_data, filtered_buf->data, filtered_size);

143

144 for (i = 0; i < s->av1_pkt.nb_obus; i++) {

145 AV1OBU *obu = &s->av1_pkt.obus[i];

146 if (obu_is_global(obu)) {

147 bytestream2_put_bufferu(&pb_extradata, obu->raw_data, obu->raw_size);

148 } else if (s->remove) {

149 bytestream2_put_bufferu(&pb_filtered_data, obu->raw_data, obu->raw_size);

150 }

151 }

152

153 if (s->remove) {

154 av_buffer_unref(&pkt->buf);

155 pkt->buf = filtered_buf;

156 pkt->data = filtered_buf->data;

157 pkt->size = filtered_size;

158 }

159 }

160

161 return 0;

162 }

163

164 static int extract_extradata_h2645(AVBSFContext *ctx, AVPacket *pkt,

165 uint8_t **data, int *size)

166 {

167 static const int extradata_nal_types_vvc[] = {

168 VVC_VPS_NUT, VVC_SPS_NUT, VVC_PPS_NUT,

169 };

170 static const int extradata_nal_types_hevc[] = {

171 HEVC_NAL_VPS, HEVC_NAL_SPS, HEVC_NAL_PPS,

172 };

173 static const int extradata_nal_types_h264[] = {

174 H264_NAL_SPS, H264_NAL_PPS,

175 };

176

177 ExtractExtradataContext *s = ctx->priv_data;

178

179 int extradata_size = 0, filtered_size = 0;

180 const int *extradata_nal_types;

181 size_t nb_extradata_nal_types;

182 int i, has_sps = 0, has_vps = 0, ret = 0;

183

184 if (ctx->par_in->codec_id == AV_CODEC_ID_VVC) {

185 extradata_nal_types = extradata_nal_types_vvc;

186 nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_vvc);

187 } else if (ctx->par_in->codec_id == AV_CODEC_ID_HEVC) {

188 extradata_nal_types = extradata_nal_types_hevc;

189 nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_hevc);

190 } else {

191 extradata_nal_types = extradata_nal_types_h264;

192 nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_h264);

193 }

194

195 ret = ff_h2645_packet_split(&s->h2645_pkt, pkt->data, pkt->size,

196 ctx, 0, ctx->par_in->codec_id, H2645_FLAG_SMALL_PADDING);

197 if (ret < 0)

198 return ret;

199

200 for (i = 0; i < s->h2645_pkt.nb_nals; i++) {

201 H2645NAL *nal = &s->h2645_pkt.nals[i];

202 if (val_in_array(extradata_nal_types, nb_extradata_nal_types, nal->type)) {

203 extradata_size += nal->raw_size + 3;

204 if (ctx->par_in->codec_id == AV_CODEC_ID_VVC) {

205 if (nal->type == VVC_SPS_NUT) has_sps = 1;

206 if (nal->type == VVC_VPS_NUT) has_vps = 1;

207 } else if (ctx->par_in->codec_id == AV_CODEC_ID_HEVC) {

208 if (nal->type == HEVC_NAL_SPS) has_sps = 1;

209 if (nal->type == HEVC_NAL_VPS) has_vps = 1;

210 } else {

211 if (nal->type == H264_NAL_SPS) has_sps = 1;

212 }

213 } else if (s->remove) {

214 filtered_size += nal->raw_size + 3;

215 }

216 }

217

218 if (extradata_size &&

219 ((ctx->par_in->codec_id == AV_CODEC_ID_VVC && has_sps) ||

220 (ctx->par_in->codec_id == AV_CODEC_ID_HEVC && has_sps && has_vps) ||

221 (ctx->par_in->codec_id == AV_CODEC_ID_H264 && has_sps))) {

222 AVBufferRef *filtered_buf = NULL;

223 PutByteContext pb_filtered_data, pb_extradata;

224 uint8_t *extradata;

225

226 if (s->remove) {

227 filtered_buf = av_buffer_alloc(filtered_size + AV_INPUT_BUFFER_PADDING_SIZE);

228 if (!filtered_buf) {

229 return AVERROR(ENOMEM);

230 }

231 memset(filtered_buf->data + filtered_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

232 }

233

234 extradata = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

235 if (!extradata) {

236 av_buffer_unref(&filtered_buf);

237 return AVERROR(ENOMEM);

238 }

239

240 *data = extradata;

241 *size = extradata_size;

242

243 bytestream2_init_writer(&pb_extradata, extradata, extradata_size);

244 if (s->remove)

245 bytestream2_init_writer(&pb_filtered_data, filtered_buf->data, filtered_size);

246

247 for (i = 0; i < s->h2645_pkt.nb_nals; i++) {

248 H2645NAL *nal = &s->h2645_pkt.nals[i];

249 if (val_in_array(extradata_nal_types, nb_extradata_nal_types,

250 nal->type)) {

251 bytestream2_put_be24u(&pb_extradata, 1); //startcode

252 bytestream2_put_bufferu(&pb_extradata, nal->raw_data, nal->raw_size);

253 } else if (s->remove) {

254 bytestream2_put_be24u(&pb_filtered_data, 1); // startcode

255 bytestream2_put_bufferu(&pb_filtered_data, nal->raw_data, nal->raw_size);

256 }

257 }

258

259 if (s->remove) {

260 av_buffer_unref(&pkt->buf);

261 pkt->buf = filtered_buf;

262 pkt->data = filtered_buf->data;

263 pkt->size = filtered_size;

264 }

265 }

266

267 return 0;

268 }

269

270 static int extract_extradata_vc1(AVBSFContext *ctx, AVPacket *pkt,

271 uint8_t **data, int *size)

272 {

273 ExtractExtradataContext *s = ctx->priv_data;

274 const uint8_t *ptr = pkt->data, *end = pkt->data + pkt->size;

275 uint32_t state = UINT32_MAX;

276 int has_extradata = 0, extradata_size = 0;

277

278 while (ptr < end) {

279 ptr = avpriv_find_start_code(ptr, end, &state);

280 if (state == VC1_CODE_SEQHDR || state == VC1_CODE_ENTRYPOINT) {

281 has_extradata = 1;

282 } else if (has_extradata && IS_MARKER(state)) {

283 extradata_size = ptr - 4 - pkt->data;

284 break;

285 }

286 }

287

288 if (extradata_size) {

289 *data = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

290 if (!*data)

291 return AVERROR(ENOMEM);

292

293 memcpy(*data, pkt->data, extradata_size);

294 *size = extradata_size;

295

296 if (s->remove) {

297 pkt->data += extradata_size;

298 pkt->size -= extradata_size;

299 }

300 }

301

302 return 0;

303 }

304

305 static int extract_extradata_mpeg12(AVBSFContext *ctx, AVPacket *pkt,

306 uint8_t **data, int *size)

307 {

308 ExtractExtradataContext *s = ctx->priv_data;

309 uint32_t state = UINT32_MAX;

310 int i, found = 0;

311

312 for (i = 0; i < pkt->size; i++) {

313 state = (state << 8) | pkt->data[i];

314 if (state == 0x1B3)

315 found = 1;

316 else if (found && state != 0x1B5 && state < 0x200 && state >= 0x100) {

317 *size = i - 3;

318 *data = av_malloc(*size + AV_INPUT_BUFFER_PADDING_SIZE);

319 if (!*data)

320 return AVERROR(ENOMEM);

321

322 memcpy(*data, pkt->data, *size);

323

324 if (s->remove) {

325 pkt->data += *size;

326 pkt->size -= *size;

327 }

328 break;

329 }

330 }

331 return 0;

332 }

333

334 static int extract_extradata_mpeg4(AVBSFContext *ctx, AVPacket *pkt,

335 uint8_t **data, int *size)

336 {

337 ExtractExtradataContext *s = ctx->priv_data;

338 const uint8_t *ptr = pkt->data, *end = pkt->data + pkt->size;

339 uint32_t state = UINT32_MAX;

340

341 while (ptr < end) {

342 ptr = avpriv_find_start_code(ptr, end, &state);

343 if (state == 0x1B3 || state == 0x1B6) {

344 if (ptr - pkt->data > 4) {

345 *size = ptr - 4 - pkt->data;

346 *data = av_malloc(*size + AV_INPUT_BUFFER_PADDING_SIZE);

347 if (!*data)

348 return AVERROR(ENOMEM);

349

350 memcpy(*data, pkt->data, *size);

351

352 if (s->remove) {

353 pkt->data += *size;

354 pkt->size -= *size;

355 }

356 }

357 break;

358 }

359 }

360 return 0;

361 }

362

363 static const struct {

364 enum AVCodecID id;

365 int (*extract)(AVBSFContext *ctx, AVPacket *pkt,

366 uint8_t **data, int *size);

367 } extract_tab[] = {

368 { AV_CODEC_ID_AV1, extract_extradata_av1 },

369 { AV_CODEC_ID_AVS2, extract_extradata_mpeg4 },

370 { AV_CODEC_ID_AVS3, extract_extradata_mpeg4 },

371 { AV_CODEC_ID_CAVS, extract_extradata_mpeg4 },

372 { AV_CODEC_ID_H264, extract_extradata_h2645 },

373 { AV_CODEC_ID_HEVC, extract_extradata_h2645 },

374 { AV_CODEC_ID_MPEG1VIDEO, extract_extradata_mpeg12 },

375 { AV_CODEC_ID_MPEG2VIDEO, extract_extradata_mpeg12 },

376 { AV_CODEC_ID_MPEG4, extract_extradata_mpeg4 },

377 { AV_CODEC_ID_VC1, extract_extradata_vc1 },

378 { AV_CODEC_ID_VVC, extract_extradata_h2645 },

379 };

380

381 static int extract_extradata_init(AVBSFContext *ctx)

382 {

383 ExtractExtradataContext *s = ctx->priv_data;

384 int i;

385

386 for (i = 0; i < FF_ARRAY_ELEMS(extract_tab); i++) {

387 if (extract_tab[i].id == ctx->par_in->codec_id) {

388 s->extract = extract_tab[i].extract;

389 break;

390 }

391 }

392 if (!s->extract)

393 return AVERROR_BUG;

394

395 return 0;

396 }

397

398 static int extract_extradata_filter(AVBSFContext *ctx, AVPacket *pkt)

399 {

400 ExtractExtradataContext *s = ctx->priv_data;

401 uint8_t *extradata = NULL;

402 int extradata_size;

403 int ret = 0;

404

405 ret = ff_bsf_get_packet_ref(ctx, pkt);

406 if (ret < 0)

407 return ret;

408

409 ret = s->extract(ctx, pkt, &extradata, &extradata_size);

410 if (ret < 0)

411 goto fail;

412

413 if (extradata) {

414 memset(extradata + extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

415 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

416 extradata, extradata_size);

417 if (ret < 0) {

418 av_freep(&extradata);

419 goto fail;

420 }

421 }

422

423 return 0;

424

425 fail:

426 av_packet_unref(pkt);

427 return ret;

428 }

429

430 static void extract_extradata_close(AVBSFContext *ctx)

431 {

432 ExtractExtradataContext *s = ctx->priv_data;

433 ff_av1_packet_uninit(&s->av1_pkt);

434 ff_h2645_packet_uninit(&s->h2645_pkt);

435 }

436

437 static const enum AVCodecID codec_ids[] = {

438 AV_CODEC_ID_AV1,

439 AV_CODEC_ID_AVS2,

440 AV_CODEC_ID_AVS3,

441 AV_CODEC_ID_CAVS,

442 AV_CODEC_ID_H264,

443 AV_CODEC_ID_HEVC,

444 AV_CODEC_ID_MPEG1VIDEO,

445 AV_CODEC_ID_MPEG2VIDEO,

446 AV_CODEC_ID_MPEG4,

447 AV_CODEC_ID_VC1,

448 AV_CODEC_ID_VVC,

449 AV_CODEC_ID_NONE,

450 };

451

452 #define OFFSET(x) offsetof(ExtractExtradataContext, x)

453 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)

454 static const AVOption options[] = {

455 { "remove", "remove the extradata from the bitstream", OFFSET(remove), AV_OPT_TYPE_INT,

456 { .i64 = 0 }, 0, 1, FLAGS },

457 { NULL },

458 };

459

460 static const AVClass extract_extradata_class = {

461 .class_name = "extract_extradata",

462 .item_name = av_default_item_name,

463 .option = options,

464 .version = LIBAVUTIL_VERSION_INT,

465 };

466

467 const FFBitStreamFilter ff_extract_extradata_bsf = {

468 .p.name = "extract_extradata",

469 .p.codec_ids = codec_ids,

470 .p.priv_class = &extract_extradata_class,

471 .priv_data_size = sizeof(ExtractExtradataContext),

472 .init = extract_extradata_init,

473 .filter = extract_extradata_filter,

474 .close = extract_extradata_close,

475 };

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: packet.c:429

ExtractExtradataContext::h2645_pkt

H2645Packet h2645_pkt

Definition: extract_extradata.c:48

h2645_parse.h

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

H2645_FLAG_SMALL_PADDING

@ H2645_FLAG_SMALL_PADDING

Definition: h2645_parse.h:98

bsf_internal.h

opt.h

extract_tab

static const struct @61 extract_tab[]

extract_extradata_h2645

static int extract_extradata_h2645(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:164

OFFSET

#define OFFSET(x)

Definition: extract_extradata.c:452

AV_PKT_DATA_NEW_EXTRADATA

@ AV_PKT_DATA_NEW_EXTRADATA

The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...

Definition: packet.h:56

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

extract_extradata_vc1

static int extract_extradata_vc1(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:270

AVBitStreamFilter::name

const char * name

Definition: bsf.h:112

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

extract_extradata_class

static const AVClass extract_extradata_class

Definition: extract_extradata.c:460

AVPacket::data

uint8_t * data

Definition: packet.h:539

AVOption

AVOption.

Definition: opt.h:429

ff_h2645_packet_uninit

void ff_h2645_packet_uninit(H2645Packet *pkt)

Free all the allocated memory in the packet.

Definition: h2645_parse.c:602

AV_CODEC_ID_AVS2

@ AV_CODEC_ID_AVS2

Definition: codec_id.h:246

data

const char data[16]

Definition: mxf.c:148

AV1OBU

Definition: av1_parse.h:38

enum AVCodecID id

Definition: extract_extradata.c:364

filter

void(* filter)(uint8_t *src, int stride, int qscale)

Definition: h263dsp.c:29

extract_extradata_mpeg12

static int extract_extradata_mpeg12(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:305

ExtractExtradataContext::av1_pkt

AV1Packet av1_pkt

Definition: extract_extradata.c:45

obu_is_global

static int obu_is_global(const AV1OBU *obu)

Definition: extract_extradata.c:79

extract

int(* extract)(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:365

ExtractExtradataContext::remove

int remove

Definition: extract_extradata.c:51

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:514

AVBSFContext

The bitstream filter state.

Definition: bsf.h:68

AV1OBU::data

const uint8_t * data

Definition: av1_parse.h:41

ff_av1_packet_split

int ff_av1_packet_split(AV1Packet *pkt, const uint8_t *buf, int length, void *logctx)

Split an input packet into OBUs.

Definition: av1_parse.c:56

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

H264_NAL_PPS

@ H264_NAL_PPS

Definition: h264.h:42

av1_parse.h

bsf.h

av_packet_add_side_data

int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)

Wrap an existing array as a packet side data.

Definition: packet.c:197

AV1Packet

An input packet split into OBUs.

Definition: av1_parse.h:60

fail

#define fail()

Definition: checkasm.h:188

ExtractExtradataContext::extract

int(* extract)(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:41

extract_extradata_close

static void extract_extradata_close(AVBSFContext *ctx)

Definition: extract_extradata.c:430

GetBitContext

Definition: get_bits.h:108

val

static double val(void *priv, double ch)

Definition: aeval.c:77

extract_extradata_mpeg4

static int extract_extradata_mpeg4(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:334

pkt

AVPacket * pkt

Definition: movenc.c:60

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

bytestream2_init_writer

static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)

Definition: bytestream.h:147

#define s(width, name)

Definition: cbs_vp9.c:198

HEVC_NAL_VPS

@ HEVC_NAL_VPS

Definition: hevc.h:61

AV1_METADATA_TYPE_HDR_CLL

@ AV1_METADATA_TYPE_HDR_CLL

Definition: av1.h:44

ctx

AVFormatContext * ctx

Definition: movenc.c:49

hevc.h

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

H2645NAL::type

int type

NAL unit type.

Definition: h2645_parse.h:52

if(ret)

Definition: filter_design.txt:179

AV_CODEC_ID_AVS3

@ AV_CODEC_ID_AVS3

Definition: codec_id.h:248

AVPacket::buf

AVBufferRef * buf

A reference to the reference-counted buffer where the packet data is stored.

Definition: packet.h:522

H2645NAL::raw_size

int raw_size

Definition: h2645_parse.h:44

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

get_leb

static unsigned get_leb(GetBitContext *s)

Read a unsigned integer coded as a variable number of up to eight little-endian bytes,...

Definition: leb.h:35

FFBitStreamFilter

Definition: bsf_internal.h:27

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:280

VC1_CODE_SEQHDR

@ VC1_CODE_SEQHDR

Definition: vc1_common.h:40

codec_ids

static enum AVCodecID codec_ids[]

Definition: extract_extradata.c:437

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

IS_MARKER

#define IS_MARKER(state)

Definition: dca_parser.c:51

VC1_CODE_ENTRYPOINT

@ VC1_CODE_ENTRYPOINT

Definition: vc1_common.h:39

extract_extradata_filter

static int extract_extradata_filter(AVBSFContext *ctx, AVPacket *pkt)

Definition: extract_extradata.c:398

avpriv_find_start_code

const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)

ff_extract_extradata_bsf

const FFBitStreamFilter ff_extract_extradata_bsf

Definition: extract_extradata.c:467

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

PutByteContext

Definition: bytestream.h:37

FFBitStreamFilter::p

AVBitStreamFilter p

The public AVBitStreamFilter.

Definition: bsf_internal.h:31

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

extract_extradata_init

static int extract_extradata_init(AVBSFContext *ctx)

Definition: extract_extradata.c:381

AVPacket::size

int size

Definition: packet.h:540

VVC_VPS_NUT

@ VVC_VPS_NUT

Definition: vvc.h:43

HEVC_NAL_SPS

@ HEVC_NAL_SPS

Definition: hevc.h:62

size

int size

Definition: twinvq_data.h:10344

H2645NAL

Definition: h2645_parse.h:34

AV1_OBU_SEQUENCE_HEADER

@ AV1_OBU_SEQUENCE_HEADER

Definition: av1.h:30

options

static const AVOption options[]

Definition: extract_extradata.c:454

val_in_array

static int val_in_array(const int *arr, size_t len, int val)

Definition: extract_extradata.c:54

HEVC_NAL_PPS

@ HEVC_NAL_PPS

Definition: hevc.h:63

AV1_METADATA_TYPE_HDR_MDCV

@ AV1_METADATA_TYPE_HDR_MDCV

Definition: av1.h:45

AV_CODEC_ID_VVC

@ AV_CODEC_ID_VVC

Definition: codec_id.h:250

AV1OBU::raw_size

int raw_size

Size of entire OBU, including header.

Definition: av1_parse.h:50

av_buffer_alloc

AVBufferRef * av_buffer_alloc(size_t size)

Allocate an AVBuffer of the given size using av_malloc().

Definition: buffer.c:77

VVC_SPS_NUT

@ VVC_SPS_NUT

Definition: vvc.h:44

vc1_common.h

AV1OBU::size_bits

int size_bits

Size, in bits, of just the data, excluding the trailing_one_bit and any trailing padding.

Definition: av1_parse.h:47

FLAGS

#define FLAGS

Definition: extract_extradata.c:453

log.h

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

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

Definition: cbs_h2645.c:256

AV_CODEC_ID_CAVS

@ AV_CODEC_ID_CAVS

Definition: codec_id.h:139

AV1OBU::raw_data

const uint8_t * raw_data

Definition: av1_parse.h:51

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:226

ff_av1_packet_uninit

void ff_av1_packet_uninit(AV1Packet *pkt)

Free all the allocated memory in the packet.

Definition: av1_parse.c:104

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:122

len

int len

Definition: vorbis_enc_data.h:426

extract_extradata_av1

static int extract_extradata_av1(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)

Definition: extract_extradata.c:94

ret

Definition: filter_design.txt:187

H2645NAL::raw_data

const uint8_t * raw_data

Definition: h2645_parse.h:45

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

VVC_PPS_NUT

@ VVC_PPS_NUT

Definition: vvc.h:45

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

ExtractExtradataContext

Definition: extract_extradata.c:38

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

AV1OBU::type

int type

Definition: av1_parse.h:53

mem.h

AVBufferRef

A reference to a data buffer.

Definition: buffer.h:82

bytestream2_put_bufferu

static av_always_inline unsigned int bytestream2_put_bufferu(PutByteContext *p, const uint8_t *src, unsigned int size)

Definition: bytestream.h:301

state

static struct @454 state

AVPacket

This structure stores compressed data.

Definition: packet.h:516

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

bytestream.h

h264.h

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:52

metadata_is_global

static int metadata_is_global(const AV1OBU *obu)

Definition: extract_extradata.c:62

ff_bsf_get_packet_ref

int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)

Called by bitstream filters to get packet for filtering.

Definition: bsf.c:256

ff_h2645_packet_split

int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int nal_length_size, enum AVCodecID codec_id, int flags)

Split an input packet into NAL units.

Definition: h2645_parse.c:465

AV_CODEC_ID_MPEG2VIDEO

@ AV_CODEC_ID_MPEG2VIDEO

preferred ID for MPEG-1/2 video decoding

Definition: codec_id.h:54

H2645Packet

Definition: h2645_parse.h:82

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1315

AV1_OBU_METADATA

@ AV1_OBU_METADATA

Definition: av1.h:34

H264_NAL_SPS

@ H264_NAL_SPS

Definition: h264.h:41

Generated on Fri Aug 22 2025 13:58:12 for FFmpeg by doxygen 1.8.17