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