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 char magic[4];

61 int16_t fileversion;

62 int16_t padding1;

63 uint32_t descriptorlength;

64 uint32_t headerlength;

65 uint32_t seektablelength;

66 uint32_t wavheaderlength;

67 uint32_t audiodatalength;

68 uint32_t audiodatalength_high;

69 uint32_t wavtaillength;

70 uint8_t md5[16];

72 /* Info from Header Block */

73 uint16_t compressiontype;

74 uint16_t formatflags;

75 uint32_t blocksperframe;

76 uint32_t finalframeblocks;

77 uint32_t totalframes;

78 uint16_t bps;

79 uint16_t channels;

80 uint32_t samplerate;

82 /* Seektable */

83 uint32_t *seektable;

84 uint8_t *bittable;

85 } APEContext;

87 static int ape_probe(AVProbeData * p)

88 {

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

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

91 return 0;

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

94 return AVPROBE_SCORE_MAX/4;

96 return AVPROBE_SCORE_MAX;

97 }

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

100 {

101 #ifdef DEBUG

102 int i;

103

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

105 av_log(s, AV_LOG_DEBUG, "magic = \"%c%c%c%c\"\n", ape_ctx->magic[0], ape_ctx->magic[1], ape_ctx->magic[2], ape_ctx->magic[3]);

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

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

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

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

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

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

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

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

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

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

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

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

118

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

120

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

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

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

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

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

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

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

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

129

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

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

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

133 } else {

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

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

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

137 i, ape_ctx->seektable[i],

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

139 if (ape_ctx->bittable)

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

141 ape_ctx->bittable[i]);

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

143 } else {

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

145 }

146 }

147 }

148

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

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

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

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

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

154

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

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

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

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

159 #endif

160 }

161

162 static int ape_read_header(AVFormatContext * s)

163 {

164 AVIOContext *pb = s->pb;

165 APEContext *ape = s->priv_data;

166 AVStream *st;

167 uint32_t tag;

168 int i;

169 int total_blocks, final_size = 0;

170 int64_t pts, file_size;

171

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

173 ape->junklength = avio_tell(pb);

174

175 tag = avio_rl32(pb);

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

177 return AVERROR_INVALIDDATA;

178

179 ape->fileversion = avio_rl16(pb);

180

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

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

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

184 return AVERROR_PATCHWELCOME;

185 }

186

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

188 ape->padding1 = avio_rl16(pb);

189 ape->descriptorlength = avio_rl32(pb);

190 ape->headerlength = avio_rl32(pb);

191 ape->seektablelength = avio_rl32(pb);

192 ape->wavheaderlength = avio_rl32(pb);

193 ape->audiodatalength = avio_rl32(pb);

194 ape->audiodatalength_high = avio_rl32(pb);

195 ape->wavtaillength = avio_rl32(pb);

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

197

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

199 This is for future compatibility */

200 if (ape->descriptorlength > 52)

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

202

203 /* Read header data */

204 ape->compressiontype = avio_rl16(pb);

205 ape->formatflags = avio_rl16(pb);

206 ape->blocksperframe = avio_rl32(pb);

207 ape->finalframeblocks = avio_rl32(pb);

208 ape->totalframes = avio_rl32(pb);

209 ape->bps = avio_rl16(pb);

210 ape->channels = avio_rl16(pb);

211 ape->samplerate = avio_rl32(pb);

212 } else {

213 ape->descriptorlength = 0;

214 ape->headerlength = 32;

215

216 ape->compressiontype = avio_rl16(pb);

217 ape->formatflags = avio_rl16(pb);

218 ape->channels = avio_rl16(pb);

219 ape->samplerate = avio_rl32(pb);

220 ape->wavheaderlength = avio_rl32(pb);

221 ape->wavtaillength = avio_rl32(pb);

222 ape->totalframes = avio_rl32(pb);

223 ape->finalframeblocks = avio_rl32(pb);

224

225 if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) {

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

227 ape->headerlength += 4;

228 }

229

230 if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) {

231 ape->seektablelength = avio_rl32(pb);

232 ape->headerlength += 4;

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

234 } else

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

236

237 if (ape->formatflags & MAC_FORMAT_FLAG_8_BIT)

238 ape->bps = 8;

239 else if (ape->formatflags & MAC_FORMAT_FLAG_24_BIT)

240 ape->bps = 24;

241 else

242 ape->bps = 16;

243

244 if (ape->fileversion >= 3950)

245 ape->blocksperframe = 73728 * 4;

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

247 ape->blocksperframe = 73728;

248 else

249 ape->blocksperframe = 9216;

250

251 /* Skip any stored wav header */

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

253 avio_skip(pb, ape->wavheaderlength);

254 }

255

