FFmpeg: libavformat/oggparsevorbis.c Source File

FFmpeg

[フレーム]

libavformat

oggparsevorbis.c

Go to the documentation of this file.

1 /*

3 *

4 * Permission is hereby granted, free of charge, to any person

5 * obtaining a copy of this software and associated documentation

6 * files (the "Software"), to deal in the Software without

7 * restriction, including without limitation the rights to use, copy,

8 * modify, merge, publish, distribute, sublicense, and/or sell copies

9 * of the Software, and to permit persons to whom the Software is

10 * furnished to do so, subject to the following conditions:

11 *

12 * The above copyright notice and this permission notice shall be

13 * included in all copies or substantial portions of the Software.

14 *

15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

19 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

20 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

22 * DEALINGS IN THE SOFTWARE.

23 */

25 #include <stdlib.h>

27 #include "libavutil/avstring.h"

28 #include "libavutil/base64.h"

29 #include "libavutil/dict.h"

30 #include "libavutil/mem.h"

32 #include "libavcodec/bytestream.h"

33 #include "libavcodec/vorbis_parser.h"

35 #include "avformat.h"

36 #include "demux.h"

37 #include "flac_picture.h"

38 #include "internal.h"

39 #include "oggdec.h"

40 #include "vorbiscomment.h"

41 #include "replaygain.h"

43 static int ogm_chapter(AVFormatContext *as, const uint8_t *key, const uint8_t *val)

44 {

45 int i, cnum, h, m, s, ms, keylen = strlen(key);

46 AVChapter *chapter = NULL;

48 if (keylen < 9 || av_strncasecmp(key, "CHAPTER", 7) || sscanf(key+7, "%03d", &cnum) != 1)

49 return 0;

51 if (keylen <= 10) {

52 if (sscanf(val, "%02d:%02d:%02d.%03d", &h, &m, &s, &ms) < 4)

53 return 0;

55 avpriv_new_chapter(as, cnum, (AVRational) { 1, 1000 },

56 ms + 1000 * (s + 60 * (m + 60 * h)),

57 AV_NOPTS_VALUE, NULL);

58 } else if (!av_strcasecmp(key + keylen - 4, "NAME")) {

59 for (i = 0; i < as->nb_chapters; i++)

60 if (as->chapters[i]->id == cnum) {

61 chapter = as->chapters[i];

62 break;

63 }

64 if (!chapter)

65 return 0;

67 av_dict_set(&chapter->metadata, "title", val, 0);

68 } else

69 return 0;

71 return 1;

72 }

74 int ff_vorbis_stream_comment(AVFormatContext *as, AVStream *st,

75 const uint8_t *buf, int size)

76 {

77 int updates = ff_vorbis_comment(as, &st->metadata, buf, size, 1);

79 if (updates > 0) {

80 st->event_flags |= AVSTREAM_EVENT_FLAG_METADATA_UPDATED;

81 }

83 return updates;

84 }

86 /**

87 * This function temporarily modifies the (const qualified) input buffer

88 * and reverts its changes before return. The input buffer needs to have

89 * at least one byte of padding.

90 */

91 static int vorbis_parse_single_comment(AVFormatContext *as, AVDictionary **m,

92 const uint8_t *buf, uint32_t size,

93 int *updates, int parse_picture)

94 {

95 char *t = (char*)buf, *v = memchr(t, '=', size);

96 int tl, vl;

97 char backup;

99 if (!v)

100 return 0;

101

102 tl = v - t;

103 vl = size - tl - 1;

104 v++;

105

106 if (!tl || !vl)

107 return 0;

108

109 t[tl] = 0;

110

111 backup = v[vl];

112 v[vl] = 0;

113

114 /* The format in which the pictures are stored is the FLAC format.

115 * Xiph says: "The binary FLAC picture structure is base64 encoded

116 * and placed within a VorbisComment with the tag name

117 * 'METADATA_BLOCK_PICTURE'. This is the preferred and

118 * recommended way of embedding cover art within VorbisComments."

119 */

120 if (!av_strcasecmp(t, "METADATA_BLOCK_PICTURE") && parse_picture) {

121 int ret, len = AV_BASE64_DECODE_SIZE(vl);

122 uint8_t *pict = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE);

123

124 if (!pict) {

125 av_log(as, AV_LOG_WARNING, "out-of-memory error. Skipping cover art block.\n");

126 goto end;

127 }

128 ret = av_base64_decode(pict, v, len);

129 if (ret > 0)

130 ret = ff_flac_parse_picture(as, &pict, ret, 0);

131 av_freep(&pict);

132 if (ret < 0) {

133 av_log(as, AV_LOG_WARNING, "Failed to parse cover art block.\n");

134 goto end;

135 }

136 } else if (!ogm_chapter(as, t, v)) {

137 (*updates)++;

138 if (av_dict_get(*m, t, NULL, 0))

139 av_dict_set(m, t, ";", AV_DICT_APPEND);

140 av_dict_set(m, t, v, AV_DICT_APPEND);

141 }

