FFmpeg: libavformat/rmenc.c Source File

FFmpeg
rmenc.c
Go to the documentation of this file.
1 /*
2  * "Real" compatible muxer.
3  * Copyright (c) 2000, 2001 Fabrice Bellard
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 "mux.h"
24 #include "rm.h"
25 #include "libavutil/dict.h"
26 
27 typedef struct StreamInfo {
28   int nb_packets;
29   int packet_total_size;
30   int packet_max_size;
31  /* codec related output */
32   int bit_rate;
33   AVRational frame_rate;
34   int nb_frames; /* current frame number */
35   int total_frames; /* total number of frames */
36   int num;
37   AVCodecParameters *par;
38 } StreamInfo;
39 
40  typedef struct RMMuxContext {
41   StreamInfo streams[2];
42   StreamInfo *audio_stream, *video_stream;
43   int data_pos; /* position of the data after the header */
44 } RMMuxContext;
45 
46 /* in ms */
47  #define BUFFER_DURATION 0
48 /* the header needs at most 7 + 4 + 12 B */
49  #define MAX_HEADER_SIZE (7 + 4 + 12)
50 /* UINT16_MAX is the maximal chunk size */
51  #define MAX_PACKET_SIZE (UINT16_MAX - MAX_HEADER_SIZE)
52 
53 
54  static void put_str(AVIOContext *s, const char *tag)
55 {
56  avio_wb16(s,strlen(tag));
57  while (*tag) {
58  avio_w8(s, *tag++);
59  }
60 }
61 
62  static void put_str8(AVIOContext *s, const char *tag)
63 {
64  avio_w8(s, strlen(tag));
65  while (*tag) {
66  avio_w8(s, *tag++);
67  }
68 }
69 
70  static int rv10_write_header(AVFormatContext *ctx,
71  int data_size, int index_pos)
72 {
73  RMMuxContext *rm = ctx->priv_data;
74  AVIOContext *s = ctx->pb;
75  StreamInfo *stream;
76  const char *desc, *mimetype;
77  int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;
78  int bit_rate, v, duration, flags;
79  int data_offset;
80  AVDictionaryEntry *tag;
81 
82  ffio_wfourcc(s, ".RMF");
83  avio_wb32(s,18); /* header size */
84  avio_wb16(s,0);
85  avio_wb32(s,0);
86  avio_wb32(s,4 + ctx->nb_streams); /* num headers */
87 
88  ffio_wfourcc(s,"PROP");
89  avio_wb32(s, 50);
90  avio_wb16(s, 0);
91  packet_max_size = 0;
92  packet_total_size = 0;
93  nb_packets = 0;
94  bit_rate = 0;
95  duration = 0;
96  for(i=0;i<ctx->nb_streams;i++) {
97  StreamInfo *stream = &rm->streams[i];
98  bit_rate += stream->bit_rate;
99  if (stream->packet_max_size > packet_max_size)
100  packet_max_size = stream->packet_max_size;
101  nb_packets += stream->nb_packets;
102  packet_total_size += stream->packet_total_size;
103  /* select maximum duration */
104  v = av_rescale_q_rnd(stream->total_frames, (AVRational){1000, 1}, stream->frame_rate, AV_ROUND_ZERO);
105  if (v > duration)
106  duration = v;
107  }
108  avio_wb32(s, bit_rate); /* max bit rate */
109  avio_wb32(s, bit_rate); /* avg bit rate */
110  avio_wb32(s, packet_max_size); /* max packet size */
111  if (nb_packets > 0)
112  packet_avg_size = packet_total_size / nb_packets;
113  else
114  packet_avg_size = 0;
115  avio_wb32(s, packet_avg_size); /* avg packet size */
116  avio_wb32(s, nb_packets); /* num packets */
117  avio_wb32(s, duration); /* duration */
118  avio_wb32(s, BUFFER_DURATION); /* preroll */
119  avio_wb32(s, index_pos); /* index offset */
120  /* computation of data the data offset */
121  data_offset = avio_tell(s);
122  avio_wb32(s, 0); /* data offset : will be patched after */
123  avio_wb16(s, ctx->nb_streams); /* num streams */
124  flags = 1 | 2; /* save allowed & perfect play */
125  if (!(s->seekable & AVIO_SEEKABLE_NORMAL))
126  flags |= 4; /* live broadcast */
127  avio_wb16(s, flags);
128 
129  /* comments */
130 
131  ffio_wfourcc(s,"CONT");
132  size = 4 * 2 + 10;
133  for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
134  tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
135  if(tag) size += strlen(tag->value);
136  }
137  avio_wb32(s,size);
138  avio_wb16(s,0);
139  for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
140  tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
141  put_str(s, tag ? tag->value : "");
142  }
143 
144  for(i=0;i<ctx->nb_streams;i++) {
145  int codec_data_size;
146 
147  stream = &rm->streams[i];
148 
149  if (stream->par->codec_type == AVMEDIA_TYPE_AUDIO) {
150  desc = "The Audio Stream";
151  mimetype = "audio/x-pn-realaudio";
152  codec_data_size = 73;
153  } else {
154  desc = "The Video Stream";
155  mimetype = "video/x-pn-realvideo";
156  codec_data_size = 34;
157  }
158 
159  ffio_wfourcc(s,"MDPR");
160  size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;
161  avio_wb32(s, size);
162  avio_wb16(s, 0);
163 
164  avio_wb16(s, i); /* stream number */
165  avio_wb32(s, stream->bit_rate); /* max bit rate */
166  avio_wb32(s, stream->bit_rate); /* avg bit rate */
167  avio_wb32(s, stream->packet_max_size); /* max packet size */
168  if (stream->nb_packets > 0)
169  packet_avg_size = stream->packet_total_size /
170  stream->nb_packets;
171  else
172  packet_avg_size = 0;
173  avio_wb32(s, packet_avg_size); /* avg packet size */
174  avio_wb32(s, 0); /* start time */
175  avio_wb32(s, BUFFER_DURATION); /* preroll */
176  /* duration */
177  if (!(s->seekable & AVIO_SEEKABLE_NORMAL) || !stream->total_frames)
178  avio_wb32(s, (int)(3600 * 1000));
179  else
180  avio_wb32(s, av_rescale_q_rnd(stream->total_frames, (AVRational){1000, 1}, stream->frame_rate, AV_ROUND_ZERO));
181  put_str8(s, desc);
182  put_str8(s, mimetype);
183  avio_wb32(s, codec_data_size);
184 
185  if (stream->par->codec_type == AVMEDIA_TYPE_AUDIO) {
186  int coded_frame_size, fscode, sample_rate;
187  int frame_size = av_get_audio_frame_duration2(stream->par, 0);
188  sample_rate = stream->par->sample_rate;
189  coded_frame_size = (stream->par->bit_rate *
190  frame_size) / (8 * sample_rate);
191  /* audio codec info */
192  avio_write(s, ".ra", 3);
193  avio_w8(s, 0xfd);
194  avio_wb32(s, 0x00040000); /* version */
195  ffio_wfourcc(s, ".ra4");
196  avio_wb32(s, 0x01b53530); /* stream length */
197  avio_wb16(s, 4); /* unknown */
198  avio_wb32(s, 0x39); /* header size */
199 
200  switch(sample_rate) {
201  case 48000:
202  case 24000:
203  case 12000:
204  fscode = 1;
205  break;
206  default:
207  case 44100:
208  case 22050:
209  case 11025:
210  fscode = 2;
211  break;
212  case 32000:
213  case 16000:
214  case 8000:
215  fscode = 3;
216  }
217  avio_wb16(s, fscode); /* codec additional info, for AC-3, seems
218  to be a frequency code */
219  /* special hack to compensate rounding errors... */
220  if (coded_frame_size == 557)
221  coded_frame_size--;
222  avio_wb32(s, coded_frame_size); /* frame length */
223  avio_wb32(s, 0x51540); /* unknown */
224  avio_wb32(s, stream->par->bit_rate / 8 * 60); /* bytes per minute */
225  avio_wb32(s, stream->par->bit_rate / 8 * 60); /* bytes per minute */
226  avio_wb16(s, 0x01);
227  /* frame length : seems to be very important */
228  avio_wb16(s, coded_frame_size);
229  avio_wb32(s, 0); /* unknown */
230  avio_wb16(s, stream->par->sample_rate); /* sample rate */
231  avio_wb32(s, 0x10); /* unknown */
232  avio_wb16(s, stream->par->ch_layout.nb_channels);
233  put_str8(s, "Int0"); /* codec name */
234  if (stream->par->codec_tag) {
235  avio_w8(s, 4); /* tag length */
236  avio_wl32(s, stream->par->codec_tag);
237  } else {
238  av_log(ctx, AV_LOG_ERROR, "Invalid codec tag\n");
239  return -1;
240  }
241  avio_wb16(s, 0); /* title length */
242  avio_wb16(s, 0); /* author length */
243  avio_wb16(s, 0); /* copyright length */
244  avio_w8(s, 0); /* end of header */
245  } else {
246  /* video codec info */
247  avio_wb32(s,34); /* size */
248  ffio_wfourcc(s, "VIDO");
249  if(stream->par->codec_id == AV_CODEC_ID_RV10)
250  ffio_wfourcc(s,"RV10");
251  else
252  ffio_wfourcc(s,"RV20");
253  avio_wb16(s, stream->par->width);
254  avio_wb16(s, stream->par->height);
255 
256  if (stream->frame_rate.num / stream->frame_rate.den > 65535) {
257  av_log(s, AV_LOG_ERROR, "Frame rate %d is too high\n", stream->frame_rate.num / stream->frame_rate.den);
258  return AVERROR(EINVAL);
259  }
260 
261  avio_wb16(s, stream->frame_rate.num / stream->frame_rate.den); /* frames per seconds ? */
262  avio_wb32(s,0); /* unknown meaning */
263  avio_wb16(s, stream->frame_rate.num / stream->frame_rate.den); /* unknown meaning */
264  avio_wb32(s,0); /* unknown meaning */
265  avio_wb16(s, 8); /* unknown meaning */
266  /* Seems to be the codec version: only use basic H.263. The next
267  versions seems to add a differential DC coding as in
268  MPEG... nothing new under the sun. */
269  if(stream->par->codec_id == AV_CODEC_ID_RV10)
270  avio_wb32(s,0x10000000);
271  else
272  avio_wb32(s,0x20103001);
273  //avio_wb32(s,0x10003000);
274  }
275  }
276 
277  /* patch data offset field */
278  rm->data_pos = avio_tell(s);
279  if (avio_seek(s, data_offset, SEEK_SET) >= 0) {
280  avio_wb32(s, rm->data_pos);
281  avio_seek(s, rm->data_pos, SEEK_SET);
282  }
283 
284  /* data stream */
285  ffio_wfourcc(s, "DATA");
286  avio_wb32(s,data_size + 10 + 8);
287  avio_wb16(s,0);
288 
289  avio_wb32(s, nb_packets); /* number of packets */
290  avio_wb32(s,0); /* next data header */
291  return 0;
292 }
293 
294  static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
295  int length, int key_frame)
296 {
297  int timestamp;
298  AVIOContext *s = ctx->pb;
299 
300  stream->nb_packets++;
301  stream->packet_total_size += length;
302  if (length > stream->packet_max_size)
303  stream->packet_max_size = length;
304 
305  avio_wb16(s,0); /* version */
306  avio_wb16(s,length + 12);
307  avio_wb16(s, stream->num); /* stream number */
308  timestamp = av_rescale_q_rnd(stream->nb_frames, (AVRational){1000, 1}, stream->frame_rate, AV_ROUND_ZERO);
309  avio_wb32(s, timestamp); /* timestamp */
310  avio_w8(s, 0); /* reserved */
311  avio_w8(s, key_frame ? 2 : 0); /* flags */
312 }
313 
314  static int rm_write_header(AVFormatContext *s)
315 {
316  RMMuxContext *rm = s->priv_data;
317  StreamInfo *stream;
318  int n;
319  AVCodecParameters *par;
320 
321  if (s->nb_streams > 2) {
322  av_log(s, AV_LOG_ERROR, "At most 2 streams are currently supported for muxing in RM\n");
323  return AVERROR_PATCHWELCOME;
324  }
325 
326  for(n=0;n<s->nb_streams;n++) {
327  AVStream *st = s->streams[n];
328  int frame_size;
329 
330  s->streams[n]->id = n;
331  par = s->streams[n]->codecpar;
332  stream = &rm->streams[n];
333  memset(stream, 0, sizeof(StreamInfo));
334  stream->num = n;
335  stream->bit_rate = par->bit_rate;
336  stream->par = par;
337 
338  switch (par->codec_type) {
339  case AVMEDIA_TYPE_AUDIO:
340  rm->audio_stream = stream;
341  frame_size = av_get_audio_frame_duration2(par, 0);
342  stream->frame_rate = (AVRational){par->sample_rate, frame_size};
343  /* XXX: dummy values */
344  stream->packet_max_size = 1024;
345  stream->nb_packets = 0;
346  stream->total_frames = stream->nb_packets;
347  break;
348  case AVMEDIA_TYPE_VIDEO:
349  rm->video_stream = stream;
350  // TODO: should be avg_frame_rate
351  stream->frame_rate = av_inv_q(st->time_base);
352  /* XXX: dummy values */
353  stream->packet_max_size = 4096;
354  stream->nb_packets = 0;
355  stream->total_frames = stream->nb_packets;
356  break;
357  default:
358  return -1;
359  }
360  }
361 
362  if (rv10_write_header(s, 0, 0))
363  return AVERROR_INVALIDDATA;
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  const FFOutputFormat ff_rm_muxer = {
470  .p.name = "rm",
471  .p.long_name = NULL_IF_CONFIG_SMALL("RealMedia"),
472  .p.mime_type = "application/vnd.rn-realmedia",
473  .p.extensions = "rm,ra",
474  .priv_data_size = sizeof(RMMuxContext),
475  .p.audio_codec = AV_CODEC_ID_AC3,
476  .p.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  .p.codec_tag = (const AVCodecTag* const []){ ff_rm_codec_tags, 0 },
481 };
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:443
RMMuxContext::streams
StreamInfo streams[2]
Definition: rmenc.c:41
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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
put_str8
static void put_str8(AVIOContext *s, const char *tag)
Definition: rmenc.c:62
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
ffio_wfourcc
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:124
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
StreamInfo::nb_packets
int nb_packets
Definition: rmenc.c:28
AVPacket::data
uint8_t * data
Definition: packet.h:539
AV_ROUND_ZERO
@ AV_ROUND_ZERO
Round toward zero.
Definition: mathematics.h:131
StreamInfo::packet_total_size
int packet_total_size
Definition: rmenc.c:29
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
StreamInfo::frame_rate
AVRational frame_rate
Definition: rmenc.c:33
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
rm_write_header
static int rm_write_header(AVFormatContext *s)
Definition: rmenc.c:314
AVRational::num
int num
Numerator.
Definition: rational.h:59
RMMuxContext::video_stream
StreamInfo * video_stream
Definition: rmenc.c:42
rv10_write_header
static int rv10_write_header(AVFormatContext *ctx, int data_size, int index_pos)
Definition: rmenc.c:70
ff_rm_metadata
const char *const ff_rm_metadata[4]
Definition: rm.c:24
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1522
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVCodecTag
Definition: internal.h:42
duration
int64_t duration
Definition: movenc.c:65
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:62
s
#define s(width, name)
Definition: cbs_vp9.c:198
frame_size
int frame_size
Definition: mxfenc.c:2424
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
StreamInfo::par
AVCodecParameters * par
Definition: rmenc.c:37
RMMuxContext
Definition: rmenc.c:40
StreamInfo::total_frames
int total_frames
Definition: rmenc.c:35
ctx
AVFormatContext * ctx
Definition: movenc.c:49
StreamInfo::bit_rate
int bit_rate
Definition: rmenc.c:32
RMMuxContext::audio_stream
StreamInfo * audio_stream
Definition: rmenc.c:42
AVFormatContext
Format I/O context.
Definition: avformat.h:1287
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:787
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
rm_write_trailer
static int rm_write_trailer(AVFormatContext *s)
Definition: rmenc.c:438
ff_rm_codec_tags
const AVCodecTag ff_rm_codec_tags[]
Definition: rm.c:31
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1329
rm_write_video
static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags)
Definition: rmenc.c:389
StreamInfo::nb_frames
int nb_frames
Definition: rmenc.c:34
FFOutputFormat
Definition: mux.h:61
RMMuxContext::data_pos
int data_pos
Definition: rmenc.c:43
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
BUFFER_DURATION
#define BUFFER_DURATION
Definition: rmenc.c:47
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1343
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
StreamInfo
Definition: mpegenc.c:51
AVPacket::size
int size
Definition: packet.h:540
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:94
size
int size
Definition: twinvq_data.h:10344
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:799
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:365
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:357
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
MAX_PACKET_SIZE
#define MAX_PACKET_SIZE
Definition: rmenc.c:51
AV_CODEC_ID_RV10
@ AV_CODEC_ID_RV10
Definition: codec_id.h:57
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
avio_internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
StreamInfo::packet_max_size
int packet_max_size
Definition: rmenc.c:30
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
write_packet_header
static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream, int length, int key_frame)
Definition: rmenc.c:294
tag
uint32_t tag
Definition: movenc.c:1879
AVStream
Stream structure.
Definition: avformat.h:748
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
avformat.h
dict.h
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
AVRational::den
int den
Denominator.
Definition: rational.h:60
put_str
static void put_str(AVIOContext *s, const char *tag)
Definition: rmenc.c:54
rm_write_packet
static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rmenc.c:429
AVPacket::stream_index
int stream_index
Definition: packet.h:541
ff_rm_muxer
const FFOutputFormat ff_rm_muxer
Definition: rmenc.c:469
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVDictionaryEntry
Definition: dict.h:89
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
StreamInfo::num
int num
Definition: rmenc.c:36
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:443
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
rm_write_audio
static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int flags)
Definition: rmenc.c:367
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
rm.h
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1315
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
mux.h
Generated on Fri Aug 22 2025 13:59:34 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /