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