142 end:

143 t[tl] = '=';

144 v[vl] = backup;

145

146 return 0;

147 }

148

149 int ff_vorbis_comment(AVFormatContext *as, AVDictionary **m,

150 const uint8_t *buf, int size,

151 int parse_picture)

152 {

153 const uint8_t *p = buf;

154 const uint8_t *end = buf + size;

155 int updates = 0;

156 unsigned n;

157 int s, ret;

158

159 /* must have vendor_length and user_comment_list_length */

160 if (size < 8)

161 return AVERROR_INVALIDDATA;

162

163 s = bytestream_get_le32(&p);

164

165 if (end - p - 4 < s || s < 0)

166 return AVERROR_INVALIDDATA;

167

168 p += s;

169

170 n = bytestream_get_le32(&p);

171

172 while (end - p >= 4 && n > 0) {

173 s = bytestream_get_le32(&p);

174

175 if (end - p < s || s < 0)

176 break;

177

178 ret = vorbis_parse_single_comment(as, m, p, s, &updates, parse_picture);

179 if (ret < 0)

180 return ret;

181 p += s;

182 n--;

183 }

184

185 if (p != end)

186 av_log(as, AV_LOG_INFO,

187 "%"PTRDIFF_SPECIFIER " bytes of comment header remain\n", end - p);

188 if (n > 0)

189 av_log(as, AV_LOG_INFO,

190 "truncated comment header, %i comments not found\n", n);

191

192 ff_metadata_conv(m, NULL, ff_vorbiscomment_metadata_conv);

193

194 return updates;

195 }

196

197 /*

198 * Parse the vorbis header

199 *

200 * Vorbis Identification header from Vorbis_I_spec.html#vorbis-spec-codec

201 * [vorbis_version] = read 32 bits as unsigned integer | Not used

202 * [audio_channels] = read 8 bit integer as unsigned | Used

203 * [audio_sample_rate] = read 32 bits as unsigned integer | Used

204 * [bitrate_maximum] = read 32 bits as signed integer | Not used yet

205 * [bitrate_nominal] = read 32 bits as signed integer | Not used yet

206 * [bitrate_minimum] = read 32 bits as signed integer | Used as bitrate

207 * [blocksize_0] = read 4 bits as unsigned integer | Not Used

208 * [blocksize_1] = read 4 bits as unsigned integer | Not Used

209 * [framing_flag] = read one bit | Not Used

210 */

211

212 struct oggvorbis_private {

213 unsigned int len[3];

214 unsigned char *packet[3];

215 AVVorbisParseContext *vp;

216 int64_t final_pts;

217 int final_duration;

218 };

219

220 static int fixup_vorbis_headers(AVFormatContext *as,

221 struct oggvorbis_private *priv,

222 uint8_t **buf)

223 {

224 int i, offset, len, err;

225 int buf_len;

226 unsigned char *ptr;

227

228 len = priv->len[0] + priv->len[1] + priv->len[2];

229 buf_len = len + len / 255 + 64;

230

231 if (*buf)

232 return AVERROR_INVALIDDATA;

233

234 ptr = *buf = av_realloc(NULL, buf_len);

235 if (!ptr)

236 return AVERROR(ENOMEM);

237 memset(*buf, '0円', buf_len);

238

239 ptr[0] = 2;

240 offset = 1;

241 offset += av_xiphlacing(&ptr[offset], priv->len[0]);

242 offset += av_xiphlacing(&ptr[offset], priv->len[1]);

243 for (i = 0; i < 3; i++) {

244 memcpy(&ptr[offset], priv->packet[i], priv->len[i]);

245 offset += priv->len[i];

246 av_freep(&priv->packet[i]);

247 }

248 if ((err = av_reallocp(buf, offset + AV_INPUT_BUFFER_PADDING_SIZE)) < 0)

249 return err;

250 return offset;

251 }

