FFmpeg: libavformat/rmenc.c Source File

FFmpeg

[フレーム]

libavformat

rmenc.c

Go to the documentation of this file.

1 /*

2 * "Real" compatible muxer.

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 */

21 #include "avformat.h"

22 #include "avio_internal.h"

23 #include "rm.h"

24 #include "libavutil/dict.h"

26 typedef struct StreamInfo {

27 int nb_packets;

28 int packet_total_size;

29 int packet_max_size;

30 /* codec related output */

31 int bit_rate;

32 AVRational frame_rate;

33 int nb_frames; /* current frame number */

34 int total_frames; /* total number of frames */

35 int num;

36 AVCodecParameters *par;

37 } StreamInfo;

39 typedef struct RMMuxContext {

40 StreamInfo streams[2];

41 StreamInfo *audio_stream, *video_stream;

42 int data_pos; /* position of the data after the header */

43 } RMMuxContext;

45 /* in ms */

46 #define BUFFER_DURATION 0

47 /* the header needs at most 7 + 4 + 12 B */

48 #define MAX_HEADER_SIZE (7 + 4 + 12)

49 /* UINT16_MAX is the maximal chunk size */

50 #define MAX_PACKET_SIZE (UINT16_MAX - MAX_HEADER_SIZE)

53 static void put_str(AVIOContext *s, const char *tag)

54 {

55 avio_wb16(s,strlen(tag));

56 while (*tag) {

57 avio_w8(s, *tag++);

58 }

59 }

61 static void put_str8(AVIOContext *s, const char *tag)

62 {

63 avio_w8(s, strlen(tag));

64 while (*tag) {

65 avio_w8(s, *tag++);

66 }

67 }

69 static int rv10_write_header(AVFormatContext *ctx,

70 int data_size, int index_pos)

71 {

72 RMMuxContext *rm = ctx->priv_data;

73 AVIOContext *s = ctx->pb;

74 StreamInfo *stream;

75 const char *desc, *mimetype;

76 int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;

77 int bit_rate, v, duration, flags;

78 int data_offset;

79 AVDictionaryEntry *tag;

81 ffio_wfourcc(s, ".RMF");

82 avio_wb32(s,18); /* header size */

83 avio_wb16(s,0);

84 avio_wb32(s,0);

85 avio_wb32(s,4 + ctx->nb_streams); /* num headers */

87 ffio_wfourcc(s,"PROP");

88 avio_wb32(s, 50);

89 avio_wb16(s, 0);

90 packet_max_size = 0;

91 packet_total_size = 0;

92 nb_packets = 0;

93 bit_rate = 0;

94 duration = 0;

95 for(i=0;i<ctx->nb_streams;i++) {

96 StreamInfo *stream = &rm->streams[i];

97 bit_rate += stream->bit_rate;

98 if (stream->packet_max_size > packet_max_size)

99 packet_max_size = stream->packet_max_size;

100 nb_packets += stream->nb_packets;

101 packet_total_size += stream->packet_total_size;

102 /* select maximum duration */

103 v = av_rescale_q_rnd(stream->total_frames, (AVRational){1000, 1}, stream->frame_rate, AV_ROUND_ZERO);

104 if (v > duration)

105 duration = v;

106 }

107 avio_wb32(s, bit_rate); /* max bit rate */

108 avio_wb32(s, bit_rate); /* avg bit rate */

109 avio_wb32(s, packet_max_size); /* max packet size */

110 if (nb_packets > 0)

111 packet_avg_size = packet_total_size / nb_packets;

112 else

113 packet_avg_size = 0;

114 avio_wb32(s, packet_avg_size); /* avg packet size */

115 avio_wb32(s, nb_packets); /* num packets */

116 avio_wb32(s, duration); /* duration */

117 avio_wb32(s, BUFFER_DURATION); /* preroll */

118 avio_wb32(s, index_pos); /* index offset */

119 /* computation of data the data offset */

120 data_offset = avio_tell(s);

121 avio_wb32(s, 0); /* data offset : will be patched after */

122 avio_wb16(s, ctx->nb_streams); /* num streams */

123 flags = 1 | 2; /* save allowed & perfect play */

124 if (!(s->seekable & AVIO_SEEKABLE_NORMAL))

125 flags |= 4; /* live broadcast */

126 avio_wb16(s, flags);

127

128 /* comments */

129

130 ffio_wfourcc(s,"CONT");

131 size = 4 * 2 + 10;

132 for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {

133 tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);

134 if(tag) size += strlen(tag->value);

135 }

136 avio_wb32(s,size);

137 avio_wb16(s,0);

138 for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {

139 tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);

140 put_str(s, tag ? tag->value : "");

141 }

142

143 for(i=0;i<ctx->nb_streams;i++) {

144 int codec_data_size;

145

146 stream = &rm->streams[i];

147

148 if (stream->par->codec_type == AVMEDIA_TYPE_AUDIO) {

149 desc = "The Audio Stream";

150 mimetype = "audio/x-pn-realaudio";

151 codec_data_size = 73;

152 } else {

153 desc = "The Video Stream";

154 mimetype = "video/x-pn-realvideo";

155 codec_data_size = 34;

156 }

157

158 ffio_wfourcc(s,"MDPR");

159 size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;

160 avio_wb32(s, size);

161 avio_wb16(s, 0);

162

163 avio_wb16(s, i); /* stream number */

164 avio_wb32(s, stream->bit_rate); /* max bit rate */

165 avio_wb32(s, stream->bit_rate); /* avg bit rate */

166 avio_wb32(s, stream->packet_max_size); /* max packet size */

167 if (stream->nb_packets > 0)

168 packet_avg_size = stream->packet_total_size /

169 stream->nb_packets;

170 else

171 packet_avg_size = 0;

172 avio_wb32(s, packet_avg_size); /* avg packet size */

173 avio_wb32(s, 0); /* start time */

174 avio_wb32(s, BUFFER_DURATION); /* preroll */

175 /* duration */

176 if (!(s->seekable & AVIO_SEEKABLE_NORMAL) || !stream->total_frames)

177 avio_wb32(s, (int)(3600 * 1000));

178 else

179 avio_wb32(s, av_rescale_q_rnd(stream->total_frames, (AVRational){1000, 1}, stream->frame_rate, AV_ROUND_ZERO));

180 put_str8(s, desc);

181 put_str8(s, mimetype);

182 avio_wb32(s, codec_data_size);

183

184 if (stream->par->codec_type == AVMEDIA_TYPE_AUDIO) {

185 int coded_frame_size, fscode, sample_rate;

186 int frame_size = av_get_audio_frame_duration2(stream->par, 0);

187 sample_rate = stream->par->sample_rate;

188 coded_frame_size = (stream->par->bit_rate *

189 frame_size) / (8 * sample_rate);

190 /* audio codec info */

191 avio_write(s, ".ra", 3);

192 avio_w8(s, 0xfd);

193 avio_wb32(s, 0x00040000); /* version */

194 ffio_wfourcc(s, ".ra4");

195 avio_wb32(s, 0x01b53530); /* stream length */

196 avio_wb16(s, 4); /* unknown */

197 avio_wb32(s, 0x39); /* header size */

198

199 switch(sample_rate) {

200 case 48000:

201 case 24000:

202 case 12000:

203 fscode = 1;

204 break;

205 default:

206 case 44100:

207 case 22050:

208 case 11025:

209 fscode = 2;

210 break;

211 case 32000:

212 case 16000:

213 case 8000:

214 fscode = 3;

215 }

216 avio_wb16(s, fscode); /* codec additional info, for AC-3, seems

217 to be a frequency code */

218 /* special hack to compensate rounding errors... */

219 if (coded_frame_size == 557)

220 coded_frame_size--;

221 avio_wb32(s, coded_frame_size); /* frame length */

222 avio_wb32(s, 0x51540); /* unknown */

223 avio_wb32(s, stream->par->bit_rate / 8 * 60); /* bytes per minute */

224 avio_wb32(s, stream->par->bit_rate / 8 * 60); /* bytes per minute */

225 avio_wb16(s, 0x01);

226 /* frame length : seems to be very important */

227 avio_wb16(s, coded_frame_size);

228 avio_wb32(s, 0); /* unknown */

229 avio_wb16(s, stream->par->sample_rate); /* sample rate */

230 avio_wb32(s, 0x10); /* unknown */

231 avio_wb16(s, stream->par->channels);

232 put_str8(s, "Int0"); /* codec name */

233 if (stream->par->codec_tag) {

234 avio_w8(s, 4); /* tag length */

235 avio_wl32(s, stream->par->codec_tag);

236 } else {

237 av_log(ctx, AV_LOG_ERROR, "Invalid codec tag\n");

238 return -1;

239 }

240 avio_wb16(s, 0); /* title length */

241 avio_wb16(s, 0); /* author length */

242 avio_wb16(s, 0); /* copyright length */

243 avio_w8(s, 0); /* end of header */

244 } else {

245 /* video codec info */

246 avio_wb32(s,34); /* size */

247 ffio_wfourcc(s, "VIDO");

248 if(stream->par->codec_id == AV_CODEC_ID_RV10)

249 ffio_wfourcc(s,"RV10");

250 else

251 ffio_wfourcc(s,"RV20");

252 avio_wb16(s, stream->par->width);

253 avio_wb16(s, stream->par->height);

254

255 if (stream->frame_rate.num / stream->frame_rate.den > 65535) {

256 av_log(s, AV_LOG_ERROR, "Frame rate %d is too high\n", stream->frame_rate.num / stream->frame_rate.den);

257 return AVERROR(EINVAL);

258 }

259

260 avio_wb16(s, stream->frame_rate.num / stream->frame_rate.den); /* frames per seconds ? */

261 avio_wb32(s,0); /* unknown meaning */

262 avio_wb16(s, stream->frame_rate.num / stream->frame_rate.den); /* unknown meaning */

263 avio_wb32(s,0); /* unknown meaning */

264 avio_wb16(s, 8); /* unknown meaning */

265 /* Seems to be the codec version: only use basic H.263. The next

266 versions seems to add a differential DC coding as in

267 MPEG... nothing new under the sun. */

268 if(stream->par->codec_id == AV_CODEC_ID_RV10)

269 avio_wb32(s,0x10000000);

270 else

271 avio_wb32(s,0x20103001);

272 //avio_wb32(s,0x10003000);

273 }

274 }

