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 rdvo_offset;

32 int audio_channels;

33 } R3DContext;

35 typedef struct Atom {

36 unsigned size;

37 uint32_t tag;

38 uint64_t offset;

39 } Atom;

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

42 {

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

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

45 if (atom->size < 8)

46 return -1;

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

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

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

50 return atom->size;

51 }

53 static int r3d_read_red1(AVFormatContext *s)

54 {

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

56 R3DContext *r3d = s->priv_data;

57 char filename[258];

58 int tmp;

59 int ret;

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 ret = avio_read(s->pb, filename, 257);

102 if (ret < 257)

103 return ret < 0 ? ret : AVERROR_EOF;

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

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

106

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

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

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

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

111 framerate.num, framerate.den);

112

113 return 0;

114 }

115

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

117 {

118 R3DContext *r3d = s->priv_data;

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

120 int i;

121

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

123

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

125 unsigned video_offset = avio_rb32(s->pb);

126 if (!video_offset) {

127 r3d->video_offsets_count = i;

128 break;

129 }

130 av_log(s, AV_LOG_TRACE, "video offset %d: %#x\n", i, video_offset);

131 }

132

133 if (st->avg_frame_rate.num)

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

135 av_inv_q(st->avg_frame_rate),

136 st->time_base);

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

138

139 return 0;

140 }

141

142 static void r3d_read_reos(AVFormatContext *s)

143 {

144 R3DContext *r3d = s->priv_data;

145 int av_unused tmp;

146

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

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

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

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

151

152 tmp = avio_rb32(s->pb);

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

154

155 tmp = avio_rb32(s->pb);

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

157

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

159 }

160

161 static int r3d_read_header(AVFormatContext *s)

162 {

163 FFFormatContext *const si = ffformatcontext(s);

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 si->data_offset = avio_tell(s->pb);

188 av_log(s, AV_LOG_TRACE, "data offset %#"PRIx64"\n", si->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, si->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

330 if (st->codecpar->sample_rate && samples > 0)

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

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

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

334

335 return 0;

336 }

337

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

339 {

340 R3DContext *r3d = s->priv_data;

341 Atom atom;

342 int err = 0;

343

344 while (!err) {

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

346 err = -1;

347 break;

348 }

349 switch (atom.tag) {

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

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

352 goto skip;

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

354 return 0;

355 break;

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

357 if (!r3d->audio_channels)

358 return -1;

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

360 goto skip;

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

362 return 0;

363 break;

364 default:

365 skip:

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

367 }

368 }

369 return err;

370 }

371

372 static int r3d_probe(const AVProbeData *p)

373 {

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

375 return AVPROBE_SCORE_MAX;

376 return 0;

377 }

378

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

380 {

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

382 R3DContext *r3d = s->priv_data;

383 int frame_num;

384

385 if (!st->avg_frame_rate.num)

386 return -1;

387

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

389 av_inv_q(st->avg_frame_rate));

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

391 frame_num, sample_time);

392

393 if (frame_num < r3d->video_offsets_count) {

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

395 return -1;

396 } else {

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

398 return -1;

399 }

400

401 return 0;

402 }

403

404 const AVInputFormat ff_r3d_demuxer = {

405 .name = "r3d",

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

407 .priv_data_size = sizeof(R3DContext),

408 .read_probe = r3d_probe,

409 .read_header = r3d_read_header,

410 .read_packet = r3d_read_packet,

411 .read_seek = r3d_seek,

412 };

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

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:56

out

FILE * out

Definition: movenc.c:54

ffformatcontext

static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)

Definition: internal.h:189

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

r3d_read_red1

static int r3d_read_red1(AVFormatContext *s)

Definition: r3d.c:53

Atom::tag

uint32_t tag

Definition: r3d.c:37

av_unused

#define av_unused

Definition: attributes.h:131

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

r3d_seek

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

Definition: r3d.c:379

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:1015

AVPacket::duration

int64_t duration

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

Definition: packet.h:391