252

253 static void vorbis_cleanup(AVFormatContext *s, int idx)

254 {

255 struct ogg *ogg = s->priv_data;

256 struct ogg_stream *os = ogg->streams + idx;

257 struct oggvorbis_private *priv = os->private;

258 int i;

259 if (os->private) {

260 av_vorbis_parse_free(&priv->vp);

261 for (i = 0; i < 3; i++)

262 av_freep(&priv->packet[i]);

263 }

264 }

265

266 static int vorbis_update_metadata(AVFormatContext *s, int idx)

267 {

268 struct ogg *ogg = s->priv_data;

269 struct ogg_stream *os = ogg->streams + idx;

270 AVStream *st = s->streams[idx];

271 int ret;

272

273 if (os->psize <= 8)

274 return 0;

275

276 /* New metadata packet; release old data. */

277 av_dict_free(&st->metadata);

278 ret = ff_vorbis_stream_comment(s, st, os->buf + os->pstart + 7,

279 os->psize - 8);

280 if (ret < 0)

281 return ret;

282

283 /* Update the metadata if possible. */

284 av_freep(&os->new_metadata);

285 if (st->metadata) {

286 os->new_metadata = av_packet_pack_dictionary(st->metadata, &os->new_metadata_size);

287 /* Send an empty dictionary to indicate that metadata has been cleared. */

288 } else {

289 os->new_metadata = av_mallocz(1);

290 os->new_metadata_size = 0;

291 }

292

293 return ret;

294 }

295

296 static int vorbis_header(AVFormatContext *s, int idx)