256 if(!ape->totalframes){

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

258 return AVERROR(EINVAL);

259 }

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

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

262 ape->totalframes);

263 return AVERROR_INVALIDDATA;

264 }

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

266 av_log(s, AV_LOG_ERROR,

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

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

269 return AVERROR_INVALIDDATA;

270 }

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

272 if(!ape->frames)

273 return AVERROR(ENOMEM);

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

275 if (ape->fileversion < 3810)

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

277 ape->currentframe = 0;

278

279

280 ape->totalsamples = ape->finalframeblocks;

281 if (ape->totalframes > 1)

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

283

284 if (ape->seektablelength > 0) {

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

286 if (!ape->seektable)

287 return AVERROR(ENOMEM);

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

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

290 if (ape->fileversion < 3810) {

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

292 if (!ape->bittable)

293 return AVERROR(ENOMEM);

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

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

296 }

297 if (pb->eof_reached)

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

299 }

300

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

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

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

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

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

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

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

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

309 }

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

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

312 file_size = avio_size(pb);

313 if (file_size > 0) {

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

315 ape->wavtaillength;

316 final_size -= final_size & 3;

317 }

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

319 final_size = ape->finalframeblocks * 8;

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

321

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

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

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

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

326 }

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

328 }

329 if (ape->fileversion < 3810) {

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

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

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

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

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

335 }

336 }

337

338 ape_dumpinfo(s, ape);

339

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

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

342 ape->compressiontype);

343

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

345 st = avformat_new_stream(s, NULL);

346 if (!st)

347 return AVERROR(ENOMEM);

348

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

350

351 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

352 st->codec->codec_id = AV_CODEC_ID_APE;

353 st->codec->codec_tag = MKTAG('A', 'P', 'E', ' ');

354 st->codec->channels = ape->channels;

355 st->codec->sample_rate = ape->samplerate;

356 st->codec->bits_per_coded_sample = ape->bps;

357

358 st->nb_frames = ape->totalframes;

359 st->start_time = 0;

360 st->duration = total_blocks;

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

362

363 if (ff_alloc_extradata(st->codec, APE_EXTRADATA_SIZE))

364 return AVERROR(ENOMEM);

365 AV_WL16(st->codec->extradata + 0, ape->fileversion);

366 AV_WL16(st->codec->extradata + 2, ape->compressiontype);

367 AV_WL16(st->codec->extradata + 4, ape->formatflags);

368

369 pts = 0;

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

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

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

373 pts += ape->blocksperframe;

374 }

375

376 /* try to read APE tags */

377 if (pb->seekable) {

378 ff_ape_parse_tag(s);

379 avio_seek(pb, 0, SEEK_SET);

380 }

381

382 return 0;

383 }

384

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

386 {

387 int ret;

388 int nblocks;

389 APEContext *ape = s->priv_data;

390 uint32_t extra_size = 8;

391

392 if (avio_feof(s->pb))

393 return AVERROR_EOF;

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

395 return AVERROR_EOF;

396

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

398 return AVERROR(EIO);

399

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

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

402 nblocks = ape->finalframeblocks;

403 else

404 nblocks = ape->blocksperframe;

405

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

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

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

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

410 ape->currentframe++;

411 return AVERROR(EIO);

412 }

413

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

415 return AVERROR(ENOMEM);

416

417 AV_WL32(pkt->data , nblocks);

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

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

420 if (ret < 0) {

421 av_packet_unref(pkt);

422 return ret;

423 }

424

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

426 pkt->stream_index = 0;

427

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

429 packet */

430 pkt->size = ret + extra_size;

431

432 ape->currentframe++;

433

434 return 0;

435 }

436

437 static int ape_read_close(AVFormatContext * s)

438 {

439 APEContext *ape = s->priv_data;

440

441 av_freep(&ape->frames);

442 av_freep(&ape->seektable);

443 av_freep(&ape->bittable);

444 return 0;

445 }

446

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

448 {

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

450 APEContext *ape = s->priv_data;

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

452

453 if (index < 0)

454 return -1;

455

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

457 return -1;

458 ape->currentframe = index;

459 return 0;

460 }

461

462 AVInputFormat ff_ape_demuxer = {

463 .name = "ape",

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

465 .priv_data_size = sizeof(APEContext),

466 .read_probe = ape_probe,

467 .read_header = ape_read_header,

468 .read_packet = ape_read_packet,

469 .read_close = ape_read_close,

470 .read_seek = ape_read_seek,

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

472 };

APEContext::audiodatalength

uint32_t audiodatalength

Definition: ape.c:67

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:631

ape_read_close

static int ape_read_close(AVFormatContext *s)

Definition: ape.c:437

AVIOContext

Bytestream IO Context.

Definition: avio.h:111

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

