FFmpeg: libavformat/flacdec.c Source File

FFmpeg

[フレーム]

libavformat

flacdec.c

Go to the documentation of this file.

1 /*

2 * Raw FLAC demuxer

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/channel_layout.h"

23 #include "libavcodec/flac.h"

24 #include "avformat.h"

25 #include "demux.h"

26 #include "flac_picture.h"

27 #include "internal.h"

28 #include "rawdec.h"

29 #include "oggdec.h"

30 #include "replaygain.h"

32 #define SEEKPOINT_SIZE 18

34 typedef struct FLACDecContext {

35 FFRawDemuxerContext rawctx;

36 int found_seektable;

37 } FLACDecContext;

39 static void reset_index_position(int64_t metadata_head_size, AVStream *st)

40 {

41 FFStream *const sti = ffstream(st);

42 /* the real seek index offset should be the size of metadata blocks with the offset in the frame blocks */

43 for (int i = 0; i < sti->nb_index_entries; i++)

44 sti->index_entries[i].pos += metadata_head_size;

45 }

47 static int flac_read_header(AVFormatContext *s)

48 {

49 int ret, metadata_last=0, metadata_type, metadata_size, found_streaminfo=0;

50 uint8_t header[4];

51 uint8_t *buffer=NULL;

52 FLACDecContext *flac = s->priv_data;

53 AVStream *st = avformat_new_stream(s, NULL);

54 if (!st)

55 return AVERROR(ENOMEM);

56 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

57 st->codecpar->codec_id = AV_CODEC_ID_FLAC;

58 ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;

59 /* the parameters will be extracted from the compressed bitstream */

61 /* if fLaC marker is not found, assume there is no header */

62 if (avio_rl32(s->pb) != MKTAG('f','L','a','C')) {

63 avio_seek(s->pb, -4, SEEK_CUR);

64 return 0;

65 }

67 /* process metadata blocks */

68 while (!avio_feof(s->pb) && !metadata_last) {

69 if (avio_read(s->pb, header, 4) != 4)

70 return AVERROR(AVERROR_INVALIDDATA);

71 flac_parse_block_header(header, &metadata_last, &metadata_type,

72 &metadata_size);

73 switch (metadata_type) {

74 /* allocate and read metadata block for supported types */

75 case FLAC_METADATA_TYPE_STREAMINFO:

76 case FLAC_METADATA_TYPE_CUESHEET:

77 case FLAC_METADATA_TYPE_PICTURE:

78 case FLAC_METADATA_TYPE_VORBIS_COMMENT:

79 case FLAC_METADATA_TYPE_SEEKTABLE:

80 buffer = av_mallocz(metadata_size + AV_INPUT_BUFFER_PADDING_SIZE);

81 if (!buffer) {

82 return AVERROR(ENOMEM);

83 }

84 if (avio_read(s->pb, buffer, metadata_size) != metadata_size) {

85 RETURN_ERROR(AVERROR(EIO));

86 }

87 break;

88 /* skip metadata block for unsupported types */

89 default:

90 ret = avio_skip(s->pb, metadata_size);

91 if (ret < 0)

92 return ret;

93 }

95 if (metadata_type == FLAC_METADATA_TYPE_STREAMINFO) {

96 uint32_t samplerate;

97 uint64_t samples;

99 /* STREAMINFO can only occur once */

100 if (found_streaminfo) {

101 RETURN_ERROR(AVERROR_INVALIDDATA);

102 }

103 if (metadata_size != FLAC_STREAMINFO_SIZE) {

104 RETURN_ERROR(AVERROR_INVALIDDATA);

105 }

106 found_streaminfo = 1;

107 st->codecpar->extradata = buffer;

108 st->codecpar->extradata_size = metadata_size;

109 buffer = NULL;

110

111 /* get sample rate and sample count from STREAMINFO header;

112 * other parameters will be extracted by the parser */

113 samplerate = AV_RB24(st->codecpar->extradata + 10) >> 4;

114 samples = (AV_RB64(st->codecpar->extradata + 13) >> 24) & ((1ULL << 36) - 1);

115

116 /* set time base and duration */

117 if (samplerate > 0) {

118 avpriv_set_pts_info(st, 64, 1, samplerate);

119 if (samples > 0)

120 st->duration = samples;

121 }

122 } else if (metadata_type == FLAC_METADATA_TYPE_CUESHEET) {

123 uint8_t isrc[13];

124 uint64_t start;

125 const uint8_t *offset;

126 int i, chapters, track, ti;

127 if (metadata_size < 431)

128 RETURN_ERROR(AVERROR_INVALIDDATA);

129 offset = buffer + 395;

130 chapters = bytestream_get_byte(&offset) - 1;

131 if (chapters <= 0)

132 RETURN_ERROR(AVERROR_INVALIDDATA);

133 for (i = 0; i < chapters; i++) {

134 if (offset + 36 - buffer > metadata_size)

135 RETURN_ERROR(AVERROR_INVALIDDATA);

136 start = bytestream_get_be64(&offset);

137 track = bytestream_get_byte(&offset);

138 bytestream_get_buffer(&offset, isrc, 12);

139 isrc[12] = 0;

140 offset += 14;

141 ti = bytestream_get_byte(&offset);

142 if (ti <= 0) RETURN_ERROR(AVERROR_INVALIDDATA);

143 offset += ti * 12;

144 avpriv_new_chapter(s, track, st->time_base, start, AV_NOPTS_VALUE, isrc);

145 }

146 av_freep(&buffer);

147 } else if (metadata_type == FLAC_METADATA_TYPE_PICTURE) {

148 ret = ff_flac_parse_picture(s, &buffer, metadata_size, 1);

149 av_freep(&buffer);

150 if (ret < 0) {

151 av_log(s, AV_LOG_ERROR, "Error parsing attached picture.\n");

152 return ret;

153 }

154 } else if (metadata_type == FLAC_METADATA_TYPE_SEEKTABLE) {

155 const uint8_t *seekpoint = buffer;

156 int i, seek_point_count = metadata_size/SEEKPOINT_SIZE;

157 flac->found_seektable = 1;

158 if ((s->flags&AVFMT_FLAG_FAST_SEEK)) {

159 for(i=0; i<seek_point_count; i++) {

160 int64_t timestamp = bytestream_get_be64(&seekpoint);

161 int64_t pos = bytestream_get_be64(&seekpoint);

162 /* skip number of samples */

163 bytestream_get_be16(&seekpoint);

164 av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);

165 }

166 }

167 av_freep(&buffer);

168 }

169 else {

170

171 /* STREAMINFO must be the first block */

172 if (!found_streaminfo) {

173 RETURN_ERROR(AVERROR_INVALIDDATA);

174 }

175 /* process supported blocks other than STREAMINFO */

176 if (metadata_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {

177 AVDictionaryEntry *chmask;

178

179 ret = ff_vorbis_comment(s, &s->metadata, buffer, metadata_size, 1);

180 if (ret < 0) {

181 av_log(s, AV_LOG_WARNING, "error parsing VorbisComment metadata\n");

182 } else if (ret > 0) {

183 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;

184 }

185

186 /* parse the channels mask if present */

187 chmask = av_dict_get(s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);

188 if (chmask) {

189 uint64_t mask = strtol(chmask->value, NULL, 0);

190 if (!mask || mask & ~0x3ffffULL) {

191 av_log(s, AV_LOG_WARNING,

192 "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");

193 } else {

194 av_channel_layout_from_mask(&st->codecpar->ch_layout, mask);

195 av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);

196 }

197 }

198 }

199 av_freep(&buffer);

200 }

201 }

