FFmpeg: libavformat/ape.c Source File

FFmpeg

[フレーム]

libavformat

ape.c

Go to the documentation of this file.

1 /*

2 * Monkey's Audio APE demuxer

4 * based upon libdemac from Dave Chapman.

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 #include <stdio.h>

25 #include "libavutil/intreadwrite.h"

26 #include "avformat.h"

27 #include "internal.h"

28 #include "apetag.h"

30 /* The earliest and latest file formats supported by this library */

31 #define APE_MIN_VERSION 3800

32 #define APE_MAX_VERSION 3990

34 #define MAC_FORMAT_FLAG_8_BIT 1 // is 8-bit [OBSOLETE]

35 #define MAC_FORMAT_FLAG_CRC 2 // uses the new CRC32 error detection [OBSOLETE]

36 #define MAC_FORMAT_FLAG_HAS_PEAK_LEVEL 4 // uint32 nPeakLevel after the header [OBSOLETE]

37 #define MAC_FORMAT_FLAG_24_BIT 8 // is 24-bit [OBSOLETE]

38 #define MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS 16 // has the number of seek elements after the peak level

39 #define MAC_FORMAT_FLAG_CREATE_WAV_HEADER 32 // create the wave header on decompression (not stored)

41 #define APE_EXTRADATA_SIZE 6

43 typedef struct APEFrame {

44 int64_t pos;

45 int nblocks;

46 int size;

47 int skip;

48 int64_t pts;

49 } APEFrame;

51 typedef struct APEContext {

52 /* Derived fields */

53 uint32_t junklength;

54 uint32_t firstframe;

55 uint32_t totalsamples;

56 int currentframe;

57 APEFrame *frames;

59 /* Info from Descriptor Block */

60 int16_t fileversion;

61 int16_t padding1;

62 uint32_t descriptorlength;

63 uint32_t headerlength;

64 uint32_t seektablelength;

65 uint32_t wavheaderlength;

66 uint32_t audiodatalength;

67 uint32_t audiodatalength_high;

68 uint32_t wavtaillength;

69 uint8_t md5[16];

71 /* Info from Header Block */

72 uint16_t compressiontype;

73 uint16_t formatflags;

74 uint32_t blocksperframe;

75 uint32_t finalframeblocks;

76 uint32_t totalframes;

77 uint16_t bps;

78 uint16_t channels;

79 uint32_t samplerate;

81 /* Seektable */

82 uint32_t *seektable;

83 uint8_t *bittable;

84 } APEContext;

86 static int ape_probe(AVProbeData * p)

87 {

88 int version = AV_RL16(p->buf+4);

89 if (AV_RL32(p->buf) != MKTAG('M', 'A', 'C', ' '))

90 return 0;

92 if (version < APE_MIN_VERSION || version > APE_MAX_VERSION)

93 return AVPROBE_SCORE_MAX/4;

95 return AVPROBE_SCORE_MAX;

96 }

98 static void ape_dumpinfo(AVFormatContext * s, APEContext * ape_ctx)