297 {

298 struct ogg *ogg = s->priv_data;

299 AVStream *st = s->streams[idx];

300 struct ogg_stream *os = ogg->streams + idx;

301 struct oggvorbis_private *priv;

302 int pkt_type = os->buf[os->pstart];

303

304 if (!os->private) {

305 os->private = av_mallocz(sizeof(struct oggvorbis_private));

306 if (!os->private)

307 return AVERROR(ENOMEM);

308 }

309

310 priv = os->private;

311

312 if (!(pkt_type & 1))

313 return priv->vp ? 0 : AVERROR_INVALIDDATA;

314

315 if (pkt_type > 5) {

316 av_log(s, AV_LOG_VERBOSE, "Ignoring packet with unknown type %d\n", pkt_type);

317 return 1;

318 }

319

320 if (os->psize < 1)

321 return AVERROR_INVALIDDATA;

322

323 if (priv->packet[pkt_type >> 1])

324 return AVERROR_INVALIDDATA;

325 if (pkt_type > 1 && !priv->packet[0] || pkt_type > 3 && !priv->packet[1])

326 return priv->vp ? 0 : AVERROR_INVALIDDATA;

327

328 priv->len[pkt_type >> 1] = os->psize;

329 priv->packet[pkt_type >> 1] = av_memdup(os->buf + os->pstart, os->psize);

330 if (!priv->packet[pkt_type >> 1])

331 return AVERROR(ENOMEM);

332 if (os->buf[os->pstart] == 1) {

333 const uint8_t *p = os->buf + os->pstart + 7; /* skip "001円vorbis" tag */

334 unsigned blocksize, bs0, bs1;

335 int srate;

336 int channels;

337

338 if (os->psize != 30)

339 return AVERROR_INVALIDDATA;

340

341 if (bytestream_get_le32(&p) != 0) /* vorbis_version */

342 return AVERROR_INVALIDDATA;

343

344 channels = bytestream_get_byte(&p);

345 if (st->codecpar->ch_layout.nb_channels &&

346 channels != st->codecpar->ch_layout.nb_channels) {

347 av_log(s, AV_LOG_ERROR, "Channel change is not supported\n");

348 return AVERROR_PATCHWELCOME;

349 }

350 st->codecpar->ch_layout.nb_channels = channels;

351 srate = bytestream_get_le32(&p);

352 p += 4; // skip maximum bitrate

353 st->codecpar->bit_rate = bytestream_get_le32(&p); // nominal bitrate

354 p += 4; // skip minimum bitrate

355

356 blocksize = bytestream_get_byte(&p);

357 bs0 = blocksize & 15;

358 bs1 = blocksize >> 4;

359

360 if (bs0 > bs1)

361 return AVERROR_INVALIDDATA;

362 if (bs0 < 6 || bs1 > 13)

363 return AVERROR_INVALIDDATA;

364

365 if (bytestream_get_byte(&p) != 1) /* framing_flag */

366 return AVERROR_INVALIDDATA;

367

368 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

369 st->codecpar->codec_id = AV_CODEC_ID_VORBIS;

370

371 if (srate > 0) {

372 st->codecpar->sample_rate = srate;

373 avpriv_set_pts_info(st, 64, 1, srate);

374 }

375 } else if (os->buf[os->pstart] == 3) {

376 if (vorbis_update_metadata(s, idx) >= 0 && priv->len[1] > 10) {

377 unsigned new_len;

378

379 int ret = ff_replaygain_export(st, st->metadata);

380 if (ret < 0)

381 return ret;

382

383 // drop all metadata we parsed and which is not required by libvorbis

384 new_len = 7 + 4 + AV_RL32(priv->packet[1] + 7) + 4 + 1;

385 if (new_len >= 16 && new_len < os->psize) {

386 AV_WL32(priv->packet[1] + new_len - 5, 0);

387 priv->packet[1][new_len - 1] = 1;

388 priv->len[1] = new_len;

389 }

390 }

391 } else {

392 int ret;

393

394 if (priv->vp)

395 return AVERROR_INVALIDDATA;

396

397 ret = fixup_vorbis_headers(s, priv, &st->codecpar->extradata);

398 if (ret < 0) {

399 st->codecpar->extradata_size = 0;

400 return ret;

401 }

402 st->codecpar->extradata_size = ret;

403

404 priv->vp = av_vorbis_parse_init(st->codecpar->extradata, st->codecpar->extradata_size);

405 if (!priv->vp) {

406 av_freep(&st->codecpar->extradata);

407 st->codecpar->extradata_size = 0;

408 return AVERROR_UNKNOWN;

409 }

410 }

411

412 return 1;

413 }

414

415 static int vorbis_packet(AVFormatContext *s, int idx)