202

203 ret = ff_replaygain_export(st, s->metadata);

204 if (ret < 0)

205 return ret;

206

207 reset_index_position(avio_tell(s->pb), st);

208 return 0;

209

210 fail:

211 av_free(buffer);

212 return ret;

213 }

214

215 static int raw_flac_probe(const AVProbeData *p)

216 {

217 if ((p->buf[2] & 0xF0) == 0) // blocksize code invalid

218 return 0;

219 if ((p->buf[2] & 0x0F) == 0x0F) // sample rate code invalid

220 return 0;

221 if ((p->buf[3] & 0xF0) >= FLAC_MAX_CHANNELS + FLAC_CHMODE_MID_SIDE << 4)

222 // channel mode invalid

223 return 0;

224 if ((p->buf[3] & 0x06) == 0x06) // bits per sample code invalid

225 return 0;

226 if ((p->buf[3] & 0x01) == 0x01) // reserved bit set

227 return 0;

228 return AVPROBE_SCORE_EXTENSION / 4 + 1;

229 }

230

231 static int flac_probe(const AVProbeData *p)

232 {

233 if ((AV_RB16(p->buf) & 0xFFFE) == 0xFFF8)

234 return raw_flac_probe(p);

235

236 /* file header + metadata header + checked bytes of streaminfo */

237 if (p->buf_size >= 4 + 4 + 13) {

238 int type = p->buf[4] & 0x7f;

239 int size = AV_RB24(p->buf + 5);

240 int min_block_size = AV_RB16(p->buf + 8);

241 int max_block_size = AV_RB16(p->buf + 10);

242 int sample_rate = AV_RB24(p->buf + 18) >> 4;

243

244 if (memcmp(p->buf, "fLaC", 4))

245 return 0;

246 if (type == FLAC_METADATA_TYPE_STREAMINFO &&

247 size == FLAC_STREAMINFO_SIZE &&

248 min_block_size >= 16 &&

249 max_block_size >= min_block_size &&

250 sample_rate && sample_rate <= 655350)

251 return AVPROBE_SCORE_MAX;

252 return AVPROBE_SCORE_EXTENSION;

253 }

254

255 return 0;

256 }

