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