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 /* convert from av time to windows time */
298 static int64_t unix_to_file_time(int64_t ti)
299 {
300  int64_t t;
301 
302  t = ti * INT64_C(10);
303  t += INT64_C(116444736000000000);
304  return t;
305 }
306 
307 static int32_t get_send_time(ASFContext *asf, int64_t pres_time, uint64_t *offset)
308 {
309  int32_t send_time = 0;
310  *offset = asf->data_offset + DATA_HEADER_SIZE;
311  for (int i = 0; i < asf->next_start_sec; i++) {
312  if (pres_time <= asf->index_ptr[i].send_time)
313  break;
314  send_time = asf->index_ptr[i].send_time;
315  *offset = asf->index_ptr[i].offset;
316  }
317 
318  return send_time / 10000;
319 }
320 
321 static void asf_write_markers(AVFormatContext *s, AVIOContext *dyn_buf)
322 {
323  ASFContext *asf = s->priv_data;
324  AVIOContext *pb = s->pb;
325  AVRational scale = {1, 10000000};
326  int64_t hpos = put_header(pb, &ff_asf_marker_header);
327 
328  ff_put_guid(pb, &ff_asf_reserved_4);// ASF spec mandates this reserved value
329  avio_wl32(pb, s->nb_chapters); // markers count
330  avio_wl16(pb, 0); // ASF spec mandates 0 for this
331  avio_wl16(pb, 0); // name length 0, no name given
332 
333  for (unsigned i = 0; i < s->nb_chapters; i++) {
334  AVChapter *c = s->chapters[i];
335  AVDictionaryEntry *t = av_dict_get(c->metadata, "title", NULL, 0);
336  int64_t pres_time = av_rescale_q(c->start, c->time_base, scale);
337  uint64_t offset;
338  int32_t send_time = get_send_time(asf, pres_time, &offset);
339  int len = 0;
340  uint8_t *buf;
341  if (t) {
342  avio_put_str16le(dyn_buf, t->value);
343  len = avio_get_dyn_buf(dyn_buf, &buf);
344  }
345  avio_wl64(pb, offset); // offset of the packet with send_time
346  avio_wl64(pb, pres_time + PREROLL_TIME * 10000); // presentation time
347  avio_wl16(pb, 12 + len); // entry length
348  avio_wl32(pb, send_time); // send time
349  avio_wl32(pb, 0); // flags, should be 0
350  avio_wl32(pb, len / 2); // marker desc length in WCHARS!
351  if (t) {
352  avio_write(pb, buf, len); // marker desc
353  ffio_reset_dyn_buf(dyn_buf);
354  }
355  }
356  end_header(pb, hpos);
357 }
358 
359 /* write the header (used two times if non streamed) */
360 static int asf_write_header1(AVFormatContext *s, int64_t file_size,
361  int64_t data_chunk_size)
362 {
363  ASFContext *asf = s->priv_data;
364  AVIOContext *pb = s->pb, *dyn_buf;
365  AVDictionaryEntry *tags[5];
366  int header_size, extra_size, extra_size2, wav_extra_size;
367  int has_title, has_aspect_ratio = 0;
368  int metadata_count;
369  int64_t header_offset, cur_pos, hpos;
370  int bit_rate, ret;
371  int64_t duration;
372  int audio_language_counts[128] = { 0 };
373 
374  ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
375 
376  tags[0] = av_dict_get(s->metadata, "title", NULL, 0);
377  tags[1] = av_dict_get(s->metadata, "author", NULL, 0);
378  tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0);
379  tags[3] = av_dict_get(s->metadata, "comment", NULL, 0);
380  tags[4] = av_dict_get(s->metadata, "rating", NULL, 0);
381 
382  duration = asf->duration + PREROLL_TIME * 10000;
383  has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
384 
385  if (!file_size) {
386  if (ff_parse_creation_time_metadata(s, &asf->creation_time, 0) != 0)
387  av_dict_set(&s->metadata, "creation_time", NULL, 0);
388  }
389 
390  metadata_count = av_dict_count(s->metadata);
391 
392  bit_rate = 0;
393  for (unsigned n = 0; n < s->nb_streams; n++) {
394  AVStream *const st = s->streams[n];
395  AVCodecParameters *const par = st->codecpar;
396  AVDictionaryEntry *entry;
397 
398  avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
399 
400  bit_rate += par->bit_rate;
401  if ( par->codec_type == AVMEDIA_TYPE_VIDEO
402  && par->sample_aspect_ratio.num > 0
403  && par->sample_aspect_ratio.den > 0)
404  has_aspect_ratio++;
405 
406  entry = av_dict_get(s->streams[n]->metadata, "language", NULL, 0);
407  if (entry) {
408  const char *iso6391lang = ff_convert_lang_to(entry->value, AV_LANG_ISO639_1);
409  if (iso6391lang) {
410  int i;
411  for (i = 0; i < asf->nb_languages; i++) {
412  if (!strcmp(asf->languages[i], iso6391lang)) {
413  asf->streams[n].stream_language_index = i;
414  break;
415  }
416  }
417  if (i >= asf->nb_languages) {
418  asf->languages[asf->nb_languages] = iso6391lang;
419  asf->streams[n].stream_language_index = asf->nb_languages;
420  asf->nb_languages++;
421  }
422  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
423  audio_language_counts[asf->streams[n].stream_language_index]++;
424  }
425  } else {
426  asf->streams[n].stream_language_index = 128;
427  }
428  }
429 
430  if (asf->is_streamed) {
431  put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */
432  }
433 
434  ff_put_guid(pb, &ff_asf_header);
435  avio_wl64(pb, -1); /* header length, will be patched after */
436  avio_wl32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
437  avio_w8(pb, 1); /* ??? */
438  avio_w8(pb, 2); /* ??? */
439 
440  /* file header */
441  header_offset = avio_tell(pb);
442  hpos = put_header(pb, &ff_asf_file_header);
443  ff_put_guid(pb, &ff_asf_my_guid);
444  avio_wl64(pb, file_size);
445  avio_wl64(pb, unix_to_file_time(asf->creation_time));
446  avio_wl64(pb, asf->nb_packets); /* number of packets */
447  avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
448  avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
449  avio_wl64(pb, PREROLL_TIME); /* start time stamp */
450  avio_wl32(pb, (asf->is_streamed || !(pb->seekable & AVIO_SEEKABLE_NORMAL)) ? 3 : 2); /* ??? */
451  avio_wl32(pb, s->packet_size); /* packet size */
452  avio_wl32(pb, s->packet_size); /* packet size */
453  avio_wl32(pb, bit_rate ? bit_rate : -1); /* Maximum data rate in bps */
454  end_header(pb, hpos);
455 
456  /* header_extension */
457  hpos = put_header(pb, &ff_asf_head1_guid);
458  ff_put_guid(pb, &ff_asf_head2_guid);
459  avio_wl16(pb, 6);
460  avio_wl32(pb, 0); /* length, to be filled later */
461  if (asf->nb_languages) {
462  int64_t hpos2;
463  int nb_audio_languages = 0;
464 
465  hpos2 = put_header(pb, &ff_asf_language_guid);
466  avio_wl16(pb, asf->nb_languages);
467  for (int i = 0; i < asf->nb_languages; i++) {
468  avio_w8(pb, 6);
469  avio_put_str16le(pb, asf->languages[i]);
470  }
471  end_header(pb, hpos2);
472 
473  for (int i = 0; i < asf->nb_languages; i++)
474  if (audio_language_counts[i])
475  nb_audio_languages++;
476 
477  if (nb_audio_languages > 1) {
478  hpos2 = put_header(pb, &ff_asf_group_mutual_exclusion_object);
479  ff_put_guid(pb, &ff_asf_mutex_language);
480  avio_wl16(pb, nb_audio_languages);
481  for (int i = 0; i < asf->nb_languages; i++) {
482  if (audio_language_counts[i]) {
483  avio_wl16(pb, audio_language_counts[i]);
484  for (unsigned n = 0; n < s->nb_streams; n++)
485  if (asf->streams[n].stream_language_index == i && s->streams[n]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
486  avio_wl16(pb, n + 1);
487  }
488  }
489  end_header(pb, hpos2);
490  }
491 
492  for (unsigned n = 0; n < s->nb_streams; n++) {
493  int64_t es_pos;
494  if (asf->streams[n].stream_language_index > 127)
495  continue;
496  es_pos = put_header(pb, &ff_asf_extended_stream_properties_object);
497  avio_wl64(pb, 0); /* start time */
498  avio_wl64(pb, 0); /* end time */
499  avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* data bitrate bps */
500  avio_wl32(pb, 5000); /* buffer size ms */
501  avio_wl32(pb, 0); /* initial buffer fullness */
502  avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* peak data bitrate */
503  avio_wl32(pb, 5000); /* maximum buffer size ms */
504  avio_wl32(pb, 0); /* max initial buffer fullness */
505  avio_wl32(pb, 0); /* max object size */
506  avio_wl32(pb, (!asf->is_streamed && (pb->seekable & AVIO_SEEKABLE_NORMAL)) << 1); /* flags - seekable */
507  avio_wl16(pb, n + 1); /* stream number */
508  avio_wl16(pb, asf->streams[n].stream_language_index); /* language id index */
509  avio_wl64(pb, 0); /* avg time per frame */
510  avio_wl16(pb, 0); /* stream name count */
511  avio_wl16(pb, 0); /* payload extension system count */
512  end_header(pb, es_pos);
513  }
514  }
515  if (has_aspect_ratio) {
516  int64_t hpos2;
517  hpos2 = put_header(pb, &ff_asf_metadata_header);
518  avio_wl16(pb, 2 * has_aspect_ratio);
519  for (unsigned n = 0; n < s->nb_streams; n++) {
520  AVCodecParameters *const par = s->streams[n]->codecpar;
521  if ( par->codec_type == AVMEDIA_TYPE_VIDEO
522  && par->sample_aspect_ratio.num > 0
523  && par->sample_aspect_ratio.den > 0) {
524  AVRational sar = par->sample_aspect_ratio;
525  avio_wl16(pb, 0);
526  // the stream number is set like this below
527  avio_wl16(pb, n + 1);
528  avio_wl16(pb, 26); // name_len
529  avio_wl16(pb, 3); // value_type
530  avio_wl32(pb, 4); // value_len
531  avio_put_str16le(pb, "AspectRatioX");
532  avio_wl32(pb, sar.num);
533  avio_wl16(pb, 0);
534  // the stream number is set like this below
535  avio_wl16(pb, n + 1);
536  avio_wl16(pb, 26); // name_len
537  avio_wl16(pb, 3); // value_type
538  avio_wl32(pb, 4); // value_len
539  avio_put_str16le(pb, "AspectRatioY");
540  avio_wl32(pb, sar.den);
541  }
542  }
543  end_header(pb, hpos2);
544  }
545  {
546  int64_t pos1;
547  pos1 = avio_tell(pb);
548  avio_seek(pb, hpos + 42, SEEK_SET);
549  avio_wl32(pb, pos1 - hpos - 46);
550  avio_seek(pb, pos1, SEEK_SET);
551  }
552  end_header(pb, hpos);
553 
554  if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
555  return ret;
556 
557  /* title and other info */
558  if (has_title) {
559  uint8_t *buf;
560  int len;
561 
562  hpos = put_header(pb, &ff_asf_comment_header);
563 
564  for (size_t n = 0; n < FF_ARRAY_ELEMS(tags); n++) {
565  len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
566  avio_wl16(pb, len);
567  }
568  len = avio_get_dyn_buf(dyn_buf, &buf);
569  avio_write(pb, buf, len);
570  ffio_reset_dyn_buf(dyn_buf);
571  end_header(pb, hpos);
572  }
573  if (metadata_count) {
574  const AVDictionaryEntry *tag = NULL;
575  hpos = put_header(pb, &ff_asf_extended_content_header);
576  avio_wl16(pb, metadata_count);
577  while ((tag = av_dict_iterate(s->metadata, tag))) {
578  put_str16(pb, dyn_buf, tag->key);
579  avio_wl16(pb, 0);
580  put_str16(pb, dyn_buf, tag->value);
581  }
582  end_header(pb, hpos);
583  }
584  /* chapters using ASF markers */
585  if (!asf->is_streamed && s->nb_chapters) {
586  asf_write_markers(s, dyn_buf);
587  }
588  /* stream headers */
589  for (unsigned n = 0; n < s->nb_streams; n++) {
590  AVCodecParameters *const par = s->streams[n]->codecpar;
591  int64_t es_pos;
592  // ASFStream *stream = &asf->streams[n];
593 
594  asf->streams[n].num = n + 1;
595  asf->streams[n].seq = 1;
596 
597  switch (par->codec_type) {
598  case AVMEDIA_TYPE_AUDIO:
599  wav_extra_size = 0;
600  extra_size = 18 + wav_extra_size;
601  extra_size2 = 8;
602  break;
603  default:
604  case AVMEDIA_TYPE_VIDEO:
605  wav_extra_size = par->extradata_size;
606  extra_size = 0x33 + wav_extra_size;
607  extra_size2 = 0;
608  break;
609  }
610 
611  hpos = put_header(pb, &ff_asf_stream_header);
612  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
613  ff_put_guid(pb, &ff_asf_audio_stream);
614  ff_put_guid(pb, &ff_asf_audio_conceal_spread);
615  } else {
616  ff_put_guid(pb, &ff_asf_video_stream);
617  ff_put_guid(pb, &ff_asf_video_conceal_none);
618  }
619  avio_wl64(pb, 0); /* ??? */
620  es_pos = avio_tell(pb);
621  avio_wl32(pb, extra_size); /* wav header len */
622  avio_wl32(pb, extra_size2); /* additional data len */
623  avio_wl16(pb, n + 1); /* stream number */
624  avio_wl32(pb, 0); /* ??? */
625 
626  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
627  /* WAVEFORMATEX header */
628  int wavsize = ff_put_wav_header(s, pb, par, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX);
629 
630  if (wavsize < 0) {
631  ret = wavsize;
632  goto fail;
633  }
634  if (wavsize != extra_size) {
635  cur_pos = avio_tell(pb);
636  avio_seek(pb, es_pos, SEEK_SET);
637  avio_wl32(pb, wavsize); /* wav header len */
638  avio_seek(pb, cur_pos, SEEK_SET);
639  }
640  /* ERROR Correction */
641  avio_w8(pb, 0x01);
642  if (par->codec_id == AV_CODEC_ID_ADPCM_G726 || !par->block_align) {
643  avio_wl16(pb, 0x0190);
644  avio_wl16(pb, 0x0190);
645  } else {
646  avio_wl16(pb, par->block_align);
647  avio_wl16(pb, par->block_align);
648  }
649  avio_wl16(pb, 0x01);
650  avio_w8(pb, 0x00);
651  } else {
652  avio_wl32(pb, par->width);
653  avio_wl32(pb, par->height);
654  avio_w8(pb, 2); /* ??? */
655  avio_wl16(pb, 40 + par->extradata_size); /* size */
656 
657  /* BITMAPINFOHEADER header */
658  ff_put_bmp_header(pb, par, 1, 0, 0);
659  }
660  end_header(pb, hpos);
661  }
662 
663  /* media comments */
664 
665  hpos = put_header(pb, &ff_asf_codec_comment_header);
666  ff_put_guid(pb, &ff_asf_codec_comment1_header);
667  avio_wl32(pb, s->nb_streams);
668  for (unsigned n = 0; n < s->nb_streams; n++) {
669  AVCodecParameters *const par = s->streams[n]->codecpar;
670  const AVCodecDescriptor *const codec_desc = avcodec_descriptor_get(par->codec_id);
671  const char *desc;
672 
673  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
674  avio_wl16(pb, 2);
675  else if (par->codec_type == AVMEDIA_TYPE_VIDEO)
676  avio_wl16(pb, 1);
677  else
678  avio_wl16(pb, -1);
679 
680  if (par->codec_id == AV_CODEC_ID_WMAV2)
681  desc = "Windows Media Audio V8";
682  else
683  desc = codec_desc ? codec_desc->name : NULL;
684 
685  if (desc) {
686  uint8_t *buf;
687  int len;
688 
689  avio_put_str16le(dyn_buf, desc);
690  len = avio_get_dyn_buf(dyn_buf, &buf);
691  avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2
692 
693  avio_write(pb, buf, len);
694  ffio_reset_dyn_buf(dyn_buf);
695  } else
696  avio_wl16(pb, 0);
697 
698  avio_wl16(pb, 0); /* no parameters */
699 
700  /* id */
701  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
702  avio_wl16(pb, 2);
703  avio_wl16(pb, par->codec_tag);
704  } else {
705  avio_wl16(pb, 4);
706  avio_wl32(pb, par->codec_tag);
707  }
708  if (!par->codec_tag) {
709  ret = AVERROR(EINVAL);
710  goto fail;
711  }
712  }
713  end_header(pb, hpos);
714 
715  /* patch the header size fields */
716 
717  cur_pos = avio_tell(pb);
718  header_size = cur_pos - header_offset;
719  if (asf->is_streamed) {
720  header_size += 8 + 30 + DATA_HEADER_SIZE;
721 
722  avio_seek(pb, header_offset - 10 - 30, SEEK_SET);
723  avio_wl16(pb, header_size);
724  avio_seek(pb, header_offset - 2 - 30, SEEK_SET);
725  avio_wl16(pb, header_size);
726 
727  header_size -= 8 + 30 + DATA_HEADER_SIZE;
728  }
729  header_size += 24 + 6;
730  avio_seek(pb, header_offset - 14, SEEK_SET);
731  avio_wl64(pb, header_size);
732  avio_seek(pb, cur_pos, SEEK_SET);
733 
734  /* movie chunk, followed by packets of packet_size */
735  asf->data_offset = cur_pos;
736  ff_put_guid(pb, &ff_asf_data_header);
737  avio_wl64(pb, data_chunk_size);
738  ff_put_guid(pb, &ff_asf_my_guid);
739  avio_wl64(pb, asf->nb_packets); /* nb packets */
740  avio_w8(pb, 1); /* ??? */
741  avio_w8(pb, 1); /* ??? */
742  ret = 0;
743 fail:
744  ffio_free_dyn_buf(&dyn_buf);
745  return ret;
746 }
747 
748 static int asf_write_header(AVFormatContext *s)
749 {
750  ASFContext *asf = s->priv_data;
751  int ret;
752 
753  s->packet_size = asf->packet_size;
754  s->max_interleave_delta = 0;
755  asf->nb_packets = 0;
756 
757  if (s->nb_streams > 127) {
758  av_log(s, AV_LOG_ERROR, "ASF can only handle 127 streams\n");
759  return AVERROR(EINVAL);
760  }
761 
762  asf->index_ptr = av_malloc(sizeof(ASFIndex) * ASF_INDEX_BLOCK);
763  if (!asf->index_ptr)
764  return AVERROR(ENOMEM);
765  asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
766  asf->maximum_packet = 0;
767 
768  /* the data-chunk-size has to be 50 (DATA_HEADER_SIZE), which is
769  * data_size - asf->data_offset at the moment this function is done.
770  * It is needed to use asf as a streamable format. */
771  if ((ret = asf_write_header1(s, 0, DATA_HEADER_SIZE)) < 0)
772  return ret;
773 
774  asf->packet_nb_payloads = 0;
775  asf->packet_timestamp_start = -1;
776  asf->packet_timestamp_end = -1;
777  ffio_init_write_context(&asf->pb, asf->packet_buf, s->packet_size);
778 
779  if (s->avoid_negative_ts < 0)
780  s->avoid_negative_ts = 1;
781 
782  return 0;
783 }
784 
785 static int asf_write_stream_header(AVFormatContext *s)
786 {
787  ASFContext *asf = s->priv_data;
788 
789  asf->is_streamed = 1;
790 
791  return asf_write_header(s);
792 }
793 
794 static int put_payload_parsing_info(AVFormatContext *s,
795  unsigned sendtime, unsigned duration,
796  int nb_payloads, int padsize)
797 {
798  ASFContext *asf = s->priv_data;
799  AVIOContext *pb = s->pb;
800  int ppi_size;
801  int64_t start = avio_tell(pb);
802 
803  int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;
804 
805  padsize -= PACKET_HEADER_MIN_SIZE;
806  if (asf->multi_payloads_present)
807  padsize--;
808  av_assert0(padsize >= 0);
809 
810  avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
811  ffio_fill(pb, 0x0, ASF_PACKET_ERROR_CORRECTION_DATA_SIZE);
812 
813  if (asf->multi_payloads_present)
814  iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT;
815 
816  if (padsize > 0) {
817  if (padsize < 256)
818  iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE;
819  else
820  iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;
821  }
822  avio_w8(pb, iLengthTypeFlags);
823 
824  avio_w8(pb, ASF_PPI_PROPERTY_FLAGS);
825 
826  if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)
827  avio_wl16(pb, padsize - 2);
828  if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)
829  avio_w8(pb, padsize - 1);
830 
831  avio_wl32(pb, sendtime);
832  avio_wl16(pb, duration);
833  if (asf->multi_payloads_present)
834  avio_w8(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
835 
836  ppi_size = avio_tell(pb) - start;
837 
838  return ppi_size;
839 }
840 
841 static void flush_packet(AVFormatContext *s)
842 {
843  ASFContext *asf = s->priv_data;
844  int packet_hdr_size, packet_filled_size;
845 
846  av_assert0(asf->packet_timestamp_end >= asf->packet_timestamp_start);
847 
848  if (asf->is_streamed)
849  put_chunk(s, 0x4424, s->packet_size, 0);
850 
851  packet_hdr_size = put_payload_parsing_info(s,
852  asf->packet_timestamp_start,
853  asf->packet_timestamp_end - asf->packet_timestamp_start,
854  asf->packet_nb_payloads,
855  asf->packet_size_left);
856 
857  packet_filled_size = asf->packet_size - asf->packet_size_left;
858  av_assert0(packet_hdr_size <= asf->packet_size_left);
859  memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);
860 
861  avio_write(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
862 
863  avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
864 
865  asf->nb_packets++;
866  asf->packet_nb_payloads = 0;
867  asf->packet_timestamp_start = -1;
868  asf->packet_timestamp_end = -1;
869  ffio_init_write_context(&asf->pb, asf->packet_buf, s->packet_size);
870 }
871 
872 static void put_payload_header(AVFormatContext *s, ASFStream *stream,
873  int64_t presentation_time, int m_obj_size,
874  int m_obj_offset, int payload_len, int flags)
875 {
876  ASFContext *asf = s->priv_data;
877  AVIOContext *const pb = &asf->pb.pub;
878  int val;
879 
880  val = stream->num;
881  if (flags & AV_PKT_FLAG_KEY)
882  val |= ASF_PL_FLAG_KEY_FRAME;
883  avio_w8(pb, val);
884 
885  avio_w8(pb, stream->seq); // Media object number
886  avio_wl32(pb, m_obj_offset); // Offset Into Media Object
887 
888  // Replicated Data shall be at least 8 bytes long.
889  // The first 4 bytes of data shall contain the
890  // Size of the Media Object that the payload belongs to.
891  // The next 4 bytes of data shall contain the
892  // Presentation Time for the media object that the payload belongs to.
893  avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
894 
895  avio_wl32(pb, m_obj_size); // Replicated Data - Media Object Size
896  avio_wl32(pb, (uint32_t) presentation_time); // Replicated Data - Presentation Time
897 
898  if (asf->multi_payloads_present) {
899  avio_wl16(pb, payload_len); // payload length
900  }
901 }
902 
903 static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
904  int64_t timestamp, const uint8_t *buf,
905  int m_obj_size, int flags)
906 {
907  ASFContext *asf = s->priv_data;
908  int m_obj_offset, payload_len, frag_len1;
909 
910  m_obj_offset = 0;
911  while (m_obj_offset < m_obj_size) {
912  payload_len = m_obj_size - m_obj_offset;
913  if (asf->packet_timestamp_start == -1) {
914  const int multi_payload_constant = (asf->packet_size - MULTI_PAYLOAD_HEADERS);
915  asf->multi_payloads_present = (payload_len < multi_payload_constant);
916 
917  asf->packet_size_left = asf->packet_size;
918  if (asf->multi_payloads_present) {
919  frag_len1 = multi_payload_constant - 1;
920  } else {
921  frag_len1 = asf->packet_size - SINGLE_PAYLOAD_HEADERS;
922  }
923  asf->packet_timestamp_start = timestamp;
924  } else {
925  // multi payloads
926  frag_len1 = asf->packet_size_left -
927  PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS -
928  PACKET_HEADER_MIN_SIZE - 1;
929 
930  if (frag_len1 < payload_len &&
931  avst->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
932  flush_packet(s);
933  continue;
934  }
935  if (asf->packet_timestamp_start > INT64_MAX - UINT16_MAX ||
936  timestamp > asf->packet_timestamp_start + UINT16_MAX) {
937  flush_packet(s);
938  continue;
939  }
940  }
941  if (frag_len1 > 0) {
942  if (payload_len > frag_len1)
943  payload_len = frag_len1;
944  else if (payload_len == (frag_len1 - 1))
945  payload_len = frag_len1 - 2; // additional byte need to put padding length
946 
947  put_payload_header(s, stream, timestamp + PREROLL_TIME,
948  m_obj_size, m_obj_offset, payload_len, flags);
949  avio_write(&asf->pb.pub, buf, payload_len);
950 
951  if (asf->multi_payloads_present)
952  asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);
953  else
954  asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD);
955  asf->packet_timestamp_end = timestamp;
956 
957  asf->packet_nb_payloads++;
958  } else {
959  payload_len = 0;
960  }
961  m_obj_offset += payload_len;
962  buf += payload_len;
963 
964  if (!asf->multi_payloads_present)
965  flush_packet(s);
966  else if (asf->packet_size_left <= (PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS + PACKET_HEADER_MIN_SIZE + 1))
967  flush_packet(s);
968  else if (asf->packet_nb_payloads == ASF_PAYLOADS_PER_PACKET)
969  flush_packet(s);
970  }
971  stream->seq++;
972 }
973 
974 static int update_index(AVFormatContext *s, int start_sec,
975  uint32_t packet_number, uint16_t packet_count,
976  uint64_t packet_offset)
977 {
978  ASFContext *asf = s->priv_data;
979 
980  if (start_sec > asf->next_start_sec) {
981  if (!asf->next_start_sec) {
982  asf->next_packet_number = packet_number;
983  asf->next_packet_count = packet_count;
984  asf->next_packet_offset = packet_offset;
985  }
986 
987  if (start_sec > asf->nb_index_memory_alloc) {
988  int err;
989  asf->nb_index_memory_alloc = (start_sec + ASF_INDEX_BLOCK) & ~(ASF_INDEX_BLOCK - 1);
990  if ((err = av_reallocp_array(&asf->index_ptr,
991  asf->nb_index_memory_alloc,
992  sizeof(*asf->index_ptr))) < 0) {
993  asf->nb_index_memory_alloc = 0;
994  return err;
995  }
996  }
997  for (int i = asf->next_start_sec; i < start_sec; i++) {
998  asf->index_ptr[i].packet_number = asf->next_packet_number;
999  asf->index_ptr[i].packet_count = asf->next_packet_count;
1000  asf->index_ptr[i].send_time = asf->next_start_sec * INT64_C(10000000);
1001  asf->index_ptr[i].offset = asf->next_packet_offset;
1002 
1003  }
1004  }
1005  asf->maximum_packet = FFMAX(asf->maximum_packet, packet_count);
1006  asf->next_packet_number = packet_number;
1007  asf->next_packet_count = packet_count;
1008  asf->next_packet_offset = packet_offset;
1009  asf->next_start_sec = start_sec;
1010 
1011  return 0;
1012 }
1013 
1014 static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
1015 {
1016  ASFContext *asf = s->priv_data;
1017  AVIOContext *pb = s->pb;
1018  ASFStream *stream;
1019  AVCodecParameters *par;
1020  uint32_t packet_number;
1021  int64_t pts;
1022  int start_sec;
1023  int flags = pkt->flags;
1024  int ret;
1025  uint64_t offset = avio_tell(pb);
1026 
1027  par = s->streams[pkt->stream_index]->codecpar;
1028  stream = &asf->streams[pkt->stream_index];
1029 
1030  if (par->codec_type == AVMEDIA_TYPE_AUDIO)
1031  flags &= ~AV_PKT_FLAG_KEY;
1032 
1033  pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
1034  av_assert0(pts != AV_NOPTS_VALUE);
1035  if ( pts < - PREROLL_TIME
1036  || pts > (INT_MAX-3)/10000LL * ASF_INDEXED_INTERVAL - PREROLL_TIME) {
1037  av_log(s, AV_LOG_ERROR, "input pts %"PRId64" is invalid\n", pts);
1038  return AVERROR(EINVAL);
1039  }
1040  pts *= 10000;
1041  asf->duration = FFMAX(asf->duration, pts + pkt->duration * 10000);
1042 
1043  packet_number = asf->nb_packets;
1044  put_frame(s, stream, s->streams[pkt->stream_index],
1045  pkt->dts, pkt->data, pkt->size, flags);
1046 
1047  start_sec = (int)((PREROLL_TIME * 10000 + pts + ASF_INDEXED_INTERVAL - 1)
1048  / ASF_INDEXED_INTERVAL);
1049 
1050  /* check index */
1051  if ((!asf->is_streamed) && (flags & AV_PKT_FLAG_KEY)) {
1052  uint16_t packet_count = asf->nb_packets - packet_number;
1053  ret = update_index(s, start_sec, packet_number, packet_count, offset);
1054  if (ret < 0)
1055  return ret;
1056  }
1057  asf->end_sec = start_sec;
1058 
1059  return 0;
1060 }
1061 
1062 static int asf_write_index(AVFormatContext *s, const ASFIndex *index,
1063  uint16_t max, uint32_t count)
1064 {
1065  AVIOContext *pb = s->pb;
1066 
1067  ff_put_guid(pb, &ff_asf_simple_index_header);
1068  avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2) * count);
1069  ff_put_guid(pb, &ff_asf_my_guid);
1070  avio_wl64(pb, ASF_INDEXED_INTERVAL);
1071  avio_wl32(pb, max);
1072  avio_wl32(pb, count);
1073  for (uint32_t i = 0; i < count; i++) {
1074  avio_wl32(pb, index[i].packet_number);
1075  avio_wl16(pb, index[i].packet_count);
1076  }
1077 
1078  return 0;
1079 }
1080 
1081 static int asf_write_trailer(AVFormatContext *s)
1082 {
1083  ASFContext *asf = s->priv_data;
1084  int64_t file_size, data_size;
1085  int ret;
1086 
1087  /* flush the current packet */
1088  if (asf->pb.pub.buf_ptr > asf->pb.pub.buffer)
1089  flush_packet(s);
1090 
1091  /* write index */
1092  data_size = avio_tell(s->pb);
1093  if (!asf->is_streamed && asf->next_start_sec) {
1094  if ((ret = update_index(s, asf->end_sec + 1, 0, 0, 0)) < 0)
1095  return ret;
1096  asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->next_start_sec);
1097  }
1098 
1099  if (asf->is_streamed || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1100  put_chunk(s, 0x4524, 0, 0); /* end of stream */
1101  } else {
1102  /* rewrite an updated header */
1103  file_size = avio_tell(s->pb);
1104  avio_seek(s->pb, 0, SEEK_SET);
1105  asf_write_header1(s, file_size, data_size - asf->data_offset);
1106  }
1107 
1108  return 0;
1109 }
1110 
1111 static void asf_deinit(AVFormatContext *s)
1112 {
1113  ASFContext *const asf = s->priv_data;
1114 
1115  av_freep(&asf->index_ptr);
1116 }
1117 
1118 static const AVOption asf_options[] = {
1119  { "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 },
1120  { NULL },
1121 };
1122 
1123 static const AVClass asf_muxer_class = {
1124  .class_name = "ASF (stream) muxer",
1125  .item_name = av_default_item_name,
1126  .option = asf_options,
1127  .version = LIBAVUTIL_VERSION_INT,
1128 };
1129 
1130 #if CONFIG_ASF_MUXER
1131 const FFOutputFormat ff_asf_muxer = {
1132  .p.name = "asf",
1133  .p.long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1134  .p.mime_type = "video/x-ms-asf",
1135  .p.extensions = "asf,wmv,wma",
1136  .p.audio_codec = AV_CODEC_ID_WMAV2,
1137  .p.video_codec = AV_CODEC_ID_MSMPEG4V3,
1138  .p.flags = AVFMT_GLOBALHEADER,
1139  .p.codec_tag = asf_codec_tags,
1140  .p.priv_class = &asf_muxer_class,
1141  .priv_data_size = sizeof(ASFContext),
1142  .write_header = asf_write_header,
1143  .write_packet = asf_write_packet,
1144  .write_trailer = asf_write_trailer,
1145  .deinit = asf_deinit,
1146 };
1147 #endif /* CONFIG_ASF_MUXER */
1148 
1149 #if CONFIG_ASF_STREAM_MUXER
1150 const FFOutputFormat ff_asf_stream_muxer = {
1151  .p.name = "asf_stream",
1152  .p.long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1153  .p.mime_type = "video/x-ms-asf",
1154  .p.extensions = "asf,wmv,wma",
1155  .priv_data_size = sizeof(ASFContext),
1156  .p.audio_codec = AV_CODEC_ID_WMAV2,
1157  .p.video_codec = AV_CODEC_ID_MSMPEG4V3,
1158  .write_header = asf_write_stream_header,
1159  .write_packet = asf_write_packet,
1160  .write_trailer = asf_write_trailer,
1161  .p.flags = AVFMT_GLOBALHEADER,
1162  .p.codec_tag = asf_codec_tags,
1163  .p.priv_class = &asf_muxer_class,
1164  .deinit = asf_deinit,
1165 };
1166 #endif /* CONFIG_ASF_STREAM_MUXER */
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:510
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
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:1123
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
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:39
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:215
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
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:64
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:50
AVPacket::data
uint8_t * data
Definition: packet.h:524
AVOption
AVOption.
Definition: opt.h:346
asf_deinit
static void asf_deinit(AVFormatContext *s)
Definition: asfenc.c:1111
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:138
avio_wl64
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:425
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:518
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:448
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
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:1374
FFIOContext
Definition: avio_internal.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
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
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:437
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:461
asf_write_packet
static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: asfenc.c:1014
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:853
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
fail
#define fail()
Definition: checkasm.h:179
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:1214
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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:644
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
pkt
AVPacket * pkt
Definition: movenc.c:60
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:215
AVCodecTag
Definition: internal.h:42
duration
int64_t duration
Definition: movenc.c:65
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:1362
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:62
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:378
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
Video only.
Definition: codec_par.h:144
g
const char * g
Definition: vf_curves.c:128
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
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:148
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:748
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:1255
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:766
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: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:237
put_payload_parsing_info
static int put_payload_parsing_info(AVFormatContext *s, unsigned sendtime, unsigned duration, int nb_payloads, int padsize)
Definition: asfenc.c:794
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:143
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
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:99
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:187
ASFContext::packet_size_left
int packet_size_left
Definition: asfdec_f.c:84
ff_asf_extended_stream_properties_object
const ff_asf_guid ff_asf_extended_stream_properties_object
Definition: asf_tags.c:140
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:269
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:872
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
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:1396
AVPacket::size
int size
Definition: packet.h:525
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:94
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
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:100
ASF_INDEX_BLOCK
#define ASF_INDEX_BLOCK
Definition: asfenc.c:39
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:204
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
asf_write_header1
static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size)
Definition: asfenc.c:360
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:357
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:530
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:176
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:478
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
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
Definition: codec_par.h:135
ASFContext::creation_time
int64_t creation_time
Definition: asfenc.c:208
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
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
unix_to_file_time
static int64_t unix_to_file_time(int64_t ti)
Definition: asfenc.c:298
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:209
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:1787
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1435
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
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_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:1118
asf.h
get_send_time
static int32_t get_send_time(ASFContext *asf, int64_t pres_time, uint64_t *offset)
Definition: asfenc.c:307
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:1081
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:136
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:841
ff_put_guid
void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
Definition: riffenc.c:358
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
Definition: opt.h:235
asf_write_markers
static void asf_write_markers(AVFormatContext *s, AVIOContext *dyn_buf)
Definition: asfenc.c:321
end_header
static void end_header(AVIOContext *pb, int64_t pos)
Definition: asfenc.c:270
ASFContext::duration
int duration
Definition: asfdec_o.c:102
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:974
AVPacket::stream_index
int stream_index
Definition: packet.h:526
SINGLE_PAYLOAD_HEADERS
#define SINGLE_PAYLOAD_HEADERS
Definition: asfenc.c:180
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:144
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:903
AVDictionaryEntry
Definition: dict.h:89
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:88
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
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_MSMPEG4V3
@ AV_CODEC_ID_MSMPEG4V3
Definition: codec_id.h:68
asf_write_stream_header
static int asf_write_stream_header(AVFormatContext *s)
Definition: asfenc.c:785
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:3734
AVDictionaryEntry::value
char * value
Definition: dict.h:91
ff_asf_header
const ff_asf_guid ff_asf_header
Definition: asf_tags.c:23
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:345
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:144
AVIOContext::buf_ptr
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:227
codec_desc.h
int
int
Definition: ffmpeg_filter.c:424
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:44
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:1062
Generated on Tue Apr 16 2024 19:22:25 for FFmpeg by   doxygen 1.8.17