FFmpeg  4.0
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:679
NULL
#define NULL
Definition: coverity.c:32
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:3965
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:469
s
const char * s
Definition: avisynth_c.h:768
CONFIG_LIBMP3LAME
#define CONFIG_LIBMP3LAME
Definition: config.h:451
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
size
int size
Definition: twinvq_data.h:11134
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
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:4811
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
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:3884
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:935
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:104
AVPacket::size
int size
Definition: avcodec.h:1431
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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
AV_CODEC_ID_MPEG4
Definition: avcodec.h:230
AVStream::priv_data
void * priv_data
Definition: avformat.h:888
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
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:3876
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
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.
avpriv_request_sample
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
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:3950
AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
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:1448
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:1410
avio_internal.h
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
AVPacket::data
uint8_t * data
Definition: avcodec.h:1430
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
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:3913
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1462
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
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:1430
AVERROR
#define AVERROR(e)
Definition: error.h:43
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:552
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3880
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
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
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:475
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
fail
#define fail()
Definition: checkasm.h:116
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1436
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:1398
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:4001
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
avio_flush
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
av_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:1501
AVOutputFormat::name
const char * name
Definition: avformat.h:507
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:5637
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
n
int n
Definition: avisynth_c.h:684
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:937
AV_CODEC_ID_XSUB
Definition: avcodec.h:646
AVIIndex::indx_start
int64_t indx_start
Definition: avienc.c:60
if
if(ret< 0)
Definition: vf_mcdeint.c:279
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:1499
AVFormatContext::metadata_header_padding
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1840
AVStream
Stream structure.
Definition: avformat.h:873
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:457
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:1384
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:554
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
type
cl_device_type type
Definition: hwcontext_opencl.c:189
AVMediaType
AVMediaType
Definition: avutil.h:199
AV_CODEC_ID_MP2
Definition: avcodec.h:551
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:1500
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
AV_FIELD_BT
Definition: avcodec.h:1502
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:309
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1370
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:3926
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:1429
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:1457
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:1020
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:3888
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:2279
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1432
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:902
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:250
AVISF_VIDEO_PALCHANGES
#define AVISF_VIDEO_PALCHANGES
Definition: avi.h:35
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1407
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 Tue May 22 2018 07:06:52 for FFmpeg by   doxygen 1.8.13