FFmpeg: libavformat/r3d.c Source File

FFmpeg

[フレーム]

libavformat

r3d.c

Go to the documentation of this file.

1 /*

2 * R3D REDCODE 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/intreadwrite.h"

23 #include "libavutil/dict.h"

24 #include "libavutil/mathematics.h"

25 #include "avformat.h"

26 #include "internal.h"

28 typedef struct R3DContext {

29 unsigned video_offsets_count;

30 unsigned *video_offsets;

31 unsigned rdvo_offset;

33 int audio_channels;

34 } R3DContext;

36 typedef struct Atom {

37 unsigned size;

38 uint32_t tag;

39 uint64_t offset;

40 } Atom;

42 static int read_atom(AVFormatContext *s, Atom *atom)

43 {

44 atom->offset = avio_tell(s->pb);

45 atom->size = avio_rb32(s->pb);

46 if (atom->size < 8)

47 return -1;

48 atom->tag = avio_rl32(s->pb);

49 av_log(s, AV_LOG_TRACE, "atom %u %.4s offset %#"PRIx64"\n",

50 atom->size, (char*)&atom->tag, atom->offset);

51 return atom->size;

52 }

54 static int r3d_read_red1(AVFormatContext *s)

55 {

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

57 R3DContext *r3d = s->priv_data;

58 char filename[258];

59 int tmp;

60 int av_unused tmp2;

61 AVRational framerate;

63 if (!st)

64 return AVERROR(ENOMEM);

65 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

66 st->codecpar->codec_id = AV_CODEC_ID_JPEG2000;

68 tmp = avio_r8(s->pb); // major version

69 tmp2 = avio_r8(s->pb); // minor version

70 av_log(s, AV_LOG_TRACE, "version %d.%d\n", tmp, tmp2);

72 tmp = avio_rb16(s->pb); // unknown

73 av_log(s, AV_LOG_TRACE, "unknown1 %d\n", tmp);

75 tmp = avio_rb32(s->pb);

76 avpriv_set_pts_info(st, 32, 1, tmp);

78 tmp = avio_rb32(s->pb); // filenum

79 av_log(s, AV_LOG_TRACE, "filenum %d\n", tmp);

81 avio_skip(s->pb, 32); // unknown

83 st->codecpar->width = avio_rb32(s->pb);

84 st->codecpar->height = avio_rb32(s->pb);

86 tmp = avio_rb16(s->pb); // unknown

87 av_log(s, AV_LOG_TRACE, "unknown2 %d\n", tmp);

89 framerate.num = avio_rb16(s->pb);

90 framerate.den = avio_rb16(s->pb);

91 if (framerate.num > 0 && framerate.den > 0) {

92 #if FF_API_R_FRAME_RATE

93 st->r_frame_rate =

94 #endif

95 st->avg_frame_rate = framerate;

96 }

98 r3d->audio_channels = avio_r8(s->pb); // audio channels

99 av_log(s, AV_LOG_TRACE, "audio channels %d\n", tmp);

100

101 avio_read(s->pb, filename, 257);

102 filename[sizeof(filename)-1] = 0;

103 av_dict_set(&st->metadata, "filename", filename, 0);

104

105 av_log(s, AV_LOG_TRACE, "filename %s\n", filename);

106 av_log(s, AV_LOG_TRACE, "resolution %dx%d\n", st->codecpar->width, st->codecpar->height);

107 av_log(s, AV_LOG_TRACE, "timescale %d\n", st->time_base.den);

108 av_log(s, AV_LOG_TRACE, "frame rate %d/%d\n",

109 framerate.num, framerate.den);

110

111 return 0;

112 }

113

114 static int r3d_read_rdvo(AVFormatContext *s, Atom *atom)

115 {

116 R3DContext *r3d = s->priv_data;

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

118 int i;

119

120 r3d->video_offsets_count = (atom->size - 8) / 4;

121 r3d->video_offsets = av_malloc(atom->size);

122 if (!r3d->video_offsets)

123 return AVERROR(ENOMEM);

124

125 for (i = 0; i < r3d->video_offsets_count; i++) {

126 r3d->video_offsets[i] = avio_rb32(s->pb);

127 if (!r3d->video_offsets[i]) {

128 r3d->video_offsets_count = i;

129 break;

130 }

131 av_log(s, AV_LOG_TRACE, "video offset %d: %#x\n", i, r3d->video_offsets[i]);

132 }

133

134 if (st->avg_frame_rate.num)

135 st->duration = av_rescale_q(r3d->video_offsets_count,

136 av_inv_q(st->avg_frame_rate),

137 st->time_base);

138 av_log(s, AV_LOG_TRACE, "duration %"PRId64"\n", st->duration);

139

140 return 0;

141 }

142

143 static void r3d_read_reos(AVFormatContext *s)

144 {

145 R3DContext *r3d = s->priv_data;

146 int av_unused tmp;

147

148 r3d->rdvo_offset = avio_rb32(s->pb);

149 avio_rb32(s->pb); // rdvs offset

150 avio_rb32(s->pb); // rdao offset

151 avio_rb32(s->pb); // rdas offset

152

153 tmp = avio_rb32(s->pb);

154 av_log(s, AV_LOG_TRACE, "num video chunks %d\n", tmp);

155

156 tmp = avio_rb32(s->pb);

157 av_log(s, AV_LOG_TRACE, "num audio chunks %d\n", tmp);

158

159 avio_skip(s->pb, 6*4);

160 }

161

162 static int r3d_read_header(AVFormatContext *s)

163 {

164 R3DContext *r3d = s->priv_data;

165 Atom atom;

166 int ret;

167

168 if (read_atom(s, &atom) < 0) {

169 av_log(s, AV_LOG_ERROR, "error reading atom\n");

170 return -1;

171 }

172 if (atom.tag == MKTAG('R','E','D','1')) {

173 if ((ret = r3d_read_red1(s)) < 0) {

174 av_log(s, AV_LOG_ERROR, "error parsing 'red1' atom\n");

175 return ret;

176 }

177 } else {

178 av_log(s, AV_LOG_ERROR, "could not find 'red1' atom\n");

179 return -1;

180 }

181

182 /* we cannot create the audio stream now because we do not know the

183 * sample rate */

184 if (r3d->audio_channels)

185 s->ctx_flags |= AVFMTCTX_NOHEADER;

186

187 s->internal->data_offset = avio_tell(s->pb);

188 av_log(s, AV_LOG_TRACE, "data offset %#"PRIx64"\n", s->internal->data_offset);

189 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))

190 return 0;

191 // find REOB/REOF/REOS to load index

192 avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET);

193 if (read_atom(s, &atom) < 0)

194 av_log(s, AV_LOG_ERROR, "error reading end atom\n");

195

196 if (atom.tag != MKTAG('R','E','O','B') &&

197 atom.tag != MKTAG('R','E','O','F') &&

198 atom.tag != MKTAG('R','E','O','S'))

199 goto out;

200

201 r3d_read_reos(s);

202

203 if (r3d->rdvo_offset) {

204 avio_seek(s->pb, r3d->rdvo_offset, SEEK_SET);

205 if (read_atom(s, &atom) < 0)

206 av_log(s, AV_LOG_ERROR, "error reading 'rdvo' atom\n");

207 if (atom.tag == MKTAG('R','D','V','O')) {

208 if (r3d_read_rdvo(s, &atom) < 0)

209 av_log(s, AV_LOG_ERROR, "error parsing 'rdvo' atom\n");

210 }

211 }

212

213 out:

214 avio_seek(s->pb, s->internal->data_offset, SEEK_SET);

215 return 0;

216 }

217

218 static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)