99 {

100 #ifdef DEBUG

101 int i;

102

103 av_log(s, AV_LOG_DEBUG, "Descriptor Block:\n\n");

104 av_log(s, AV_LOG_DEBUG, "fileversion = %"PRId16"\n", ape_ctx->fileversion);

105 av_log(s, AV_LOG_DEBUG, "descriptorlength = %"PRIu32"\n", ape_ctx->descriptorlength);

106 av_log(s, AV_LOG_DEBUG, "headerlength = %"PRIu32"\n", ape_ctx->headerlength);

107 av_log(s, AV_LOG_DEBUG, "seektablelength = %"PRIu32"\n", ape_ctx->seektablelength);

108 av_log(s, AV_LOG_DEBUG, "wavheaderlength = %"PRIu32"\n", ape_ctx->wavheaderlength);

109 av_log(s, AV_LOG_DEBUG, "audiodatalength = %"PRIu32"\n", ape_ctx->audiodatalength);

110 av_log(s, AV_LOG_DEBUG, "audiodatalength_high = %"PRIu32"\n", ape_ctx->audiodatalength_high);

111 av_log(s, AV_LOG_DEBUG, "wavtaillength = %"PRIu32"\n", ape_ctx->wavtaillength);

112 av_log(s, AV_LOG_DEBUG, "md5 = ");

113 for (i = 0; i < 16; i++)

114 av_log(s, AV_LOG_DEBUG, "%02x", ape_ctx->md5[i]);

115 av_log(s, AV_LOG_DEBUG, "\n");

116

117 av_log(s, AV_LOG_DEBUG, "\nHeader Block:\n\n");

118

119 av_log(s, AV_LOG_DEBUG, "compressiontype = %"PRIu16"\n", ape_ctx->compressiontype);

120 av_log(s, AV_LOG_DEBUG, "formatflags = %"PRIu16"\n", ape_ctx->formatflags);

121 av_log(s, AV_LOG_DEBUG, "blocksperframe = %"PRIu32"\n", ape_ctx->blocksperframe);

122 av_log(s, AV_LOG_DEBUG, "finalframeblocks = %"PRIu32"\n", ape_ctx->finalframeblocks);

123 av_log(s, AV_LOG_DEBUG, "totalframes = %"PRIu32"\n", ape_ctx->totalframes);

124 av_log(s, AV_LOG_DEBUG, "bps = %"PRIu16"\n", ape_ctx->bps);

125 av_log(s, AV_LOG_DEBUG, "channels = %"PRIu16"\n", ape_ctx->channels);

126 av_log(s, AV_LOG_DEBUG, "samplerate = %"PRIu32"\n", ape_ctx->samplerate);

127

128 av_log(s, AV_LOG_DEBUG, "\nSeektable\n\n");

129 if ((ape_ctx->seektablelength / sizeof(uint32_t)) != ape_ctx->totalframes) {

130 av_log(s, AV_LOG_DEBUG, "No seektable\n");

131 } else {

132 for (i = 0; i < ape_ctx->seektablelength / sizeof(uint32_t); i++) {

133 if (i < ape_ctx->totalframes - 1) {

134 av_log(s, AV_LOG_DEBUG, "%8d %"PRIu32" (%"PRIu32" bytes)",

135 i, ape_ctx->seektable[i],

136 ape_ctx->seektable[i + 1] - ape_ctx->seektable[i]);

137 if (ape_ctx->bittable)

138 av_log(s, AV_LOG_DEBUG, " + %2d bits\n",

139 ape_ctx->bittable[i]);

140 av_log(s, AV_LOG_DEBUG, "\n");

141 } else {

142 av_log(s, AV_LOG_DEBUG, "%8d %"PRIu32"\n", i, ape_ctx->seektable[i]);

143 }

144 }

145 }

146

147 av_log(s, AV_LOG_DEBUG, "\nFrames\n\n");

148 for (i = 0; i < ape_ctx->totalframes; i++)

149 av_log(s, AV_LOG_DEBUG, "%8d %8"PRId64" %8d (%d samples)\n", i,

150 ape_ctx->frames[i].pos, ape_ctx->frames[i].size,

151 ape_ctx->frames[i].nblocks);

152

153 av_log(s, AV_LOG_DEBUG, "\nCalculated information:\n\n");

154 av_log(s, AV_LOG_DEBUG, "junklength = %"PRIu32"\n", ape_ctx->junklength);

155 av_log(s, AV_LOG_DEBUG, "firstframe = %"PRIu32"\n", ape_ctx->firstframe);

156 av_log(s, AV_LOG_DEBUG, "totalsamples = %"PRIu32"\n", ape_ctx->totalsamples);

157 #endif

158 }

159

160 static int ape_read_header(AVFormatContext * s)