257

258 static av_unused int64_t flac_read_timestamp(AVFormatContext *s, int stream_index,

259 int64_t *ppos, int64_t pos_limit)

260 {

261 FFFormatContext *const si = ffformatcontext(s);

262 AVPacket *const pkt = si->parse_pkt;

263 AVStream *st = s->streams[stream_index];

264 AVCodecParserContext *parser;

265 int ret;

266 int64_t pts = AV_NOPTS_VALUE;

267

268 if (avio_seek(s->pb, *ppos, SEEK_SET) < 0)

269 return AV_NOPTS_VALUE;

270

271 parser = av_parser_init(st->codecpar->codec_id);

272 if (!parser){

273 return AV_NOPTS_VALUE;

274 }

275 parser->flags |= PARSER_FLAG_USE_CODEC_TS;

276

277 for (;;){

278 uint8_t *data;

279 int size;

280

281 ret = ff_raw_read_partial_packet(s, pkt);

282 if (ret < 0){

283 if (ret == AVERROR(EAGAIN))

284 continue;

285 else {

286 av_packet_unref(pkt);

287 av_assert1(!pkt->size);

288 }

289 }

290 av_parser_parse2(parser, ffstream(st)->avctx,

291 &data, &size, pkt->data, pkt->size,

292 pkt->pts, pkt->dts, *ppos);

293

294 av_packet_unref(pkt);

295 if (size) {

296 if (parser->pts != AV_NOPTS_VALUE){

297 // seeking may not have started from beginning of a frame

298 // calculate frame start position from next frame backwards

299 *ppos = parser->next_frame_offset - size;

300 pts = parser->pts;

301 break;

302 }

303 } else if (ret < 0)

304 break;

305 }

306 av_parser_close(parser);

307 return pts;

308 }

309

310 static int flac_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {

311 AVStream *const st = s->streams[0];

312 FFStream *const sti = ffstream(st);

313 int index;

314 int64_t pos;

315 AVIndexEntry e;

316 FLACDecContext *flac = s->priv_data;

317

318 if (!flac->found_seektable || !(s->flags&AVFMT_FLAG_FAST_SEEK)) {

319 return -1;

320 }

321

322 index = av_index_search_timestamp(st, timestamp, flags);

323 if (index < 0 || index >= sti->nb_index_entries)

324 return -1;

325

326 e = sti->index_entries[index];

327 pos = avio_seek(s->pb, e.pos, SEEK_SET);

328 if (pos >= 0) {

329 return 0;

330 }

331 return -1;

332 }

333

334 const AVInputFormat ff_flac_demuxer = {

335 .name = "flac",

336 .long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),