219 {

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

221 int tmp;

222 int av_unused tmp2;

223 int64_t pos = avio_tell(s->pb);

224 unsigned dts;

225 int ret;

226

227 dts = avio_rb32(s->pb);

228

229 tmp = avio_rb32(s->pb);

230 av_log(s, AV_LOG_TRACE, "frame num %d\n", tmp);

231

232 tmp = avio_r8(s->pb); // major version

233 tmp2 = avio_r8(s->pb); // minor version

234 av_log(s, AV_LOG_TRACE, "version %d.%d\n", tmp, tmp2);

235

236 tmp = avio_rb16(s->pb); // unknown

237 av_log(s, AV_LOG_TRACE, "unknown %d\n", tmp);

238

239 if (tmp > 4) {

240 tmp = avio_rb16(s->pb); // unknown

241 av_log(s, AV_LOG_TRACE, "unknown %d\n", tmp);

242

243 tmp = avio_rb16(s->pb); // unknown

244 av_log(s, AV_LOG_TRACE, "unknown %d\n", tmp);

245

246 tmp = avio_rb32(s->pb);

247 av_log(s, AV_LOG_TRACE, "width %d\n", tmp);

248 tmp = avio_rb32(s->pb);

249 av_log(s, AV_LOG_TRACE, "height %d\n", tmp);

250

251 tmp = avio_rb32(s->pb);

252 av_log(s, AV_LOG_TRACE, "metadata len %d\n", tmp);

253 }

254 tmp = atom->size - 8 - (avio_tell(s->pb) - pos);

255 if (tmp < 0)

256 return -1;

257 ret = av_get_packet(s->pb, pkt, tmp);

258 if (ret < 0) {

259 av_log(s, AV_LOG_ERROR, "error reading video packet\n");

260 return -1;

261 }

262

263 pkt->stream_index = 0;

264 pkt->dts = dts;

265 if (st->avg_frame_rate.num)

266 pkt->duration = (uint64_t)st->time_base.den*

267 st->avg_frame_rate.den/st->avg_frame_rate.num;

268 av_log(s, AV_LOG_TRACE, "pkt dts %"PRId64" duration %"PRId64"\n", pkt->dts, pkt->duration);

269

270 return 0;

271 }

272

273 static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)

274 {

275 R3DContext *r3d = s->priv_data;

276 AVStream *st;

277 int av_unused tmp, tmp2;

278 int samples, size;

279 int64_t pos = avio_tell(s->pb);

280 unsigned dts;

281 int ret;

282

283 if (s->nb_streams < 2) {

284 st = avformat_new_stream(s, NULL);

285 if (!st)

286 return AVERROR(ENOMEM);

287 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

288 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;

289 st->codecpar->channels = r3d->audio_channels;

290 avpriv_set_pts_info(st, 32, 1, s->streams[0]->time_base.den);

291 } else {

292 st = s->streams[1];

293 }

294

295 dts = avio_rb32(s->pb);

296

297 st->codecpar->sample_rate = avio_rb32(s->pb);

298 if (st->codecpar->sample_rate <= 0) {

299 av_log(s, AV_LOG_ERROR, "Bad sample rate\n");

300 return AVERROR_INVALIDDATA;

301 }

302

303 samples = avio_rb32(s->pb);

304

305 tmp = avio_rb32(s->pb);

306 av_log(s, AV_LOG_TRACE, "packet num %d\n", tmp);

307

308 tmp = avio_rb16(s->pb); // unknown

309 av_log(s, AV_LOG_TRACE, "unknown %d\n", tmp);

310

311 tmp = avio_r8(s->pb); // major version

312 tmp2 = avio_r8(s->pb); // minor version

313 av_log(s, AV_LOG_TRACE, "version %d.%d\n", tmp, tmp2);

314

315 tmp = avio_rb32(s->pb); // unknown

316 av_log(s, AV_LOG_TRACE, "unknown %d\n", tmp);

317

318 size = atom->size - 8 - (avio_tell(s->pb) - pos);

319 if (size < 0)

320 return -1;

321 ret = av_get_packet(s->pb, pkt, size);

322 if (ret < 0) {

323 av_log(s, AV_LOG_ERROR, "error reading audio packet\n");

324 return ret;

325 }

326

327 pkt->stream_index = 1;

328 pkt->dts = dts;

329 if (st->codecpar->sample_rate)

330 pkt->duration = av_rescale(samples, st->time_base.den, st->codecpar->sample_rate);

331 av_log(s, AV_LOG_TRACE, "pkt dts %"PRId64" duration %"PRId64" samples %d sample rate %d\n",

332 pkt->dts, pkt->duration, samples, st->codecpar->sample_rate);

333

334 return 0;

335 }