161 {

162 AVIOContext *pb = s->pb;

163 APEContext *ape = s->priv_data;

164 AVStream *st;

165 uint32_t tag;

166 int i;

167 int total_blocks, final_size = 0;

168 int64_t pts, file_size;

169

170 /* Skip any leading junk such as id3v2 tags */

171 ape->junklength = avio_tell(pb);

172

173 tag = avio_rl32(pb);

174 if (tag != MKTAG('M', 'A', 'C', ' '))

175 return AVERROR_INVALIDDATA;

176

177 ape->fileversion = avio_rl16(pb);

178

179 if (ape->fileversion < APE_MIN_VERSION || ape->fileversion > APE_MAX_VERSION) {

180 av_log(s, AV_LOG_ERROR, "Unsupported file version - %d.%02d\n",

181 ape->fileversion / 1000, (ape->fileversion % 1000) / 10);

182 return AVERROR_PATCHWELCOME;

183 }

184

185 if (ape->fileversion >= 3980) {

186 ape->padding1 = avio_rl16(pb);

187 ape->descriptorlength = avio_rl32(pb);

188 ape->headerlength = avio_rl32(pb);

189 ape->seektablelength = avio_rl32(pb);

190 ape->wavheaderlength = avio_rl32(pb);

191 ape->audiodatalength = avio_rl32(pb);

192 ape->audiodatalength_high = avio_rl32(pb);

193 ape->wavtaillength = avio_rl32(pb);

194 avio_read(pb, ape->md5, 16);

195

196 /* Skip any unknown bytes at the end of the descriptor.

197 This is for future compatibility */

198 if (ape->descriptorlength > 52)

199 avio_skip(pb, ape->descriptorlength - 52);

200

201 /* Read header data */

202 ape->compressiontype = avio_rl16(pb);

203 ape->formatflags = avio_rl16(pb);

204 ape->blocksperframe = avio_rl32(pb);

205 ape->finalframeblocks = avio_rl32(pb);

206 ape->totalframes = avio_rl32(pb);

207 ape->bps = avio_rl16(pb);

208 ape->channels = avio_rl16(pb);

209 ape->samplerate = avio_rl32(pb);

210 } else {

211 ape->descriptorlength = 0;

212 ape->headerlength = 32;

213

214 ape->compressiontype = avio_rl16(pb);

215 ape->formatflags = avio_rl16(pb);

216 ape->channels = avio_rl16(pb);

217 ape->samplerate = avio_rl32(pb);

218 ape->wavheaderlength = avio_rl32(pb);

219 ape->wavtaillength = avio_rl32(pb);

220 ape->totalframes = avio_rl32(pb);

221 ape->finalframeblocks = avio_rl32(pb);

222

223 if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) {

224 avio_skip(pb, 4); /* Skip the peak level */

225 ape->headerlength += 4;

226 }

227

228 if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) {

229 ape->seektablelength = avio_rl32(pb);

230 ape->headerlength += 4;

231 ape->seektablelength *= sizeof(int32_t);

232 } else

233 ape->seektablelength = ape->totalframes * sizeof(int32_t);

234

235 if (ape->formatflags & MAC_FORMAT_FLAG_8_BIT)

236 ape->bps = 8;

237 else if (ape->formatflags & MAC_FORMAT_FLAG_24_BIT)

238 ape->bps = 24;

239 else

240 ape->bps = 16;

241

242 if (ape->fileversion >= 3950)

243 ape->blocksperframe = 73728 * 4;

244 else if (ape->fileversion >= 3900 || (ape->fileversion >= 3800 && ape->compressiontype >= 4000))

245 ape->blocksperframe = 73728;

246 else

247 ape->blocksperframe = 9216;

248

249 /* Skip any stored wav header */

250 if (!(ape->formatflags & MAC_FORMAT_FLAG_CREATE_WAV_HEADER))

251 avio_skip(pb, ape->wavheaderlength);

252 }

253

254 if(!ape->totalframes){

255 av_log(s, AV_LOG_ERROR, "No frames in the file!\n");

256 return AVERROR(EINVAL);

257 }

258 if(ape->totalframes > UINT_MAX / sizeof(APEFrame)){

259 av_log(s, AV_LOG_ERROR, "Too many frames: %"PRIu32"\n",

260 ape->totalframes);

261 return AVERROR_INVALIDDATA;

262 }

263 if (ape->seektablelength / sizeof(*ape->seektable) < ape->totalframes) {

264 av_log(s, AV_LOG_ERROR,

265 "Number of seek entries is less than number of frames: %"SIZE_SPECIFIER " vs. %"PRIu32"\n",

266 ape->seektablelength / sizeof(*ape->seektable), ape->totalframes);

267 return AVERROR_INVALIDDATA;

268 }

269 ape->frames = av_malloc_array(ape->totalframes, sizeof(APEFrame));

270 if(!ape->frames)

271 return AVERROR(ENOMEM);

272 ape->firstframe = ape->junklength + ape->descriptorlength + ape->headerlength + ape->seektablelength + ape->wavheaderlength;

273 if (ape->fileversion < 3810)

274 ape->firstframe += ape->totalframes;

275 ape->currentframe = 0;

276

277

278 ape->totalsamples = ape->finalframeblocks;

279 if (ape->totalframes > 1)

280 ape->totalsamples += ape->blocksperframe * (ape->totalframes - 1);

281

282 if (ape->seektablelength > 0) {

283 ape->seektable = av_mallocz(ape->seektablelength);

284 if (!ape->seektable)

285 return AVERROR(ENOMEM);

286 for (i = 0; i < ape->seektablelength / sizeof(uint32_t) && !pb->eof_reached; i++)

287 ape->seektable[i] = avio_rl32(pb);

288 if (ape->fileversion < 3810) {

289 ape->bittable = av_mallocz(ape->totalframes);

290 if (!ape->bittable)

291 return AVERROR(ENOMEM);

292 for (i = 0; i < ape->totalframes && !pb->eof_reached; i++)

293 ape->bittable[i] = avio_r8(pb);

294 }

295 if (pb->eof_reached)

296 av_log(s, AV_LOG_WARNING, "File truncated\n");

297 }

298

299 ape->frames[0].pos = ape->firstframe;

300 ape->frames[0].nblocks = ape->blocksperframe;

301 ape->frames[0].skip = 0;

302 for (i = 1; i < ape->totalframes; i++) {

303 ape->frames[i].pos = ape->seektable[i] + ape->junklength;

304 ape->frames[i].nblocks = ape->blocksperframe;

305 ape->frames[i - 1].size = ape->frames[i].pos - ape->frames[i - 1].pos;

306 ape->frames[i].skip = (ape->frames[i].pos - ape->frames[0].pos) & 3;

307 }

308 ape->frames[ape->totalframes - 1].nblocks = ape->finalframeblocks;

309 /* calculate final packet size from total file size, if available */

310 file_size = avio_size(pb);

311 if (file_size > 0) {

312 final_size = file_size - ape->frames[ape->totalframes - 1].pos -

313 ape->wavtaillength;

314 final_size -= final_size & 3;

315 }

316 if (file_size <= 0 || final_size <= 0)

317 final_size = ape->finalframeblocks * 8;

318 ape->frames[ape->totalframes - 1].size = final_size;

319

320 for (i = 0; i < ape->totalframes; i++) {

321 if(ape->frames[i].skip){

322 ape->frames[i].pos -= ape->frames[i].skip;

323 ape->frames[i].size += ape->frames[i].skip;

324 }

325 ape->frames[i].size = (ape->frames[i].size + 3) & ~3;

326 }

327 if (ape->fileversion < 3810) {

328 for (i = 0; i < ape->totalframes; i++) {

329 if (i < ape->totalframes - 1 && ape->bittable[i + 1])

330 ape->frames[i].size += 4;

331 ape->frames[i].skip <<= 3;

332 ape->frames[i].skip += ape->bittable[i];

333 }

334 }

335

336 ape_dumpinfo(s, ape);

337

338 av_log(s, AV_LOG_VERBOSE, "Decoding file - v%d.%02d, compression level %"PRIu16"\n",

339 ape->fileversion / 1000, (ape->fileversion % 1000) / 10,

340 ape->compressiontype);

341

342 /* now we are ready: build format streams */

343 st = avformat_new_stream(s, NULL);

344 if (!st)

345 return AVERROR(ENOMEM);

346

347 total_blocks = (ape->totalframes == 0) ? 0 : ((ape->totalframes - 1) * ape->blocksperframe) + ape->finalframeblocks;

348

349 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

350 st->codecpar->codec_id = AV_CODEC_ID_APE;

351 st->codecpar->codec_tag = MKTAG('A', 'P', 'E', ' ');

352 st->codecpar->channels = ape->channels;

353 st->codecpar->sample_rate = ape->samplerate;

354 st->codecpar->bits_per_coded_sample = ape->bps;

355

356 st->nb_frames = ape->totalframes;

