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