336

337 static int r3d_read_packet(AVFormatContext *s, AVPacket *pkt)

338 {

339 R3DContext *r3d = s->priv_data;

340 Atom atom;

341 int err = 0;

342

343 while (!err) {

344 if (read_atom(s, &atom) < 0) {

345 err = -1;

346 break;

347 }

348 switch (atom.tag) {

349 case MKTAG('R','E','D','V'):

350 if (s->streams[0]->discard == AVDISCARD_ALL)

351 goto skip;

352 if (!(err = r3d_read_redv(s, pkt, &atom)))

353 return 0;

354 break;

355 case MKTAG('R','E','D','A'):

356 if (!r3d->audio_channels)

357 return -1;

358 if (s->nb_streams >= 2 && s->streams[1]->discard == AVDISCARD_ALL)

359 goto skip;

360 if (!(err = r3d_read_reda(s, pkt, &atom)))

361 return 0;

362 break;

363 default:

364 skip:

365 avio_skip(s->pb, atom.size-8);

366 }

367 }

368 return err;

369 }

370

371 static int r3d_probe(AVProbeData *p)

372 {

373 if (AV_RL32(p->buf + 4) == MKTAG('R','E','D','1'))

374 return AVPROBE_SCORE_MAX;

375 return 0;

376 }

377

378 static int r3d_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)

379 {

380 AVStream *st = s->streams[0]; // video stream

381 R3DContext *r3d = s->priv_data;

382 int frame_num;

383

384 if (!st->avg_frame_rate.num)

385 return -1;

386

387 frame_num = av_rescale_q(sample_time, st->time_base,

388 av_inv_q(st->avg_frame_rate));

389 av_log(s, AV_LOG_TRACE, "seek frame num %d timestamp %"PRId64"\n",

390 frame_num, sample_time);

391

392 if (frame_num < r3d->video_offsets_count) {

393 if (avio_seek(s->pb, r3d->video_offsets_count, SEEK_SET) < 0)

394 return -1;

395 } else {

396 av_log(s, AV_LOG_ERROR, "could not seek to frame %d\n", frame_num);

397 return -1;

398 }

399

400 return 0;

401 }

402

403 static int r3d_close(AVFormatContext *s)

404 {

405 R3DContext *r3d = s->priv_data;

406

407 av_freep(&r3d->video_offsets);

408

409 return 0;

410 }

411

412 AVInputFormat ff_r3d_demuxer = {

413 .name = "r3d",

414 .long_name = NULL_IF_CONFIG_SMALL("REDCODE R3D"),

415 .priv_data_size = sizeof(R3DContext),

416 .read_probe = r3d_probe,

417 .read_header = r3d_read_header,

418 .read_packet = r3d_read_packet,

419 .read_close = r3d_close,

420 .read_seek = r3d_seek,

421 };

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:768

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

Atom::offset

uint64_t offset

Definition: r3d.c:39

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:336

Atom::tag

uint32_t tag

Definition: r3d.c:38

R3DContext::video_offsets_count

unsigned video_offsets_count

Definition: r3d.c:29

read_atom

static int read_atom(AVFormatContext *s, Atom *atom)

Definition: r3d.c:42

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

AVFormatInternal::data_offset

int64_t data_offset

offset of the first packet

Definition: internal.h:82

read_seek

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

Definition: libcdio.c:153

r3d_close

static int r3d_close(AVFormatContext *s)

Definition: r3d.c:403

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: avcodec.h:3884

AVRational::num

int num

Numerator.

Definition: rational.h:59

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:246

Atom::size

unsigned size

Definition: r3d.c:37

AVFormatContext::internal

AVFormatInternal * internal

An opaque field for libavformat internal usage.

Definition: avformat.h:1793

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:331

AVDISCARD_ALL

discard all

Definition: avcodec.h:794

AVInputFormat

Definition: avformat.h:642

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:786

AVFormatContext::ctx_flags

int ctx_flags

Flags signalling stream properties.

Definition: avformat.h:1391

AVFormatContext

Format I/O context.

Definition: avformat.h:1342

mathematics.h

dict.h

Public dictionary API.

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

AVCodecParameters::width

int width

Video only.

Definition: avcodec.h:3950

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

signal that no header is present (streams are added dynamically)

Definition: avformat.h:1286

AV_LOG_TRACE

#define AV_LOG_TRACE

Extremely verbose debugging, useful for libav* development.

Definition: log.h:202

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:801

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: avcodec.h:1448

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

r3d_read_reda

static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)

Definition: r3d.c:273

flags

static int flags

Definition: log.c:55

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:145

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

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

Definition: utils.c:310

size

ptrdiff_t size

Definition: opengl_enc.c:101

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:557

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_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

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

r3d_read_reos

static void r3d_read_reos(AVFormatContext *s)

Definition: r3d.c:143

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:3880

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

Atom

Definition: r3d.c:36

R3DContext::audio_channels

int audio_channels

Definition: r3d.c:33

internal.h

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:946

R3DContext

Definition: r3d.c:28

R3DContext::rdvo_offset

unsigned rdvo_offset

Definition: r3d.c:31

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

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1398

AVIOContext::seekable

int seekable

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

Definition: avio.h:260

ff_r3d_demuxer

AVInputFormat ff_r3d_demuxer

Definition: r3d.c:412

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

read_probe

static int read_probe(AVProbeData *pd)

Definition: jvdec.c:55

intreadwrite.h

AVCodecParameters::height

int height

Definition: avcodec.h:3951

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:937

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:530

AVStream

Stream structure.

Definition: avformat.h:873

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

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1384

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

r3d_probe

static int r3d_probe(AVProbeData *p)

Definition: r3d.c:371

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

r3d_read_rdvo

static int r3d_read_rdvo(AVFormatContext *s, Atom *atom)

Definition: r3d.c:114

AVProbeData

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

Definition: avformat.h:448

R3DContext::video_offsets

unsigned * video_offsets

Definition: r3d.c:30

AV_CODEC_ID_JPEG2000

Definition: avcodec.h:306

r3d_seek

static int r3d_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)

Definition: r3d.c:378

AVStream::duration

int64_t duration

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

Definition: avformat.h:922

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

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

avformat.h

Main libavformat public API header.

r3d_read_header

static int r3d_read_header(AVFormatContext *s)

Definition: r3d.c:162

r3d_read_packet

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

Definition: r3d.c:337

AVRational::den

int den

Denominator.

Definition: rational.h:60

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1370

r3d_read_redv

static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)

Definition: r3d.c:218

AVCodecParameters::channels

int channels

Audio only.

Definition: avcodec.h:3990

AVPacket::dts

int64_t dts

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

Definition: avcodec.h:1429

out

FILE * out

Definition: movenc.c:54

r3d_read_red1

static int r3d_read_red1(AVFormatContext *s)

Definition: r3d.c:54

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

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1020

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1432

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

MKTAG

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

Definition: common.h:366

AVStream::discard

enum AVDiscard discard

Selects which packets can be discarded at will and do not need to be demuxed.

Definition: avformat.h:928

AVStream::r_frame_rate

AVRational r_frame_rate

Real base framerate of the stream.

Definition: avformat.h:997

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

av_unused

#define av_unused

Definition: attributes.h:125

AV_CODEC_ID_PCM_S32BE

Definition: avcodec.h:461

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

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