275

276 /* patch data offset field */

277 rm->data_pos = avio_tell(s);

278 if (avio_seek(s, data_offset, SEEK_SET) >= 0) {

279 avio_wb32(s, rm->data_pos);

280 avio_seek(s, rm->data_pos, SEEK_SET);

281 }

282

283 /* data stream */

284 ffio_wfourcc(s, "DATA");

285 avio_wb32(s,data_size + 10 + 8);

286 avio_wb16(s,0);

287

288 avio_wb32(s, nb_packets); /* number of packets */

289 avio_wb32(s,0); /* next data header */

290 return 0;

291 }

292

293 static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,

294 int length, int key_frame)

295 {

296 int timestamp;

297 AVIOContext *s = ctx->pb;

298

299 stream->nb_packets++;

300 stream->packet_total_size += length;

301 if (length > stream->packet_max_size)

302 stream->packet_max_size = length;

303

304 avio_wb16(s,0); /* version */

305 avio_wb16(s,length + 12);

306 avio_wb16(s, stream->num); /* stream number */

307 timestamp = av_rescale_q_rnd(stream->nb_frames, (AVRational){1000, 1}, stream->frame_rate, AV_ROUND_ZERO);

308 avio_wb32(s, timestamp); /* timestamp */

309 avio_w8(s, 0); /* reserved */

310 avio_w8(s, key_frame ? 2 : 0); /* flags */

311 }

