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;
61  int entry;
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;
75 } AVIContext;
76 
77 typedef struct AVIStream {
78  int64_t frames_hdr_strm;
81  int entry;
82  int max_size;
84 
85  int64_t last_dts;
86 
88 
90 
91  uint32_t palette[AVPALETTE_COUNT];
92  uint32_t old_palette[AVPALETTE_COUNT];
93  int64_t pal_offset;
94 } AVIStream;
95 
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] =
124  if (!idx->cluster[cl])
125  return AVERROR(ENOMEM);
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) {
149  } else
151  av_log(s, AV_LOG_DEBUG, "reserve_index_space:%d master_index_max_size:%d\n",
153 
154  return 1; /* stream initialization continues in avi_write_header */
155 }
156 
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;
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) {
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 
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;
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 "
272  ">"AV_STRINGIFY(AVI_MAX_STREAM_COUNT)" streams\n");
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
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) {
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 */
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) {
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);
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",
461 
462  if (par->format == AV_PIX_FMT_PAL8) {
463  if (par->bits_per_coded_sample < 0 || par->bits_per_coded_sample > 8) {
464  av_log(s, AV_LOG_ERROR, "PAL8 with %d bps is not allowed\n", par->bits_per_coded_sample);
465  return AVERROR(EINVAL);
466  }
467  }
468 
469  break;
470  case AVMEDIA_TYPE_AUDIO:
471  flags = (avi->write_channel_mask == 0) ? FF_PUT_WAV_HEADER_SKIP_CHANNELMASK : 0;
472  if ((ret = ff_put_wav_header(s, pb, par, flags)) < 0)
473  return ret;
474  break;
475  default:
476  av_log(s, AV_LOG_ERROR,
477  "Invalid or not supported codec type '%s' found in the input\n",
478  (char *)av_x_if_null(av_get_media_type_string(par->codec_type), "?"));
479  return AVERROR(EINVAL);
480  }
481  ff_end_tag(pb, strf);
482  if ((t = av_dict_get(st->metadata, "title", NULL, 0))) {
483  ff_riff_write_info_tag(s->pb, "strn", t->value);
484  t = NULL;
485  }
486  if (par->codec_id == AV_CODEC_ID_XSUB
487  && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) {
488  const char* langstr = ff_convert_lang_to(t->value, AV_LANG_ISO639_1);
489  t = NULL;
490  if (langstr) {
491  char* str = av_asprintf("Subtitle - %s-xx;02", langstr);
492  if (!str)
493  return AVERROR(ENOMEM);
494  ff_riff_write_info_tag(s->pb, "strn", str);
495  av_free(str);
496  }
497  }
498  }
499 
500  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
501  write_odml_master(s, i);
502  }
503 
504  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
505  st->sample_aspect_ratio.num > 0 &&
506  st->sample_aspect_ratio.den > 0) {
507  int vprp = ff_start_tag(pb, "vprp");
509  (AVRational) { par->width,
510  par->height });
511  int num, den, fields, i;
512  av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
513  if (par->field_order == AV_FIELD_TT || par->field_order == AV_FIELD_BB ||
514  par->field_order == AV_FIELD_TB || par->field_order == AV_FIELD_BT) {
515  fields = 2; // interlaced
516  } else {
517  fields = 1; // progressive
518  }
519 
520  avio_wl32(pb, 0); // video format = unknown
521  avio_wl32(pb, 0); // video standard = unknown
522  // TODO: should be avg_frame_rate
523  avio_wl32(pb, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num));
524  avio_wl32(pb, par->width);
525  avio_wl32(pb, par->height);
526  avio_wl16(pb, den);
527  avio_wl16(pb, num);
528  avio_wl32(pb, par->width);
529  avio_wl32(pb, par->height);
530  avio_wl32(pb, fields); // fields per frame
531 
532  for (i = 0; i < fields; i++) {
533  int start_line;
534  // OpenDML v1.02 is not very specific on what value to use for
535  // start_line when frame data is not coming from a capturing device,
536  // so just use 0/1 depending on the field order for interlaced frames
537  if (par->field_order == AV_FIELD_TT || par->field_order == AV_FIELD_TB) {
538  start_line = (i == 0) ? 0 : 1;
539  } else if (par->field_order == AV_FIELD_BB || par->field_order == AV_FIELD_BT) {
540  start_line = (i == 0) ? 1 : 0;
541  } else {
542  start_line = 0;
543  }
544 
545  avio_wl32(pb, par->height / fields); // compressed bitmap height
546  avio_wl32(pb, par->width); // compressed bitmap width
547  avio_wl32(pb, par->height / fields); // valid bitmap height
548  avio_wl32(pb, par->width); // valid bitmap width
549  avio_wl32(pb, 0); // valid bitmap X offset
550  avio_wl32(pb, 0); // valid bitmap Y offset
551  avio_wl32(pb, 0); // valid X offset in T
552  avio_wl32(pb, start_line); // valid Y start line
553  }
554  ff_end_tag(pb, vprp);
555  }
556 
557  ff_end_tag(pb, list2);
558  }
559 
560  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
561  /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
562  avi->odml_list = ff_start_tag(pb, "JUNK");
563  ffio_wfourcc(pb, "odml");
564  ffio_wfourcc(pb, "dmlh");
565  avio_wl32(pb, 248);
566  for (i = 0; i < 248; i += 4)
567  avio_wl32(pb, 0);
568  ff_end_tag(pb, avi->odml_list);
569  }
570 
571  ff_end_tag(pb, list1);
572 
574 
575 
576  padding = s->metadata_header_padding;
577  if (padding < 0)
578  padding = 1016;
579 
580  /* some padding for easier tag editing */
581  if (padding) {
582  list2 = ff_start_tag(pb, "JUNK");
583  for (i = padding; i > 0; i -= 4)
584  avio_wl32(pb, 0);
585  ff_end_tag(pb, list2);
586  }
587 
588  avi->movi_list = ff_start_tag(pb, "LIST");
589  ffio_wfourcc(pb, "movi");
590 
591  return 0;
592 }
593 
594 static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
595 {
596  AVIOContext *pb = s->pb;
597  AVIContext *avi = s->priv_data;
598  AVIStream *avist = s->streams[stream_index]->priv_data;
599  int64_t pos;
600  int au_byterate, au_ssize, au_scale;
601 
602  pos = avio_tell(pb);
603 
604  /* Updating one entry in the AVI OpenDML master index */
605  avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET);
606  ffio_wfourcc(pb, "indx"); /* enabling this entry */
607  avio_skip(pb, 8);
608  avio_wl32(pb, avi->riff_id - avist->indexes.master_odml_riff_id_base); /* nEntriesInUse */
609  avio_skip(pb, 16 * (avi->riff_id - avist->indexes.master_odml_riff_id_base));
610  avio_wl64(pb, ix); /* qwOffset */
611  avio_wl32(pb, size); /* dwSize */
612  ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale);
613  if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) {
614  uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset);
615  if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) {
616  avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames");
617  avist->sample_requested = 1;
618  }
619  avio_wl32(pb, audio_segm_size / au_ssize); /* dwDuration (sample count) */
620  } else
621  avio_wl32(pb, avist->indexes.entry); /* dwDuration (packet count) */
622 
623  avio_seek(pb, pos, SEEK_SET);
624 }
625 
627 {
628  AVIOContext *pb = s->pb;
629  AVIContext *avi = s->priv_data;
630  char tag[5];
631  char ix_tag[] = "ix00";
632  int i, j;
633 
635 
636  for (i = 0; i < s->nb_streams; i++) {
637  AVIStream *avist = s->streams[i]->priv_data;
639  int64_t pos;
641 
642  pos = avio_tell(pb);
643  update_odml_entry(s, i, pos, size);
644  write_odml_master(s, i);
645  av_assert1(avio_tell(pb) - pos == size);
646  avist->indexes.master_odml_riff_id_base = avi->riff_id - 1;
647  }
649  }
650 
651  for (i = 0; i < s->nb_streams; i++) {
652  AVIStream *avist = s->streams[i]->priv_data;
653  int64_t ix;
654 
655  avi_stream2fourcc(tag, i, s->streams[i]->codecpar->codec_type);
656  ix_tag[3] = '0' + i;
657 
658  /* Writing AVI OpenDML leaf index chunk */
659  ix = avio_tell(pb);
660  ffio_wfourcc(pb, ix_tag); /* ix?? */
661  avio_wl32(pb, avist->indexes.entry * 8 + 24);
662  /* chunk size */
663  avio_wl16(pb, 2); /* wLongsPerEntry */
664  avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
665  avio_w8(pb, 1); /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
666  avio_wl32(pb, avist->indexes.entry);
667  /* nEntriesInUse */
668  ffio_wfourcc(pb, tag); /* dwChunkId */
669  avio_wl64(pb, avi->movi_list); /* qwBaseOffset */
670  avio_wl32(pb, 0); /* dwReserved_3 (must be 0) */
671 
672  for (j = 0; j < avist->indexes.entry; j++) {
673  AVIIentry *ie = avi_get_ientry(&avist->indexes, j);
674  avio_wl32(pb, ie->pos + 8);
675  avio_wl32(pb, ((uint32_t) ie->len & ~0x80000000) |
676  (ie->flags & 0x10 ? 0 : 0x80000000));
677  }
678 
679  update_odml_entry(s, i, ix, avio_tell(pb) - ix);
680  }
681  return 0;
682 }
683 
685 {
686  AVIOContext *pb = s->pb;
687  AVIContext *avi = s->priv_data;
688  int64_t idx_chunk;
689  int i;
690  char tag[5];
691 
692  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
693  AVIStream *avist;
694  AVIIentry *ie = 0, *tie;
695  int empty, stream_id = -1;
696 
697  idx_chunk = ff_start_tag(pb, "idx1");
698  for (i = 0; i < s->nb_streams; i++) {
699  avist = s->streams[i]->priv_data;
700  avist->entry = 0;
701  }
702 
703  do {
704  empty = 1;
705  for (i = 0; i < s->nb_streams; i++) {
706  avist = s->streams[i]->priv_data;
707  if (avist->indexes.entry <= avist->entry)
708  continue;
709 
710  tie = avi_get_ientry(&avist->indexes, avist->entry);
711  if (empty || tie->pos < ie->pos) {
712  ie = tie;
713  stream_id = i;
714  }
715  empty = 0;
716  }
717  if (!empty) {
718  avist = s->streams[stream_id]->priv_data;
719  if (*ie->tag)
720  ffio_wfourcc(pb, ie->tag);
721  else {
722  avi_stream2fourcc(tag, stream_id,
723  s->streams[stream_id]->codecpar->codec_type);
724  ffio_wfourcc(pb, tag);
725  }
726  avio_wl32(pb, ie->flags);
727  avio_wl32(pb, ie->pos);
728  avio_wl32(pb, ie->len);
729  avist->entry++;
730  }
731  } while (!empty);
732  ff_end_tag(pb, idx_chunk);
733 
734  avi_write_counters(s, avi->riff_id);
735  }
736  return 0;
737 }
738 
739 static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
740 {
741  AVIStream *avist = s->streams[stream_index]->priv_data;
742  AVCodecParameters *par = s->streams[stream_index]->codecpar;
743 
744  ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);
745  while (par->block_align == 0 && dts != AV_NOPTS_VALUE &&
746  dts > avist->packet_count && par->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) {
747  AVPacket empty_packet;
748 
749  if (dts - avist->packet_count > 60000) {
750  av_log(s, AV_LOG_ERROR, "Too large number of skipped frames %"PRId64" > 60000\n", dts - avist->packet_count);
751  return AVERROR(EINVAL);
752  }
753 
754  av_init_packet(&empty_packet);
755  empty_packet.size = 0;
756  empty_packet.data = NULL;
757  empty_packet.stream_index = stream_index;
758  avi_write_packet_internal(s, &empty_packet);
759  ff_dlog(s, "dup dts:%s packet_count:%d\n", av_ts2str(dts), avist->packet_count);
760  }
761 
762  return 0;
763 }
764 
766 {
767  const int stream_index = pkt->stream_index;
768  AVCodecParameters *par = s->streams[stream_index]->codecpar;
769  int ret;
770 
771  if (par->codec_id == AV_CODEC_ID_H264 && par->codec_tag == MKTAG('H','2','6','4') && pkt->size) {
772  ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt);
773  if (ret < 0)
774  return ret;
775  }
776 
777  if ((ret = write_skip_frames(s, stream_index, pkt->dts)) < 0)
778  return ret;
779 
780  if (!pkt->size)
781  return avi_write_packet_internal(s, pkt); /* Passthrough */
782 
783  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
784  AVIStream *avist = s->streams[stream_index]->priv_data;
785  AVIOContext *pb = s->pb;
786  AVPacket *opkt = pkt;
787  int reshuffle_ret;
788  if (par->codec_id == AV_CODEC_ID_RAWVIDEO && par->codec_tag == 0) {
789  int64_t bpc = par->bits_per_coded_sample != 15 ? par->bits_per_coded_sample : 16;
790  int expected_stride = ((par->width * bpc + 31) >> 5)*4;
791  reshuffle_ret = ff_reshuffle_raw_rgb(s, &pkt, par, expected_stride);
792  if (reshuffle_ret < 0)
793  return reshuffle_ret;
794  } else
795  reshuffle_ret = 0;
796  if (par->format == AV_PIX_FMT_PAL8) {
797  ret = ff_get_packet_palette(s, opkt, reshuffle_ret, avist->palette);
798  if (ret < 0)
799  goto fail;
800  if (ret) {
801  int pal_size = 1 << par->bits_per_coded_sample;
802  int pc_tag, i;
803 
805 
806  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && avist->pal_offset) {
807  int64_t cur_offset = avio_tell(pb);
808  avio_seek(pb, avist->pal_offset, SEEK_SET);
809  for (i = 0; i < pal_size; i++) {
810  uint32_t v = avist->palette[i];
811  avio_wl32(pb, v & 0xffffff);
812  }
813  avio_seek(pb, cur_offset, SEEK_SET);
814  memcpy(avist->old_palette, avist->palette, pal_size * 4);
815  avist->pal_offset = 0;
816  }
817  if (memcmp(avist->palette, avist->old_palette, pal_size * 4)) {
818  unsigned char tag[5];
819  avi_stream2fourcc(tag, stream_index, par->codec_type);
820  tag[2] = 'p'; tag[3] = 'c';
821  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
822  if (avist->strh_flags_offset) {
823  int64_t cur_offset = avio_tell(pb);
824  avio_seek(pb, avist->strh_flags_offset, SEEK_SET);
826  avio_seek(pb, cur_offset, SEEK_SET);
827  avist->strh_flags_offset = 0;
828  }
829  ret = avi_add_ientry(s, stream_index, tag, AVIIF_NO_TIME,
830  pal_size * 4 + 4);
831  if (ret < 0)
832  goto fail;
833  }
834  pc_tag = ff_start_tag(pb, tag);
835  avio_w8(pb, 0);
836  avio_w8(pb, pal_size & 0xFF);
837  avio_wl16(pb, 0); // reserved
838  for (i = 0; i < pal_size; i++) {
839  uint32_t v = avist->palette[i];
840  avio_wb32(pb, v<<8);
841  }
842  ff_end_tag(pb, pc_tag);
843  memcpy(avist->old_palette, avist->palette, pal_size * 4);
844  }
845  }
846  }
847  if (reshuffle_ret) {
848  ret = avi_write_packet_internal(s, pkt);
849 
850 fail:
851  if (reshuffle_ret)
852  av_packet_free(&pkt);
853  return ret;
854  }
855  }
856 
857  return avi_write_packet_internal(s, pkt);
858 }
859 
861 {
862  unsigned char tag[5];
863  unsigned int flags = 0;
864  const int stream_index = pkt->stream_index;
865  int size = pkt->size;
866  AVIContext *avi = s->priv_data;
867  AVIOContext *pb = s->pb;
868  AVIStream *avist = s->streams[stream_index]->priv_data;
869  AVCodecParameters *par = s->streams[stream_index]->codecpar;
870 
871  if (pkt->dts != AV_NOPTS_VALUE)
872  avist->last_dts = pkt->dts + pkt->duration;
873 
874  avist->packet_count++;
875 
876  // Make sure to put an OpenDML chunk when the file size exceeds the limits
877  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) &&
878  (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
879  avi_write_ix(s);
880  ff_end_tag(pb, avi->movi_list);
881 
882  if (avi->riff_id == 1)
883  avi_write_idx1(s);
884 
885  ff_end_tag(pb, avi->riff_start);
886  avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi");
887  }
888 
889  avi_stream2fourcc(tag, stream_index, par->codec_type);
890  if (pkt->flags & AV_PKT_FLAG_KEY)
891  flags = 0x10;
892  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
893  avist->audio_strm_length += size;
894 
895  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
896  int ret;
897  ret = avi_add_ientry(s, stream_index, NULL, flags, size);
898  if (ret < 0)
899  return ret;
900  }
901 
902  avio_write(pb, tag, 4);
903  avio_wl32(pb, size);
904  avio_write(pb, pkt->data, size);
905  if (size & 1)
906  avio_w8(pb, 0);
907 
908  return 0;
909 }
910 
912 {
913  AVIContext *avi = s->priv_data;
914  AVIOContext *pb = s->pb;
915  int res = 0;
916  int i, n, nb_frames;
917  int64_t file_size;
918 
919  for (i = 0; i < s->nb_streams; i++) {
920  AVIStream *avist = s->streams[i]->priv_data;
921  write_skip_frames(s, i, avist->last_dts);
922  }
923 
924  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
925  if (avi->riff_id == 1) {
926  ff_end_tag(pb, avi->movi_list);
927  res = avi_write_idx1(s);
928  ff_end_tag(pb, avi->riff_start);
929  } else {
930  avi_write_ix(s);
931  ff_end_tag(pb, avi->movi_list);
932  ff_end_tag(pb, avi->riff_start);
933 
934  file_size = avio_tell(pb);
935  avio_seek(pb, avi->odml_list - 8, SEEK_SET);
936  ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */
937  avio_skip(pb, 16);
938 
939  for (n = nb_frames = 0; n < s->nb_streams; n++) {
940  AVCodecParameters *par = s->streams[n]->codecpar;
941  AVIStream *avist = s->streams[n]->priv_data;
942 
943  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
944  if (nb_frames < avist->packet_count)
945  nb_frames = avist->packet_count;
946  } else {
947  if (par->codec_id == AV_CODEC_ID_MP2 ||
948  par->codec_id == AV_CODEC_ID_MP3)
949  nb_frames += avist->packet_count;
950  }
951  }
952  avio_wl32(pb, nb_frames);
953  avio_seek(pb, file_size, SEEK_SET);
954 
955  avi_write_counters(s, avi->riff_id);
956  }
957  }
958 
959  if (avi->riff_id >= avi->master_index_max_size) {
960  int index_space = AVI_MASTER_INDEX_PREFIX_SIZE +
962  av_log(s, AV_LOG_WARNING, "Output file not strictly OpenDML compliant, "
963  "consider re-muxing with 'reserve_index_space' option value >= %d\n",
964  index_space);
965  }
966 
967  for (i = 0; i < s->nb_streams; i++) {
968  AVIStream *avist = s->streams[i]->priv_data;
969  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
970  avio_seek(pb, avist->frames_hdr_strm + 4, SEEK_SET);
971  avio_wl32(pb, avist->max_size);
972  }
973  }
974 
975  return res;
976 }
977 
979 {
980  for (int i = 0; i < s->nb_streams; i++) {
981  AVIStream *avist = s->streams[i]->priv_data;
982  if (!avist)
983  continue;
984  for (int j = 0; j < avist->indexes.ents_allocated / AVI_INDEX_CLUSTER_SIZE; j++)
985  av_freep(&avist->indexes.cluster[j]);
986  av_freep(&avist->indexes.cluster);
987  avist->indexes.ents_allocated = avist->indexes.entry = 0;
988  }
989 }
990 
991 #define OFFSET(x) offsetof(AVIContext, x)
992 #define ENC AV_OPT_FLAG_ENCODING_PARAM
993 static const AVOption options[] = {
994  { "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 },
995  { "write_channel_mask", "write channel mask into wave format header", OFFSET(write_channel_mask), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, ENC },
996  { NULL },
997 };
998 
999 static const AVClass avi_muxer_class = {
1000  .class_name = "AVI muxer",
1001  .item_name = av_default_item_name,
1002  .option = options,
1003  .version = LIBAVUTIL_VERSION_INT,
1004 };
1005 
1007  .name = "avi",
1008  .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1009  .mime_type = "video/x-msvideo",
1010  .extensions = "avi",
1011  .priv_data_size = sizeof(AVIContext),
1012  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,
1013  .video_codec = AV_CODEC_ID_MPEG4,
1014  .init = avi_init,
1015  .deinit = avi_deinit,
1019  .codec_tag = (const AVCodecTag * const []) {
1021  },
1022  .priv_class = &avi_muxer_class,
1023 };
#define AVI_MASTER_INDEX_PREFIX_SIZE
Definition: avienc.c:54
static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
Definition: avienc.c:739
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:698
#define NULL
Definition: coverity.c:32
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4117
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:467
Bytestream IO Context.
Definition: avio.h:161
static enum AVPixelFormat pix_fmt
#define AVI_MASTER_INDEX_SIZE_DEFAULT
Definition: avienc.c:56
#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:63
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
unsigned int pos
Definition: avienc.c:49
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int ents_allocated
Definition: avienc.c:62
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:4943
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define AVI_MAX_RIFF_SIZE
Definition: avi.h:31
#define avpriv_request_sample(...)
int64_t audio_strm_offset
Definition: avienc.c:60
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:937
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:108
int size
Definition: avcodec.h:1534
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
Convenience header that includes libavutil&#39;s core.
static char * avi_stream2fourcc(char *tag, int index, enum AVMediaType type)
Definition: avienc.c:178
GLint GLenum type
Definition: opengl_enc.c:104
void * priv_data
Definition: avformat.h:890
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:236
static AVPacket pkt
AVOutputFormat ff_avi_muxer
Definition: avienc.c:1006
int64_t frames_hdr_strm
Definition: avienc.c:78
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4028
Format I/O context.
Definition: avformat.h:1352
int64_t odml_list
Definition: avienc.c:69
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 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:367
#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:4102
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
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:105
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1551
int64_t movi_list
Definition: avidec.c:74
#define OFFSET(x)
Definition: avienc.c:991
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1420
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:1533
int64_t riff_start
Definition: avienc.c:69
#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:157
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
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:213
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:999
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:4065
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:455
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:92
#define ENC
Definition: avienc.c:992
#define AVI_MAX_STREAM_COUNT
Definition: avi.h:32
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#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:684
int master_index_max_size
Definition: avienc.c:73
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:1449
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:186
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:47
#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:578
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
simple assert() macros that are a bit more flexible than ISO C assert().
unsigned int flags
Definition: avienc.c:48
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:504
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
int packet_count
Definition: avienc.c:80
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
unsigned int len
Definition: avienc.c:50
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1408
static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
Definition: avienc.c:594
int block_align
Audio only.
Definition: avcodec.h:4153
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
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
#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:500
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:5735
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:911
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:939
int64_t indx_start
Definition: avienc.c:59
int64_t audio_strm_length
Definition: avienc.c:79
static int avi_write_header(AVFormatContext *s)
Definition: avienc.c:258
#define AVIF_HASINDEX
Definition: avi.h:24
if(ret)
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1852
Stream structure.
Definition: avformat.h:875
int64_t pal_offset
Definition: avienc.c:93
#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:765
#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:467
static av_cold int avi_init(struct AVFormatContext *s)
Definition: avienc.c:142
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1394
static const AVOption options[]
Definition: avienc.c:993
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:191
int sample_requested
Definition: avienc.c:83
#define AVIIF_NO_TIME
Definition: avi.h:39
void ff_riff_write_info(AVFormatContext *s)
Write all recognized RIFF tags from s->metadata.
Definition: riffenc.c:327
#define AV_STRINGIFY(s)
Definition: macros.h:36
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AVI_INDEX_CLUSTER_SIZE
Definition: avienc.c:53
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:55
AVMediaType
Definition: avutil.h:199
static void avi_deinit(AVFormatContext *s)
Definition: avienc.c:978
static AVIIentry * avi_get_ientry(const AVIIndex *idx, int ent_id)
Definition: avienc.c:98
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
int64_t strh_flags_offset
Definition: avienc.c:89
static void write_odml_master(AVFormatContext *s, int stream_index)
Definition: avienc.c:230
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:64
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
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:924
int64_t bitrate
Definition: h264_levels.c:131
static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
Definition: avienc.c:860
Main libavformat public API header.
int write_channel_mask
Definition: avienc.c:74
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:72
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:70
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
Definition: raw.c:315
void * priv_data
Format private data.
Definition: avformat.h:1380
#define FF_PUT_WAV_HEADER_SKIP_CHANNELMASK
Tell ff_put_wav_header() to write an empty channel mask.
Definition: riff.h:59
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
int entry
Definition: avienc.c:81
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:87
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4078
static int avi_write_counters(AVFormatContext *s, int riff_id)
Definition: avienc.c:197
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
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:375
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1467
#define AVIF_TRUSTCKTYPE
Definition: avi.h:27
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1022
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:4040
int entry
Definition: avienc.c:61
uint32_t palette[AVPALETTE_COUNT]
Definition: avienc.c:91
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:2465
int stream_index
Definition: avcodec.h:1535
int max_size
Definition: avienc.c:82
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:904
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
int64_t last_dts
Definition: avienc.c:85
#define MKTAG(a, b, c, d)
Definition: common.h:366
enum AVCodecID id
#define AVISF_VIDEO_PALCHANGES
Definition: avi.h:35
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1510
static int avi_write_ix(AVFormatContext *s)
Definition: avienc.c:626
3-char terminological language codes as per ISO-IEC 639-2
Definition: avlanguage.h:33
int riff_id
Definition: avienc.c:71
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248