416 {

417 struct ogg *ogg = s->priv_data;

418 struct ogg_stream *os = ogg->streams + idx;

419 struct oggvorbis_private *priv = os->private;

420 int duration, flags = 0;

421

422 if (!priv->vp)

423 return AVERROR_INVALIDDATA;

424

425 /* first packet handling

426 * here we parse the duration of each packet in the first page and compare

427 * the total duration to the page granule to find the encoder delay and

428 * set the first timestamp */

429 if ((!os->lastpts || os->lastpts == AV_NOPTS_VALUE) && !(os->flags & OGG_FLAG_EOS) && (int64_t)os->granule>=0) {

430 int seg, d;

431 uint8_t *last_pkt = os->buf + os->pstart;

432 uint8_t *next_pkt = last_pkt;

433

434 av_vorbis_parse_reset(priv->vp);

435 duration = 0;

436 seg = os->segp;

437 d = av_vorbis_parse_frame_flags(priv->vp, last_pkt, 1, &flags);

438 if (d < 0) {

439 os->pflags |= AV_PKT_FLAG_CORRUPT;

440 return 0;

441 } else if (flags & VORBIS_FLAG_COMMENT) {

442 vorbis_update_metadata(s, idx);

443 flags = 0;

444 }

445 duration += d;

446 last_pkt = next_pkt = next_pkt + os->psize;

447 for (; seg < os->nsegs; seg++) {

448 if (os->segments[seg] < 255) {

449 int d = av_vorbis_parse_frame_flags(priv->vp, last_pkt, 1, &flags);

450 if (d < 0) {

451 duration = os->granule;

452 break;

453 } else if (flags & VORBIS_FLAG_COMMENT) {

454 vorbis_update_metadata(s, idx);

455 flags = 0;

456 }

457 duration += d;

458 last_pkt = next_pkt + os->segments[seg];

459 }

460 next_pkt += os->segments[seg];

461 }

462 os->lastpts =

463 os->lastdts = os->granule - duration;

464

465 if (!os->granule && duration) //hack to deal with broken files (Ticket3710)

466 os->lastpts = os->lastdts = AV_NOPTS_VALUE;

467

468 if (s->streams[idx]->start_time == AV_NOPTS_VALUE) {

469 s->streams[idx]->start_time = FFMAX(os->lastpts, 0);

470 if (s->streams[idx]->duration != AV_NOPTS_VALUE)

471 s->streams[idx]->duration -= s->streams[idx]->start_time;

472 }

473 priv->final_pts = AV_NOPTS_VALUE;

474 av_vorbis_parse_reset(priv->vp);

475 }

476

477 /* parse packet duration */

478 if (os->psize > 0) {

479 duration = av_vorbis_parse_frame_flags(priv->vp, os->buf + os->pstart, 1, &flags);

480 if (duration < 0) {

481 os->pflags |= AV_PKT_FLAG_CORRUPT;

482 return 0;

483 } else if (flags & VORBIS_FLAG_COMMENT) {

484 vorbis_update_metadata(s, idx);

485 flags = 0;

486 }

487 os->pduration = duration;

488 }

489

490 /* final packet handling

491 * here we save the pts of the first packet in the final page, sum up all

492 * packet durations in the final page except for the last one, and compare

493 * to the page granule to find the duration of the final packet */

494 if (os->flags & OGG_FLAG_EOS) {

495 if (os->lastpts != AV_NOPTS_VALUE) {

496 priv->final_pts = os->lastpts;

497 priv->final_duration = 0;

498 }

499 if (os->segp == os->nsegs) {

500 int64_t skip = priv->final_pts + priv->final_duration + os->pduration - os->granule;

501 if (skip > 0)

502 os->end_trimming = skip;

503 os->pduration = os->granule - priv->final_pts - priv->final_duration;

504 }

505 priv->final_duration += os->pduration;

506 }

507

508 return 0;

509 }

510

511 const struct ogg_codec ff_vorbis_codec = {

512 .magic = "001円vorbis",

513 .magicsize = 7,

514 .header = vorbis_header,

515 .packet = vorbis_packet,

516 .cleanup = vorbis_cleanup,

517 .nb_header = 3,

518 };

avpriv_new_chapter

AVChapter * avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, int64_t start, int64_t end, const char *title)

Add a new chapter.

Definition: demux_utils.c:42

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AVCodecParameters::extradata

uint8_t * extradata

Extra binary data needed for initializing the decoder, codec-dependent.

Definition: codec_par.h:69

ogg_stream::segp

int segp

Definition: oggdec.h:78

av_vorbis_parse_free

void av_vorbis_parse_free(AVVorbisParseContext **s)

Free the parser and everything associated with it.

Definition: vorbis_parser.c:279

AVChapter::metadata

AVDictionary * metadata

Definition: avformat.h:1250

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

ogg_stream::lastpts

int64_t lastpts

Definition: oggdec.h:71

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:422

AVVorbisParseContext

Definition: vorbis_parser_internal.h:34

AVFormatContext::nb_chapters

unsigned int nb_chapters

Number of chapters in AVChapter array.

Definition: avformat.h:1387

ff_replaygain_export

int ff_replaygain_export(AVStream *st, AVDictionary *metadata)

Parse replaygain tags and export them as per-stream side data.

Definition: replaygain.c:94

av_vorbis_parse_frame_flags

int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf, int buf_size, int *flags)

Get the duration for a Vorbis packet.

Definition: vorbis_parser.c:215

int64_t

long long int64_t

Definition: coverity.c:34

av_strcasecmp

int av_strcasecmp(const char *a, const char *b)

Locale-independent case-insensitive compare.

Definition: avstring.c:207

ff_metadata_conv

void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)

Definition: metadata.c:26

ff_vorbis_stream_comment

int ff_vorbis_stream_comment(AVFormatContext *as, AVStream *st, const uint8_t *buf, int size)

Parse Vorbis comments and add metadata to an AVStream.

Definition: oggparsevorbis.c:74

vorbiscomment.h

ogg_stream::granule

uint64_t granule

Definition: oggdec.h:69