312

313 static int rm_write_header(AVFormatContext *s)

314 {

315 RMMuxContext *rm = s->priv_data;

316 StreamInfo *stream;

317 int n;

318 AVCodecParameters *par;

319

320 if (s->nb_streams > 2) {

321 av_log(s, AV_LOG_ERROR, "At most 2 streams are currently supported for muxing in RM\n");

322 return AVERROR_PATCHWELCOME;

323 }

324

325 for(n=0;n<s->nb_streams;n++) {

326 AVStream *st = s->streams[n];

327 int frame_size;

328

329 s->streams[n]->id = n;

330 par = s->streams[n]->codecpar;

331 stream = &rm->streams[n];

332 memset(stream, 0, sizeof(StreamInfo));

333 stream->num = n;

334 stream->bit_rate = par->bit_rate;

335 stream->par = par;

336

337 switch (par->codec_type) {

338 case AVMEDIA_TYPE_AUDIO:

339 rm->audio_stream = stream;

340 frame_size = av_get_audio_frame_duration2(par, 0);

341 stream->frame_rate = (AVRational){par->sample_rate, frame_size};

342 /* XXX: dummy values */

343 stream->packet_max_size = 1024;

344 stream->nb_packets = 0;

345 stream->total_frames = stream->nb_packets;

346 break;

347 case AVMEDIA_TYPE_VIDEO:

348 rm->video_stream = stream;

349 // TODO: should be avg_frame_rate

350 stream->frame_rate = av_inv_q(st->time_base);

351 /* XXX: dummy values */

352 stream->packet_max_size = 4096;

353 stream->nb_packets = 0;

354 stream->total_frames = stream->nb_packets;

355 break;

356 default:

357 return -1;

358 }

359 }

360

361 if (rv10_write_header(s, 0, 0))

362 return AVERROR_INVALIDDATA;

363 avio_flush(s->pb);

364 return 0;

365 }

366

367 static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int flags)

368 {

369 RMMuxContext *rm = s->priv_data;

370 AVIOContext *pb = s->pb;

371 StreamInfo *stream = rm->audio_stream;

372 int i;

373

374 write_packet_header(s, stream, size, !!(flags & AV_PKT_FLAG_KEY));

375

376 if (stream->par->codec_id == AV_CODEC_ID_AC3) {

377 /* for AC-3, the words seem to be reversed */

378 for (i = 0; i < size; i += 2) {

379 avio_w8(pb, buf[i + 1]);

380 avio_w8(pb, buf[i]);

381 }

382 } else {

383 avio_write(pb, buf, size);

384 }

385 stream->nb_frames++;

386 return 0;

387 }

388

389 static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags)

390 {

391 RMMuxContext *rm = s->priv_data;

392 AVIOContext *pb = s->pb;

393 StreamInfo *stream = rm->video_stream;

394 int key_frame = !!(flags & AV_PKT_FLAG_KEY);

395

396 /* XXX: this is incorrect: should be a parameter */

397

398 /* Well, I spent some time finding the meaning of these bits. I am

399 not sure I understood everything, but it works !! */

400 if (size > MAX_PACKET_SIZE) {

401 av_log(s, AV_LOG_ERROR, "Muxing packets larger than 64 kB (%d) is not supported\n", size);

402 return AVERROR_PATCHWELCOME;

403 }

404 write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame);

405 /* bit 7: '1' if final packet of a frame converted in several packets */

406 avio_w8(pb, 0x81);

407 /* bit 7: '1' if I-frame. bits 6..0 : sequence number in current

408 frame starting from 1 */

409 if (key_frame) {

410 avio_w8(pb, 0x81);

411 } else {

412 avio_w8(pb, 0x01);

413 }

414 if(size >= 0x4000){

415 avio_wb32(pb, size); /* total frame size */

416 avio_wb32(pb, size); /* offset from the start or the end */

417 }else{

418 avio_wb16(pb, 0x4000 | size); /* total frame size */

419 avio_wb16(pb, 0x4000 | size); /* offset from the start or the end */

420 }

