FFmpeg
avienc.c
Go to the documentation of this file.
1 /*
2  * AVI muxer
3  * Copyright (c) 2000 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 
22 #include <math.h>
23 
24 #include "avformat.h"
25 #include "internal.h"
26 #include "avi.h"
27 #include "avio_internal.h"
28 #include "libavutil/attributes.h"
29 #include "riff.h"
30 #include "mpegts.h"
31 #include "mux.h"
32 #include "rawutils.h"
33 #include "libavformat/avlanguage.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/dict.h"
38 #include "libavutil/avassert.h"
39 #include "libavutil/mem.h"
40 #include "libavutil/timestamp.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavcodec/raw.h"
44 
45 /*
46  * TODO:
47  * - fill all fields if non streamed (nb_frames for example)
48  */
49 
50 typedef struct AVIIentry {
51  char tag[4];
52  unsigned int flags;
53  unsigned int pos;
54  unsigned int len;
55 } AVIIentry;
56 
57 #define AVI_INDEX_CLUSTER_SIZE 16384
58 #define AVI_MASTER_INDEX_PREFIX_SIZE (8+2+1+1+4+8+4+4)
59 #define AVI_MASTER_INDEX_ENTRY_SIZE 16 /* bytes per entry */
60 #define AVI_MASTER_INDEX_SIZE_DEFAULT 256 /* number of entries */
61 
62 typedef struct AVIIndex {
63  int64_t indx_start;
64  int64_t audio_strm_offset;
65  int entry;
66  int ents_allocated;
67  int master_odml_riff_id_base;
68  AVIIentry** cluster;
69 } AVIIndex;
70 
71 typedef struct AVIContext {
72  const AVClass *class;
73  AVPacket *empty_packet;
74  int64_t riff_start, movi_list, odml_list;
75  int64_t frames_hdr_all;
76  int riff_id;
77  int reserve_index_space;
78  int master_index_max_size;
79  int write_channel_mask;
80  int flipped_raw_rgb;
81 } AVIContext;
82 
83 typedef struct AVIStream {
84  int64_t frames_hdr_strm;
85  int64_t audio_strm_length;
86  int packet_count;
87  int entry;
88  int max_size;
89  int sample_requested;
90 
91  int64_t last_dts;
92 
93  AVIIndex indexes;
94 
95  int64_t strh_flags_offset;
96 
97  uint32_t palette[AVPALETTE_COUNT];
98  uint32_t old_palette[AVPALETTE_COUNT];
99  int64_t pal_offset;
100 } AVIStream;
101 
102 static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt);
103 
104 static inline AVIIentry *avi_get_ientry(const AVIIndex *idx, int ent_id)
105 {
106  int cl = ent_id / AVI_INDEX_CLUSTER_SIZE;
107  int id = ent_id % AVI_INDEX_CLUSTER_SIZE;
108  return &idx->cluster[cl][id];
109 }
110 
111 static int avi_add_ientry(AVFormatContext *s, int stream_index, char *tag,
112  unsigned int flags, unsigned int size)
113 {
114  AVIContext *avi = s->priv_data;
115  AVIOContext *pb = s->pb;
116  AVIStream *avist = s->streams[stream_index]->priv_data;
117  AVIIndex *idx = &avist->indexes;
118  int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE;
119  int id = idx->entry % AVI_INDEX_CLUSTER_SIZE;
120 
121  if (idx->ents_allocated <= idx->entry) {
122  idx->cluster = av_realloc_f(idx->cluster, sizeof(void*), cl+1);
123  if (!idx->cluster) {
124  idx->ents_allocated = 0;
125  idx->entry = 0;
126  return AVERROR(ENOMEM);
127  }
128  idx->cluster[cl] =
129  av_malloc(AVI_INDEX_CLUSTER_SIZE * sizeof(AVIIentry));
130  if (!idx->cluster[cl])
131  return AVERROR(ENOMEM);
132  idx->ents_allocated += AVI_INDEX_CLUSTER_SIZE;
133  }
134 
135  if (tag)
136  memcpy(idx->cluster[cl][id].tag, tag, 4);
137  else
138  memset(idx->cluster[cl][id].tag, 0, 4);
139  idx->cluster[cl][id].flags = flags;
140  idx->cluster[cl][id].pos = avio_tell(pb) - avi->movi_list;
141  idx->cluster[cl][id].len = size;
142  avist->max_size = FFMAX(avist->max_size, size);
143  idx->entry++;
144 
145  return 0;
146 }
147 
148 static av_cold int avi_init(struct AVFormatContext *s)
149 {
150  AVIContext *avi = s->priv_data;
151 
152  if (avi->reserve_index_space > 0) {
153  avi->master_index_max_size = (avi->reserve_index_space - AVI_MASTER_INDEX_PREFIX_SIZE) / AVI_MASTER_INDEX_ENTRY_SIZE;
154  avi->master_index_max_size = FFMAX(avi->master_index_max_size, 16);
155  } else
156  avi->master_index_max_size = AVI_MASTER_INDEX_SIZE_DEFAULT;
157  av_log(s, AV_LOG_DEBUG, "reserve_index_space:%d master_index_max_size:%d\n",
158  avi->reserve_index_space, avi->master_index_max_size);
159 
160  return 1; /* stream initialization continues in avi_write_header */
161 }
162 
163 static int64_t avi_start_new_riff(AVFormatContext *s, AVIOContext *pb,
164  const char *riff_tag, const char *list_tag)
165 {
166  AVIContext *avi = s->priv_data;
167  int64_t loff;
168  int i;
169 
170  avi->riff_id++;
171  for (i = 0; i < s->nb_streams; i++) {
172  AVIStream *avist = s->streams[i]->priv_data;
173  avist->indexes.audio_strm_offset = avist->audio_strm_length;
174  avist->indexes.entry = 0;
175  }
176 
177  avi->riff_start = ff_start_tag(pb, "RIFF");
178  ffio_wfourcc(pb, riff_tag);
179  loff = ff_start_tag(pb, "LIST");
180  ffio_wfourcc(pb, list_tag);
181  return loff;
182 }
183 
184 static char *avi_stream2fourcc(char *tag, int index, enum AVMediaType type)
185 {
186  tag[0] = '0' + index / 10;
187  tag[1] = '0' + index % 10;
188  if (type == AVMEDIA_TYPE_VIDEO) {
189  tag[2] = 'd';
190  tag[3] = 'c';
191  } else if (type == AVMEDIA_TYPE_SUBTITLE) {
192  // note: this is not an official code
193  tag[2] = 's';
194  tag[3] = 'b';
195  } else {
196  tag[2] = 'w';
197  tag[3] = 'b';
198  }
199  tag[4] = '\0';
200  return tag;
201 }
202 
203 static int avi_write_counters(AVFormatContext *s, int riff_id)
204 {
205  AVIOContext *pb = s->pb;
206  AVIContext *avi = s->priv_data;
207  int n, au_byterate, au_ssize, au_scale, nb_frames = 0;
208  int64_t file_size;
209  AVCodecParameters *par;
210 
211  file_size = avio_tell(pb);
212  for (n = 0; n < s->nb_streams; n++) {
213  AVIStream *avist = s->streams[n]->priv_data;
214 
215  av_assert0(avist->frames_hdr_strm);
216  par = s->streams[n]->codecpar;
217  avio_seek(pb, avist->frames_hdr_strm, SEEK_SET);
218  ff_parse_specific_params(s->streams[n], &au_byterate, &au_ssize, &au_scale);
219  if (au_ssize == 0)
220  avio_wl32(pb, avist->packet_count);
221  else
222  avio_wl32(pb, avist->audio_strm_length / au_ssize);
223  if (par->codec_type == AVMEDIA_TYPE_VIDEO)
224  nb_frames = FFMAX(nb_frames, avist->packet_count);
225  }
226  if (riff_id == 1) {
227  av_assert0(avi->frames_hdr_all);
228  avio_seek(pb, avi->frames_hdr_all, SEEK_SET);
229  avio_wl32(pb, nb_frames);
230  }
231  avio_seek(pb, file_size, SEEK_SET);
232 
233  return 0;
234 }
235 
236 static void write_odml_master(AVFormatContext *s, int stream_index)
237 {
238  AVIOContext *pb = s->pb;
239  AVIContext *avi = s->priv_data;
240  AVStream *st = s->streams[stream_index];
241  AVCodecParameters *par = st->codecpar;
242  AVIStream *avist = st->priv_data;
243  unsigned char tag[5];
244 
245  /* Starting to lay out AVI OpenDML master index.
246  * We want to make it JUNK entry for now, since we'd
247  * like to get away without making AVI an OpenDML one
248  * for compatibility reasons. */
249  avist->indexes.indx_start = ff_start_tag(pb, "JUNK");
250  avio_wl16(pb, 4); /* wLongsPerEntry */
251  avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
252  avio_w8(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
253  avio_wl32(pb, 0); /* nEntriesInUse (will fill out later on) */
254  ffio_wfourcc(pb, avi_stream2fourcc(tag, stream_index, par->codec_type));
255  /* dwChunkId */
256  ffio_fill(pb, 0, 3 * 4 /* dwReserved[3] */
257  + 16LL * avi->master_index_max_size);
258  ff_end_tag(pb, avist->indexes.indx_start);
259 }
260 
261 static int avi_write_header(AVFormatContext *s)
262 {
263  AVIContext *avi = s->priv_data;
264  AVIOContext *pb = s->pb;
265  int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
266  int64_t max_stream_duration = 0;
267  AVCodecParameters *video_par;
268  AVStream *video_st = NULL;
269  int64_t list1, list2, strh, strf;
270  AVDictionaryEntry *t = NULL;
271  int padding;
272 
273  if (s->nb_streams > AVI_MAX_STREAM_COUNT) {
274  av_log(s, AV_LOG_ERROR, "AVI does not support "
275  ">"AV_STRINGIFY(AVI_MAX_STREAM_COUNT)" streams\n");
276  return AVERROR(EINVAL);
277  }
278 
279  avi->empty_packet = ffformatcontext(s)->pkt;
280 
281  for (n = 0; n < s->nb_streams; n++) {
282  s->streams[n]->priv_data = av_mallocz(sizeof(AVIStream));
283  if (!s->streams[n]->priv_data)
284  return AVERROR(ENOMEM);
285  }
286 
287  /* header list */
288  avi->riff_id = 0;
289  list1 = avi_start_new_riff(s, pb, "AVI ", "hdrl");
290 
291  /* avi header */
292  ffio_wfourcc(pb, "avih");
293  avio_wl32(pb, 14 * 4);
294  bitrate = 0;
295 
296  video_par = NULL;
297  for (n = 0; n < s->nb_streams; n++) {
298  AVCodecParameters *par = s->streams[n]->codecpar;
299  AVStream *st = s->streams[n];
300  bitrate = FFMIN(bitrate + par->bit_rate, INT32_MAX);
301  if (st->duration > 0) {
302  int64_t stream_duration = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
303  max_stream_duration = FFMAX(stream_duration, max_stream_duration);
304  }
305  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
306  video_par = par;
307  video_st = st;
308  }
309  }
310 
311  /* guess master index size based on bitrate and duration */
312  if (!avi->reserve_index_space) {
313  double duration_est, filesize_est;
314  if (s->duration > 0)
315  duration_est = (double)s->duration / AV_TIME_BASE;
316  else if (max_stream_duration > 0)
317  duration_est = (double)max_stream_duration / AV_TIME_BASE;
318  else
319  duration_est = 10 * 60 * 60; /* default to 10 hours */
320  filesize_est = duration_est * (bitrate / 8) * 1.10; /* add 10% safety margin for muxer+bitrate */
321  avi->master_index_max_size = FFMAX((int)ceil(filesize_est / AVI_MAX_RIFF_SIZE) + 1,
322  avi->master_index_max_size);
323  av_log(s, AV_LOG_DEBUG, "duration_est:%0.3f, filesize_est:%0.1fGiB, master_index_max_size:%d\n",
324  duration_est, filesize_est / (1024*1024*1024), avi->master_index_max_size);
325  }
326 
327  nb_frames = 0;
328 
329  // TODO: should be avg_frame_rate
330  if (video_st)
331  avio_wl32(pb, (uint32_t) (INT64_C(1000000) * video_st->time_base.num /
332  video_st->time_base.den));
333  else
334  avio_wl32(pb, 0);
335  avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
336  avio_wl32(pb, 0); /* padding */
337  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
338  avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
339  else
340  avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
341  avi->frames_hdr_all = avio_tell(pb); /* remember this offset to fill later */
342  avio_wl32(pb, nb_frames); /* nb frames, filled later */
343  avio_wl32(pb, 0); /* initial frame */
344  avio_wl32(pb, s->nb_streams); /* nb streams */
345  avio_wl32(pb, 1024 * 1024); /* suggested buffer size */
346  if (video_par) {
347  avio_wl32(pb, video_par->width);
348  avio_wl32(pb, video_par->height);
349  } else {
350  avio_wl32(pb, 0);
351  avio_wl32(pb, 0);
352  }
353  ffio_fill(pb, 0, 4 * 4); /* reserved */
354 
355  /* stream list */
356  for (i = 0; i < n; i++) {
357  AVStream *st = s->streams[i];
358  AVCodecParameters *par = st->codecpar;
359  AVIStream *avist = st->priv_data;
360  list2 = ff_start_tag(pb, "LIST");
361  ffio_wfourcc(pb, "strl");
362 
363  /* stream generic header */
364  strh = ff_start_tag(pb, "strh");
365  switch (par->codec_type) {
366  case AVMEDIA_TYPE_SUBTITLE:
367  // XSUB subtitles behave like video tracks, other subtitles
368  // are not (yet) supported.
369  if (par->codec_id != AV_CODEC_ID_XSUB) {
370  avpriv_report_missing_feature(s, "Subtitle streams other than DivX XSUB");
371  return AVERROR_PATCHWELCOME;
372  }
373  av_fallthrough;
374  case AVMEDIA_TYPE_VIDEO:
375  ffio_wfourcc(pb, "vids");
376  break;
377  case AVMEDIA_TYPE_AUDIO:
378  ffio_wfourcc(pb, "auds");
379  break;
380 // case AVMEDIA_TYPE_TEXT:
381 // ffio_wfourcc(pb, "txts");
382 // break;
383  case AVMEDIA_TYPE_DATA:
384  ffio_wfourcc(pb, "dats");
385  break;
386  }
387  if (par->codec_type == AVMEDIA_TYPE_VIDEO ||
388  par->codec_id == AV_CODEC_ID_XSUB)
389  avio_wl32(pb, par->codec_tag);
390  else
391  avio_wl32(pb, 1);
392  avist->strh_flags_offset = avio_tell(pb);
393  avio_wl32(pb, 0); /* flags */
394  avio_wl16(pb, 0); /* priority */
395  avio_wl16(pb, 0); /* language */
396  avio_wl32(pb, 0); /* initial frame */
397 
398  ff_parse_specific_params(st, &au_byterate, &au_ssize, &au_scale);
399 
400  if ( par->codec_type == AVMEDIA_TYPE_VIDEO
401  && par->codec_id != AV_CODEC_ID_XSUB
402  && au_byterate > 1000LL*au_scale) {
403  au_byterate = 600;
404  au_scale = 1;
405  }
406  avpriv_set_pts_info(st, 64, au_scale, au_byterate);
407  if (par->codec_id == AV_CODEC_ID_XSUB)
408  au_scale = au_byterate = 0;
409 
410  avio_wl32(pb, au_scale); /* scale */
411  avio_wl32(pb, au_byterate); /* rate */
412 
413  avio_wl32(pb, 0); /* start */
414  /* remember this offset to fill later */
415  avist->frames_hdr_strm = avio_tell(pb);
416  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
417  /* FIXME: this may be broken, but who cares */
418  avio_wl32(pb, AVI_MAX_RIFF_SIZE);
419  else
420  avio_wl32(pb, 0); /* length, XXX: filled later */
421 
422  /* suggested buffer size, is set to largest chunk size in avi_write_trailer */
423  if (par->codec_type == AVMEDIA_TYPE_VIDEO)
424  avio_wl32(pb, 1024 * 1024);
425  else if (par->codec_type == AVMEDIA_TYPE_AUDIO)
426  avio_wl32(pb, 12 * 1024);
427  else
428  avio_wl32(pb, 0);
429  avio_wl32(pb, -1); /* quality */
430  avio_wl32(pb, au_ssize); /* sample size */
431  avio_wl32(pb, 0);
432  if (par->width > 65535 || par->height > 65535) {
433  av_log(s, AV_LOG_ERROR, "%dx%d dimensions are too big\n", par->width, par->height);
434  return AVERROR(EINVAL);
435  }
436  avio_wl16(pb, par->width);
437  avio_wl16(pb, par->height);
438  ff_end_tag(pb, strh);
439 
440  if (par->codec_type != AVMEDIA_TYPE_DATA) {
441  int ret, flags;
442  enum AVPixelFormat pix_fmt;
443 
444  strf = ff_start_tag(pb, "strf");
445  switch (par->codec_type) {
446  case AVMEDIA_TYPE_SUBTITLE:
447  /* XSUB subtitles behave like video tracks, other subtitles
448  * are not (yet) supported. */
449  if (par->codec_id != AV_CODEC_ID_XSUB)
450  break;
451  av_fallthrough;
452  case AVMEDIA_TYPE_VIDEO:
453  /* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */
454  if ( !par->codec_tag
455  && par->codec_id == AV_CODEC_ID_RAWVIDEO
456  && par->format == AV_PIX_FMT_RGB555LE
457  && par->bits_per_coded_sample == 15)
458  par->bits_per_coded_sample = 16;
459  avist->pal_offset = avio_tell(pb) + 40;
460  ff_put_bmp_header(pb, par, 0, 0, avi->flipped_raw_rgb);
461  pix_fmt = avpriv_pix_fmt_find(PIX_FMT_LIST_AVI,
462  par->bits_per_coded_sample);
463  if ( !par->codec_tag
464  && par->codec_id == AV_CODEC_ID_RAWVIDEO
465  && par->format != pix_fmt
466  && par->format != AV_PIX_FMT_NONE)
467  av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to avi, output file will be unreadable\n",
468  av_get_pix_fmt_name(par->format));
469 
470  if (par->format == AV_PIX_FMT_PAL8) {
471  if (par->bits_per_coded_sample < 0 || par->bits_per_coded_sample > 8) {
472  av_log(s, AV_LOG_ERROR, "PAL8 with %d bps is not allowed\n", par->bits_per_coded_sample);
473  return AVERROR(EINVAL);
474  }
475  }
476 
477  break;
478  case AVMEDIA_TYPE_AUDIO:
479  flags = (avi->write_channel_mask == 0) ? FF_PUT_WAV_HEADER_SKIP_CHANNELMASK : 0;
480  if ((ret = ff_put_wav_header(s, pb, par, flags)) < 0)
481  return ret;
482  break;
483  default:
484  av_log(s, AV_LOG_ERROR,
485  "Invalid or not supported codec type '%s' found in the input\n",
486  (char *)av_x_if_null(av_get_media_type_string(par->codec_type), "?"));
487  return AVERROR(EINVAL);
488  }
489  ff_end_tag(pb, strf);
490  if ((t = av_dict_get(st->metadata, "title", NULL, 0))) {
491  ff_riff_write_info_tag(s->pb, "strn", t->value);
492  t = NULL;
493  }
494  if (par->codec_id == AV_CODEC_ID_XSUB
495  && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) {
496  const char* langstr = ff_convert_lang_to(t->value, AV_LANG_ISO639_1);
497  t = NULL;
498  if (langstr) {
499  char* str = av_asprintf("Subtitle - %s-xx;02", langstr);
500  if (!str)
501  return AVERROR(ENOMEM);
502  ff_riff_write_info_tag(s->pb, "strn", str);
503  av_free(str);
504  }
505  }
506  }
507 
508  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
509  write_odml_master(s, i);
510  }
511 
512  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
513  st->sample_aspect_ratio.num > 0 &&
514  st->sample_aspect_ratio.den > 0) {
515  int vprp = ff_start_tag(pb, "vprp");
516  AVRational dar = av_mul_q(st->sample_aspect_ratio,
517  (AVRational) { par->width,
518  par->height });
519  int num, den, fields, i;
520  av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
521  if (par->field_order == AV_FIELD_TT || par->field_order == AV_FIELD_BB ||
522  par->field_order == AV_FIELD_TB || par->field_order == AV_FIELD_BT) {
523  fields = 2; // interlaced
524  } else {
525  fields = 1; // progressive
526  }
527 
528  avio_wl32(pb, 0); // video format = unknown
529  avio_wl32(pb, 0); // video standard = unknown
530  // TODO: should be avg_frame_rate
531  avio_wl32(pb, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num));
532  avio_wl32(pb, par->width);
533  avio_wl32(pb, par->height);
534  avio_wl16(pb, den);
535  avio_wl16(pb, num);
536  avio_wl32(pb, par->width);
537  avio_wl32(pb, par->height);
538  avio_wl32(pb, fields); // fields per frame
539 
540  for (i = 0; i < fields; i++) {
541  int start_line;
542  // OpenDML v1.02 is not very specific on what value to use for
543  // start_line when frame data is not coming from a capturing device,
544  // so just use 0/1 depending on the field order for interlaced frames
545  if (par->field_order == AV_FIELD_TT || par->field_order == AV_FIELD_TB) {
546  start_line = (i == 0) ? 0 : 1;
547  } else if (par->field_order == AV_FIELD_BB || par->field_order == AV_FIELD_BT) {
548  start_line = (i == 0) ? 1 : 0;
549  } else {
550  start_line = 0;
551  }
552 
553  avio_wl32(pb, par->height / fields); // compressed bitmap height
554  avio_wl32(pb, par->width); // compressed bitmap width
555  avio_wl32(pb, par->height / fields); // valid bitmap height
556  avio_wl32(pb, par->width); // valid bitmap width
557  avio_wl32(pb, 0); // valid bitmap X offset
558  avio_wl32(pb, 0); // valid bitmap Y offset
559  avio_wl32(pb, 0); // valid X offset in T
560  avio_wl32(pb, start_line); // valid Y start line
561  }
562  ff_end_tag(pb, vprp);
563  }
564 
565  ff_end_tag(pb, list2);
566  }
567 
568  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
569  /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
570  avi->odml_list = ff_start_tag(pb, "JUNK");
571  ffio_wfourcc(pb, "odml");
572  ffio_wfourcc(pb, "dmlh");
573  avio_wl32(pb, 248);
574  ffio_fill(pb, 0, 248);
575  ff_end_tag(pb, avi->odml_list);
576  }
577 
578  ff_end_tag(pb, list1);
579 
580  ff_riff_write_info(s);
581 
582 
583  padding = s->metadata_header_padding;
584  if (padding < 0)
585  padding = 1016;
586 
587  /* some padding for easier tag editing */
588  if (padding) {
589  list2 = ff_start_tag(pb, "JUNK");
590  ffio_fill(pb, 0, FFALIGN((uint32_t)padding, 4));
591  ff_end_tag(pb, list2);
592  }
593 
594  avi->movi_list = ff_start_tag(pb, "LIST");
595  ffio_wfourcc(pb, "movi");
596 
597  return 0;
598 }
599 
600 static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
601 {
602  AVIOContext *pb = s->pb;
603  AVIContext *avi = s->priv_data;
604  AVIStream *avist = s->streams[stream_index]->priv_data;
605  int64_t pos;
606  int au_byterate, au_ssize, au_scale;
607 
608  pos = avio_tell(pb);
609 
610  /* Updating one entry in the AVI OpenDML master index */
611  avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET);
612  ffio_wfourcc(pb, "indx"); /* enabling this entry */
613  avio_skip(pb, 8);
614  avio_wl32(pb, avi->riff_id - avist->indexes.master_odml_riff_id_base); /* nEntriesInUse */
615  avio_skip(pb, 16 * (avi->riff_id - avist->indexes.master_odml_riff_id_base));
616  avio_wl64(pb, ix); /* qwOffset */
617  avio_wl32(pb, size); /* dwSize */
618  ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale);
619  if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) {
620  uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset);
621  if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) {
622  avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames");
623  avist->sample_requested = 1;
624  }
625  avio_wl32(pb, audio_segm_size / au_ssize); /* dwDuration (sample count) */
626  } else
627  avio_wl32(pb, avist->indexes.entry); /* dwDuration (packet count) */
628 
629  avio_seek(pb, pos, SEEK_SET);
630 }
631 
632 static int avi_write_ix(AVFormatContext *s)
633 {
634  AVIOContext *pb = s->pb;
635  AVIContext *avi = s->priv_data;
636  char tag[5];
637  char ix_tag[] = "ix00";
638  int i, j;
639 
640  av_assert0(pb->seekable & AVIO_SEEKABLE_NORMAL);
641 
642  for (i = 0; i < s->nb_streams; i++) {
643  AVIStream *avist = s->streams[i]->priv_data;
644  if (avi->riff_id - avist->indexes.master_odml_riff_id_base == avi->master_index_max_size) {
645  int64_t pos;
646  int size = AVI_MASTER_INDEX_PREFIX_SIZE + AVI_MASTER_INDEX_ENTRY_SIZE * avi->master_index_max_size;
647 
648  pos = avio_tell(pb);
649  update_odml_entry(s, i, pos, size);
650  write_odml_master(s, i);
651  av_assert1(avio_tell(pb) - pos == size);
652  avist->indexes.master_odml_riff_id_base = avi->riff_id - 1;
653  }
654  av_assert0(avi->riff_id - avist->indexes.master_odml_riff_id_base < avi->master_index_max_size);
655  }
656 
657  for (i = 0; i < s->nb_streams; i++) {
658  AVIStream *avist = s->streams[i]->priv_data;
659  int64_t ix;
660 
661  avi_stream2fourcc(tag, i, s->streams[i]->codecpar->codec_type);
662  ix_tag[3] = '0' + i;
663 
664  /* Writing AVI OpenDML leaf index chunk */
665  ix = avio_tell(pb);
666  ffio_wfourcc(pb, ix_tag); /* ix?? */
667  avio_wl32(pb, avist->indexes.entry * 8 + 24);
668  /* chunk size */
669  avio_wl16(pb, 2); /* wLongsPerEntry */
670  avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
671  avio_w8(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
672  avio_wl32(pb, avist->indexes.entry);
673  /* nEntriesInUse */
674  ffio_wfourcc(pb, tag); /* dwChunkId */
675  avio_wl64(pb, avi->movi_list); /* qwBaseOffset */
676  avio_wl32(pb, 0); /* dwReserved_3 (must be 0) */
677 
678  for (j = 0; j < avist->indexes.entry; j++) {
679  AVIIentry *ie = avi_get_ientry(&avist->indexes, j);
680  avio_wl32(pb, ie->pos + 8);
681  avio_wl32(pb, ((uint32_t) ie->len & ~0x80000000) |
682  (ie->flags & 0x10 ? 0 : 0x80000000));
683  }
684 
685  update_odml_entry(s, i, ix, avio_tell(pb) - ix);
686  }
687  return 0;
688 }
689 
690 static int avi_write_idx1(AVFormatContext *s)
691 {
692  AVIOContext *pb = s->pb;
693  AVIContext *avi = s->priv_data;
694  int64_t idx_chunk;
695  int i;
696  char tag[5];
697 
698  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
699  AVIStream *avist;
700  AVIIentry *ie = 0, *tie;
701  int empty, stream_id = -1;
702 
703  idx_chunk = ff_start_tag(pb, "idx1");
704  for (i = 0; i < s->nb_streams; i++) {
705  avist = s->streams[i]->priv_data;
706  avist->entry = 0;
707  }
708 
709  do {
710  empty = 1;
711  for (i = 0; i < s->nb_streams; i++) {
712  avist = s->streams[i]->priv_data;
713  if (avist->indexes.entry <= avist->entry)
714  continue;
715 
716  tie = avi_get_ientry(&avist->indexes, avist->entry);
717  if (empty || tie->pos < ie->pos) {
718  ie = tie;
719  stream_id = i;
720  }
721  empty = 0;
722  }
723  if (!empty) {
724  avist = s->streams[stream_id]->priv_data;
725  if (*ie->tag)
726  ffio_wfourcc(pb, ie->tag);
727  else {
728  avi_stream2fourcc(tag, stream_id,
729  s->streams[stream_id]->codecpar->codec_type);
730  ffio_wfourcc(pb, tag);
731  }
732  avio_wl32(pb, ie->flags);
733  avio_wl32(pb, ie->pos);
734  avio_wl32(pb, ie->len);
735  avist->entry++;
736  }
737  } while (!empty);
738  ff_end_tag(pb, idx_chunk);
739 
740  avi_write_counters(s, avi->riff_id);
741  }
742  return 0;
743 }
744 
745 static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
746 {
747  AVIContext *avi = s->priv_data;
748  AVIStream *avist = s->streams[stream_index]->priv_data;
749  AVCodecParameters *par = s->streams[stream_index]->codecpar;
750 
751  ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);
752  while (par->block_align == 0 && dts != AV_NOPTS_VALUE &&
753  dts > avist->packet_count && par->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) {
754 
755  if (dts - avist->packet_count > 60000) {
756  av_log(s, AV_LOG_ERROR, "Too large number of skipped frames %"PRId64" > 60000\n", dts - avist->packet_count);
757  return AVERROR(EINVAL);
758  }
759 
760  avi->empty_packet->stream_index = stream_index;
761  avi_write_packet_internal(s, avi->empty_packet);
762  ff_dlog(s, "dup dts:%s packet_count:%d\n", av_ts2str(dts), avist->packet_count);
763  }
764 
765  return 0;
766 }
767 
768 static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
769 {
770  const int stream_index = pkt->stream_index;
771  AVCodecParameters *par = s->streams[stream_index]->codecpar;
772  int ret;
773 
774  if (par->codec_id == AV_CODEC_ID_H264 && par->codec_tag == MKTAG('H','2','6','4') && pkt->size) {
775  ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt);
776  if (ret < 0)
777  return ret;
778  }
779 
780  if ((ret = write_skip_frames(s, stream_index, pkt->dts)) < 0)
781  return ret;
782 
783  if (!pkt->size)
784  return avi_write_packet_internal(s, pkt); /* Passthrough */
785 
786  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
787  AVIStream *avist = s->streams[stream_index]->priv_data;
788  AVIOContext *pb = s->pb;
789  AVPacket *opkt = pkt;
790  int reshuffle_ret;
791  if (par->codec_id == AV_CODEC_ID_RAWVIDEO && par->codec_tag == 0) {
792  int64_t bpc = par->bits_per_coded_sample != 15 ? par->bits_per_coded_sample : 16;
793  int expected_stride = ((par->width * bpc + 31) >> 5)*4;
794  reshuffle_ret = ff_reshuffle_raw_rgb(s, &pkt, par, expected_stride);
795  if (reshuffle_ret < 0)
796  return reshuffle_ret;
797  } else
798  reshuffle_ret = 0;
799  if (par->format == AV_PIX_FMT_PAL8) {
800  ret = ff_get_packet_palette(s, opkt, reshuffle_ret, avist->palette);
801  if (ret < 0)
802  goto fail;
803  if (ret) {
804  int pal_size = 1 << par->bits_per_coded_sample;
805  int pc_tag, i;
806 
807  av_assert0(par->bits_per_coded_sample >= 0 && par->bits_per_coded_sample <= 8);
808 
809  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && avist->pal_offset) {
810  int64_t cur_offset = avio_tell(pb);
811  avio_seek(pb, avist->pal_offset, SEEK_SET);
812  for (i = 0; i < pal_size; i++) {
813  uint32_t v = avist->palette[i];
814  avio_wl32(pb, v & 0xffffff);
815  }
816  avio_seek(pb, cur_offset, SEEK_SET);
817  memcpy(avist->old_palette, avist->palette, pal_size * 4);
818  avist->pal_offset = 0;
819  }
820  if (memcmp(avist->palette, avist->old_palette, pal_size * 4)) {
821  unsigned char tag[5];
822  avi_stream2fourcc(tag, stream_index, par->codec_type);
823  tag[2] = 'p'; tag[3] = 'c';
824  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
825  if (avist->strh_flags_offset) {
826  int64_t cur_offset = avio_tell(pb);
827  avio_seek(pb, avist->strh_flags_offset, SEEK_SET);
828  avio_wl32(pb, AVISF_VIDEO_PALCHANGES);
829  avio_seek(pb, cur_offset, SEEK_SET);
830  avist->strh_flags_offset = 0;
831  }
832  ret = avi_add_ientry(s, stream_index, tag, AVIIF_NO_TIME,
833  pal_size * 4 + 4);
834  if (ret < 0)
835  goto fail;
836  }
837  pc_tag = ff_start_tag(pb, tag);
838  avio_w8(pb, 0);
839  avio_w8(pb, pal_size & 0xFF);
840  avio_wl16(pb, 0); // reserved
841  for (i = 0; i < pal_size; i++) {
842  uint32_t v = avist->palette[i];
843  avio_wb32(pb, v<<8);
844  }
845  ff_end_tag(pb, pc_tag);
846  memcpy(avist->old_palette, avist->palette, pal_size * 4);
847  }
848  }
849  }
850  if (reshuffle_ret) {
851  ret = avi_write_packet_internal(s, pkt);
852 
853 fail:
854  if (reshuffle_ret)
855  av_packet_free(&pkt);
856  return ret;
857  }
858  }
859 
860  return avi_write_packet_internal(s, pkt);
861 }
862 
863 static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
864 {
865  unsigned char tag[5];
866  unsigned int flags = 0;
867  const int stream_index = pkt->stream_index;
868  int size = pkt->size;
869  AVIContext *avi = s->priv_data;
870  AVIOContext *pb = s->pb;
871  AVIStream *avist = s->streams[stream_index]->priv_data;
872  AVCodecParameters *par = s->streams[stream_index]->codecpar;
873 
874  if (pkt->dts != AV_NOPTS_VALUE)
875  avist->last_dts = pkt->dts + pkt->duration;
876 
877  avist->packet_count++;
878 
879  // Make sure to put an OpenDML chunk when the file size exceeds the limits
880  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) &&
881  (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
882  avi_write_ix(s);
883  ff_end_tag(pb, avi->movi_list);
884 
885  if (avi->riff_id == 1)
886  avi_write_idx1(s);
887 
888  ff_end_tag(pb, avi->riff_start);
889  avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi");
890  }
891 
892  avi_stream2fourcc(tag, stream_index, par->codec_type);
893  if (pkt->flags & AV_PKT_FLAG_KEY)
894  flags = 0x10;
895  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
896  avist->audio_strm_length += size;
897 
898  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
899  int ret;
900  ret = avi_add_ientry(s, stream_index, NULL, flags, size);
901  if (ret < 0)
902  return ret;
903  }
904 
905  avio_write(pb, tag, 4);
906  avio_wl32(pb, size);
907  avio_write(pb, pkt->data, size);
908  if (size & 1)
909  avio_w8(pb, 0);
910 
911  return 0;
912 }
913 
914 static int avi_write_trailer(AVFormatContext *s)
915 {
916  AVIContext *avi = s->priv_data;
917  AVIOContext *pb = s->pb;
918  int res = 0;
919  int i, n, nb_frames;
920  int64_t file_size;
921 
922  for (i = 0; i < s->nb_streams; i++) {
923  AVIStream *avist = s->streams[i]->priv_data;
924  write_skip_frames(s, i, avist->last_dts);
925  }
926 
927  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
928  if (avi->riff_id == 1) {
929  ff_end_tag(pb, avi->movi_list);
930  res = avi_write_idx1(s);
931  ff_end_tag(pb, avi->riff_start);
932  } else {
933  avi_write_ix(s);
934  ff_end_tag(pb, avi->movi_list);
935  ff_end_tag(pb, avi->riff_start);
936 
937  file_size = avio_tell(pb);
938  avio_seek(pb, avi->odml_list - 8, SEEK_SET);
939  ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */
940  avio_skip(pb, 16);
941 
942  for (n = nb_frames = 0; n < s->nb_streams; n++) {
943  AVCodecParameters *par = s->streams[n]->codecpar;
944  AVIStream *avist = s->streams[n]->priv_data;
945 
946  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
947  if (nb_frames < avist->packet_count)
948  nb_frames = avist->packet_count;
949  } else {
950  if (par->codec_id == AV_CODEC_ID_MP2 ||
951  par->codec_id == AV_CODEC_ID_MP3)
952  nb_frames += avist->packet_count;
953  }
954  }
955  avio_wl32(pb, nb_frames);
956  avio_seek(pb, file_size, SEEK_SET);
957 
958  avi_write_counters(s, avi->riff_id);
959  }
960  }
961 
962  if (avi->riff_id >= avi->master_index_max_size) {
963  int index_space = AVI_MASTER_INDEX_PREFIX_SIZE +
964  AVI_MASTER_INDEX_ENTRY_SIZE * avi->riff_id;
965  av_log(s, AV_LOG_WARNING, "Output file not strictly OpenDML compliant, "
966  "consider re-muxing with 'reserve_index_space' option value >= %d\n",
967  index_space);
968  }
969 
970  for (i = 0; i < s->nb_streams; i++) {
971  AVIStream *avist = s->streams[i]->priv_data;
972  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
973  avio_seek(pb, avist->frames_hdr_strm + 4, SEEK_SET);
974  avio_wl32(pb, avist->max_size);
975  }
976  }
977 
978  return res;
979 }
980 
981 static void avi_deinit(AVFormatContext *s)
982 {
983  for (int i = 0; i < s->nb_streams; i++) {
984  AVIStream *avist = s->streams[i]->priv_data;
985  if (!avist)
986  continue;
987  for (int j = 0; j < avist->indexes.ents_allocated / AVI_INDEX_CLUSTER_SIZE; j++)
988  av_freep(&avist->indexes.cluster[j]);
989  av_freep(&avist->indexes.cluster);
990  avist->indexes.ents_allocated = avist->indexes.entry = 0;
991  }
992 }
993 
994 #define OFFSET(x) offsetof(AVIContext, x)
995 #define ENC AV_OPT_FLAG_ENCODING_PARAM
996 static const AVOption options[] = {
997  { "reserve_index_space", "reserve space (in bytes) at the beginning of the file for each stream index", OFFSET(reserve_index_space), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, ENC },
998  { "write_channel_mask", "write channel mask into wave format header", OFFSET(write_channel_mask), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, ENC },
999  { "flipped_raw_rgb", "Raw RGB bitmaps are stored bottom-up", OFFSET(flipped_raw_rgb), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
1000  { NULL },
1001 };
1002 
1003 static const AVClass avi_muxer_class = {
1004  .class_name = "AVI muxer",
1005  .item_name = av_default_item_name,
1006  .option = options,
1007  .version = LIBAVUTIL_VERSION_INT,
1008 };
1009 
1010 const FFOutputFormat ff_avi_muxer = {
1011  .p.name = "avi",
1012  .p.long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1013  .p.mime_type = "video/x-msvideo",
1014  .p.extensions = "avi",
1015  .priv_data_size = sizeof(AVIContext),
1016  .p.audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,
1017  .p.video_codec = AV_CODEC_ID_MPEG4,
1018  .init = avi_init,
1019  .deinit = avi_deinit,
1020  .write_header = avi_write_header,
1021  .write_packet = avi_write_packet,
1022  .write_trailer = avi_write_trailer,
1023  .p.codec_tag = ff_riff_codec_tags_list,
1024  .p.priv_class = &avi_muxer_class,
1025 };
flags
const SwsFlags flags[]
Definition: swscale.c:72
AVIContext::flipped_raw_rgb
int flipped_raw_rgb
Definition: avienc.c:80
AVIStream::strh_flags_offset
int64_t strh_flags_offset
Definition: avienc.c:95
options
static const AVOption options[]
Definition: avienc.c:996
AV_LANG_ISO639_1
@ AV_LANG_ISO639_1
3-char terminological language codes as per ISO-IEC 639-2
Definition: avlanguage.h:30
avi_stream2fourcc
static char * avi_stream2fourcc(char *tag, int index, enum AVMediaType type)
Definition: avienc.c:184
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVIIentry::len
unsigned int len
Definition: avienc.c:54
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:463
AVOutputFormat::name
const char * name
Definition: avformat.h:506
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
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:53
mpegts.h
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:49
avi_start_new_riff
static int64_t avi_start_new_riff(AVFormatContext *s, AVIOContext *pb, const char *riff_tag, const char *list_tag)
Definition: avienc.c:163
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:123
AVI_MASTER_INDEX_SIZE_DEFAULT
#define AVI_MASTER_INDEX_SIZE_DEFAULT
Definition: avienc.c:60
AVStream::priv_data
void * priv_data
Definition: avformat.h:769
ff_put_bmp_header
void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par, int for_asf, int ignore_extradata, int rgb_frame_is_flipped)
Definition: riffenc.c:228
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
int64_t
long long int64_t
Definition: coverity.c:34
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
AVIStream
Definition: avidec.c:47
avlanguage.h
avi_get_ientry
static AVIIentry * avi_get_ientry(const AVIIndex *idx, int ent_id)
Definition: avienc.c:104
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
pixdesc.h
AVPacket::data
uint8_t * data
Definition: packet.h:595
AVOption
AVOption.
Definition: opt.h:429
avio_wl64
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:428
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:613
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:61
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
avi_write_counters
static int avi_write_counters(AVFormatContext *s, int riff_id)
Definition: avienc.c:203
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:650
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
AVIIndex::audio_strm_offset
int64_t audio_strm_offset
Definition: avienc.c:64
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:217
AVIStream::palette
uint32_t palette[AVPALETTE_COUNT]
Definition: avienc.c:97
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:440
avi_muxer_class
static const AVClass avi_muxer_class
Definition: avienc.c:1003
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:214
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: avformat.c:781
AVIIndex::indx_start
int64_t indx_start
Definition: avienc.c:63
fail
#define fail()
Definition: checkasm.h:224
AVIContext::frames_hdr_all
int64_t frames_hdr_all
Definition: avienc.c:75
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
AVIStream::entry
int entry
Definition: avienc.c:87
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
avi_add_ientry
static int avi_add_ientry(AVFormatContext *s, int stream_index, char *tag, unsigned int flags, unsigned int size)
Definition: avienc.c:111
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:461
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:803
avi_write_trailer
static int avi_write_trailer(AVFormatContext *s)
Definition: avienc.c:914
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:216
raw.h
ff_start_tag
int64_t ff_start_tag(AVIOContext *pb, const char *tag)
Definition: riffenc.c:31
avassert.h
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
AVIStream::last_dts
int64_t last_dts
Definition: avienc.c:91
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:119
AVIStream::old_palette
uint32_t old_palette[AVPALETTE_COUNT]
Definition: avienc.c:98
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:60
AVIContext::odml_list
int64_t odml_list
Definition: avienc.c:74
AVIContext
Definition: avidec.c:74
avi_write_header
static int avi_write_header(AVFormatContext *s)
Definition: avienc.c:261
s
#define s(width, name)
Definition: cbs_vp9.c:198
avi_write_packet
static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: avienc.c:768
bitrate
int64_t bitrate
Definition: av1_levels.c:47
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVIContext::movi_list
int64_t movi_list
Definition: avidec.c:80
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AVCodecParameters::width
int width
The width of the video frame in pixels.
Definition: codec_par.h:143
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:460
avi_init
static av_cold int avi_init(struct AVFormatContext *s)
Definition: avienc.c:148
AVI_MASTER_INDEX_PREFIX_SIZE
#define AVI_MASTER_INDEX_PREFIX_SIZE
Definition: avienc.c:58
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
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
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:202
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
AVIIF_NO_TIME
#define AVIIF_NO_TIME
Definition: avi.h:39
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
avi_write_idx1
static int avi_write_idx1(AVFormatContext *s)
Definition: avienc.c:690
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
if
if(ret)
Definition: filter_design.txt:179
AVIContext::write_channel_mask
int write_channel_mask
Definition: avienc.c:79
AVFormatContext
Format I/O context.
Definition: avformat.h:1263
PIX_FMT_LIST_AVI
@ PIX_FMT_LIST_AVI
Definition: raw.h:39
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVISF_VIDEO_PALCHANGES
#define AVISF_VIDEO_PALCHANGES
Definition: avi.h:35
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:783
NULL
#define NULL
Definition: coverity.c:32
ff_put_wav_header
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
update_odml_entry
static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
Definition: avienc.c:600
AVI_MAX_RIFF_SIZE
#define AVI_MAX_RIFF_SIZE
Definition: avi.h:31
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
avi_deinit
static void avi_deinit(AVFormatContext *s)
Definition: avienc.c:981
AVI_MAX_STREAM_COUNT
#define AVI_MAX_STREAM_COUNT
Definition: avi.h:32
options
Definition: swscale.c:45
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:824
AVIStream::packet_count
int packet_count
Definition: avienc.c:86
AVIStream::pal_offset
int64_t pal_offset
Definition: avienc.c:99
FFOutputFormat
Definition: mux.h:61
double
double
Definition: af_crystalizer.c:132
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:184
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:192
index
int index
Definition: gxfenc.c:90
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
OFFSET
#define OFFSET(x)
Definition: avienc.c:994
avi.h
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVMediaType
AVMediaType
Definition: avutil.h:198
AVPacket::size
int size
Definition: packet.h:596
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
avpriv_pix_fmt_find
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
Definition: raw.c:78
ff_riff_write_info_tag
void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
Write a single RIFF info tag.
Definition: riffenc.c:317
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
ff_convert_lang_to
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:741
AVIIndex::cluster
AVIIentry ** cluster
Definition: avienc.c:68
size
int size
Definition: twinvq_data.h:10344
video_st
static AVStream * video_st
Definition: movenc.c:61
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
FF_PUT_WAV_HEADER_SKIP_CHANNELMASK
#define FF_PUT_WAV_HEADER_SKIP_CHANNELMASK
Tell ff_put_wav_header() to write an empty channel mask.
Definition: riff.h:58
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:822
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:594
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:206
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:368
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:360
ENC
#define ENC
Definition: avienc.c:995
AVIIentry::pos
unsigned int pos
Definition: avienc.c:53
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:601
ff_end_tag
void ff_end_tag(AVIOContext *pb, int64_t start)
Definition: riffenc.c:38
avi_write_packet_internal
static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
Definition: avienc.c:863
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:115
av_malloc
#define av_malloc(s)
Definition: ops_asmgen.c:44
AVIStream::max_size
int max_size
Definition: avienc.c:88
avio_internal.h
AVI_MASTER_INDEX_ENTRY_SIZE
#define AVI_MASTER_INDEX_ENTRY_SIZE
Definition: avienc.c:59
internal.h
AVIF_TRUSTCKTYPE
#define AVIF_TRUSTCKTYPE
Definition: avi.h:27
AVCodecParameters::height
int height
The height of the video frame in pixels.
Definition: codec_par.h:150
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:253
AVCodecParameters::block_align
int block_align
The number of bytes per coded audio frame, required by some formats.
Definition: codec_par.h:221
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:215
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
ff_get_packet_palette
int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
Retrieves the palette from a packet, either from side data, or appended to the video data in the pack...
Definition: rawutils.c:71
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_STRINGIFY
#define AV_STRINGIFY(s)
Definition: macros.h:66
AVI_INDEX_CLUSTER_SIZE
#define AVI_INDEX_CLUSTER_SIZE
Definition: avienc.c:57
AVCodecParameters::field_order
enum AVFieldOrder field_order
The order of the fields in interlaced video.
Definition: codec_par.h:182
ff_check_h264_startcode
int ff_check_h264_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
Check presence of H264 startcode.
Definition: mpegtsenc.c:1794
AV_CODEC_ID_XSUB
@ AV_CODEC_ID_XSUB
Definition: codec_id.h:575
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
tag
uint32_t tag
Definition: movenc.c:2046
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:236
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
AVIContext::riff_id
int riff_id
Definition: avienc.c:76
rawutils.h
ff_parse_specific_params
void ff_parse_specific_params(AVStream *st, int *au_rate, int *au_ssize, int *au_scale)
Definition: riffenc.c:287
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
AVIStream::sample_requested
int sample_requested
Definition: avienc.c:89
dict.h
id
enum AVCodecID id
Definition: dts2pts.c:550
write_odml_master
static void write_odml_master(AVFormatContext *s, int stream_index)
Definition: avienc.c:236
AVIContext::reserve_index_space
int reserve_index_space
Definition: avienc.c:77
AVIIndex::master_odml_riff_id_base
int master_odml_riff_id_base
Definition: avienc.c:67
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
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
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
ff_riff_write_info
void ff_riff_write_info(AVFormatContext *s)
Write all recognized RIFF tags from s->metadata.
Definition: riffenc.c:349
AVIIentry
Definition: avienc.c:50
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
ff_avi_muxer
const FFOutputFormat ff_avi_muxer
Definition: avienc.c:1010
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVPacket::stream_index
int stream_index
Definition: packet.h:597
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:321
AVIF_HASINDEX
#define AVIF_HASINDEX
Definition: avi.h:24
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
ff_reshuffle_raw_rgb
int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride)
Reshuffles the lines to use the user specified stride.
Definition: rawutils.c:27
avutil.h
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:113
mem.h
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:111
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
AVCodecParameters::format
int format
Definition: codec_par.h:94
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:57
AVPacket
This structure stores compressed data.
Definition: packet.h:572
AVIF_ISINTERLEAVED
#define AVIF_ISINTERLEAVED
Definition: avi.h:26
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
riff.h
AVIStream::frames_hdr_strm
int64_t frames_hdr_strm
Definition: avienc.c:84
timestamp.h
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:99
AVIIndex::entry
int entry
Definition: avienc.c:65
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVIIndex
Definition: avienc.c:62
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVIStream::indexes
AVIIndex indexes
Definition: avienc.c:93
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
AVDictionaryEntry::value
char * value
Definition: dict.h:92
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
avstring.h
AVIContext::empty_packet
AVPacket * empty_packet
Definition: avienc.c:73
AVIStream::audio_strm_length
int64_t audio_strm_length
Definition: avienc.c:85
AVIIentry::tag
char tag[4]
Definition: avienc.c:51
ff_riff_codec_tags_list
const AVCodecTag *const ff_riff_codec_tags_list[]
AVIContext::riff_start
int64_t riff_start
Definition: avienc.c:74
write_skip_frames
static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
Definition: avienc.c:745
AVIIentry::flags
unsigned int flags
Definition: avienc.c:52
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:311
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3376
AVIContext::master_index_max_size
int master_index_max_size
Definition: avienc.c:78
AVIIndex::ents_allocated
int ents_allocated
Definition: avienc.c:66
avi_write_ix
static int avi_write_ix(AVFormatContext *s)
Definition: avienc.c:632
mux.h
Generated on Tue Apr 28 2026 19:24:04 for FFmpeg by   doxygen 1.8.17