APEContext::wavtaillength

uint32_t wavtaillength

Definition: ape.c:69

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

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

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

AVIndexEntry::pos

int64_t pos

Definition: avformat.h:817

MAC_FORMAT_FLAG_24_BIT

#define MAC_FORMAT_FLAG_24_BIT

Definition: ape.c:37

APEContext::wavheaderlength

uint32_t wavheaderlength

Definition: ape.c:66

read_seek

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

Definition: libcdio.c:153

AVPacket::size

int size

Definition: avcodec.h:1468

APEContext::channels

uint16_t channels

Definition: ape.c:79

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:208

AVStream::index_entries

AVIndexEntry * index_entries

Only used if the format does not support seeking natively.

Definition: avformat.h:1080

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:282

version

int version

Definition: avisynth_c.h:629

AVInputFormat

Definition: avformat.h:656

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

APEContext::magic

char magic[4]

Definition: ape.c:60

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

APEContext::fileversion

int16_t fileversion

Definition: ape.c:61

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

ape_probe

static int ape_probe(AVProbeData *p)

Definition: ape.c:87

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1647

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:3805

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1382

APEContext::seektablelength

uint32_t seektablelength

Definition: ape.c:65

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

tag

uint32_t tag

Definition: movenc.c:1348

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

MAC_FORMAT_FLAG_8_BIT

#define MAC_FORMAT_FLAG_8_BIT

Definition: ape.c:34

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:2917

APEContext

Decoder context.

Definition: apedec.c:136

APEContext::compressiontype

uint16_t compressiontype

Definition: ape.c:73

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

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

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

APEContext::samplerate

uint32_t samplerate

Definition: ape.c:80

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:667

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

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:194

internal.h

APEContext::md5

uint8_t md5[16]

Definition: ape.c:70

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

AVStream::codec

AVCodecContext * codec

Codec context associated with this stream.

Definition: avformat.h:896

AVProbeData::buf

unsigned char * buf

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

Definition: avformat.h:462

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

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

APEContext::finalframeblocks

uint32_t finalframeblocks

Definition: ape.c:76

int32_t

Definition: audio_convert.c:194

APEContext::junklength

uint32_t junklength

Definition: ape.c:53

APEContext::formatflags

uint16_t formatflags

Definition: ape.c:74

ff_ape_demuxer

AVInputFormat ff_ape_demuxer

Definition: ape.c:462

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:638

APEFrame

Definition: ape.c:43

AVStream

Stream structure.

Definition: avformat.h:877

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

AVCodecContext::codec_type

enum AVMediaType codec_type

Definition: avcodec.h:1540

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1549

APEContext::bps

uint16_t bps

Definition: ape.c:78

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:2287

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1356

APEContext::totalframes

uint32_t totalframes

Definition: ape.c:77

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:545

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:1564

ape_read_header

static int ape_read_header(AVFormatContext *s)

Definition: ape.c:162

ff_alloc_extradata

int ff_alloc_extradata(AVCodecContext *avctx, int size)

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

Definition: utils.c:2979

APEContext::headerlength

uint32_t headerlength

Definition: ape.c:64

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

APEContext::bittable

uint8_t * bittable

Definition: ape.c:84

pts

static int64_t pts

Global timestamp for the audio frames.

Definition: transcode_aac.c:547

SIZE_SPECIFIER

#define SIZE_SPECIFIER

Definition: internal.h:251

flags

static int flags

Definition: cpu.c:47

AVStream::duration

int64_t duration

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

Definition: avformat.h:936

APEContext::descriptorlength

uint32_t descriptorlength

Definition: ape.c:63

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:472

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

avformat.h

Main libavformat public API header.

if(ret< 0)

Definition: vf_mcdeint.c:282

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

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

AVIOContext::eof_reached

int eof_reached

true if eof reached

Definition: avio.h:186

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2288

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1342

APE_EXTRADATA_SIZE

#define APE_EXTRADATA_SIZE

Definition: ape.c:41

APEContext::firstframe

uint32_t firstframe

Definition: ape.c:54

APEContext::padding1

int16_t padding1

Definition: ape.c:62

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

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

APEFrame::nblocks

int nblocks

Definition: ape.c:45

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1469

ape_dumpinfo

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

Definition: ape.c:99

MKTAG

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

Definition: common.h:342

APEContext::audiodatalength_high

uint32_t audiodatalength_high

Definition: ape.c:68

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

av_mallocz

void * av_mallocz(size_t size)

Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...

Definition: mem.c:252

AVPacket::pts

int64_t pts

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

Definition: avcodec.h:1460

AV_CODEC_ID_APE

Definition: avcodec.h:454

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:426

Generated on Mon Feb 15 2016 15:20:45 for FFmpeg by doxygen 1.8.6