421 avio_w8(pb, stream->nb_frames & 0xff);

422

423 avio_write(pb, buf, size);

424

425 stream->nb_frames++;

426 return 0;

427 }

428

429 static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)

430 {

431 if (s->streams[pkt->stream_index]->codecpar->codec_type ==

432 AVMEDIA_TYPE_AUDIO)

433 return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);

434 else

435 return rm_write_video(s, pkt->data, pkt->size, pkt->flags);

436 }

437

438 static int rm_write_trailer(AVFormatContext *s)

439 {

440 RMMuxContext *rm = s->priv_data;

441 int data_size, index_pos, i;

442 AVIOContext *pb = s->pb;

443

444 if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {

445 /* end of file: finish to write header */

446 index_pos = avio_tell(pb);

447 data_size = index_pos - rm->data_pos;

448

449 /* FIXME: write index */

450

451 /* undocumented end header */

452 avio_wb32(pb, 0);

453 avio_wb32(pb, 0);

454

455 avio_seek(pb, 0, SEEK_SET);

456 for(i=0;i<s->nb_streams;i++)

457 rm->streams[i].total_frames = rm->streams[i].nb_frames;

458 rv10_write_header(s, data_size, 0);

459 } else {

460 /* undocumented end header */

461 avio_wb32(pb, 0);

462 avio_wb32(pb, 0);

463 }

464

465 return 0;

466 }

467

468

469 AVOutputFormat ff_rm_muxer = {

470 .name = "rm",

471 .long_name = NULL_IF_CONFIG_SMALL("RealMedia"),

472 .mime_type = "application/vnd.rn-realmedia",

473 .extensions = "rm,ra",

474 .priv_data_size = sizeof(RMMuxContext),

475 .audio_codec = AV_CODEC_ID_AC3,

476 .video_codec = AV_CODEC_ID_RV10,

477 .write_header = rm_write_header,

478 .write_packet = rm_write_packet,

479 .write_trailer = rm_write_trailer,

480 .codec_tag = (const AVCodecTag* const []){ ff_rm_codec_tags, 0 },

481 };

write_packet

static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)

Definition: ffmpeg.c:679

NULL

#define NULL

Definition: coverity.c:32

rm_write_audio

static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int flags)

Definition: rmenc.c:367

const char * s

Definition: avisynth_c.h:768

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVDictionaryEntry

Definition: dict.h:85

StreamInfo::nb_packets

int nb_packets

Definition: rmenc.c:27

desc

const char * desc

Definition: nvenc.c:65

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

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:246

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: avcodec.h:3876

AVFormatContext

Format I/O context.

Definition: avformat.h:1342

dict.h

Public dictionary API.

StreamInfo::packet_total_size

int packet_total_size

Definition: rmenc.c:28

avio_wl32

void avio_wl32(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:369

uint8_t

Definition: audio_convert.c:194

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:880

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1410

duration

int64_t duration

Definition: movenc.c:63

AVCodecTag

Definition: internal.h:44

put_str

static void put_str(AVIOContext *s, const char *tag)

Definition: rmenc.c:53

avio_internal.h

av_dict_get

AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)

Get a dictionary entry with matching key.

Definition: dict.c:40

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

StreamInfo::frame_rate

AVRational frame_rate

Definition: rmenc.c:32

put_str8

static void put_str8(AVIOContext *s, const char *tag)

Definition: rmenc.c:61

size

ptrdiff_t size

Definition: opengl_enc.c:101

RMMuxContext::audio_stream

StreamInfo * audio_stream

Definition: rmenc.c:41

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:557

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:218

ffio_wfourcc

static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)

Definition: avio_internal.h:58

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

AVCodecParameters::bit_rate

int64_t bit_rate

The average bitrate of the encoded data (in bits per second).