AV_DICT_APPEND

#define AV_DICT_APPEND

If the entry already exists, append to it.

Definition: dict.h:82

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

AVDictionary

Definition: dict.c:34

ogg_stream::buf

uint8_t * buf

Definition: oggdec.h:61

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ogg_stream::nsegs

int nsegs

Definition: oggdec.h:78

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

ogg

Definition: oggdec.h:101

ogm_chapter

static int ogm_chapter(AVFormatContext *as, const uint8_t *key, const uint8_t *val)

Definition: oggparsevorbis.c:43

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

av_memdup

void * av_memdup(const void *p, size_t size)

Duplicate a buffer with av_malloc().

Definition: mem.c:304

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:860

AV_BASE64_DECODE_SIZE

#define AV_BASE64_DECODE_SIZE(x)

Calculate the output size in bytes needed to decode a base64 string with length x to a data buffer.

Definition: base64.h:48

ogg_stream::lastdts

int64_t lastdts

Definition: oggdec.h:72

AVChapter

Definition: avformat.h:1246

val

static double val(void *priv, double ch)

Definition: aeval.c:77

ff_vorbis_comment

int ff_vorbis_comment(AVFormatContext *as, AVDictionary **m, const uint8_t *buf, int size, int parse_picture)

Parse Vorbis comments.

Definition: oggparsevorbis.c:149

vorbis_parse_single_comment

static int vorbis_parse_single_comment(AVFormatContext *as, AVDictionary **m, const uint8_t *buf, uint32_t size, int *updates, int parse_picture)

This function temporarily modifies the (const qualified) input buffer and reverts its changes before ...

Definition: oggparsevorbis.c:91

ogg_stream::pstart

unsigned int pstart

Definition: oggdec.h:64

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

AV_PKT_FLAG_CORRUPT

#define AV_PKT_FLAG_CORRUPT

The packet content is corrupted.

Definition: packet.h:595

duration

int64_t duration

Definition: movenc.c:65

av_dict_get

AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)

Get a dictionary entry with matching key.

Definition: dict.c:62

#define s(width, name)

Definition: cbs_vp9.c:198

AVFormatContext::chapters

AVChapter ** chapters

Definition: avformat.h:1388

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

VORBIS_FLAG_COMMENT

#define VORBIS_FLAG_COMMENT

Definition: vorbis_parser.h:45

ff_vorbis_codec

const struct ogg_codec ff_vorbis_codec

Definition: oggparsevorbis.c:511

channels

Definition: aptx.h:31

flac_picture.h

oggvorbis_private::final_duration

int final_duration

Definition: oggparsevorbis.c:217

oggvorbis_private::packet

unsigned char * packet[3]

Definition: oggparsevorbis.c:214

ogg_stream::new_metadata

uint8_t * new_metadata

Definition: oggdec.h:88

oggvorbis_private::len

unsigned int len[3]

Definition: oggparsevorbis.c:213

ff_vorbiscomment_metadata_conv

const AVMetadataConv ff_vorbiscomment_metadata_conv[]

VorbisComment metadata conversion mapping.

Definition: vorbiscomment.c:33

key

const char * key

Definition: hwcontext_opencl.c:189

AVFormatContext

Format I/O context.

Definition: avformat.h:1287

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:771

oggvorbis_private

Definition: oggparsevorbis.c:212

PTRDIFF_SPECIFIER

#define PTRDIFF_SPECIFIER

Definition: internal.h:128

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

ogg_stream::flags

int flags

Definition: oggdec.h:75

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:828

vorbis_parser.h

av_base64_decode

int av_base64_decode(uint8_t *out, const char *in_str, int out_size)

Decode a base64-encoded string.

Definition: base64.c:81

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

base64.h

ogg::streams

struct ogg_stream * streams

Definition: oggdec.h:102

AVSTREAM_EVENT_FLAG_METADATA_UPDATED

#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED

Definition: avformat.h:898

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

ff_flac_parse_picture

int ff_flac_parse_picture(AVFormatContext *s, uint8_t **bufp, int buf_size, int truncate_workaround)

Parse a FLAC METADATA_BLOCK_PICTURE.

Definition: flac_picture.c:33

AVCodecParameters::extradata_size

int extradata_size