357 st->start_time = 0;

358 st->duration = total_blocks;

359 avpriv_set_pts_info(st, 64, 1, ape->samplerate);

360

361 if (ff_alloc_extradata(st->codecpar, APE_EXTRADATA_SIZE))

362 return AVERROR(ENOMEM);

363 AV_WL16(st->codecpar->extradata + 0, ape->fileversion);

364 AV_WL16(st->codecpar->extradata + 2, ape->compressiontype);

365 AV_WL16(st->codecpar->extradata + 4, ape->formatflags);

366

367 pts = 0;

368 for (i = 0; i < ape->totalframes; i++) {

369 ape->frames[i].pts = pts;

370 av_add_index_entry(st, ape->frames[i].pos, ape->frames[i].pts, 0, 0, AVINDEX_KEYFRAME);

371 pts += ape->blocksperframe;

372 }

373

374 /* try to read APE tags */

375 if (pb->seekable & AVIO_SEEKABLE_NORMAL) {

376 ff_ape_parse_tag(s);

377 avio_seek(pb, 0, SEEK_SET);

378 }

379

380 return 0;

381 }

382

383 static int ape_read_packet(AVFormatContext * s, AVPacket * pkt)

384 {

385 int ret;

386 int nblocks;

387 APEContext *ape = s->priv_data;

388 uint32_t extra_size = 8;

389

390 if (avio_feof(s->pb))

391 return AVERROR_EOF;

392 if (ape->currentframe >= ape->totalframes)

393 return AVERROR_EOF;

394

395 if (avio_seek(s->pb, ape->frames[ape->currentframe].pos, SEEK_SET) < 0)

396 return AVERROR(EIO);

397

398 /* Calculate how many blocks there are in this frame */

399 if (ape->currentframe == (ape->totalframes - 1))

400 nblocks = ape->finalframeblocks;

401 else

402 nblocks = ape->blocksperframe;

403

404 if (ape->frames[ape->currentframe].size <= 0 ||

405 ape->frames[ape->currentframe].size > INT_MAX - extra_size) {

406 av_log(s, AV_LOG_ERROR, "invalid packet size: %d\n",

407 ape->frames[ape->currentframe].size);

408 ape->currentframe++;

409 return AVERROR(EIO);

410 }

411

412 if (av_new_packet(pkt, ape->frames[ape->currentframe].size + extra_size) < 0)

413 return AVERROR(ENOMEM);

414

415 AV_WL32(pkt->data , nblocks);

416 AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip);

417 ret = avio_read(s->pb, pkt->data + extra_size, ape->frames[ape->currentframe].size);

418 if (ret < 0) {

419 av_packet_unref(pkt);

420 return ret;

421 }

422

423 pkt->pts = ape->frames[ape->currentframe].pts;

424 pkt->stream_index = 0;

425

426 /* note: we need to modify the packet size here to handle the last

427 packet */

428 pkt->size = ret + extra_size;

429

430 ape->currentframe++;

431

432 return 0;

433 }

434

435 static int ape_read_close(AVFormatContext * s)

436 {

437 APEContext *ape = s->priv_data;

438

439 av_freep(&ape->frames);

440 av_freep(&ape->seektable);

441 av_freep(&ape->bittable);

442 return 0;

443 }

444

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

446 {

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

448 APEContext *ape = s->priv_data;

449 int index = av_index_search_timestamp(st, timestamp, flags);

450

451 if (index < 0)

452 return -1;

453

454 if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0)

455 return -1;

456 ape->currentframe = index;

457 return 0;

458 }

459

460 AVInputFormat ff_ape_demuxer = {

461 .name = "ape",

462 .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),

463 .priv_data_size = sizeof(APEContext),

464 .read_probe = ape_probe,

465 .read_header = ape_read_header,

466 .read_packet = ape_read_packet,

467 .read_close = ape_read_close,

468 .read_seek = ape_read_seek,

469 .extensions = "ape,apl,mac",

470 };

APEContext::audiodatalength

uint32_t audiodatalength

Definition: ape.c:66

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:768

ape_read_close

static int ape_read_close(AVFormatContext *s)

Definition: ape.c:435

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:336

APEContext::wavtaillength

