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