Size of the extradata content in bytes.

Definition: codec_par.h:73

vorbis_cleanup

static void vorbis_cleanup(AVFormatContext *s, int idx)

Definition: oggparsevorbis.c:253

av_strncasecmp

int av_strncasecmp(const char *a, const char *b, size_t n)

Locale-independent case-insensitive compare.

Definition: avstring.c:217

ogg_stream::private

void * private

Definition: oggdec.h:90

size

int size

Definition: twinvq_data.h:10344

av_reallocp

int av_reallocp(void *ptr, size_t size)

Allocate, reallocate, or free a block of memory through a pointer to a pointer.

Definition: mem.c:188

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

AVStream::event_flags

int event_flags

Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.

Definition: avformat.h:891

av_xiphlacing

unsigned int av_xiphlacing(unsigned char *s, unsigned int v)

Encode extradata length to a buffer.

Definition: utils.c:812

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

av_packet_pack_dictionary

uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)

Pack a dictionary for use in side_data.

Definition: packet.c:314

av_dict_free

void av_dict_free(AVDictionary **pm)

Free all the memory allocated for an AVDictionary struct and all keys and values.

Definition: dict.c:223

oggvorbis_private::final_pts

int64_t final_pts

Definition: oggparsevorbis.c:216

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

vorbis_update_metadata

static int vorbis_update_metadata(AVFormatContext *s, int idx)

Definition: oggparsevorbis.c:266

ogg_stream::pflags

unsigned int pflags

Definition: oggdec.h:66

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

Definition: cbs_h2645.c:256

ogg_stream

Definition: oggdec.h:60

AVChapter::id

int64_t id

unique ID to identify the chapter

Definition: avformat.h:1247

vorbis_header

static int vorbis_header(AVFormatContext *s, int idx)

Definition: oggparsevorbis.c:296

vorbis_packet

static int vorbis_packet(AVFormatContext *s, int idx)

Definition: oggparsevorbis.c:415

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

demux.h

len

int len

Definition: vorbis_enc_data.h:426

oggvorbis_private::vp

AVVorbisParseContext * vp

Definition: oggparsevorbis.c:215

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:748

av_vorbis_parse_init

AVVorbisParseContext * av_vorbis_parse_init(const uint8_t *extradata, int extradata_size)

Allocate and initialize the Vorbis parser using headers in the extradata.

Definition: vorbis_parser.c:284

avformat.h

dict.h

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

oggdec.h

ogg_stream::new_metadata_size

size_t new_metadata_size

Definition: oggdec.h:89

ogg_stream::segments

uint8_t segments[255]

Definition: oggdec.h:79

mem.h

OGG_FLAG_EOS

#define OGG_FLAG_EOS

Definition: oggdec.h:112

av_vorbis_parse_reset

void av_vorbis_parse_reset(AVVorbisParseContext *s)

Definition: vorbis_parser.c:273

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:55

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:88

ogg_stream::psize

unsigned int psize

Definition: oggdec.h:65

ogg_codec

Definition: oggdec.h:30

bytestream.h

replaygain.h

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:482

AVCodecParameters::bit_rate

int64_t bit_rate

The average bitrate of the encoded data (in bits per second).

Definition: codec_par.h:97

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

Definition: vp9dsp_template.c:2070

AV_CODEC_ID_VORBIS

@ AV_CODEC_ID_VORBIS

Definition: codec_id.h:445

ogg_codec::magic

const int8_t * magic

Definition: oggdec.h:31

ogg_stream::end_trimming

int end_trimming

set the number of packets to drop from the end

Definition: oggdec.h:87

avstring.h

ogg_stream::pduration

unsigned int pduration

Definition: oggdec.h:67

skip

static void BS_FUNC() skip(BSCTX *bc, unsigned int n)

Skip n bits in the buffer.

Definition: bitstream_template.h:375

av_realloc

void * av_realloc(void *ptr, size_t size)

Allocate, reallocate, or free a block of memory.

Definition: mem.c:155

fixup_vorbis_headers

static int fixup_vorbis_headers(AVFormatContext *as, struct oggvorbis_private *priv, uint8_t **buf)

Definition: oggparsevorbis.c:220

Generated on Fri Aug 22 2025 13:59:33 for FFmpeg by doxygen 1.8.17