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