mathematics.h

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:352

Atom::offset

uint64_t offset

Definition: r3d.c:38

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:459

framerate

int framerate

Definition: h264_levels.c:65

AVCodecParameters::channels

int channels

Audio only.

Definition: codec_par.h:166

r3d_read_reda

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

Definition: r3d.c:273

read_seek

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

Definition: libcdio.c:149

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:504

Atom

Definition: r3d.c:35

AVStream::duration

int64_t duration

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

Definition: avformat.h:985

AVRational::num

int num

Numerator.

Definition: rational.h:59

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:790

AV_LOG_TRACE

#define AV_LOG_TRACE

Extremely verbose debugging, useful for libav* development.

Definition: log.h:206

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

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:257

r3d_read_reos

static void r3d_read_reos(AVFormatContext *s)

Definition: r3d.c:142

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:655

AVProbeData::buf

unsigned char * buf

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

Definition: avformat.h:449

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:126

FFFormatContext::data_offset

int64_t data_offset

offset of the first packet

Definition: internal.h:99

read_atom

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

Definition: r3d.c:41

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

r3d_probe

static int r3d_probe(const AVProbeData *p)

Definition: r3d.c:372

FFFormatContext

Definition: internal.h:73

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:54

AVFormatContext

Format I/O context.

Definition: avformat.h:1200

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1095

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:527

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

NULL

#define NULL

Definition: coverity.c:32

R3DContext

Definition: r3d.c:28

read_probe

static int read_probe(const AVProbeData *pd)

Definition: jvdec.c:55

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

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

Definition: avformat.h:1151

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVProbeData

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

Definition: avformat.h:447

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:1006

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:170

R3DContext::video_offsets_count

unsigned video_offsets_count

Definition: r3d.c:29

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:759

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

size

int size

Definition: twinvq_data.h:10344

r3d_read_packet

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

Definition: r3d.c:338

AVPacket::dts

int64_t dts

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

Definition: packet.h:372

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:632

r3d_read_header

static int r3d_read_header(AVFormatContext *s)

Definition: r3d.c:161

r3d_read_redv

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

Definition: r3d.c:218

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

Definition: cbs_h2645.c:271

AVCodecParameters::height

int height

Definition: codec_par.h:127

AV_CODEC_ID_PCM_S32BE

@ AV_CODEC_ID_PCM_S32BE

Definition: codec_id.h:323

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

AV_CODEC_ID_JPEG2000

@ AV_CODEC_ID_JPEG2000

Definition: codec_id.h:138

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

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

ret

Definition: filter_design.txt:187

read_packet

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

Definition: avio_reading.c:42

AVStream

Stream structure.

Definition: avformat.h:935

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:260

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:775

pos

unsigned int pos

Definition: spdifenc.c:412

avformat.h

dict.h

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

R3DContext::audio_channels

int audio_channels

Definition: r3d.c:32

AVIO_SEEKABLE_NORMAL

#define AVIO_SEEKABLE_NORMAL

Seeking works like for a local file.

Definition: avio.h:40

AVRational::den

int den

Denominator.

Definition: rational.h:60

avio_read

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

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:641

AVStream::r_frame_rate

AVRational r_frame_rate

Real base framerate of the stream.

Definition: avformat.h:1084

samples

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

Definition: filter_design.txt:8

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

AVPacket::stream_index

int stream_index

Definition: packet.h:375

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:347

r3d_read_rdvo

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

Definition: r3d.c:116

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: codec_par.h:60

AVPacket

This structure stores compressed data.

Definition: packet.h:350

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

ff_r3d_demuxer

const AVInputFormat ff_r3d_demuxer

Definition: r3d.c:404

flags

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

Definition: cbs_av1.c:561

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

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

R3DContext::rdvo_offset

unsigned rdvo_offset

Definition: r3d.c:30

Atom::size

unsigned size

Definition: r3d.c:36

Generated on Wed Aug 24 2022 21:38:26 for FFmpeg by doxygen 1.8.17