FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 //#define DEBUG
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/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/dict.h"
35 #include "libavutil/avassert.h"
36 #include "libavutil/timestamp.h"
37 #include "libavutil/pixdesc.h"
38 #include "libavcodec/raw.h"
39 
40 /*
41  * TODO:
42  * - fill all fields if non streamed (nb_frames for example)
43  */
44 
45 typedef struct AVIIentry {
46  unsigned int flags, pos, len;
47 } AVIIentry;
48 
49 #define AVI_INDEX_CLUSTER_SIZE 16384
50 
51 typedef struct AVIIndex {
52  int64_t indx_start;
53  int64_t audio_strm_offset;
54  int entry;
55  int ents_allocated;
56  int master_odml_riff_id_base;
57  AVIIentry** cluster;
58 } AVIIndex;
59 
60 typedef struct AVIContext {
61  int64_t riff_start, movi_list, odml_list;
62  int64_t frames_hdr_all;
63  int riff_id;
64 } AVIContext;
65 
66 typedef struct AVIStream {
67  int64_t frames_hdr_strm;
68  int64_t audio_strm_length;
69  int packet_count;
70  int entry;
71  int max_size;
72  int sample_requested;
73 
74  int64_t last_dts;
75 
76  AVIIndex indexes;
77 } AVIStream;
78 
79 static int avi_write_packet(AVFormatContext *s, AVPacket *pkt);
80 
81 static inline AVIIentry *avi_get_ientry(const AVIIndex *idx, int ent_id)
82 {
83  int cl = ent_id / AVI_INDEX_CLUSTER_SIZE;
84  int id = ent_id % AVI_INDEX_CLUSTER_SIZE;
85  return &idx->cluster[cl][id];
86 }
87 
88 static int64_t avi_start_new_riff(AVFormatContext *s, AVIOContext *pb,
89  const char *riff_tag, const char *list_tag)
90 {
91  AVIContext *avi = s->priv_data;
92  int64_t loff;
93  int i;
94 
95  avi->riff_id++;
96  for (i = 0; i < s->nb_streams; i++) {
97  AVIStream *avist = s->streams[i]->priv_data;
98  avist->indexes.audio_strm_offset = avist->audio_strm_length;
99  avist->indexes.entry = 0;
100  }
101 
102  avi->riff_start = ff_start_tag(pb, "RIFF");
103  ffio_wfourcc(pb, riff_tag);
104  loff = ff_start_tag(pb, "LIST");
105  ffio_wfourcc(pb, list_tag);
106  return loff;
107 }
108 
109 static char *avi_stream2fourcc(char *tag, int index, enum AVMediaType type)
110 {
111  tag[0] = '0' + index / 10;
112  tag[1] = '0' + index % 10;
113  if (type == AVMEDIA_TYPE_VIDEO) {
114  tag[2] = 'd';
115  tag[3] = 'c';
116  } else if (type == AVMEDIA_TYPE_SUBTITLE) {
117  // note: this is not an official code
118  tag[2] = 's';
119  tag[3] = 'b';
120  } else {
121  tag[2] = 'w';
122  tag[3] = 'b';
123  }
124  tag[4] = '\0';
125  return tag;
126 }
127 
128 static int avi_write_counters(AVFormatContext *s, int riff_id)
129 {
130  AVIOContext *pb = s->pb;
131  AVIContext *avi = s->priv_data;
132  int n, au_byterate, au_ssize, au_scale, nb_frames = 0;
133  int64_t file_size;
134  AVCodecContext *stream;
135 
136  file_size = avio_tell(pb);
137  for (n = 0; n < s->nb_streams; n++) {
138  AVIStream *avist = s->streams[n]->priv_data;
139 
140  av_assert0(avist->frames_hdr_strm);
141  stream = s->streams[n]->codec;
142  avio_seek(pb, avist->frames_hdr_strm, SEEK_SET);
143  ff_parse_specific_params(s->streams[n], &au_byterate, &au_ssize, &au_scale);
144  if (au_ssize == 0)
145  avio_wl32(pb, avist->packet_count);
146  else
147  avio_wl32(pb, avist->audio_strm_length / au_ssize);
148  if (stream->codec_type == AVMEDIA_TYPE_VIDEO)
149  nb_frames = FFMAX(nb_frames, avist->packet_count);
150  }
151  if (riff_id == 1) {
152  av_assert0(avi->frames_hdr_all);
153  avio_seek(pb, avi->frames_hdr_all, SEEK_SET);
154  avio_wl32(pb, nb_frames);
155  }
156  avio_seek(pb, file_size, SEEK_SET);
157 
158  return 0;
159 }
160 
161 static void write_odml_master(AVFormatContext *s, int stream_index)
162 {
163  AVIOContext *pb = s->pb;
164  AVStream *st = s->streams[stream_index];
165  AVCodecContext *enc = st->codec;
166  AVIStream *avist = st->priv_data;
167  unsigned char tag[5];
168  int j;
169 
170  /* Starting to lay out AVI OpenDML master index.
171  * We want to make it JUNK entry for now, since we'd
172  * like to get away without making AVI an OpenDML one
173  * for compatibility reasons. */
174  avist->indexes.indx_start = ff_start_tag(pb, "JUNK");
175  avio_wl16(pb, 4); /* wLongsPerEntry */
176  avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
177  avio_w8(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
178  avio_wl32(pb, 0); /* nEntriesInUse (will fill out later on) */
179  ffio_wfourcc(pb, avi_stream2fourcc(tag, stream_index, enc->codec_type));
180  /* dwChunkId */
181  avio_wl64(pb, 0); /* dwReserved[3] */
182  avio_wl32(pb, 0); /* Must be 0. */
183  for (j = 0; j < AVI_MASTER_INDEX_SIZE * 2; j++)
184  avio_wl64(pb, 0);
185  ff_end_tag(pb, avist->indexes.indx_start);
186 }
187 
188 static int avi_write_header(AVFormatContext *s)
189 {
190  AVIContext *avi = s->priv_data;
191  AVIOContext *pb = s->pb;
192  int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
193  AVCodecContext *video_enc;
194  AVStream *video_st = NULL;
195  int64_t list1, list2, strh, strf;
196  AVDictionaryEntry *t = NULL;
197  int padding;
198 
199  if (s->nb_streams > AVI_MAX_STREAM_COUNT) {
200  av_log(s, AV_LOG_ERROR, "AVI does not support >%d streams\n",
201  AVI_MAX_STREAM_COUNT);
202  return AVERROR(EINVAL);
203  }
204 
205  for (n = 0; n < s->nb_streams; n++) {
206  s->streams[n]->priv_data = av_mallocz(sizeof(AVIStream));
207  if (!s->streams[n]->priv_data)
208  return AVERROR(ENOMEM);
209  }
210 
211  /* header list */
212  avi->riff_id = 0;
213  list1 = avi_start_new_riff(s, pb, "AVI ", "hdrl");
214 
215  /* avi header */
216  ffio_wfourcc(pb, "avih");
217  avio_wl32(pb, 14 * 4);
218  bitrate = 0;
219 
220  video_enc = NULL;
221  for (n = 0; n < s->nb_streams; n++) {
222  AVCodecContext *codec = s->streams[n]->codec;
223  bitrate += codec->bit_rate;
224  if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
225  video_enc = codec;
226  video_st = s->streams[n];
227  }
228  }
229 
230  nb_frames = 0;
231 
232  // TODO: should be avg_frame_rate
233  if (video_st)
234  avio_wl32(pb, (uint32_t) (INT64_C(1000000) * video_st->time_base.num /
235  video_st->time_base.den));
236  else
237  avio_wl32(pb, 0);
238  avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
239  avio_wl32(pb, 0); /* padding */
240  if (!pb->seekable)
241  avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
242  else
243  avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
244  avi->frames_hdr_all = avio_tell(pb); /* remember this offset to fill later */
245  avio_wl32(pb, nb_frames); /* nb frames, filled later */
246  avio_wl32(pb, 0); /* initial frame */
247  avio_wl32(pb, s->nb_streams); /* nb streams */
248  avio_wl32(pb, 1024 * 1024); /* suggested buffer size */
249  if (video_enc) {
250  avio_wl32(pb, video_enc->width);
251  avio_wl32(pb, video_enc->height);
252  } else {
253  avio_wl32(pb, 0);
254  avio_wl32(pb, 0);
255  }
256  avio_wl32(pb, 0); /* reserved */
257  avio_wl32(pb, 0); /* reserved */
258  avio_wl32(pb, 0); /* reserved */
259  avio_wl32(pb, 0); /* reserved */
260 
261  /* stream list */
262  for (i = 0; i < n; i++) {
263  AVStream *st = s->streams[i];
264  AVCodecContext *enc = st->codec;
265  AVIStream *avist = st->priv_data;
266  list2 = ff_start_tag(pb, "LIST");
267  ffio_wfourcc(pb, "strl");
268 
269  /* stream generic header */
270  strh = ff_start_tag(pb, "strh");
271  switch (enc->codec_type) {
272  case AVMEDIA_TYPE_SUBTITLE:
273  // XSUB subtitles behave like video tracks, other subtitles
274  // are not (yet) supported.
275  if (enc->codec_id != AV_CODEC_ID_XSUB) {
276  av_log(s, AV_LOG_ERROR,
277  "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
278  return AVERROR_PATCHWELCOME;
279  }
280  case AVMEDIA_TYPE_VIDEO:
281  ffio_wfourcc(pb, "vids");
282  break;
283  case AVMEDIA_TYPE_AUDIO:
284  ffio_wfourcc(pb, "auds");
285  break;
286 // case AVMEDIA_TYPE_TEXT:
287 // ffio_wfourcc(pb, "txts");
288 // break;
289  case AVMEDIA_TYPE_DATA:
290  ffio_wfourcc(pb, "dats");
291  break;
292  }
293  if (enc->codec_type == AVMEDIA_TYPE_VIDEO ||
294  enc->codec_id == AV_CODEC_ID_XSUB)
295  avio_wl32(pb, enc->codec_tag);
296  else
297  avio_wl32(pb, 1);
298  avio_wl32(pb, 0); /* flags */
299  avio_wl16(pb, 0); /* priority */
300  avio_wl16(pb, 0); /* language */
301  avio_wl32(pb, 0); /* initial frame */
302 
303  ff_parse_specific_params(st, &au_byterate, &au_ssize, &au_scale);
304 
305  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
306  && enc->codec_id != AV_CODEC_ID_XSUB
307  && au_byterate > 1000LL*au_scale) {
308  au_byterate = 600;
309  au_scale = 1;
310  }
311  avpriv_set_pts_info(st, 64, au_scale, au_byterate);
312  if (enc->codec_id == AV_CODEC_ID_XSUB)
313  au_scale = au_byterate = 0;
314 
315  avio_wl32(pb, au_scale); /* scale */
316  avio_wl32(pb, au_byterate); /* rate */
317 
318  avio_wl32(pb, 0); /* start */
319  /* remember this offset to fill later */
320  avist->frames_hdr_strm = avio_tell(pb);
321  if (!pb->seekable)
322  /* FIXME: this may be broken, but who cares */
323  avio_wl32(pb, AVI_MAX_RIFF_SIZE);
324  else
325  avio_wl32(pb, 0); /* length, XXX: filled later */
326 
327  /* suggested buffer size, is set to largest chunk size in avi_write_trailer */
328  if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
329  avio_wl32(pb, 1024 * 1024);
330  else if (enc->codec_type == AVMEDIA_TYPE_AUDIO)
331  avio_wl32(pb, 12 * 1024);
332  else
333  avio_wl32(pb, 0);
334  avio_wl32(pb, -1); /* quality */
335  avio_wl32(pb, au_ssize); /* sample size */
336  avio_wl32(pb, 0);
337  avio_wl16(pb, enc->width);
338  avio_wl16(pb, enc->height);
339  ff_end_tag(pb, strh);
340 
341  if (enc->codec_type != AVMEDIA_TYPE_DATA) {
342  int ret;
343  enum AVPixelFormat pix_fmt;
344 
345  strf = ff_start_tag(pb, "strf");
346  switch (enc->codec_type) {
347  case AVMEDIA_TYPE_SUBTITLE:
348  /* XSUB subtitles behave like video tracks, other subtitles
349  * are not (yet) supported. */
350  if (enc->codec_id != AV_CODEC_ID_XSUB)
351  break;
352  case AVMEDIA_TYPE_VIDEO:
353  /* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */
354  if ( !enc->codec_tag
355  && enc->codec_id == AV_CODEC_ID_RAWVIDEO
356  && enc->pix_fmt == AV_PIX_FMT_RGB555LE
357  && enc->bits_per_coded_sample == 15)
358  enc->bits_per_coded_sample = 16;
359  ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 0, 0);
360  pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
361  enc->bits_per_coded_sample);
362  if ( !enc->codec_tag
363  && enc->codec_id == AV_CODEC_ID_RAWVIDEO
364  && enc->pix_fmt != pix_fmt
365  && enc->pix_fmt != AV_PIX_FMT_NONE)
366  av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to avi, output file will be unreadable\n",
367  av_get_pix_fmt_name(enc->pix_fmt));
368  break;
369  case AVMEDIA_TYPE_AUDIO:
370  if ((ret = ff_put_wav_header(pb, enc, 0)) < 0)
371  return ret;
372  break;
373  default:
374  av_log(s, AV_LOG_ERROR,
375  "Invalid or not supported codec type '%s' found in the input\n",
376  (char *)av_x_if_null(av_get_media_type_string(enc->codec_type), "?"));
377  return AVERROR(EINVAL);
378  }
379  ff_end_tag(pb, strf);
380  if ((t = av_dict_get(st->metadata, "title", NULL, 0))) {
381  ff_riff_write_info_tag(s->pb, "strn", t->value);
382  t = NULL;
383  }
384  if (enc->codec_id == AV_CODEC_ID_XSUB
385  && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) {
386  const char* langstr = av_convert_lang_to(t->value, AV_LANG_ISO639_1);
387  t = NULL;
388  if (langstr) {
389  char* str = av_asprintf("Subtitle - %s-xx;02", langstr);
390  if (!str)
391  return AVERROR(ENOMEM);
392  ff_riff_write_info_tag(s->pb, "strn", str);
393  av_free(str);
394  }
395  }
396  }
397 
398  if (pb->seekable) {
399  write_odml_master(s, i);
400  }
401 
402  if (enc->codec_type == AVMEDIA_TYPE_VIDEO &&
403  st->sample_aspect_ratio.num > 0 &&
404  st->sample_aspect_ratio.den > 0) {
405  int vprp = ff_start_tag(pb, "vprp");
406  AVRational dar = av_mul_q(st->sample_aspect_ratio,
407  (AVRational) { enc->width,
408  enc->height });
409  int num, den;
410  av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
411 
412  avio_wl32(pb, 0); // video format = unknown
413  avio_wl32(pb, 0); // video standard = unknown
414  // TODO: should be avg_frame_rate
415  avio_wl32(pb, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num));
416  avio_wl32(pb, enc->width);
417  avio_wl32(pb, enc->height);
418  avio_wl16(pb, den);
419  avio_wl16(pb, num);
420  avio_wl32(pb, enc->width);
421  avio_wl32(pb, enc->height);
422  avio_wl32(pb, 1); // progressive FIXME
423 
424  avio_wl32(pb, enc->height);
425  avio_wl32(pb, enc->width);
426  avio_wl32(pb, enc->height);
427  avio_wl32(pb, enc->width);
428  avio_wl32(pb, 0);
429  avio_wl32(pb, 0);
430 
431  avio_wl32(pb, 0);
432  avio_wl32(pb, 0);
433  ff_end_tag(pb, vprp);
434  }
435 
436  ff_end_tag(pb, list2);
437  }
438 
439  if (pb->seekable) {
440  /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
441  avi->odml_list = ff_start_tag(pb, "JUNK");
442  ffio_wfourcc(pb, "odml");
443  ffio_wfourcc(pb, "dmlh");
444  avio_wl32(pb, 248);
445  for (i = 0; i < 248; i += 4)
446  avio_wl32(pb, 0);
447  ff_end_tag(pb, avi->odml_list);
448  }
449 
450  ff_end_tag(pb, list1);
451 
452  ff_riff_write_info(s);
453 
454 
455  padding = s->metadata_header_padding;
456  if (padding < 0)
457  padding = 1016;
458 
459  /* some padding for easier tag editing */
460  if (padding) {
461  list2 = ff_start_tag(pb, "JUNK");
462  for (i = padding; i > 0; i -= 4)
463  avio_wl32(pb, 0);
464  ff_end_tag(pb, list2);
465  }
466 
467  avi->movi_list = ff_start_tag(pb, "LIST");
468  ffio_wfourcc(pb, "movi");
469 
470  avio_flush(pb);
471 
472  return 0;
473 }
474 
475 static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
476 {
477  AVIOContext *pb = s->pb;
478  AVIContext *avi = s->priv_data;
479  AVIStream *avist = s->streams[stream_index]->priv_data;
480  int64_t pos;
481  int au_byterate, au_ssize, au_scale;
482 
483  avio_flush(pb);
484  pos = avio_tell(pb);
485 
486  /* Updating one entry in the AVI OpenDML master index */
487  avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET);
488  ffio_wfourcc(pb, "indx"); /* enabling this entry */
489  avio_skip(pb, 8);
490  avio_wl32(pb, avi->riff_id - avist->indexes.master_odml_riff_id_base); /* nEntriesInUse */
491  avio_skip(pb, 16 * (avi->riff_id - avist->indexes.master_odml_riff_id_base));
492  avio_wl64(pb, ix); /* qwOffset */
493  avio_wl32(pb, size); /* dwSize */
494  ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale);
495  if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) {
496  uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset);
497  if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) {
498  avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames");
499  avist->sample_requested = 1;
500  }
501  avio_wl32(pb, audio_segm_size / au_ssize); /* dwDuration (sample count) */
502  } else
503  avio_wl32(pb, avist->indexes.entry); /* dwDuration (packet count) */
504 
505  avio_seek(pb, pos, SEEK_SET);
506 }
507 
508 static int avi_write_ix(AVFormatContext *s)
509 {
510  AVIOContext *pb = s->pb;
511  AVIContext *avi = s->priv_data;
512  char tag[5];
513  char ix_tag[] = "ix00";
514  int i, j;
515 
516  av_assert0(pb->seekable);
517 
518  for (i = 0; i < s->nb_streams; i++) {
519  AVIStream *avist = s->streams[i]->priv_data;
520  if (avi->riff_id - avist->indexes.master_odml_riff_id_base == AVI_MASTER_INDEX_SIZE) {
521  int64_t pos;
522  int size = 8+2+1+1+4+8+4+4+16*AVI_MASTER_INDEX_SIZE;
523 
524  pos = avio_tell(pb);
525  update_odml_entry(s, i, pos, size);
526  write_odml_master(s, i);
527  av_assert1(avio_tell(pb) - pos == size);
528  avist->indexes.master_odml_riff_id_base = avi->riff_id - 1;
529  }
530  av_assert0(avi->riff_id - avist->indexes.master_odml_riff_id_base < AVI_MASTER_INDEX_SIZE);
531  }
532 
533  for (i = 0; i < s->nb_streams; i++) {
534  AVIStream *avist = s->streams[i]->priv_data;
535  int64_t ix;
536 
537  avi_stream2fourcc(tag, i, s->streams[i]->codec->codec_type);
538  ix_tag[3] = '0' + i;
539 
540  /* Writing AVI OpenDML leaf index chunk */
541  ix = avio_tell(pb);
542  ffio_wfourcc(pb, ix_tag); /* ix?? */
543  avio_wl32(pb, avist->indexes.entry * 8 + 24);
544  /* chunk size */
545  avio_wl16(pb, 2); /* wLongsPerEntry */
546  avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
547  avio_w8(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
548  avio_wl32(pb, avist->indexes.entry);
549  /* nEntriesInUse */
550  ffio_wfourcc(pb, tag); /* dwChunkId */
551  avio_wl64(pb, avi->movi_list); /* qwBaseOffset */
552  avio_wl32(pb, 0); /* dwReserved_3 (must be 0) */
553 
554  for (j = 0; j < avist->indexes.entry; j++) {
555  AVIIentry *ie = avi_get_ientry(&avist->indexes, j);
556  avio_wl32(pb, ie->pos + 8);
557  avio_wl32(pb, ((uint32_t) ie->len & ~0x80000000) |
558  (ie->flags & 0x10 ? 0 : 0x80000000));
559  }
560 
561  update_odml_entry(s, i, ix, avio_tell(pb) - ix);
562  }
563  return 0;
564 }
565 
566 static int avi_write_idx1(AVFormatContext *s)
567 {
568  AVIOContext *pb = s->pb;
569  AVIContext *avi = s->priv_data;
570  int64_t idx_chunk;
571  int i;
572  char tag[5];
573 
574  if (pb->seekable) {
575  AVIStream *avist;
576  AVIIentry *ie = 0, *tie;
577  int empty, stream_id = -1;
578 
579  idx_chunk = ff_start_tag(pb, "idx1");
580  for (i = 0; i < s->nb_streams; i++) {
581  avist = s->streams[i]->priv_data;
582  avist->entry = 0;
583  }
584 
585  do {
586  empty = 1;
587  for (i = 0; i < s->nb_streams; i++) {
588  avist = s->streams[i]->priv_data;
589  if (avist->indexes.entry <= avist->entry)
590  continue;
591 
592  tie = avi_get_ientry(&avist->indexes, avist->entry);
593  if (empty || tie->pos < ie->pos) {
594  ie = tie;
595  stream_id = i;
596  }
597  empty = 0;
598  }
599  if (!empty) {
600  avist = s->streams[stream_id]->priv_data;
601  avi_stream2fourcc(tag, stream_id,
602  s->streams[stream_id]->codec->codec_type);
603  ffio_wfourcc(pb, tag);
604  avio_wl32(pb, ie->flags);
605  avio_wl32(pb, ie->pos);
606  avio_wl32(pb, ie->len);
607  avist->entry++;
608  }
609  } while (!empty);
610  ff_end_tag(pb, idx_chunk);
611 
612  avi_write_counters(s, avi->riff_id);
613  }
614  return 0;
615 }
616 
617 static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
618 {
619  AVIStream *avist = s->streams[stream_index]->priv_data;
620  AVCodecContext *enc = s->streams[stream_index]->codec;
621 
622  ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);
623  while (enc->block_align == 0 && dts != AV_NOPTS_VALUE &&
624  dts > avist->packet_count && enc->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) {
625  AVPacket empty_packet;
626 
627  if (dts - avist->packet_count > 60000) {
628  av_log(s, AV_LOG_ERROR, "Too large number of skipped frames %"PRId64" > 60000\n", dts - avist->packet_count);
629  return AVERROR(EINVAL);
630  }
631 
632  av_init_packet(&empty_packet);
633  empty_packet.size = 0;
634  empty_packet.data = NULL;
635  empty_packet.stream_index = stream_index;
636  avi_write_packet(s, &empty_packet);
637  ff_dlog(s, "dup dts:%s packet_count:%d\n", av_ts2str(dts), avist->packet_count);
638  }
639 
640  return 0;
641 }
642 
643 static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
644 {
645  unsigned char tag[5];
646  unsigned int flags = 0;
647  const int stream_index = pkt->stream_index;
648  int size = pkt->size;
649  AVIContext *avi = s->priv_data;
650  AVIOContext *pb = s->pb;
651  AVIStream *avist = s->streams[stream_index]->priv_data;
652  AVCodecContext *enc = s->streams[stream_index]->codec;
653  int ret;
654 
655  if (enc->codec_id == AV_CODEC_ID_H264 && enc->codec_tag == MKTAG('H','2','6','4') && pkt->size) {
656  ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt);
657  if (ret < 0)
658  return ret;
659  }
660 
661  if ((ret = write_skip_frames(s, stream_index, pkt->dts)) < 0)
662  return ret;
663 
664  if (pkt->dts != AV_NOPTS_VALUE)
665  avist->last_dts = pkt->dts + pkt->duration;
666 
667  avist->packet_count++;
668 
669  // Make sure to put an OpenDML chunk when the file size exceeds the limits
670  if (pb->seekable &&
671  (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
672  avi_write_ix(s);
673  ff_end_tag(pb, avi->movi_list);
674 
675  if (avi->riff_id == 1)
676  avi_write_idx1(s);
677 
678  ff_end_tag(pb, avi->riff_start);
679  avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi");
680  }
681 
682  avi_stream2fourcc(tag, stream_index, enc->codec_type);
683  if (pkt->flags & AV_PKT_FLAG_KEY)
684  flags = 0x10;
685  if (enc->codec_type == AVMEDIA_TYPE_AUDIO)
686  avist->audio_strm_length += size;
687 
688  if (s->pb->seekable) {
689  AVIIndex *idx = &avist->indexes;
690  int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE;
691  int id = idx->entry % AVI_INDEX_CLUSTER_SIZE;
692  if (idx->ents_allocated <= idx->entry) {
693  idx->cluster = av_realloc_f(idx->cluster, sizeof(void*), cl+1);
694  if (!idx->cluster) {
695  idx->ents_allocated = 0;
696  idx->entry = 0;
697  return AVERROR(ENOMEM);
698  }
699  idx->cluster[cl] =
700  av_malloc(AVI_INDEX_CLUSTER_SIZE * sizeof(AVIIentry));
701  if (!idx->cluster[cl])
702  return AVERROR(ENOMEM);
703  idx->ents_allocated += AVI_INDEX_CLUSTER_SIZE;
704  }
705 
706  idx->cluster[cl][id].flags = flags;
707  idx->cluster[cl][id].pos = avio_tell(pb) - avi->movi_list;
708  idx->cluster[cl][id].len = size;
709  avist->max_size = FFMAX(avist->max_size, size);
710  idx->entry++;
711  }
712 
713  avio_write(pb, tag, 4);
714  avio_wl32(pb, size);
715  avio_write(pb, pkt->data, size);
716  if (size & 1)
717  avio_w8(pb, 0);
718 
719  return 0;
720 }
721 
722 static int avi_write_trailer(AVFormatContext *s)
723 {
724  AVIContext *avi = s->priv_data;
725  AVIOContext *pb = s->pb;
726  int res = 0;
727  int i, j, n, nb_frames;
728  int64_t file_size;
729 
730  for (i = 0; i < s->nb_streams; i++) {
731  AVIStream *avist = s->streams[i]->priv_data;
732  write_skip_frames(s, i, avist->last_dts);
733  }
734 
735  if (pb->seekable) {
736  if (avi->riff_id == 1) {
737  ff_end_tag(pb, avi->movi_list);
738  res = avi_write_idx1(s);
739  ff_end_tag(pb, avi->riff_start);
740  } else {
741  avi_write_ix(s);
742  ff_end_tag(pb, avi->movi_list);
743  ff_end_tag(pb, avi->riff_start);
744 
745  file_size = avio_tell(pb);
746  avio_seek(pb, avi->odml_list - 8, SEEK_SET);
747  ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */
748  avio_skip(pb, 16);
749 
750  for (n = nb_frames = 0; n < s->nb_streams; n++) {
751  AVCodecContext *stream = s->streams[n]->codec;
752  AVIStream *avist = s->streams[n]->priv_data;
753 
754  if (stream->codec_type == AVMEDIA_TYPE_VIDEO) {
755  if (nb_frames < avist->packet_count)
756  nb_frames = avist->packet_count;
757  } else {
758  if (stream->codec_id == AV_CODEC_ID_MP2 ||
759  stream->codec_id == AV_CODEC_ID_MP3)
760  nb_frames += avist->packet_count;
761  }
762  }
763  avio_wl32(pb, nb_frames);
764  avio_seek(pb, file_size, SEEK_SET);
765 
766  avi_write_counters(s, avi->riff_id);
767  }
768  }
769 
770  for (i = 0; i < s->nb_streams; i++) {
771  AVIStream *avist = s->streams[i]->priv_data;
772  for (j = 0; j < avist->indexes.ents_allocated / AVI_INDEX_CLUSTER_SIZE; j++)
773  av_freep(&avist->indexes.cluster[j]);
774  av_freep(&avist->indexes.cluster);
775  avist->indexes.ents_allocated = avist->indexes.entry = 0;
776  if (pb->seekable) {
777  avio_seek(pb, avist->frames_hdr_strm + 4, SEEK_SET);
778  avio_wl32(pb, avist->max_size);
779  }
780  }
781 
782  return res;
783 }
784 
785 AVOutputFormat ff_avi_muxer = {
786  .name = "avi",
787  .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
788  .mime_type = "video/x-msvideo",
789  .extensions = "avi",
790  .priv_data_size = sizeof(AVIContext),
791  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,
792  .video_codec = AV_CODEC_ID_MPEG4,
793  .write_header = avi_write_header,
794  .write_packet = avi_write_packet,
795  .write_trailer = avi_write_trailer,
796  .codec_tag = (const AVCodecTag * const []) {
797  ff_codec_bmp_tags, ff_codec_wav_tags, 0
798  },
799 };
write_skip_frames
static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
Definition: avienc.c:617
NULL
#define NULL
Definition: coverity.c:32
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:417
s
const char * s
Definition: avisynth_c.h:631
AVIOContext
Bytestream IO Context.
Definition: avio.h:111
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
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
id
enum AVCodecID id
Definition: mxfenc.c:101
AVIIndex::master_odml_riff_id_base
int master_odml_riff_id_base
Definition: avienc.c:56
AVIIentry::pos
unsigned int pos
Definition: avienc.c:46
AVIIndex::ents_allocated
int ents_allocated
Definition: avienc.c:55
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:4083
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:53
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:914
AVRational::num
int num
numerator
Definition: rational.h:44
AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:117
AVPacket::size
int size
Definition: avcodec.h:1424
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:204
AVI_MASTER_INDEX_SIZE
#define AVI_MASTER_INDEX_SIZE
Definition: avi.h:32
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1722
avi_stream2fourcc
static char * avi_stream2fourcc(char *tag, int index, enum AVMediaType type)
Definition: avienc.c:109
AV_CODEC_ID_MPEG4
Definition: avcodec.h:120
AVStream::priv_data
void * priv_data
Definition: avformat.h:862
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:277
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
ff_avi_muxer
AVOutputFormat ff_avi_muxer
Definition: avienc.c:785
AV_CODEC_ID_H264
Definition: avcodec.h:135
AVIStream::frames_hdr_strm
int64_t frames_hdr_strm
Definition: avienc.c:67
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2299
AVFormatContext
Format I/O context.
Definition: avformat.h:1273
AVIContext::odml_list
int64_t odml_list
Definition: avienc.c:61
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.
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:319
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:195
timestamp.h
timestamp utils, mostly useful for debugging/logging purposes
AVIContext::movi_list
int64_t movi_list
Definition: avidec.c:75
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1341
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:39
AVPacket::data
uint8_t * data
Definition: avcodec.h:1423
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVIContext::riff_start
int64_t riff_start
Definition: avienc.c:61
tag
uint32_t tag
Definition: movenc.c:1334
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:88
size
ptrdiff_t size
Definition: opengl_enc.c:101
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:390
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2996
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:178
ffio_wfourcc
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:67
AVPacket::duration
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1441
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1469
avio_wl64
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:405
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:300
AVI_MAX_STREAM_COUNT
#define AVI_MAX_STREAM_COUNT
Definition: avi.h:33
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:566
ff_parse_specific_params
void ff_parse_specific_params(AVStream *st, int *au_rate, int *au_ssize, int *au_scale)
Definition: riffenc.c:237
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:1234
AVERROR
#define AVERROR(e)
Definition: error.h:43
av_convert_lang_to
const char * av_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:175
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:270
AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:425
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:194
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AVIIentry::flags
unsigned int flags
Definition: avienc.c:46
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:378
FFMAX
#define FFMAX(a, b)
Definition: common.h:79
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1429
AVIStream::packet_count
int packet_count
Definition: avienc.c:69
AVStream::codec
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:861
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
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
AVIIentry::len
unsigned int len
Definition: avienc.c:46
internal.h
common internal API header
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1329
update_odml_entry
static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
Definition: avienc.c:475
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:160
AVCodecContext::bit_rate
int bit_rate
the average bitrate
Definition: avcodec.h:1567
avio_flush
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:198
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
raw.h
Raw Video Codec.
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1681
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
AVOutputFormat::name
const char * name
Definition: avformat.h:513
riff.h
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
avi_write_trailer
static int avi_write_trailer(AVFormatContext *s)
Definition: avienc.c:722
n
int n
Definition: avisynth_c.h:547
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:916
AV_CODEC_ID_XSUB
Definition: avcodec.h:513
AVIIndex::indx_start
int64_t indx_start
Definition: avienc.c:52
AVIStream::audio_strm_length
int64_t audio_strm_length
Definition: avienc.c:68
avi_write_header
static int avi_write_header(AVFormatContext *s)
Definition: avienc.c:188
AVIF_HASINDEX
#define AVIF_HASINDEX
Definition: avi.h:24
AVStream
Stream structure.
Definition: avformat.h:842
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:643
avpriv_find_pix_fmt
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:1134
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:1510
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1519
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1315
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:156
AVCodecContext
main external API structure.
Definition: avcodec.h:1502
AVIStream::sample_requested
int sample_requested
Definition: avienc.c:72
AV_CODEC_ID_AC3
Definition: avcodec.h:427
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1534
type
GLint GLenum type
Definition: opengl_enc.c:105
ff_riff_write_info
void ff_riff_write_info(AVFormatContext *s)
Write all recognized RIFF tags from s->metadata.
Definition: riffenc.c:301
AVI_INDEX_CLUSTER_SIZE
#define AVI_INDEX_CLUSTER_SIZE
Definition: avienc.c:49
index
int index
Definition: gxfenc.c:89
AVRational
rational number numerator/denominator
Definition: rational.h:43
ff_put_bmp_header
void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc, const AVCodecTag *tags, int for_asf, int ignore_extradata)
Definition: riffenc.c:205
AVMediaType
AVMediaType
Definition: avutil.h:191
AV_CODEC_ID_MP2
Definition: avcodec.h:424
avi_get_ientry
static AVIIentry * avi_get_ientry(const AVIIndex *idx, int ent_id)
Definition: avienc.c:81
write_odml_master
static void write_odml_master(AVFormatContext *s, int stream_index)
Definition: avienc.c:161
AVIIndex::cluster
AVIIentry ** cluster
Definition: avienc.c:57
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:79
flags
static int flags
Definition: cpu.c:47
avformat.h
Main libavformat public API header.
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:49
AVRational::den
int den
denominator
Definition: rational.h:45
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry::value
char * value
Definition: dict.h:88
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:62
avpriv_pix_fmt_bps_avi
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
Definition: raw.c:243
ff_put_wav_header
int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1301
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:493
AVIStream::entry
int entry
Definition: avienc.c:70
AVIStream::indexes
AVIIndex indexes
Definition: avienc.c:76
avi_write_counters
static int avi_write_counters(AVFormatContext *s, int riff_id)
Definition: avienc.c:128
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1422
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:193
AV_CODEC_ID_RAWVIDEO
Definition: avcodec.h:121
AVIIndex::entry
int entry
Definition: avienc.c:54
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:2050
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1425
AVIStream::max_size
int max_size
Definition: avienc.c:71
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:884
AVIStream::last_dts
int64_t last_dts
Definition: avienc.c:74
AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:196
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:330
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1400
write_packet
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:86
av_mallocz
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
avi_write_ix
static int avi_write_ix(AVFormatContext *s)
Definition: avienc.c:508
AV_LANG_ISO639_1
3-char terminologic language codes as per ISO-IEC 639-2
Definition: avlanguage.h:30
AVIContext::riff_id
int riff_id
Definition: avienc.c:63
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:240
Generated on Thu Sep 10 2015 11:39:04 for FFmpeg by   doxygen 1.8.6