Definition: avcodec.h:3913

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: avcodec.h:1462

StreamInfo::total_frames

int total_frames

Definition: rmenc.c:34

RMMuxContext::streams

StreamInfo streams[2]

Definition: rmenc.c:40

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVFormatContext::metadata

AVDictionary * metadata

Metadata that applies to the whole file.

Definition: avformat.h:1580

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

StreamInfo::nb_frames

int nb_frames

Definition: rmenc.c:33

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:3880

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

length

GLsizei GLsizei * length

Definition: opengl_enc.c:115

StreamInfo::par

AVCodecParameters * par

Definition: rmenc.c:36

av_get_audio_frame_duration2

int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)

This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...

Definition: utils.c:1709

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: avcodec.h:1436

rm.h

StreamInfo::bit_rate

int bit_rate

Definition: rmenc.c:31

write_packet_header

static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream, int length, int key_frame)

Definition: rmenc.c:293

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

avio_flush

int void avio_flush(AVIOContext *s)

Force flushing of buffered data.

Definition: aviobuf.c:238

AV_ROUND_ZERO

Round toward zero.

Definition: mathematics.h:80

StreamInfo

Definition: mpegenc.c:46

write_trailer

static int write_trailer(AVFormatContext *s1)

Definition: v4l2enc.c:94

AVOutputFormat::name

const char * name

Definition: avformat.h:507

ctx

AVFormatContext * ctx

Definition: movenc.c:48

AV_CODEC_ID_RV10

Definition: avcodec.h:223

rm_write_header

static int rm_write_header(AVFormatContext *s)

Definition: rmenc.c:313

int n

Definition: avisynth_c.h:684

rm_write_packet

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

Definition: rmenc.c:429

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

AVStream

Stream structure.

Definition: avformat.h:873

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

AVIO_SEEKABLE_NORMAL

#define AVIO_SEEKABLE_NORMAL

Seeking works like for a local file.

Definition: avio.h:40

ff_rm_codec_tags

const AVCodecTag ff_rm_codec_tags[]

Definition: rm.c:31

sample_rate

Definition: ffmpeg_filter.c:190

frame_size

int frame_size

Definition: mxfenc.c:1947

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1384

avio_w8

void avio_w8(AVIOContext *s, int b)

Definition: aviobuf.c:196

AV_CODEC_ID_AC3

Definition: avcodec.h:554

buf

void * buf

Definition: avisynth_c.h:690

BUFFER_DURATION

#define BUFFER_DURATION

Definition: rmenc.c:46

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

rm_write_trailer

static int rm_write_trailer(AVFormatContext *s)

Definition: rmenc.c:438

avio_wb16

void avio_wb16(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:475

ff_rm_metadata

const char *const ff_rm_metadata[4]

Definition: rm.c:24

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

avformat.h

Main libavformat public API header.

StreamInfo::packet_max_size

int packet_max_size

Definition: rmenc.c:29

RMMuxContext::data_pos

int data_pos

Definition: rmenc.c:42

ff_rm_muxer

AVOutputFormat ff_rm_muxer

Definition: rmenc.c:469

MAX_PACKET_SIZE

#define MAX_PACKET_SIZE

Definition: rmenc.c:50

AVOutputFormat

Definition: avformat.h:506

rv10_write_header

static int rv10_write_header(AVFormatContext *ctx, int data_size, int index_pos)

Definition: rmenc.c:69

RMMuxContext

Definition: rmenc.c:39

StreamInfo::num

int num

Definition: rmenc.c:35

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1370

write_header

static void write_header(FFV1Context *f)

Definition: ffv1enc.c:337

avio_wb32

void avio_wb32(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:377

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1020

av_rescale_q_rnd

int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)

Rescale a 64-bit integer by 2 rational numbers with specified rounding.

Definition: mathematics.c:134

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

rm_write_video

static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags)

Definition: rmenc.c:389

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

RMMuxContext::video_stream

StreamInfo * video_stream

Definition: rmenc.c:41

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