uint32_t wavtaillength

Definition: ape.c:68

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: utils.c:2038

APEContext::fileversion

int fileversion

codec version, very important in decoding process

Definition: apedec.c:145

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

APEContext::blocksperframe

uint32_t blocksperframe

Definition: ape.c:74

avpriv_set_pts_info

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

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

Definition: utils.c:4820

AVIndexEntry::pos

int64_t pos

Definition: avformat.h:803

MAC_FORMAT_FLAG_24_BIT

#define MAC_FORMAT_FLAG_24_BIT

Definition: ape.c:37

APEContext::wavheaderlength

uint32_t wavheaderlength

Definition: ape.c:65

read_seek

static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)

Definition: libcdio.c:153

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: avcodec.h:3884

AVPacket::size

int size

Definition: avcodec.h:1431

APEContext::channels

uint16_t channels

Definition: ape.c:78

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:246

AVStream::index_entries

AVIndexEntry * index_entries

Only used if the format does not support seeking natively.

Definition: avformat.h:1102

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:331

version

int version

Definition: avisynth_c.h:766

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

AVInputFormat

Definition: avformat.h:642

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

APEContext::currentframe

int currentframe

Definition: ape.c:56

APEContext::seektable

uint32_t * seektable

Definition: ape.c:82

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:87

MAC_FORMAT_FLAG_HAS_PEAK_LEVEL

#define MAC_FORMAT_FLAG_HAS_PEAK_LEVEL

Definition: ape.c:36

AVFormatContext

Format I/O context.

Definition: avformat.h:1342

APEContext::fileversion

int16_t fileversion

Definition: ape.c:60

uint8_t

Definition: audio_convert.c:194

ape_read_seek

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

Definition: ape.c:445

ape_probe

static int ape_probe(AVProbeData *p)

Definition: ape.c:86

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:4450

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1410

APEContext::seektablelength

uint32_t seektablelength

Definition: ape.c:64

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

flags

static int flags

Definition: log.c:55

tag

uint32_t tag

Definition: movenc.c:1455

APEContext::frames

APEFrame * frames

Definition: ape.c:57

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:145

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:557

MAC_FORMAT_FLAG_8_BIT

#define MAC_FORMAT_FLAG_8_BIT

Definition: ape.c:34

APEContext

Decoder context.

Definition: apedec.c:136

APEContext::compressiontype

uint16_t compressiontype

Definition: ape.c:72

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

avio_read

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

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:648

av_new_packet

int av_new_packet(AVPacket *pkt, int size)

Allocate the payload of a packet and initialize its fields with default values.

Definition: avpacket.c:86

AVINDEX_KEYFRAME

#define AVINDEX_KEYFRAME

Definition: avformat.h:810

APEContext::bps

int bps

Definition: apedec.c:143

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

av_index_search_timestamp

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

Get the index for a specific timestamp.

Definition: utils.c:2147

APEContext::samplerate

uint32_t samplerate

Definition: ape.c:79

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:770

AVERROR

#define AVERROR(e)

Definition: error.h:43

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

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:3880

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

internal.h

APEContext::md5

uint8_t md5[16]

Definition: ape.c:69

MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS

#define MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS

Definition: ape.c:38

ff_ape_parse_tag

int64_t ff_ape_parse_tag(AVFormatContext *s)

Read and parse an APE tag.

Definition: apetag.c:118

APEFrame::skip

int skip

Definition: ape.c:47

APEContext::totalsamples

uint32_t totalsamples

Definition: ape.c:55

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:639

AVProbeData::buf

unsigned char * buf

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

Definition: avformat.h:450

APEFrame::size

int size

Definition: ape.c:46

AVIOContext::seekable

int seekable

A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.

Definition: avio.h:260

ff_alloc_extradata

int ff_alloc_extradata(AVCodecParameters *par, int size)

Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...

Definition: utils.c:3280

APEFrame::pos

int64_t pos

Definition: ape.c:44

read_probe

static int read_probe(AVProbeData *pd)

Definition: jvdec.c:55

intreadwrite.h

apetag.h

ape_read_packet

static int ape_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: ape.c:383

APEContext::finalframeblocks

uint32_t finalframeblocks

Definition: ape.c:75

int32_t

