FFmpeg
asfenc.c
Go to the documentation of this file.
1 /*
2  * ASF muxer
3  * Copyright (c) 2000, 2001 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 "libavutil/avassert.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/mathematics.h"
25 #include "libavutil/opt.h"
26 #include "avformat.h"
27 #include "avlanguage.h"
28 #include "avio_internal.h"
29 #include "internal.h"
30 #include "riff.h"
31 #include "asf.h"
32 
33 #define ASF_INDEXED_INTERVAL 10000000
34 #define ASF_INDEX_BLOCK (1<<9)
35 #define ASF_PAYLOADS_PER_PACKET 63
36 
37 #define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
38 #define ASF_PACKET_ERROR_CORRECTION_FLAGS \
39  (ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \
40  ASF_PACKET_ERROR_CORRECTION_DATA_SIZE)
41 
42 #if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0)
43 # define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1
44 #else
45 # define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0
46 #endif
47 
48 #define ASF_PPI_PROPERTY_FLAGS \
49  (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \
50  ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \
51  ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \
52  ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE)
53 
54 #define ASF_PPI_LENGTH_TYPE_FLAGS 0
55 
56 #define ASF_PAYLOAD_FLAGS ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD
57 
58 #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
59 # define ASF_PPI_SEQUENCE_FIELD_SIZE 1
60 #endif
61 #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
62 # define ASF_PPI_SEQUENCE_FIELD_SIZE 2
63 #endif
64 #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
65 # define ASF_PPI_SEQUENCE_FIELD_SIZE 4
66 #endif
67 #ifndef ASF_PPI_SEQUENCE_FIELD_SIZE
68 # define ASF_PPI_SEQUENCE_FIELD_SIZE 0
69 #endif
70 
71 #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
72 # define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 1
73 #endif
74 #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
75 # define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 2
76 #endif
77 #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
78 # define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 4
79 #endif
80 #ifndef ASF_PPI_PACKET_LENGTH_FIELD_SIZE
81 # define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 0
82 #endif
83 
84 #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
85 # define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 1
86 #endif
87 #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
88 # define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 2
89 #endif
90 #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
91 # define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 4
92 #endif
93 #ifndef ASF_PPI_PADDING_LENGTH_FIELD_SIZE
94 # define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 0
95 #endif
96 
97 #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
98 # define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 1
99 #endif
100 #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
101 # define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 2
102 #endif
103 #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
104 # define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 4
105 #endif
106 #ifndef ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE
107 # define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 0
108 #endif
109 
110 #if (ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE))
111 # define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 1
112 #endif
113 #if (ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE))
114 # define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 2
115 #endif
116 #if (ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE))
117 # define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 4
118 #endif
119 #ifndef ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE
120 # define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 0
121 #endif
122 
123 #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
124 # define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 1
125 #endif
126 #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
127 # define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 2
128 #endif
129 #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
130 # define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 4
131 #endif
132 #ifndef ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE
133 # define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 0
134 #endif
135 
136 #if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_BYTE == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))
137 # define ASF_PAYLOAD_LENGTH_FIELD_SIZE 1
138 #endif
139 #if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))
140 # define ASF_PAYLOAD_LENGTH_FIELD_SIZE 2
141 #endif
142 #ifndef ASF_PAYLOAD_LENGTH_FIELD_SIZE
143 # define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0
144 #endif
145 
146 #define PACKET_HEADER_MIN_SIZE \
147  (ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \
148  ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \
149  1 + /* Length Type Flags */ \
150  1 + /* Property Flags */ \
151  ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \
152  ASF_PPI_SEQUENCE_FIELD_SIZE + \
153  ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \
154  4 + /* Send Time Field */ \
155  2) /* Duration Field */
156 
157 // Replicated Data shall be at least 8 bytes long.
158 #define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08
159 
160 #define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \
161  (1 + /* Stream Number */ \
162  ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
163  ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
164  ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
165  ASF_PAYLOAD_REPLICATED_DATA_LENGTH)
166 
167 #define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \
168  (1 + /* Stream Number */ \
169  ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
170  ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
171  ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
172  ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \
173  ASF_PAYLOAD_LENGTH_FIELD_SIZE)
174 
175 #define SINGLE_PAYLOAD_HEADERS \
176  (PACKET_HEADER_MIN_SIZE + \
177  PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD)
178 
179 #define MULTI_PAYLOAD_HEADERS \
180  (PACKET_HEADER_MIN_SIZE + \
181  1 + /* Payload Flags */ \
182  2 * PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS)
183 
184 #define DATA_HEADER_SIZE 50
185 
186 #define PACKET_SIZE_MAX 65536
187 #define PACKET_SIZE_MIN 100
188 
189 typedef struct ASFStream {
190  int num;
191  unsigned char seq;
192 
193  uint16_t stream_language_index;
194 } ASFStream;
195 
196 typedef struct ASFContext {
197  AVClass *av_class;
198  uint32_t seqno;
199  int is_streamed;
200  ASFStream streams[128]; ///< it's max number and it's not that big
201  const char *languages[128];
202  int nb_languages;
203  int64_t creation_time;
204  /* non-streamed additional info */
205  uint64_t nb_packets; ///< how many packets are there in the file, invalid if broadcasting
206  int64_t duration; ///< in 100ns units
207  /* packet filling */
208  unsigned char multi_payloads_present;
209  int packet_size_left;
210  int64_t packet_timestamp_start;
211  int64_t packet_timestamp_end;
212  unsigned int packet_nb_payloads;
213  uint8_t packet_buf[PACKET_SIZE_MAX];
214  FFIOContext pb;
215  /* only for reading */
216  uint64_t data_offset; ///< beginning of the first data packet
217 
218  ASFIndex *index_ptr;
219  uint32_t nb_index_memory_alloc;
220  uint16_t maximum_packet;
221  uint32_t next_packet_number;
222  uint16_t next_packet_count;
223  uint64_t next_packet_offset;
224  int next_start_sec;
225  int end_sec;
226  int packet_size;
227 } ASFContext;
228 
229 static const AVCodecTag codec_asf_bmp_tags[] = {
230  { AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
231  { AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
232  { AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
233  { AV_CODEC_ID_NONE, 0 },
234 };
235 
236 static const AVCodecTag *const asf_codec_tags[] = {
237  codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, NULL
238 };
239 
240 #define PREROLL_TIME 3100
241 
242 static void put_str16(AVIOContext *s, AVIOContext *dyn_buf, const char *tag)
243 {
244  uint8_t *buf;
245  int len;
246 
247  avio_put_str16le(dyn_buf, tag);
248  len = avio_get_dyn_buf(dyn_buf, &buf);
249  avio_wl16(s, len);
250  avio_write(s, buf, len);
251  ffio_reset_dyn_buf(dyn_buf);
252 }
253 
254 static int64_t put_header(AVIOContext *pb, const ff_asf_guid *g)
255 {
256  int64_t pos;
257 
258  pos = avio_tell(pb);
259  ff_put_guid(pb, g);
260  avio_wl64(pb, 24);
261  return pos;
262 }
263 
264 /* update header size */
265 static void end_header(AVIOContext *pb, int64_t pos)
266 {
267  int64_t pos1;
268 
269  pos1 = avio_tell(pb);
270  avio_seek(pb, pos + 16, SEEK_SET);
271  avio_wl64(pb, pos1 - pos);
272  avio_seek(pb, pos1, SEEK_SET);
273 }
274 
275 /* write an asf chunk (only used in streaming case) */
276 static void put_chunk(AVFormatContext *s, int type,
277  int payload_length, int flags)
278 {
279  ASFContext *asf = s->priv_data;
280  AVIOContext *pb = s->pb;
281  int length;
282 
283  length = payload_length + 8;
284  avio_wl16(pb, type);
285  avio_wl16(pb, length); // size
286  avio_wl32(pb, asf->seqno); // sequence number
287  avio_wl16(pb, flags); // unknown bytes
288  avio_wl16(pb, length); // size_confirm
289  asf->seqno++;
290 }
291 
292 /* convert from av time to windows time */
293 static int64_t unix_to_file_time(int64_t ti)
294 {
295  int64_t t;
296 
297  t = ti * INT64_C(10);
298  t += INT64_C(116444736000000000);
299  return t;
300 }
301 
302 static int32_t get_send_time(ASFContext *asf, int64_t pres_time, uint64_t *offset)
303 {
304  int32_t send_time = 0;
305  *offset = asf->data_offset + DATA_HEADER_SIZE;
306  for (int i = 0; i < asf->next_start_sec; i++) {
307  if (pres_time <= asf->index_ptr[i].send_time)
308  break;
309  send_time = asf->index_ptr[i].send_time;
310  *offset = asf->index_ptr[i].offset;
311  }
312 
313  return send_time / 10000;
314 }
315 
316 static void asf_write_markers(AVFormatContext *s, AVIOContext *dyn_buf)
317 {
318  ASFContext *asf = s->priv_data;
319  AVIOContext *pb = s->pb;
320  AVRational scale = {1, 10000000};
321  int64_t hpos = put_header(pb, &ff_asf_marker_header);
322 
323  ff_put_guid(pb, &ff_asf_reserved_4);// ASF spec mandates this reserved value
324  avio_wl32(pb, s->nb_chapters); // markers count
325  avio_wl16(pb, 0); // ASF spec mandates 0 for this
326  avio_wl16(pb, 0); // name length 0, no name given
327 
328  for (unsigned i = 0; i < s->nb_chapters; i++) {
329  AVChapter *c = s->chapters[i];
330  AVDictionaryEntry *t = av_dict_get(c->metadata, "title", NULL, 0);
331  int64_t pres_time = av_rescale_q(c->start, c->time_base, scale);
332  uint64_t offset;
333  int32_t send_time = get_send_time(asf, pres_time, &offset);
334  int len = 0;
335  uint8_t *buf;
336  if (t) {
337  avio_put_str16le(dyn_buf, t->value);
338  len = avio_get_dyn_buf(dyn_buf, &buf);
339  }
340  avio_wl64(pb, offset); // offset of the packet with send_time
341  avio_wl64(pb, pres_time + PREROLL_TIME * 10000); // presentation time
342  avio_wl16(pb, 12 + len); // entry length
343  avio_wl32(pb, send_time); // send time
344  avio_wl32(pb, 0); // flags, should be 0
345  avio_wl32(pb, len / 2); // marker desc length in WCHARS!
346  if (t) {
347  avio_write(pb, buf, len); // marker desc
348  ffio_reset_dyn_buf(dyn_buf);
349  }
350  }
351  end_header(pb, hpos);
352 }
353 
354 /* write the header (used two times if non streamed) */
355 static int asf_write_header1(AVFormatContext *s, int64_t file_size,
356  int64_t data_chunk_size)
357 {
358  ASFContext *asf = s->priv_data;
359  AVIOContext *pb = s->pb, *dyn_buf;
360  AVDictionaryEntry *tags[5];
361  int header_size, extra_size, extra_size2, wav_extra_size;
362  int has_title, has_aspect_ratio = 0;
363  int metadata_count;
364  int64_t header_offset, cur_pos, hpos;
365  int bit_rate, ret;
366  int64_t duration;
367  int audio_language_counts[128] = { 0 };
368 
369  ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
370 
371  tags[0] = av_dict_get(s->metadata, "title", NULL, 0);
372  tags[1] = av_dict_get(s->metadata, "author", NULL, 0);
373  tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0);
374  tags[3] = av_dict_get(s->metadata, "comment", NULL, 0);
375  tags[4] = av_dict_get(s->metadata, "rating", NULL, 0);
376 
377  duration = asf->duration + PREROLL_TIME * 10000;
378  has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
379 
380  if (!file_size) {
381  if (ff_parse_creation_time_metadata(s, &asf->creation_time, 0) != 0)
382  av_dict_set(&s->metadata, "creation_time", NULL, 0);
383  }
384 
385  metadata_count = av_dict_count(s->metadata);
386 
387  bit_rate = 0;
388  for (unsigned n = 0; n < s->nb_streams; n++) {
389  AVStream *const st = s->streams[n];
390  AVCodecParameters *const par = st->codecpar;
391  AVDictionaryEntry *entry;
392 
393  avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
394 
395  bit_rate += par->bit_rate;
396  if ( par->codec_type == AVMEDIA_TYPE_VIDEO
397  && par->sample_aspect_ratio.num > 0
398  && par->sample_aspect_ratio.den > 0)
399  has_aspect_ratio++;
400 
401  entry = av_dict_get(s->streams[n]->metadata, "language", NULL, 0);
402  if (entry) {
403  const char *iso6391lang = ff_convert_lang_to(entry->value, AV_LANG_ISO639_1);
404  if (iso6391lang) {
405  int i;
406  for (i = 0; i < asf->nb_languages; i++) {
407  if (!strcmp(asf->languages[i], iso6391lang)) {
408  asf->streams[n].stream_language_index = i;
409  break;
410  }
411  }
412  if (i >= asf->nb_languages) {
413  asf->languages[asf->nb_languages] = iso6391lang;
414  asf->streams[n].stream_language_index = asf->nb_languages;
415  asf->nb_languages++;
416  }
417  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
418  audio_language_counts[asf->streams[n].stream_language_index]++;
419  }
420  } else {
421  asf->streams[n].stream_language_index = 128;
422  }
423  }
424 
425  if (asf->is_streamed) {
426  put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */
427  }
428 
429  ff_put_guid(pb, &ff_asf_header);
430  avio_wl64(pb, -1); /* header length, will be patched after */
431  avio_wl32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
432  avio_w8(pb, 1); /* ??? */
433  avio_w8(pb, 2); /* ??? */
434 
435  /* file header */
436  header_offset = avio_tell(pb);
437  hpos = put_header(pb, &ff_asf_file_header);
438  ff_put_guid(pb, &ff_asf_my_guid);
439  avio_wl64(pb, file_size);
440  avio_wl64(pb, unix_to_file_time(asf->creation_time));
441  avio_wl64(pb, asf->nb_packets); /* number of packets */
442  avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
443  avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
444  avio_wl64(pb, PREROLL_TIME); /* start time stamp */
445  avio_wl32(pb, (asf->is_streamed || !(pb->seekable & AVIO_SEEKABLE_NORMAL)) ? 3 : 2); /* ??? */
446  avio_wl32(pb, s->packet_size); /* packet size */
447  avio_wl32(pb, s->packet_size); /* packet size */
448  avio_wl32(pb, bit_rate ? bit_rate : -1); /* Maximum data rate in bps */
449  end_header(pb, hpos);
450 
451  /* header_extension */
452  hpos = put_header(pb, &ff_asf_head1_guid);
453  ff_put_guid(pb, &ff_asf_head2_guid);
454  avio_wl16(pb, 6);
455  avio_wl32(pb, 0); /* length, to be filled later */
456  if (asf->nb_languages) {
457  int64_t hpos2;
458  int nb_audio_languages = 0;
459 
460  hpos2 = put_header(pb, &ff_asf_language_guid);
461  avio_wl16(pb, asf->nb_languages);
462  for (int i = 0; i < asf->nb_languages; i++) {
463  avio_w8(pb, 6);
464  avio_put_str16le(pb, asf->languages[i]);
465  }
466  end_header(pb, hpos2);
467 
468  for (int i = 0; i < asf->nb_languages; i++)
469  if (audio_language_counts[i])
470  nb_audio_languages++;
471 
472  if (nb_audio_languages > 1) {
473  hpos2 = put_header(pb, &ff_asf_group_mutual_exclusion_object);
474  ff_put_guid(pb, &ff_asf_mutex_language);
475  avio_wl16(pb, nb_audio_languages);
476  for (int i = 0; i < asf->nb_languages; i++) {
477  if (audio_language_counts[i]) {
478  avio_wl16(pb, audio_language_counts[i]);
479  for (unsigned n = 0; n < s->nb_streams; n++)
480  if (asf->streams[n].stream_language_index == i && s->streams[n]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
481  avio_wl16(pb, n + 1);
482  }
483  }
484  end_header(pb, hpos2);
485  }
486 
487  for (unsigned n = 0; n < s->nb_streams; n++) {
488  int64_t es_pos;
489  if (asf->streams[n].stream_language_index > 127)
490  continue;
491  es_pos = put_header(pb, &ff_asf_extended_stream_properties_object);
492  avio_wl64(pb, 0); /* start time */
493  avio_wl64(pb, 0); /* end time */
494  avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* data bitrate bps */
495  avio_wl32(pb, 5000); /* buffer size ms */
496  avio_wl32(pb, 0); /* initial buffer fullness */
497  avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* peak data bitrate */
498  avio_wl32(pb, 5000); /* maximum buffer size ms */
499  avio_wl32(pb, 0); /* max initial buffer fullness */
500  avio_wl32(pb, 0); /* max object size */
501  avio_wl32(pb, (!asf->is_streamed && (pb->seekable & AVIO_SEEKABLE_NORMAL)) << 1); /* flags - seekable */
502  avio_wl16(pb, n + 1); /* stream number */
503  avio_wl16(pb, asf->streams[n].stream_language_index); /* language id index */
504  avio_wl64(pb, 0); /* avg time per frame */
505  avio_wl16(pb, 0); /* stream name count */
506  avio_wl16(pb, 0); /* payload extension system count */
507  end_header(pb, es_pos);
508  }
509  }
510  if (has_aspect_ratio) {
511  int64_t hpos2;
512  hpos2 = put_header(pb, &ff_asf_metadata_header);
513  avio_wl16(pb, 2 * has_aspect_ratio);
514  for (unsigned n = 0; n < s->nb_streams; n++) {
515  AVCodecParameters *const par = s->streams[n]->codecpar;
516  if ( par->codec_type == AVMEDIA_TYPE_VIDEO
517  && par->sample_aspect_ratio.num > 0
518  && par->sample_aspect_ratio.den > 0) {
519  AVRational sar = par->sample_aspect_ratio;
520  avio_wl16(pb, 0);
521  // the stream number is set like this below
522  avio_wl16(pb, n + 1);
523  avio_wl16(pb, 26); // name_len
524  avio_wl16(pb, 3); // value_type
525  avio_wl32(pb, 4); // value_len
526  avio_put_str16le(pb, "AspectRatioX");
527  avio_wl32(pb, sar.num);
528  avio_wl16(pb, 0);
529  // the stream number is set like this below
530  avio_wl16(pb, n + 1);
531  avio_wl16(pb, 26); // name_len
532  avio_wl16(pb, 3); // value_type
533  avio_wl32(pb, 4); // value_len
534  avio_put_str16le(pb, "AspectRatioY");
535  avio_wl32(pb, sar.den);
536  }
537  }
538  end_header(pb, hpos2);
539  }
540  {
541  int64_t pos1;
542  pos1 = avio_tell(pb);
543  avio_seek(pb, hpos + 42, SEEK_SET);
544  avio_wl32(pb, pos1 - hpos - 46);
545  avio_seek(pb, pos1, SEEK_SET);
546  }
547  end_header(pb, hpos);
548 
549  if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
550  return ret;
551 
552  /* title and other info */
553  if (has_title) {
554  uint8_t *buf;
555  int len;
556 
557  hpos = put_header(pb, &ff_asf_comment_header);
558 
559  for (size_t n = 0; n < FF_ARRAY_ELEMS(tags); n++) {
560  len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
561  avio_wl16(pb, len);
562  }
563  len = avio_get_dyn_buf(dyn_buf, &buf);
564  avio_write(pb, buf, len);
565  ffio_reset_dyn_buf(dyn_buf);
566  end_header(pb, hpos);
567  }
568  if (metadata_count) {
569  AVDictionaryEntry *tag = NULL;
570  hpos = put_header(pb, &ff_asf_extended_content_header);
571  avio_wl16(pb, metadata_count);
572  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
573  put_str16(pb, dyn_buf, tag->key);
574  avio_wl16(pb, 0);
575  put_str16(pb, dyn_buf, tag->value);
576  }
577  end_header(pb, hpos);
578  }
579  /* chapters using ASF markers */
580  if (!asf->is_streamed && s->nb_chapters) {
581  asf_write_markers(s, dyn_buf);
582  }
583  /* stream headers */
584  for (unsigned n = 0; n < s->nb_streams; n++) {
585  AVCodecParameters *const par = s->streams[n]->codecpar;
586  int64_t es_pos;
587  // ASFStream *stream = &asf->streams[n];
588 
589  asf->streams[n].num = n + 1;
590  asf->streams[n].seq = 1;
591 
592  switch (par->codec_type) {
593  case AVMEDIA_TYPE_AUDIO:
594  wav_extra_size = 0;
595  extra_size = 18 + wav_extra_size;
596  extra_size2 = 8;
597  break;
598  default:
599  case AVMEDIA_TYPE_VIDEO:
600  wav_extra_size = par->extradata_size;
601  extra_size = 0x33 + wav_extra_size;
602  extra_size2 = 0;
603  break;
604  }
605 
606  hpos = put_header(pb, &ff_asf_stream_header);
607  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
608  ff_put_guid(pb, &ff_asf_audio_stream);
609  ff_put_guid(pb, &ff_asf_audio_conceal_spread);
610  } else {
611  ff_put_guid(pb, &ff_asf_video_stream);
612  ff_put_guid(pb, &ff_asf_video_conceal_none);
613  }
614  avio_wl64(pb, 0); /* ??? */
615  es_pos = avio_tell(pb);
616  avio_wl32(pb, extra_size); /* wav header len */
617  avio_wl32(pb, extra_size2); /* additional data len */
618  avio_wl16(pb, n + 1); /* stream number */
619  avio_wl32(pb, 0); /* ??? */
620 
621  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
622  /* WAVEFORMATEX header */
623  int wavsize = ff_put_wav_header(s, pb, par, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX);
624 
625  if (wavsize < 0) {
626  ret = wavsize;
627  goto fail;
628  }
629  if (wavsize != extra_size) {
630  cur_pos = avio_tell(pb);
631  avio_seek(pb, es_pos, SEEK_SET);
632  avio_wl32(pb, wavsize); /* wav header len */
633  avio_seek(pb, cur_pos, SEEK_SET);
634  }
635  /* ERROR Correction */
636  avio_w8(pb, 0x01);
637  if (par->codec_id == AV_CODEC_ID_ADPCM_G726 || !par->block_align) {
638  avio_wl16(pb, 0x0190);
639  avio_wl16(pb, 0x0190);
640  } else {
641  avio_wl16(pb, par->block_align);
642  avio_wl16(pb, par->block_align);
643  }
644  avio_wl16(pb, 0x01);
645  avio_w8(pb, 0x00);
646  } else {
647  avio_wl32(pb, par->width);
648  avio_wl32(pb, par->height);
649  avio_w8(pb, 2); /* ??? */
650  avio_wl16(pb, 40 + par->extradata_size); /* size */
651 
652  /* BITMAPINFOHEADER header */
653  ff_put_bmp_header(pb, par, 1, 0, 0);
654  }
655  end_header(pb, hpos);
656  }
657 
658  /* media comments */
659 
660  hpos = put_header(pb, &ff_asf_codec_comment_header);
661  ff_put_guid(pb, &ff_asf_codec_comment1_header);
662  avio_wl32(pb, s->nb_streams);
663  for (unsigned n = 0; n < s->nb_streams; n++) {
664  AVCodecParameters *const par = s->streams[n]->codecpar;
665  const AVCodecDescriptor *const codec_desc = avcodec_descriptor_get(par->codec_id);
666  const char *desc;
667 
668  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
669  avio_wl16(pb, 2);
670  else if (par->codec_type == AVMEDIA_TYPE_VIDEO)
671  avio_wl16(pb, 1);
672  else
673  avio_wl16(pb, -1);
674 
675  if (par->codec_id == AV_CODEC_ID_WMAV2)
676  desc = "Windows Media Audio V8";
677  else
678  desc = codec_desc ? codec_desc->name : NULL;
679 
680  if (desc) {
681  uint8_t *buf;
682  int len;
683 
684  avio_put_str16le(dyn_buf, desc);
685  len = avio_get_dyn_buf(dyn_buf, &buf);
686  avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2
687 
688  avio_write(pb, buf, len);
689  ffio_reset_dyn_buf(dyn_buf);
690  } else
691  avio_wl16(pb, 0);
692 
693  avio_wl16(pb, 0); /* no parameters */
694 
695  /* id */
696  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
697  avio_wl16(pb, 2);
698  avio_wl16(pb, par->codec_tag);
699  } else {
700  avio_wl16(pb, 4);
701  avio_wl32(pb, par->codec_tag);
702  }
703  if (!par->codec_tag) {
704  ret = AVERROR(EINVAL);
705  goto fail;
706  }
707  }
708  end_header(pb, hpos);
709 
710  /* patch the header size fields */
711 
712  cur_pos = avio_tell(pb);
713  header_size = cur_pos - header_offset;
714  if (asf->is_streamed) {
715  header_size += 8 + 30 + DATA_HEADER_SIZE;
716 
717  avio_seek(pb, header_offset - 10 - 30, SEEK_SET);
718  avio_wl16(pb, header_size);
719  avio_seek(pb, header_offset - 2 - 30, SEEK_SET);
720  avio_wl16(pb, header_size);
721 
722  header_size -= 8 + 30 + DATA_HEADER_SIZE;
723  }
724  header_size += 24 + 6;
725  avio_seek(pb, header_offset - 14, SEEK_SET);
726  avio_wl64(pb, header_size);
727  avio_seek(pb, cur_pos, SEEK_SET);
728 
729  /* movie chunk, followed by packets of packet_size */
730  asf->data_offset = cur_pos;
731  ff_put_guid(pb, &ff_asf_data_header);
732  avio_wl64(pb, data_chunk_size);
733  ff_put_guid(pb, &ff_asf_my_guid);
734  avio_wl64(pb, asf->nb_packets); /* nb packets */
735  avio_w8(pb, 1); /* ??? */
736  avio_w8(pb, 1); /* ??? */
737  ret = 0;
738 fail:
739  ffio_free_dyn_buf(&dyn_buf);
740  return ret;
741 }
742 
743 static int asf_write_header(AVFormatContext *s)
744 {
745  ASFContext *asf = s->priv_data;
746  int ret;
747 
748  s->packet_size = asf->packet_size;
749  s->max_interleave_delta = 0;
750  asf->nb_packets = 0;
751 
752  if (s->nb_streams > 127) {
753  av_log(s, AV_LOG_ERROR, "ASF can only handle 127 streams\n");
754  return AVERROR(EINVAL);
755  }
756 
757  asf->index_ptr = av_malloc(sizeof(ASFIndex) * ASF_INDEX_BLOCK);
758  if (!asf->index_ptr)
759  return AVERROR(ENOMEM);
760  asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
761  asf->maximum_packet = 0;
762 
763  /* the data-chunk-size has to be 50 (DATA_HEADER_SIZE), which is
764  * data_size - asf->data_offset at the moment this function is done.
765  * It is needed to use asf as a streamable format. */
766  if ((ret = asf_write_header1(s, 0, DATA_HEADER_SIZE)) < 0)
767  return ret;
768 
769  asf->packet_nb_payloads = 0;
770  asf->packet_timestamp_start = -1;
771  asf->packet_timestamp_end = -1;
772  ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
773  NULL, NULL, NULL, NULL);
774 
775  if (s->avoid_negative_ts < 0)
776  s->avoid_negative_ts = 1;
777 
778  return 0;
779 }
780 
781 static int asf_write_stream_header(AVFormatContext *s)
782 {
783  ASFContext *asf = s->priv_data;
784 
785  asf->is_streamed = 1;
786 
787  return asf_write_header(s);
788 }
789 
790 static int put_payload_parsing_info(AVFormatContext *s,
791  unsigned sendtime, unsigned duration,
792  int nb_payloads, int padsize)
793 {
794  ASFContext *asf = s->priv_data;
795  AVIOContext *pb = s->pb;
796  int ppi_size;
797  int64_t start = avio_tell(pb);
798 
799  int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;
800 
801  padsize -= PACKET_HEADER_MIN_SIZE;
802  if (asf->multi_payloads_present)
803  padsize--;
804  av_assert0(padsize >= 0);
805 
806  avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
807  ffio_fill(pb, 0x0, ASF_PACKET_ERROR_CORRECTION_DATA_SIZE);
808 
809  if (asf->multi_payloads_present)
810  iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT;
811 
812  if (padsize > 0) {
813  if (padsize < 256)
814  iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE;
815  else
816  iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;
817  }
818  avio_w8(pb, iLengthTypeFlags);
819 
820  avio_w8(pb, ASF_PPI_PROPERTY_FLAGS);
821 
822  if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)
823  avio_wl16(pb, padsize - 2);
824  if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)
825  avio_w8(pb, padsize - 1);
826 
827  avio_wl32(pb, sendtime);
828  avio_wl16(pb, duration);
829  if (asf->multi_payloads_present)
830  avio_w8(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
831 
832  ppi_size = avio_tell(pb) - start;
833 
834  return ppi_size;
835 }
836 
837 static void flush_packet(AVFormatContext *s)
838 {
839  ASFContext *asf = s->priv_data;
840  int packet_hdr_size, packet_filled_size;
841 
842  av_assert0(asf->packet_timestamp_end >= asf->packet_timestamp_start);
843 
844  if (asf->is_streamed)
845  put_chunk(s, 0x4424, s->packet_size, 0);
846 
847  packet_hdr_size = put_payload_parsing_info(s,
848  asf->packet_timestamp_start,
849  asf->packet_timestamp_end - asf->packet_timestamp_start,
850  asf->packet_nb_payloads,
851  asf->packet_size_left);
852 
853  packet_filled_size = asf->packet_size - asf->packet_size_left;
854  av_assert0(packet_hdr_size <= asf->packet_size_left);
855  memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);
856 
857  avio_write(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
858 
859  avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
860 
861  asf->nb_packets++;
862  asf->packet_nb_payloads = 0;
863  asf->packet_timestamp_start = -1;
864  asf->packet_timestamp_end = -1;
865  ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
866  NULL, NULL, NULL, NULL);
867 }
868 
869 static void put_payload_header(AVFormatContext *s, ASFStream *stream,
870  int64_t presentation_time, int m_obj_size,
871  int m_obj_offset, int payload_len, int flags)
872 {
873  ASFContext *asf = s->priv_data;
874  AVIOContext *const pb = &asf->pb.pub;
875  int val;
876 
877  val = stream->num;
878  if (flags & AV_PKT_FLAG_KEY)
879  val |= ASF_PL_FLAG_KEY_FRAME;
880  avio_w8(pb, val);
881 
882  avio_w8(pb, stream->seq); // Media object number
883  avio_wl32(pb, m_obj_offset); // Offset Into Media Object
884 
885  // Replicated Data shall be at least 8 bytes long.
886  // The first 4 bytes of data shall contain the
887  // Size of the Media Object that the payload belongs to.
888  // The next 4 bytes of data shall contain the
889  // Presentation Time for the media object that the payload belongs to.
890  avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
891 
892  avio_wl32(pb, m_obj_size); // Replicated Data - Media Object Size
893  avio_wl32(pb, (uint32_t) presentation_time); // Replicated Data - Presentation Time
894 
895  if (asf->multi_payloads_present) {
896  avio_wl16(pb, payload_len); // payload length
897  }
898 }
899 
900 static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
901  int64_t timestamp, const uint8_t *buf,
902  int m_obj_size, int flags)
903 {
904  ASFContext *asf = s->priv_data;
905  int m_obj_offset, payload_len, frag_len1;
906 
907  m_obj_offset = 0;
908  while (m_obj_offset < m_obj_size) {
909  payload_len = m_obj_size - m_obj_offset;
910  if (asf->packet_timestamp_start == -1) {
911  const int multi_payload_constant = (asf->packet_size - MULTI_PAYLOAD_HEADERS);
912  asf->multi_payloads_present = (payload_len < multi_payload_constant);
913 
914  asf->packet_size_left = asf->packet_size;
915  if (asf->multi_payloads_present) {
916  frag_len1 = multi_payload_constant - 1;
917  } else {
918  frag_len1 = asf->packet_size - SINGLE_PAYLOAD_HEADERS;
919  }
920  asf->packet_timestamp_start = timestamp;
921  } else {
922  // multi payloads
923  frag_len1 = asf->packet_size_left -
924  PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS -
925  PACKET_HEADER_MIN_SIZE - 1;
926 
927  if (frag_len1 < payload_len &&
928  avst->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
929  flush_packet(s);
930  continue;
931  }
932  if (asf->packet_timestamp_start > INT64_MAX - UINT16_MAX ||
933  timestamp > asf->packet_timestamp_start + UINT16_MAX) {
934  flush_packet(s);
935  continue;
936  }
937  }
938  if (frag_len1 > 0) {
939  if (payload_len > frag_len1)
940  payload_len = frag_len1;
941  else if (payload_len == (frag_len1 - 1))
942  payload_len = frag_len1 - 2; // additional byte need to put padding length
943 
944  put_payload_header(s, stream, timestamp + PREROLL_TIME,
945  m_obj_size, m_obj_offset, payload_len, flags);
946  avio_write(&asf->pb.pub, buf, payload_len);
947 
948  if (asf->multi_payloads_present)
949  asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);
950  else
951  asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD);
952  asf->packet_timestamp_end = timestamp;
953 
954  asf->packet_nb_payloads++;
955  } else {
956  payload_len = 0;
957  }
958  m_obj_offset += payload_len;
959  buf += payload_len;
960 
961  if (!asf->multi_payloads_present)
962  flush_packet(s);
963  else if (asf->packet_size_left <= (PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS + PACKET_HEADER_MIN_SIZE + 1))
964  flush_packet(s);
965  else if (asf->packet_nb_payloads == ASF_PAYLOADS_PER_PACKET)
966  flush_packet(s);
967  }
968  stream->seq++;
969 }
970 
971 static int update_index(AVFormatContext *s, int start_sec,
972  uint32_t packet_number, uint16_t packet_count,
973  uint64_t packet_offset)
974 {
975  ASFContext *asf = s->priv_data;
976 
977  if (start_sec > asf->next_start_sec) {
978  if (!asf->next_start_sec) {
979  asf->next_packet_number = packet_number;
980  asf->next_packet_count = packet_count;
981  asf->next_packet_offset = packet_offset;
982  }
983 
984  if (start_sec > asf->nb_index_memory_alloc) {
985  int err;
986  asf->nb_index_memory_alloc = (start_sec + ASF_INDEX_BLOCK) & ~(ASF_INDEX_BLOCK - 1);
987  if ((err = av_reallocp_array(&asf->index_ptr,
988  asf->nb_index_memory_alloc,
989  sizeof(*asf->index_ptr))) < 0) {
990  asf->nb_index_memory_alloc = 0;
991  return err;
992  }
993  }
994  for (int i = asf->next_start_sec; i < start_sec; i++) {
995  asf->index_ptr[i].packet_number = asf->next_packet_number;
996  asf->index_ptr[i].packet_count = asf->next_packet_count;
997  asf->index_ptr[i].send_time = asf->next_start_sec * INT64_C(10000000);
998  asf->index_ptr[i].offset = asf->next_packet_offset;
999 
1000  }
1001  }
1002  asf->maximum_packet = FFMAX(asf->maximum_packet, packet_count);
1003  asf->next_packet_number = packet_number;
1004  asf->next_packet_count = packet_count;
1005  asf->next_packet_offset = packet_offset;
1006  asf->next_start_sec = start_sec;
1007 
1008  return 0;
1009 }
1010 
1011 static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
1012 {
1013  ASFContext *asf = s->priv_data;
1014  AVIOContext *pb = s->pb;
1015  ASFStream *stream;
1016  AVCodecParameters *par;
1017  uint32_t packet_number;
1018  int64_t pts;
1019  int start_sec;
1020  int flags = pkt->flags;
1021  int ret;
1022  uint64_t offset = avio_tell(pb);
1023 
1024  par = s->streams[pkt->stream_index]->codecpar;
1025  stream = &asf->streams[pkt->stream_index];
1026 
1027  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
1028  flags &= ~AV_PKT_FLAG_KEY;
1029 
1030  pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
1031  av_assert0(pts != AV_NOPTS_VALUE);
1032  if ( pts < - PREROLL_TIME
1033  || pts > (INT_MAX-3)/10000LL * ASF_INDEXED_INTERVAL - PREROLL_TIME) {
1034  av_log(s, AV_LOG_ERROR, "input pts %"PRId64" is invalid\n", pts);
1035  return AVERROR(EINVAL);
1036  }
1037  pts *= 10000;
1038  asf->duration = FFMAX(asf->duration, pts + pkt->duration * 10000);
1039 
1040  packet_number = asf->nb_packets;
1041  put_frame(s, stream, s->streams[pkt->stream_index],
1042  pkt->dts, pkt->data, pkt->size, flags);
1043 
1044  start_sec = (int)((PREROLL_TIME * 10000 + pts + ASF_INDEXED_INTERVAL - 1)
1045  / ASF_INDEXED_INTERVAL);
1046 
1047  /* check index */
1048  if ((!asf->is_streamed) && (flags & AV_PKT_FLAG_KEY)) {
1049  uint16_t packet_count = asf->nb_packets - packet_number;
1050  ret = update_index(s, start_sec, packet_number, packet_count, offset);
1051  if (ret < 0)
1052  return ret;
1053  }
1054  asf->end_sec = start_sec;
1055 
1056  return 0;
1057 }
1058 
1059 static int asf_write_index(AVFormatContext *s, const ASFIndex *index,
1060  uint16_t max, uint32_t count)
1061 {
1062  AVIOContext *pb = s->pb;
1063 
1064  ff_put_guid(pb, &ff_asf_simple_index_header);
1065  avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2) * count);
1066  ff_put_guid(pb, &ff_asf_my_guid);
1067  avio_wl64(pb, ASF_INDEXED_INTERVAL);
1068  avio_wl32(pb, max);
1069  avio_wl32(pb, count);
1070  for (uint32_t i = 0; i < count; i++) {
1071  avio_wl32(pb, index[i].packet_number);
1072  avio_wl16(pb, index[i].packet_count);
1073  }
1074 
1075  return 0;
1076 }
1077 
1078 static int asf_write_trailer(AVFormatContext *s)
1079 {
1080  ASFContext *asf = s->priv_data;
1081  int64_t file_size, data_size;
1082  int ret;
1083 
1084  /* flush the current packet */
1085  if (asf->pb.pub.buf_ptr > asf->pb.pub.buffer)
1086  flush_packet(s);
1087 
1088  /* write index */
1089  data_size = avio_tell(s->pb);
1090  if (!asf->is_streamed && asf->next_start_sec) {
1091  if ((ret = update_index(s, asf->end_sec + 1, 0, 0, 0)) < 0)
1092  return ret;
1093  asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->next_start_sec);
1094  }
1095 
1096  if (asf->is_streamed || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1097  put_chunk(s, 0x4524, 0, 0); /* end of stream */
1098  } else {
1099  /* rewrite an updated header */
1100  file_size = avio_tell(s->pb);
1101  avio_seek(s->pb, 0, SEEK_SET);
1102  asf_write_header1(s, file_size, data_size - asf->data_offset);
1103  }
1104 
1105  return 0;
1106 }
1107 
1108 static void asf_deinit(AVFormatContext *s)
1109 {
1110  ASFContext *const asf = s->priv_data;
1111 
1112  av_freep(&asf->index_ptr);
1113 }
1114 
1115 static const AVOption asf_options[] = {
1116  { "packet_size", "Packet size", offsetof(ASFContext, packet_size), AV_OPT_TYPE_INT, {.i64 = 3200}, PACKET_SIZE_MIN, PACKET_SIZE_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1117  { NULL },
1118 };
1119 
1120 static const AVClass asf_muxer_class = {
1121  .class_name = "ASF (stream) muxer",
1122  .item_name = av_default_item_name,
1123  .option = asf_options,
1124  .version = LIBAVUTIL_VERSION_INT,
1125 };
1126 
1127 #if CONFIG_ASF_MUXER
1128 const AVOutputFormat ff_asf_muxer = {
1129  .name = "asf",
1130  .long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1131  .mime_type = "video/x-ms-asf",
1132  .extensions = "asf,wmv,wma",
1133  .priv_data_size = sizeof(ASFContext),
1134  .audio_codec = AV_CODEC_ID_WMAV2,
1135  .video_codec = AV_CODEC_ID_MSMPEG4V3,
1136  .write_header = asf_write_header,
1137  .write_packet = asf_write_packet,
1138  .write_trailer = asf_write_trailer,
1139  .flags = AVFMT_GLOBALHEADER,
1140  .codec_tag = asf_codec_tags,
1141  .priv_class = &asf_muxer_class,
1142  .deinit = asf_deinit,
1143 };
1144 #endif /* CONFIG_ASF_MUXER */
1145 
1146 #if CONFIG_ASF_STREAM_MUXER
1147 const AVOutputFormat ff_asf_stream_muxer = {
1148  .name = "asf_stream",
1149  .long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1150  .mime_type = "video/x-ms-asf",
1151  .extensions = "asf,wmv,wma",
1152  .priv_data_size = sizeof(ASFContext),
1153  .audio_codec = AV_CODEC_ID_WMAV2,
1154  .video_codec = AV_CODEC_ID_MSMPEG4V3,
1155  .write_header = asf_write_stream_header,
1156  .write_packet = asf_write_packet,
1157  .write_trailer = asf_write_trailer,
1158  .flags = AVFMT_GLOBALHEADER,
1159  .codec_tag = asf_codec_tags,
1160  .priv_class = &asf_muxer_class,
1161  .deinit = asf_deinit,
1162 };
1163 #endif /* CONFIG_ASF_STREAM_MUXER */
ASFContext::packet_size
int packet_size
Definition: asfenc.c:226
AV_LANG_ISO639_1
@ AV_LANG_ISO639_1
3-char terminological language codes as per ISO-IEC 639-2
Definition: avlanguage.h:30
ASF_INDEXED_INTERVAL
#define ASF_INDEXED_INTERVAL
Definition: asfenc.c:33
AVOutputFormat::name
const char * name
Definition: avformat.h:504
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:56
PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD
#define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD
Definition: asfenc.c:160
ASFIndex
Definition: asf.h:65
asf_muxer_class
static const AVClass asf_muxer_class
Definition: asfenc.c:1120
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ASFContext::next_start_sec
int next_start_sec
Definition: asfenc.c:224
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:35
ff_asf_stream_muxer
const AVOutputFormat ff_asf_stream_muxer
codec_asf_bmp_tags
static const AVCodecTag codec_asf_bmp_tags[]
Definition: asfenc.c:229
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:216
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
avlanguage.h
ff_asf_extended_stream_properties_object
const ff_asf_guid ff_asf_extended_stream_properties_object
Definition: asf.c:142
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
ASFContext::duration
int64_t duration
in 100ns units
Definition: asfenc.c:206
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
index
fg index
Definition: ffmpeg_filter.c:167
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
ff_parse_creation_time_metadata
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails.
Definition: utils.c:1866
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
asf_deinit
static void asf_deinit(AVFormatContext *s)
Definition: asfenc.c:1108
ff_asf_video_stream
const ff_asf_guid ff_asf_video_stream
Definition: asf.c:49
ff_asf_simple_index_header
const ff_asf_guid ff_asf_simple_index_header
Definition: asf.c:92
avio_wl64
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:454
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:509
put_chunk
static void put_chunk(AVFormatContext *s, int type, int payload_length, int flags)
Definition: asfenc.c:276
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:431
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ASFContext::packet_buf
uint8_t packet_buf[PACKET_SIZE_MAX]
Definition: asfenc.c:213
ff_asf_stream_header
const ff_asf_guid ff_asf_stream_header
Definition: asf.c:33
ASFContext::seqno
uint32_t seqno
Definition: asfenc.c:198
ff_asf_codec_comment_header
const ff_asf_guid ff_asf_codec_comment_header
Definition: asf.c:69
ASFContext::data_offset
uint64_t data_offset
beginning of the first data packet
Definition: asfdec_f.c:84
ASFContext::av_class
AVClass * av_class
Definition: asfenc.c:197
avio_get_dyn_buf
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1483
FFIOContext
Definition: avio_internal.h:29
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
ASFContext::nb_index_memory_alloc
uint32_t nb_index_memory_alloc
Definition: asfenc.c:219
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:466
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:490
asf_write_packet
static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: asfenc.c:1011
ff_asf_mutex_language
const ff_asf_guid ff_asf_mutex_language
Definition: asf.c:150
ASFContext::languages
const char * languages[128]
Definition: asfenc.c:201
ASFContext::streams
ASFStream streams[128]
it's max number and it's not that big
Definition: asfdec_f.c:76
fail
#define fail()
Definition: checkasm.h:127
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:504
ASF_PACKET_ERROR_CORRECTION_FLAGS
#define ASF_PACKET_ERROR_CORRECTION_FLAGS
Definition: asfenc.c:38
AVChapter
Definition: avformat.h:1159
val
static double val(void *priv, double ch)
Definition: aeval.c:76
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
ff_asf_group_mutual_exclusion_object
const ff_asf_guid ff_asf_group_mutual_exclusion_object
Definition: asf.c:146
ASF_PAYLOAD_REPLICATED_DATA_LENGTH
#define ASF_PAYLOAD_REPLICATED_DATA_LENGTH
Definition: asfenc.c:158
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1388
pts
static int64_t pts
Definition: transcode_aac.c:653
AVRational::num
int num
Numerator.
Definition: rational.h:59
ASFContext::end_sec
int end_sec
Definition: asfenc.c:225
ASFContext::next_packet_number
uint32_t next_packet_number
Definition: asfenc.c:221
avassert.h
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ASFContext::packet_timestamp_start
int64_t packet_timestamp_start
Definition: asfenc.c:210
AVCodecTag
Definition: internal.h:51
duration
int64_t duration
Definition: movenc.c:64
MULTI_PAYLOAD_HEADERS
#define MULTI_PAYLOAD_HEADERS
Definition: asfenc.c:179
PACKET_SIZE_MIN
#define PACKET_SIZE_MIN
Definition: asfenc.c:187
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1471
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:364
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:277
ASFContext::maximum_packet
uint16_t maximum_packet
Definition: asfenc.c:220
ASFContext::packet_timestamp_end
int64_t packet_timestamp_end
Definition: asfenc.c:211
ff_asf_data_header
const ff_asf_guid ff_asf_data_header
Definition: asf.c:76
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE
#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE
Definition: asfenc.c:37
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:141
ASF_PAYLOAD_FLAGS
#define ASF_PAYLOAD_FLAGS
Definition: asfenc.c:56
asf_write_header
static int asf_write_header(AVFormatContext *s)
Definition: asfenc.c:743
ASF_PAYLOADS_PER_PACKET
#define ASF_PAYLOADS_PER_PACKET
Definition: asfenc.c:35
ASFIndex::send_time
uint64_t send_time
Definition: asf.h:68
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
put_str16
static void put_str16(AVIOContext *s, AVIOContext *dyn_buf, const char *tag)
Definition: asfenc.c:242
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
ff_asf_guid
uint8_t ff_asf_guid[16]
Definition: riff.h:95
ff_asf_audio_conceal_spread
const ff_asf_guid ff_asf_audio_conceal_spread
Definition: asf.c:45
ff_put_wav_header
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:55
ff_asf_header
const ff_asf_guid ff_asf_header
Definition: asf.c:25
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
ASFStream::seq
unsigned char seq
Definition: asfdec_f.c:48
ff_asf_metadata_conv
const AVMetadataConv ff_asf_metadata_conv[]
Definition: asf.c:155
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ASFContext::pb
FFIOContext pb
Definition: asfenc.c:214
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
put_payload_parsing_info
static int put_payload_parsing_info(AVFormatContext *s, unsigned sendtime, unsigned duration, int nb_payloads, int padsize)
Definition: asfenc.c:790
ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE
#define ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE
Definition: asf.h:143
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
ASFContext::nb_packets
uint64_t nb_packets
how many packets are there in the file, invalid if broadcasting
Definition: asfdec_o.c:96
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:218
ASFContext::packet_size_left
int packet_size_left
Definition: asfdec_f.c:82
ff_asf_head1_guid
const ff_asf_guid ff_asf_head1_guid
Definition: asf.c:80
asf_codec_tags
static const AVCodecTag *const asf_codec_tags[]
Definition: asfenc.c:236
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
put_payload_header
static void put_payload_header(AVFormatContext *s, ASFStream *stream, int64_t presentation_time, int m_obj_size, int m_obj_offset, int payload_len, int flags)
Definition: asfenc.c:869
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
ASFIndex::packet_number
uint32_t packet_number
Definition: asf.h:66
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
ffio_reset_dyn_buf
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1505
AVPacket::size
int size
Definition: packet.h:374
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:117
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:262
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:30
ff_convert_lang_to
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:736
ASFContext::packet_size
uint32_t packet_size
Definition: asfdec_o.c:97
ASF_INDEX_BLOCK
#define ASF_INDEX_BLOCK
Definition: asfenc.c:34
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
#define FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
Tell ff_put_wav_header() to use WAVEFORMATEX even for PCM codecs.
Definition: riff.h:53
ASFContext::is_streamed
int is_streamed
Definition: asfenc.c:199
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
asf_write_header1
static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size)
Definition: asfenc.c:355
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:232
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:386
offset
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 offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:727
ASF_PPI_LENGTH_TYPE_FLAGS
#define ASF_PPI_LENGTH_TYPE_FLAGS
Definition: asfenc.c:54
ASFIndex::offset
uint64_t offset
Definition: asf.h:69
ASF_PL_FLAG_KEY_FRAME
#define ASF_PL_FLAG_KEY_FRAME
Definition: asf.h:176
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:474
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
avio_internal.h
ff_asf_reserved_4
const ff_asf_guid ff_asf_reserved_4
Definition: asf.c:116
AVCodecParameters::height
int height
Definition: codec_par.h:127
ASFContext::creation_time
int64_t creation_time
Definition: asfenc.c:203
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
ASFStream::stream_language_index
uint16_t stream_language_index
Definition: asfdec_f.c:64
ffio_init_context
void ffio_init_context(FFIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:81
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
value
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 default value
Definition: writing_filters.txt:86
unix_to_file_time
static int64_t unix_to_file_time(int64_t ti)
Definition: asfenc.c:293
PREROLL_TIME
#define PREROLL_TIME
Definition: asfenc.c:240
len
int len
Definition: vorbis_enc_data.h:426
ff_asf_extended_content_header
const ff_asf_guid ff_asf_extended_content_header
Definition: asf.c:88
DATA_HEADER_SIZE
#define DATA_HEADER_SIZE
Definition: asfenc.c:184
put_header
static int64_t put_header(AVIOContext *pb, const ff_asf_guid *g)
Definition: asfenc.c:254
ASFContext::packet_nb_payloads
unsigned int packet_nb_payloads
Definition: asfenc.c:212
tag
uint32_t tag
Definition: movenc.c:1596
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1544
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
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
ff_asf_audio_stream
const ff_asf_guid ff_asf_audio_stream
Definition: asf.c:41
PACKET_SIZE_MAX
#define PACKET_SIZE_MAX
Definition: asfenc.c:186
ASFContext::nb_languages
int nb_languages
Definition: asfenc.c:202
ASFContext::multi_payloads_present
unsigned char multi_payloads_present
Definition: asfenc.c:208
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
dict.h
asf_options
static const AVOption asf_options[]
Definition: asfenc.c:1115
asf.h
get_send_time
static int32_t get_send_time(ASFContext *asf, int64_t pres_time, uint64_t *offset)
Definition: asfenc.c:302
ASFContext::next_packet_offset
uint64_t next_packet_offset
Definition: asfenc.c:223
asf_write_trailer
static int asf_write_trailer(AVFormatContext *s)
Definition: asfenc.c:1078
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:34
ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT
#define ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT
Definition: asf.h:136
ff_asf_comment_header
const ff_asf_guid ff_asf_comment_header
Definition: asf.c:65
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
flush_packet
static void flush_packet(AVFormatContext *s)
Definition: asfenc.c:837
ff_put_guid
void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
Definition: riffenc.c:357
AVRational::den
int den
Denominator.
Definition: rational.h:60
PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS
#define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS
Definition: asfenc.c:167
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
asf_write_markers
static void asf_write_markers(AVFormatContext *s, AVIOContext *dyn_buf)
Definition: asfenc.c:316
end_header
static void end_header(AVIOContext *pb, int64_t pos)
Definition: asfenc.c:265
ASFContext::duration
int duration
Definition: asfdec_o.c:99
ASFStream::num
int num
Definition: asfdec_f.c:47
update_index
static int update_index(AVFormatContext *s, int start_sec, uint32_t packet_number, uint16_t packet_count, uint64_t packet_offset)
Definition: asfenc.c:971
ff_asf_language_guid
const ff_asf_guid ff_asf_language_guid
Definition: asf.c:126
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: utils.c:1196
AVPacket::stream_index
int stream_index
Definition: packet.h:375
SINGLE_PAYLOAD_HEADERS
#define SINGLE_PAYLOAD_HEADERS
Definition: asfenc.c:175
ff_asf_file_header
const ff_asf_guid ff_asf_file_header
Definition: asf.c:29
ff_asf_metadata_header
const ff_asf_guid ff_asf_metadata_header
Definition: asf.c:104
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ASFContext
Definition: asfdec_f.c:73
ff_asf_head2_guid
const ff_asf_guid ff_asf_head2_guid
Definition: asf.c:84
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
put_frame
static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst, int64_t timestamp, const uint8_t *buf, int m_obj_size, int flags)
Definition: asfenc.c:900
AVDictionaryEntry
Definition: dict.h:79
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
riff.h
PACKET_HEADER_MIN_SIZE
#define PACKET_HEADER_MIN_SIZE
Definition: asfenc.c:146
ff_asf_my_guid
const ff_asf_guid ff_asf_my_guid
Definition: asf.c:122
ASFIndex::packet_count
uint16_t packet_count
Definition: asf.h:67
avio_put_str16le
int avio_put_str16le(AVIOContext *s, const char *str)
Convert an UTF-8 string to UTF-16LE and write it.
int32_t
int32_t
Definition: audioconvert.c:56
ASFStream
Definition: asfdec_f.c:46
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
ff_asf_marker_header
const ff_asf_guid ff_asf_marker_header
Definition: asf.c:112
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_MSMPEG4V3
@ AV_CODEC_ID_MSMPEG4V3
Definition: codec_id.h:66
asf_write_stream_header
static int asf_write_stream_header(AVFormatContext *s)
Definition: asfenc.c:781
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3521
AVDictionaryEntry::value
char * value
Definition: dict.h:81
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
ff_asf_video_conceal_none
const ff_asf_guid ff_asf_video_conceal_none
Definition: asf.c:57
ASFContext::next_packet_count
uint16_t next_packet_count
Definition: asfenc.c:222
ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD
#define ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD
Definition: asf.h:144
AVIOContext::buf_ptr
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
int
int
Definition: ffmpeg_filter.c:153
ASFContext::index_ptr
ASFIndex * index_ptr
Definition: asfenc.c:218
ff_asf_codec_comment1_header
const ff_asf_guid ff_asf_codec_comment1_header
Definition: asf.c:72
ff_asf_muxer
const AVOutputFormat ff_asf_muxer
ASF_PPI_PROPERTY_FLAGS
#define ASF_PPI_PROPERTY_FLAGS
Definition: asfenc.c:48
AVIO_DATA_MARKER_FLUSH_POINT
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
asf_write_index
static int asf_write_index(AVFormatContext *s, const ASFIndex *index, uint16_t max, uint32_t count)
Definition: asfenc.c:1059
Generated on Wed Aug 24 2022 21:38:20 for FFmpeg by   doxygen 1.8.17