337 .read_probe = flac_probe,

338 .read_header = flac_read_header,

339 .read_packet = ff_raw_read_partial_packet,

340 .read_seek = flac_seek,

341 .read_timestamp = flac_read_timestamp,

342 .flags = AVFMT_GENERIC_INDEX,

343 .extensions = "flac",

344 .raw_codec_id = AV_CODEC_ID_FLAC,

345 .priv_data_size = sizeof(FLACDecContext),

346 .priv_class = &ff_raw_demuxer_class,

347 };

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_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:422

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

AVCodecParserContext::pts

int64_t pts

Definition: avcodec.h:2808

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

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)

Add a new stream to a media file.

Definition: options.c:237

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:57

ffformatcontext

static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)

Definition: internal.h:192

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

av_unused

#define av_unused

Definition: attributes.h:131

flac_probe

static int flac_probe(const AVProbeData *p)

Definition: flacdec.c:231

AVPacket::data

uint8_t * data

Definition: packet.h:374

data

const char data[16]

Definition: mxf.c:143

FLACDecContext::rawctx

FFRawDemuxerContext rawctx

Definition: flacdec.c:35

AV_CODEC_ID_FLAC

@ AV_CODEC_ID_FLAC

Definition: codec_id.h:439

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:456

flac_read_header

static int flac_read_header(AVFormatContext *s)

Definition: flacdec.c:47

sample_rate

Definition: ffmpeg_filter.c:153

AVIndexEntry

Definition: avformat.h:807

AVINDEX_KEYFRAME

#define AVINDEX_KEYFRAME

Definition: avformat.h:815

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:465

FLAC_METADATA_TYPE_CUESHEET

@ FLAC_METADATA_TYPE_CUESHEET

Definition: flac.h:53

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

flac_seek

static int flac_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

Definition: flacdec.c:310

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:407

fail

#define fail()

Definition: checkasm.h:131

av_add_index_entry

int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)

Add an index entry into a sorted list.

Definition: seek.c:118

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:505

FFRawDemuxerContext

Definition: rawdec.h:36

AVFMT_GENERIC_INDEX

#define AVFMT_GENERIC_INDEX

Use generic index building code.

Definition: avformat.h:482

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

av_parser_init

AVCodecParserContext * av_parser_init(int codec_id)

Definition: parser.c:32

pts

static int64_t pts

Definition: transcode_aac.c:654

SEEKPOINT_SIZE

#define SEEKPOINT_SIZE

Definition: flacdec.c:32

AVStream::duration

int64_t duration

Decoding: duration of the stream, in stream time base.

Definition: avformat.h:998

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

AVInputFormat

Definition: avformat.h:656

mask

static const uint16_t mask[17]

Definition: lzw.c:38

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

ff_raw_read_partial_packet

int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

Definition: rawdec.c:36

#define s(width, name)

Definition: cbs_vp9.c:256

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:661

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:455

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

flac_picture.h

reset_index_position

static void reset_index_position(int64_t metadata_head_size, AVStream *st)

Definition: flacdec.c:39

FFFormatContext

Definition: internal.h:72

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:380

ff_raw_demuxer_class

const AVClass ff_raw_demuxer_class

Definition: rawdec.c:144

ff_flac_demuxer

const AVInputFormat ff_flac_demuxer

Definition: flacdec.c:334

AVFormatContext

Format I/O context.

Definition: avformat.h:1213

FLAC_METADATA_TYPE_STREAMINFO

@ FLAC_METADATA_TYPE_STREAMINFO

Definition: flac.h:48

internal.h

FLAC_CHMODE_MID_SIDE

@ FLAC_CHMODE_MID_SIDE

Definition: flac.h:44

FLACDecContext

Definition: flacdec.c:34

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1108

AVStream::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avformat.h:978

NULL

#define NULL

Definition: coverity.c:32

rawdec.h

flac_parse_block_header

static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)

Parse the metadata block parameters from the header.

Definition: flac.h:145

FLAC_METADATA_TYPE_SEEKTABLE

@ FLAC_METADATA_TYPE_SEEKTABLE

Definition: flac.h:51

FFStream::nb_index_entries