Definition: audio_convert.c:194

APEContext::junklength

uint32_t junklength

Definition: ape.c:53

APEContext::formatflags

uint16_t formatflags

Definition: ape.c:73

ff_ape_demuxer

AVInputFormat ff_ape_demuxer

Definition: ape.c:460

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:530

APEFrame

Definition: ape.c:43

AVStream

Stream structure.

Definition: avformat.h:873

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_reading.c:42

AVIO_SEEKABLE_NORMAL

#define AVIO_SEEKABLE_NORMAL

Seeking works like for a local file.

Definition: avio.h:40

APEContext::bps

uint16_t bps

Definition: ape.c:77

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1384

APEContext::totalframes

uint32_t totalframes

Definition: ape.c:76

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:592

ape_read_header

static int ape_read_header(AVFormatContext *s)

Definition: ape.c:160

APEContext::headerlength

uint32_t headerlength

Definition: ape.c:63

APE_MIN_VERSION

#define APE_MIN_VERSION

Definition: ape.c:31

index

int index

Definition: gxfenc.c:89

AVProbeData

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

Definition: avformat.h:448

APEContext::bittable

uint8_t * bittable

Definition: ape.c:83

pts

static int64_t pts

Definition: transcode_aac.c:647

SIZE_SPECIFIER

#define SIZE_SPECIFIER

Definition: internal.h:262

AVStream::duration

int64_t duration

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

Definition: avformat.h:922

APEContext::descriptorlength

uint32_t descriptorlength

Definition: ape.c:62

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: avcodec.h:3994

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:460

APEFrame::pts

int64_t pts

Definition: ape.c:48

APE_MAX_VERSION

#define APE_MAX_VERSION

Definition: ape.c:32

avio_rl16

unsigned int avio_rl16(AVIOContext *s)

Definition: aviobuf.c:754

avformat.h

Main libavformat public API header.

if(ret< 0)

Definition: vf_mcdeint.c:279

AVStream::start_time

int64_t start_time

Decoding: pts of the first frame of the stream in presentation order, in stream time base...

Definition: avformat.h:912

AV_WL16

#define AV_WL16(p, v)

Definition: intreadwrite.h:412

AVStream::nb_frames

int64_t nb_frames

number of frames in this stream if known or 0

Definition: avformat.h:924

AVIOContext::eof_reached

int eof_reached

true if eof reached

Definition: avio.h:239

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1370

APE_EXTRADATA_SIZE

#define APE_EXTRADATA_SIZE

Definition: ape.c:41

APEContext::firstframe

uint32_t firstframe

Definition: ape.c:54

AVCodecParameters::bits_per_coded_sample

int bits_per_coded_sample

The number of bits per sample in the codedwords.

Definition: avcodec.h:3926

AVCodecParameters::extradata

uint8_t * extradata

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

Definition: avcodec.h:3898

APEContext::padding1

int16_t padding1

Definition: ape.c:61

AVCodecParameters::channels

int channels

Audio only.

Definition: avcodec.h:3990

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:647

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1020

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

avio_feof

int avio_feof(AVIOContext *s)

feof() equivalent for AVIOContext.

Definition: aviobuf.c:358

APEFrame::nblocks

int nblocks

Definition: ape.c:45

AVCodecParameters::codec_tag

uint32_t codec_tag

Additional information about the codec (corresponds to the AVI FOURCC).

Definition: avcodec.h:3888

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1432

ape_dumpinfo

static void ape_dumpinfo(AVFormatContext *s, APEContext *ape_ctx)

Definition: ape.c:98

MKTAG

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

Definition: common.h:366

APEContext::audiodatalength_high

uint32_t audiodatalength_high

Definition: ape.c:67

APEContext::channels

int channels

Definition: apedec.c:141

MAC_FORMAT_FLAG_CREATE_WAV_HEADER

#define MAC_FORMAT_FLAG_CREATE_WAV_HEADER

Definition: ape.c:39

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:87

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

AVPacket::pts

int64_t pts

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

Definition: avcodec.h:1423

AV_CODEC_ID_APE

Definition: avcodec.h:583

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:426

Generated on Sun May 13 2018 02:04:04 for FFmpeg by doxygen 1.8.6