int nb_index_entries

Definition: internal.h:254

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:453

FLAC_STREAMINFO_SIZE

#define FLAC_STREAMINFO_SIZE

Definition: flac.h:34

AVCodecParserContext::flags

int flags

Definition: avcodec.h:2822

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:212

index

int index

Definition: gxfenc.c:89

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:463

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

flac_read_timestamp

static av_unused int64_t flac_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)

Definition: flacdec.c:258

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:759

AVPacket::size

int size

Definition: packet.h:375

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

FFFormatContext::parse_pkt

AVPacket * parse_pkt

The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.

Definition: internal.h:135

FFStream

Definition: internal.h:197

AVCodecParserContext::next_frame_offset

int64_t next_frame_offset

Definition: avcodec.h:2795

size

int size

Definition: twinvq_data.h:10344

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

header

static const uint8_t header[24]

Definition: sdr2.c:67

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:373

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

AVFMT_FLAG_FAST_SEEK

#define AVFMT_FLAG_FAST_SEEK

Enable fast, but inaccurate seeks for some formats.

Definition: avformat.h:1353

RETURN_ERROR

#define RETURN_ERROR(code)

Definition: flac_picture.h:27

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

Definition: cbs_h2645.c:269

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:367

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:53

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

demux.h

AVCodecParserContext

Definition: avcodec.h:2789

bytestream_get_buffer

static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)

Definition: bytestream.h:363

av_channel_layout_from_mask

FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)

Initialize a native channel layout from a bitmask indicating which channels are present.

Definition: channel_layout.c:389

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:948

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:260

FLACDecContext::found_seektable

int found_seektable

Definition: flacdec.c:36

pos

unsigned int pos

Definition: spdifenc.c:412

avformat.h

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

FLAC_MAX_CHANNELS

#define FLAC_MAX_CHANNELS

Definition: flac.h:35

oggdec.h

channel_layout.h

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

FLAC_METADATA_TYPE_PICTURE

@ FLAC_METADATA_TYPE_PICTURE

Definition: flac.h:54

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:641

PARSER_FLAG_USE_CODEC_TS

#define PARSER_FLAG_USE_CODEC_TS

Definition: avcodec.h:2827

AVIndexEntry::pos

int64_t pos

Definition: avformat.h:808

AVSTREAM_PARSE_FULL_RAW

@ AVSTREAM_PARSE_FULL_RAW

full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...

Definition: avformat.h:802

samples

Filter the word "frame" indicates either a video frame or a group of audio samples

Definition: filter_design.txt:8

FLAC_METADATA_TYPE_VORBIS_COMMENT

@ FLAC_METADATA_TYPE_VORBIS_COMMENT

Definition: flac.h:52

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:347

FFStream::index_entries

AVIndexEntry * index_entries

Only used if the format does not support seeking natively.

Definition: internal.h:252

av_parser_parse2

int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)

Parse a packet.

Definition: parser.c:115

raw_flac_probe

static int raw_flac_probe(const AVProbeData *p)

Definition: flacdec.c:215

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

AVDictionaryEntry

Definition: dict.h:79

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: codec_par.h:61

AVPacket

This structure stores compressed data.

Definition: packet.h:351

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

replaygain.h

flags

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

Definition: cbs_av1.c:561

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

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

AVDictionaryEntry::value

char * value

Definition: dict.h:81

flac.h

ff_vorbis_comment

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

Parse Vorbis comments.

Definition: oggparsevorbis.c:148

AV_RB24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:97

AV_RB64

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64

Definition: bytestream.h:95

AVFMT_EVENT_FLAG_METADATA_UPDATED

#define AVFMT_EVENT_FLAG_METADATA_UPDATED

Definition: avformat.h:1530

av_parser_close

void av_parser_close(AVCodecParserContext *s)

Definition: parser.c:189

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

av_index_search_timestamp

int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)

Get the index for a specific timestamp.

Definition: seek.c:238

avio_feof

int avio_feof(AVIOContext *s)

Similar to feof() but also returns nonzero on read errors.

Definition: aviobuf.c:375

Generated on Wed Aug 24 2022 21:41:25 for FFmpeg by doxygen 1.8.17