2004-03-05 21:34:30 +00:00
|
|
|
/*
|
2008-09-24 12:03:25 +00:00
|
|
|
* ASF muxer
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2000, 2001 Fabrice Bellard
|
2004-03-05 21:34:30 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2004-03-05 21:34:30 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2004-03-05 21:34:30 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2004-03-05 21:34:30 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2004-03-05 21:34:30 +00:00
|
|
|
*/
|
2013-02-05 23:44:00 +00:00
|
|
|
|
2013-04-07 01:46:50 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2013-02-05 23:44:00 +00:00
|
|
|
#include "libavutil/dict.h"
|
2013-09-19 15:50:38 +00:00
|
|
|
#include "libavutil/mathematics.h"
|
2016-02-04 00:30:31 +00:00
|
|
|
#include "libavutil/opt.h"
|
2004-03-05 21:34:30 +00:00
|
|
|
#include "avformat.h"
|
2016-02-03 02:42:50 +00:00
|
|
|
#include "avlanguage.h"
|
2013-02-05 23:44:00 +00:00
|
|
|
#include "avio_internal.h"
|
2011-11-29 18:28:15 +00:00
|
|
|
#include "internal.h"
|
2006-07-12 00:09:34 +00:00
|
|
|
#include "riff.h"
|
2004-03-05 21:34:30 +00:00
|
|
|
#include "asf.h"
|
|
|
|
|
2005-12-22 01:10:11 +00:00
|
|
|
#define ASF_INDEXED_INTERVAL 10000000
|
2012-04-04 05:48:27 +00:00
|
|
|
#define ASF_INDEX_BLOCK (1<<9)
|
2014-05-12 22:54:55 +00:00
|
|
|
#define ASF_PAYLOADS_PER_PACKET 63
|
2005-03-23 13:30:27 +00:00
|
|
|
|
2004-03-05 22:10:50 +00:00
|
|
|
#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
|
2013-02-05 23:44:00 +00:00
|
|
|
#define ASF_PACKET_ERROR_CORRECTION_FLAGS \
|
|
|
|
(ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \
|
|
|
|
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE)
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
#if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0)
|
|
|
|
# define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1
|
|
|
|
#else
|
|
|
|
# define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
#define ASF_PPI_PROPERTY_FLAGS \
|
|
|
|
(ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \
|
|
|
|
ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \
|
|
|
|
ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \
|
|
|
|
ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE)
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
#define ASF_PPI_LENGTH_TYPE_FLAGS 0
|
|
|
|
|
|
|
|
#define ASF_PAYLOAD_FLAGS ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD
|
|
|
|
|
|
|
|
#if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_SEQUENCE_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_SEQUENCE_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_SEQUENCE_FIELD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PPI_SEQUENCE_FIELD_SIZE
|
|
|
|
# define ASF_PPI_SEQUENCE_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PPI_PACKET_LENGTH_FIELD_SIZE
|
|
|
|
# define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PPI_PADDING_LENGTH_FIELD_SIZE
|
|
|
|
# define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE
|
|
|
|
# define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#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))
|
|
|
|
# define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#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))
|
|
|
|
# define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#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))
|
|
|
|
# define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE
|
|
|
|
# define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE
|
|
|
|
# define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_BYTE == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_LENGTH_FIELD_SIZE 1
|
|
|
|
#endif
|
|
|
|
#if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))
|
|
|
|
# define ASF_PAYLOAD_LENGTH_FIELD_SIZE 2
|
|
|
|
#endif
|
|
|
|
#ifndef ASF_PAYLOAD_LENGTH_FIELD_SIZE
|
|
|
|
# define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
#define PACKET_HEADER_MIN_SIZE \
|
|
|
|
(ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \
|
|
|
|
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \
|
|
|
|
1 + /* Length Type Flags */ \
|
|
|
|
1 + /* Property Flags */ \
|
|
|
|
ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \
|
|
|
|
ASF_PPI_SEQUENCE_FIELD_SIZE + \
|
|
|
|
ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \
|
|
|
|
4 + /* Send Time Field */ \
|
|
|
|
2) /* Duration Field */
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
// Replicated Data shall be at least 8 bytes long.
|
|
|
|
#define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
#define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \
|
|
|
|
(1 + /* Stream Number */ \
|
|
|
|
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
|
|
|
|
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
|
|
|
|
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
|
|
|
|
ASF_PAYLOAD_REPLICATED_DATA_LENGTH)
|
|
|
|
|
|
|
|
#define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \
|
|
|
|
(1 + /* Stream Number */ \
|
|
|
|
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
|
|
|
|
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
|
|
|
|
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
|
|
|
|
ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \
|
|
|
|
ASF_PAYLOAD_LENGTH_FIELD_SIZE)
|
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
#define SINGLE_PAYLOAD_HEADERS \
|
|
|
|
(PACKET_HEADER_MIN_SIZE + \
|
2013-02-05 23:44:00 +00:00
|
|
|
PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD)
|
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
#define MULTI_PAYLOAD_HEADERS \
|
|
|
|
(PACKET_HEADER_MIN_SIZE + \
|
|
|
|
1 + /* Payload Flags */ \
|
2013-02-05 23:44:00 +00:00
|
|
|
2 * PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS)
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2013-09-19 15:50:35 +00:00
|
|
|
#define DATA_HEADER_SIZE 50
|
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
#define PACKET_SIZE_MAX 65536
|
|
|
|
#define PACKET_SIZE_MIN 100
|
|
|
|
|
2015-06-28 11:05:45 +00:00
|
|
|
typedef struct ASFPayload {
|
|
|
|
uint8_t type;
|
|
|
|
uint16_t size;
|
|
|
|
} ASFPayload;
|
|
|
|
|
2015-06-15 12:54:45 +00:00
|
|
|
typedef struct ASFStream {
|
|
|
|
int num;
|
|
|
|
unsigned char seq;
|
|
|
|
/* use for reading */
|
|
|
|
AVPacket pkt;
|
|
|
|
int frag_offset;
|
2015-06-28 11:05:45 +00:00
|
|
|
int packet_obj_size;
|
2015-06-15 12:54:45 +00:00
|
|
|
int timestamp;
|
|
|
|
int64_t duration;
|
2015-06-28 11:05:45 +00:00
|
|
|
int skip_to_key;
|
|
|
|
int pkt_clean;
|
2015-06-15 12:54:45 +00:00
|
|
|
|
|
|
|
int ds_span; /* descrambling */
|
|
|
|
int ds_packet_size;
|
|
|
|
int ds_chunk_size;
|
|
|
|
|
|
|
|
int64_t packet_pos;
|
|
|
|
|
|
|
|
uint16_t stream_language_index;
|
|
|
|
|
|
|
|
int palette_changed;
|
|
|
|
uint32_t palette[256];
|
2015-06-28 11:05:45 +00:00
|
|
|
|
|
|
|
int payload_ext_ct;
|
|
|
|
ASFPayload payload[8];
|
2015-06-15 12:54:45 +00:00
|
|
|
} ASFStream;
|
|
|
|
|
2014-09-22 07:19:33 +00:00
|
|
|
typedef struct ASFContext {
|
2016-02-03 23:26:58 +00:00
|
|
|
AVClass *av_class;
|
2011-02-08 20:46:47 +00:00
|
|
|
uint32_t seqno;
|
|
|
|
int is_streamed;
|
|
|
|
ASFStream streams[128]; ///< it's max number and it's not that big
|
2016-02-03 02:42:50 +00:00
|
|
|
const char *languages[128];
|
|
|
|
int nb_languages;
|
2016-02-03 21:49:35 +00:00
|
|
|
int64_t creation_time;
|
2016-04-27 17:45:23 +00:00
|
|
|
/* non-streamed additional info */
|
2011-02-08 20:46:47 +00:00
|
|
|
uint64_t nb_packets; ///< how many packets are there in the file, invalid if broadcasting
|
|
|
|
int64_t duration; ///< in 100ns units
|
|
|
|
/* packet filling */
|
|
|
|
unsigned char multi_payloads_present;
|
|
|
|
int packet_size_left;
|
2011-09-09 01:32:24 +00:00
|
|
|
int64_t packet_timestamp_start;
|
|
|
|
int64_t packet_timestamp_end;
|
2011-02-08 20:46:47 +00:00
|
|
|
unsigned int packet_nb_payloads;
|
2016-02-04 00:30:31 +00:00
|
|
|
uint8_t packet_buf[PACKET_SIZE_MAX];
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext pb;
|
2011-02-08 20:46:47 +00:00
|
|
|
/* only for reading */
|
|
|
|
uint64_t data_offset; ///< beginning of the first data packet
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
ASFIndex *index_ptr;
|
2011-02-08 20:46:47 +00:00
|
|
|
uint32_t nb_index_memory_alloc;
|
|
|
|
uint16_t maximum_packet;
|
2012-04-04 05:52:27 +00:00
|
|
|
uint32_t next_packet_number;
|
|
|
|
uint16_t next_packet_count;
|
2013-09-20 09:43:32 +00:00
|
|
|
uint64_t next_packet_offset;
|
2012-04-04 05:52:27 +00:00
|
|
|
int next_start_sec;
|
|
|
|
int end_sec;
|
2016-02-04 00:30:31 +00:00
|
|
|
int packet_size;
|
2011-02-08 20:46:47 +00:00
|
|
|
} ASFContext;
|
|
|
|
|
2007-01-21 01:39:17 +00:00
|
|
|
static const AVCodecTag codec_asf_bmp_tags[] = {
|
2013-02-05 23:44:00 +00:00
|
|
|
{ AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
|
2013-02-06 13:10:26 +00:00
|
|
|
{ AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
|
2012-08-05 09:11:04 +00:00
|
|
|
{ AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
|
2013-02-05 23:44:00 +00:00
|
|
|
{ AV_CODEC_ID_NONE, 0 },
|
2007-01-21 01:39:17 +00:00
|
|
|
};
|
|
|
|
|
2021-02-18 00:24:24 +00:00
|
|
|
static const AVCodecTag *const asf_codec_tags[] = {
|
|
|
|
codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, NULL
|
|
|
|
};
|
|
|
|
|
2007-03-07 02:03:32 +00:00
|
|
|
#define PREROLL_TIME 3100
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void put_str16(AVIOContext *s, const char *tag)
|
2010-02-25 16:59:55 +00:00
|
|
|
{
|
|
|
|
int len;
|
|
|
|
uint8_t *pb;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *dyn_buf;
|
2011-03-17 07:13:34 +00:00
|
|
|
if (avio_open_dyn_buf(&dyn_buf) < 0)
|
2010-02-25 16:59:55 +00:00
|
|
|
return;
|
|
|
|
|
2011-01-21 19:18:08 +00:00
|
|
|
avio_put_str16le(dyn_buf, tag);
|
2011-03-17 07:16:07 +00:00
|
|
|
len = avio_close_dyn_buf(dyn_buf, &pb);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(s, len);
|
|
|
|
avio_write(s, pb, len);
|
2010-02-25 16:59:55 +00:00
|
|
|
av_freep(&pb);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static int64_t put_header(AVIOContext *pb, const ff_asf_guid *g)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
int64_t pos;
|
|
|
|
|
2011-03-03 19:11:45 +00:00
|
|
|
pos = avio_tell(pb);
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, g);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, 24);
|
2004-03-05 21:34:30 +00:00
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update header size */
|
2011-02-20 10:04:12 +00:00
|
|
|
static void end_header(AVIOContext *pb, int64_t pos)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
int64_t pos1;
|
|
|
|
|
2011-03-03 19:11:45 +00:00
|
|
|
pos1 = avio_tell(pb);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, pos + 16, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, pos1 - pos);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, pos1, SEEK_SET);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* write an asf chunk (only used in streaming case) */
|
2013-02-05 23:44:00 +00:00
|
|
|
static void put_chunk(AVFormatContext *s, int type,
|
|
|
|
int payload_length, int flags)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2004-03-05 21:34:30 +00:00
|
|
|
int length;
|
|
|
|
|
|
|
|
length = payload_length + 8;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, type);
|
2013-02-05 23:44:00 +00:00
|
|
|
avio_wl16(pb, length); // size
|
|
|
|
avio_wl32(pb, asf->seqno); // sequence number
|
|
|
|
avio_wl16(pb, flags); // unknown bytes
|
|
|
|
avio_wl16(pb, length); // size_confirm
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->seqno++;
|
|
|
|
}
|
|
|
|
|
2016-02-03 21:49:35 +00:00
|
|
|
/* convert from av time to windows time */
|
|
|
|
static int64_t unix_to_file_time(int64_t ti)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
int64_t t;
|
|
|
|
|
2016-02-03 21:49:35 +00:00
|
|
|
t = ti * INT64_C(10);
|
2006-12-06 23:46:11 +00:00
|
|
|
t += INT64_C(116444736000000000);
|
2004-03-05 21:34:30 +00:00
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2013-09-19 15:50:38 +00:00
|
|
|
static int32_t get_send_time(ASFContext *asf, int64_t pres_time, uint64_t *offset)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t send_time = 0;
|
|
|
|
*offset = asf->data_offset + DATA_HEADER_SIZE;
|
2013-09-20 09:56:26 +00:00
|
|
|
for (i = 0; i < asf->next_start_sec; i++) {
|
2013-09-19 15:50:38 +00:00
|
|
|
if (pres_time <= asf->index_ptr[i].send_time)
|
|
|
|
break;
|
|
|
|
send_time = asf->index_ptr[i].send_time;
|
|
|
|
*offset = asf->index_ptr[i].offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
return send_time / 10000;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asf_write_markers(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
|
|
|
AVIOContext *pb = s->pb;
|
|
|
|
int i;
|
|
|
|
AVRational scale = {1, 10000000};
|
|
|
|
int64_t hpos = put_header(pb, &ff_asf_marker_header);
|
|
|
|
|
2013-09-20 09:56:26 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_reserved_4);// ASF spec mandates this reserved value
|
2013-09-19 15:50:38 +00:00
|
|
|
avio_wl32(pb, s->nb_chapters); // markers count
|
|
|
|
avio_wl16(pb, 0); // ASF spec mandates 0 for this
|
|
|
|
avio_wl16(pb, 0); // name length 0, no name given
|
|
|
|
|
|
|
|
for (i = 0; i < s->nb_chapters; i++) {
|
|
|
|
AVChapter *c = s->chapters[i];
|
|
|
|
AVDictionaryEntry *t = av_dict_get(c->metadata, "title", NULL, 0);
|
|
|
|
int64_t pres_time = av_rescale_q(c->start, c->time_base, scale);
|
|
|
|
uint64_t offset;
|
|
|
|
int32_t send_time = get_send_time(asf, pres_time, &offset);
|
2019-12-10 21:59:53 +00:00
|
|
|
int len = 0, ret;
|
2013-09-19 15:50:38 +00:00
|
|
|
uint8_t *buf;
|
|
|
|
AVIOContext *dyn_buf;
|
|
|
|
if (t) {
|
2019-12-10 21:59:53 +00:00
|
|
|
if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
|
|
|
|
return ret;
|
2013-09-19 15:50:38 +00:00
|
|
|
avio_put_str16le(dyn_buf, t->value);
|
|
|
|
len = avio_close_dyn_buf(dyn_buf, &buf);
|
|
|
|
}
|
|
|
|
avio_wl64(pb, offset); // offset of the packet with send_time
|
|
|
|
avio_wl64(pb, pres_time + PREROLL_TIME * 10000); // presentation time
|
|
|
|
avio_wl16(pb, 12 + len); // entry length
|
|
|
|
avio_wl32(pb, send_time); // send time
|
|
|
|
avio_wl32(pb, 0); // flags, should be 0
|
|
|
|
avio_wl32(pb, len / 2); // marker desc length in WCHARS!
|
|
|
|
if (t) {
|
|
|
|
avio_write(pb, buf, len); // marker desc
|
|
|
|
av_freep(&buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end_header(pb, hpos);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-03-05 21:34:30 +00:00
|
|
|
/* write the header (used two times if non streamed) */
|
2013-02-05 23:44:00 +00:00
|
|
|
static int asf_write_header1(AVFormatContext *s, int64_t file_size,
|
|
|
|
int64_t data_chunk_size)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2016-02-06 16:56:31 +00:00
|
|
|
AVDictionaryEntry *tags[5];
|
2016-02-03 21:49:35 +00:00
|
|
|
int header_size, n, extra_size, extra_size2, wav_extra_size;
|
2014-04-17 12:55:49 +00:00
|
|
|
int has_title, has_aspect_ratio = 0;
|
2009-02-04 01:40:52 +00:00
|
|
|
int metadata_count;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par;
|
2004-03-05 21:34:30 +00:00
|
|
|
int64_t header_offset, cur_pos, hpos;
|
|
|
|
int bit_rate;
|
2006-10-01 17:05:25 +00:00
|
|
|
int64_t duration;
|
2016-02-05 22:46:25 +00:00
|
|
|
int audio_language_counts[128] = { 0 };
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2010-10-16 13:20:41 +00:00
|
|
|
ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
|
2010-10-15 19:04:25 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
tags[0] = av_dict_get(s->metadata, "title", NULL, 0);
|
|
|
|
tags[1] = av_dict_get(s->metadata, "author", NULL, 0);
|
2011-05-22 10:46:29 +00:00
|
|
|
tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0);
|
2013-02-05 23:44:00 +00:00
|
|
|
tags[3] = av_dict_get(s->metadata, "comment", NULL, 0);
|
|
|
|
tags[4] = av_dict_get(s->metadata, "rating", NULL, 0);
|
2009-02-04 01:37:16 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
duration = asf->duration + PREROLL_TIME * 10000;
|
|
|
|
has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
|
2016-02-03 21:49:35 +00:00
|
|
|
|
2016-02-06 16:56:31 +00:00
|
|
|
if (!file_size) {
|
|
|
|
if (ff_parse_creation_time_metadata(s, &asf->creation_time, 0) != 0)
|
|
|
|
av_dict_set(&s->metadata, "creation_time", NULL, 0);
|
2016-02-03 21:49:35 +00:00
|
|
|
}
|
|
|
|
|
2012-08-08 16:30:15 +00:00
|
|
|
metadata_count = av_dict_count(s->metadata);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
bit_rate = 0;
|
2013-02-05 23:44:00 +00:00
|
|
|
for (n = 0; n < s->nb_streams; n++) {
|
2016-02-03 02:42:50 +00:00
|
|
|
AVDictionaryEntry *entry;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
par = s->streams[n]->codecpar;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2011-11-29 18:28:15 +00:00
|
|
|
avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
|
2004-05-21 20:43:21 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
bit_rate += par->bit_rate;
|
2016-04-10 19:58:15 +00:00
|
|
|
if ( par->codec_type == AVMEDIA_TYPE_VIDEO
|
|
|
|
&& par->sample_aspect_ratio.num > 0
|
|
|
|
&& par->sample_aspect_ratio.den > 0)
|
2014-04-17 12:55:49 +00:00
|
|
|
has_aspect_ratio++;
|
2016-02-03 02:42:50 +00:00
|
|
|
|
|
|
|
entry = av_dict_get(s->streams[n]->metadata, "language", NULL, 0);
|
|
|
|
if (entry) {
|
2016-05-13 21:03:28 +00:00
|
|
|
const char *iso6391lang = ff_convert_lang_to(entry->value, AV_LANG_ISO639_1);
|
2016-02-03 02:42:50 +00:00
|
|
|
if (iso6391lang) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < asf->nb_languages; i++) {
|
|
|
|
if (!strcmp(asf->languages[i], iso6391lang)) {
|
|
|
|
asf->streams[n].stream_language_index = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i >= asf->nb_languages) {
|
|
|
|
asf->languages[asf->nb_languages] = iso6391lang;
|
|
|
|
asf->streams[n].stream_language_index = asf->nb_languages;
|
|
|
|
asf->nb_languages++;
|
|
|
|
}
|
2016-04-10 19:58:15 +00:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO)
|
2016-02-05 22:46:25 +00:00
|
|
|
audio_language_counts[asf->streams[n].stream_language_index]++;
|
2016-02-03 02:42:50 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
asf->streams[n].stream_language_index = 128;
|
|
|
|
}
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (asf->is_streamed) {
|
|
|
|
put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */
|
|
|
|
}
|
|
|
|
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_header);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, -1); /* header length, will be patched after */
|
|
|
|
avio_wl32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
|
|
|
|
avio_w8(pb, 1); /* ??? */
|
|
|
|
avio_w8(pb, 2); /* ??? */
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
/* file header */
|
2011-03-03 19:11:45 +00:00
|
|
|
header_offset = avio_tell(pb);
|
2013-02-05 23:44:00 +00:00
|
|
|
hpos = put_header(pb, &ff_asf_file_header);
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_my_guid);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, file_size);
|
2016-02-03 21:49:35 +00:00
|
|
|
avio_wl64(pb, unix_to_file_time(asf->creation_time));
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, asf->nb_packets); /* number of packets */
|
|
|
|
avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
|
|
|
|
avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
|
|
|
|
avio_wl64(pb, PREROLL_TIME); /* start time stamp */
|
2016-09-27 14:26:37 +00:00
|
|
|
avio_wl32(pb, (asf->is_streamed || !(pb->seekable & AVIO_SEEKABLE_NORMAL)) ? 3 : 2); /* ??? */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, s->packet_size); /* packet size */
|
|
|
|
avio_wl32(pb, s->packet_size); /* packet size */
|
2014-04-24 15:47:49 +00:00
|
|
|
avio_wl32(pb, bit_rate ? bit_rate : -1); /* Maximum data rate in bps */
|
2004-03-05 21:34:30 +00:00
|
|
|
end_header(pb, hpos);
|
|
|
|
|
2016-02-03 02:42:50 +00:00
|
|
|
/* header_extension */
|
2009-02-26 16:17:17 +00:00
|
|
|
hpos = put_header(pb, &ff_asf_head1_guid);
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_head2_guid);
|
2014-04-17 12:55:49 +00:00
|
|
|
avio_wl16(pb, 6);
|
2016-02-03 02:42:50 +00:00
|
|
|
avio_wl32(pb, 0); /* length, to be filled later */
|
|
|
|
if (asf->nb_languages) {
|
|
|
|
int64_t hpos2;
|
|
|
|
int i;
|
2016-02-05 22:46:25 +00:00
|
|
|
int nb_audio_languages = 0;
|
2016-02-03 02:42:50 +00:00
|
|
|
|
|
|
|
hpos2 = put_header(pb, &ff_asf_language_guid);
|
|
|
|
avio_wl16(pb, asf->nb_languages);
|
|
|
|
for (i = 0; i < asf->nb_languages; i++) {
|
|
|
|
avio_w8(pb, 6);
|
|
|
|
avio_put_str16le(pb, asf->languages[i]);
|
|
|
|
}
|
|
|
|
end_header(pb, hpos2);
|
|
|
|
|
2016-02-05 22:46:25 +00:00
|
|
|
for (i = 0; i < asf->nb_languages; i++)
|
|
|
|
if (audio_language_counts[i])
|
|
|
|
nb_audio_languages++;
|
|
|
|
|
|
|
|
if (nb_audio_languages > 1) {
|
|
|
|
hpos2 = put_header(pb, &ff_asf_group_mutual_exclusion_object);
|
|
|
|
ff_put_guid(pb, &ff_asf_mutex_language);
|
|
|
|
avio_wl16(pb, nb_audio_languages);
|
|
|
|
for (i = 0; i < asf->nb_languages; i++) {
|
|
|
|
if (audio_language_counts[i]) {
|
|
|
|
avio_wl16(pb, audio_language_counts[i]);
|
|
|
|
for (n = 0; n < s->nb_streams; n++)
|
2016-04-10 19:58:15 +00:00
|
|
|
if (asf->streams[n].stream_language_index == i && s->streams[n]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
|
2016-02-05 22:46:25 +00:00
|
|
|
avio_wl16(pb, n + 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end_header(pb, hpos2);
|
|
|
|
}
|
|
|
|
|
2016-02-03 02:42:50 +00:00
|
|
|
for (n = 0; n < s->nb_streams; n++) {
|
|
|
|
int64_t es_pos;
|
|
|
|
if (asf->streams[n].stream_language_index > 127)
|
|
|
|
continue;
|
|
|
|
es_pos = put_header(pb, &ff_asf_extended_stream_properties_object);
|
|
|
|
avio_wl64(pb, 0); /* start time */
|
|
|
|
avio_wl64(pb, 0); /* end time */
|
2016-04-10 19:58:15 +00:00
|
|
|
avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* data bitrate bps */
|
2016-02-03 02:42:50 +00:00
|
|
|
avio_wl32(pb, 5000); /* buffer size ms */
|
|
|
|
avio_wl32(pb, 0); /* initial buffer fullness */
|
2016-04-10 19:58:15 +00:00
|
|
|
avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* peak data bitrate */
|
2016-02-03 02:42:50 +00:00
|
|
|
avio_wl32(pb, 5000); /* maximum buffer size ms */
|
|
|
|
avio_wl32(pb, 0); /* max initial buffer fullness */
|
|
|
|
avio_wl32(pb, 0); /* max object size */
|
2017-03-21 20:02:30 +00:00
|
|
|
avio_wl32(pb, (!asf->is_streamed && (pb->seekable & AVIO_SEEKABLE_NORMAL)) << 1); /* flags - seekable */
|
2016-02-03 02:42:50 +00:00
|
|
|
avio_wl16(pb, n + 1); /* stream number */
|
|
|
|
avio_wl16(pb, asf->streams[n].stream_language_index); /* language id index */
|
|
|
|
avio_wl64(pb, 0); /* avg time per frame */
|
|
|
|
avio_wl16(pb, 0); /* stream name count */
|
|
|
|
avio_wl16(pb, 0); /* payload extension system count */
|
|
|
|
end_header(pb, es_pos);
|
|
|
|
}
|
|
|
|
}
|
2014-04-17 12:55:49 +00:00
|
|
|
if (has_aspect_ratio) {
|
|
|
|
int64_t hpos2;
|
|
|
|
hpos2 = put_header(pb, &ff_asf_metadata_header);
|
|
|
|
avio_wl16(pb, 2 * has_aspect_ratio);
|
|
|
|
for (n = 0; n < s->nb_streams; n++) {
|
2016-04-10 19:58:15 +00:00
|
|
|
par = s->streams[n]->codecpar;
|
|
|
|
if ( par->codec_type == AVMEDIA_TYPE_VIDEO
|
|
|
|
&& par->sample_aspect_ratio.num > 0
|
|
|
|
&& par->sample_aspect_ratio.den > 0) {
|
|
|
|
AVRational sar = par->sample_aspect_ratio;
|
2014-04-17 12:55:49 +00:00
|
|
|
avio_wl16(pb, 0);
|
|
|
|
// the stream number is set like this below
|
|
|
|
avio_wl16(pb, n + 1);
|
|
|
|
avio_wl16(pb, 26); // name_len
|
|
|
|
avio_wl16(pb, 3); // value_type
|
|
|
|
avio_wl32(pb, 4); // value_len
|
|
|
|
avio_put_str16le(pb, "AspectRatioX");
|
|
|
|
avio_wl32(pb, sar.num);
|
|
|
|
avio_wl16(pb, 0);
|
|
|
|
// the stream number is set like this below
|
|
|
|
avio_wl16(pb, n + 1);
|
|
|
|
avio_wl16(pb, 26); // name_len
|
|
|
|
avio_wl16(pb, 3); // value_type
|
|
|
|
avio_wl32(pb, 4); // value_len
|
|
|
|
avio_put_str16le(pb, "AspectRatioY");
|
|
|
|
avio_wl32(pb, sar.den);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end_header(pb, hpos2);
|
2016-02-03 02:42:50 +00:00
|
|
|
}
|
|
|
|
{
|
|
|
|
int64_t pos1;
|
|
|
|
pos1 = avio_tell(pb);
|
|
|
|
avio_seek(pb, hpos + 42, SEEK_SET);
|
|
|
|
avio_wl32(pb, pos1 - hpos - 46);
|
|
|
|
avio_seek(pb, pos1, SEEK_SET);
|
2014-04-17 12:55:49 +00:00
|
|
|
}
|
2004-03-05 21:34:30 +00:00
|
|
|
end_header(pb, hpos);
|
|
|
|
|
2016-04-27 17:45:23 +00:00
|
|
|
/* title and other info */
|
2004-03-05 21:34:30 +00:00
|
|
|
if (has_title) {
|
2019-12-10 21:59:53 +00:00
|
|
|
int len, ret;
|
2010-02-25 16:59:55 +00:00
|
|
|
uint8_t *buf;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *dyn_buf;
|
2010-02-25 16:59:55 +00:00
|
|
|
|
2019-12-10 21:59:53 +00:00
|
|
|
if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
|
|
|
|
return ret;
|
2010-02-25 16:59:55 +00:00
|
|
|
|
2009-02-26 16:17:17 +00:00
|
|
|
hpos = put_header(pb, &ff_asf_comment_header);
|
2010-02-25 16:59:55 +00:00
|
|
|
|
|
|
|
for (n = 0; n < FF_ARRAY_ELEMS(tags); n++) {
|
2011-01-21 19:18:08 +00:00
|
|
|
len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, len);
|
2010-02-25 16:59:55 +00:00
|
|
|
}
|
2011-03-17 07:16:07 +00:00
|
|
|
len = avio_close_dyn_buf(dyn_buf, &buf);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf, len);
|
2010-02-25 16:59:55 +00:00
|
|
|
av_freep(&buf);
|
2004-03-05 21:34:30 +00:00
|
|
|
end_header(pb, hpos);
|
|
|
|
}
|
2009-02-04 01:40:52 +00:00
|
|
|
if (metadata_count) {
|
2011-05-22 10:46:29 +00:00
|
|
|
AVDictionaryEntry *tag = NULL;
|
2009-02-26 16:17:17 +00:00
|
|
|
hpos = put_header(pb, &ff_asf_extended_content_header);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, metadata_count);
|
2011-05-22 10:46:29 +00:00
|
|
|
while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
|
2010-02-25 16:59:55 +00:00
|
|
|
put_str16(pb, tag->key);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 0);
|
2010-02-25 16:59:55 +00:00
|
|
|
put_str16(pb, tag->value);
|
2009-02-04 01:40:52 +00:00
|
|
|
}
|
|
|
|
end_header(pb, hpos);
|
|
|
|
}
|
2013-09-19 15:50:38 +00:00
|
|
|
/* chapters using ASF markers */
|
|
|
|
if (!asf->is_streamed && s->nb_chapters) {
|
|
|
|
int ret;
|
2014-12-20 00:48:26 +00:00
|
|
|
if ((ret = asf_write_markers(s)) < 0)
|
2013-09-19 15:50:38 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2004-03-05 21:34:30 +00:00
|
|
|
/* stream headers */
|
2013-02-05 23:44:00 +00:00
|
|
|
for (n = 0; n < s->nb_streams; n++) {
|
2004-03-05 21:34:30 +00:00
|
|
|
int64_t es_pos;
|
|
|
|
// ASFStream *stream = &asf->streams[n];
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
par = s->streams[n]->codecpar;
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->streams[n].num = n + 1;
|
2012-04-04 05:52:03 +00:00
|
|
|
asf->streams[n].seq = 1;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch (par->codec_type) {
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
2004-03-05 21:34:30 +00:00
|
|
|
wav_extra_size = 0;
|
2013-02-05 23:44:00 +00:00
|
|
|
extra_size = 18 + wav_extra_size;
|
|
|
|
extra_size2 = 8;
|
2004-03-05 21:34:30 +00:00
|
|
|
break;
|
|
|
|
default:
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
wav_extra_size = par->extradata_size;
|
2013-02-05 23:44:00 +00:00
|
|
|
extra_size = 0x33 + wav_extra_size;
|
|
|
|
extra_size2 = 0;
|
2004-03-05 21:34:30 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-02-26 16:17:17 +00:00
|
|
|
hpos = put_header(pb, &ff_asf_stream_header);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_audio_stream);
|
|
|
|
ff_put_guid(pb, &ff_asf_audio_conceal_spread);
|
2004-03-05 21:34:30 +00:00
|
|
|
} else {
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_video_stream);
|
|
|
|
ff_put_guid(pb, &ff_asf_video_conceal_none);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, 0); /* ??? */
|
2011-03-03 19:11:45 +00:00
|
|
|
es_pos = avio_tell(pb);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, extra_size); /* wav header len */
|
|
|
|
avio_wl32(pb, extra_size2); /* additional data len */
|
|
|
|
avio_wl16(pb, n + 1); /* stream number */
|
|
|
|
avio_wl32(pb, 0); /* ??? */
|
2004-03-05 21:34:30 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2004-03-05 21:34:30 +00:00
|
|
|
/* WAVEFORMATEX header */
|
2016-04-10 19:58:15 +00:00
|
|
|
int wavsize = ff_put_wav_header(s, pb, par, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
if (wavsize < 0)
|
|
|
|
return -1;
|
|
|
|
if (wavsize != extra_size) {
|
2011-03-03 19:11:45 +00:00
|
|
|
cur_pos = avio_tell(pb);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, es_pos, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, wavsize); /* wav header len */
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, cur_pos, SEEK_SET);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
2005-03-23 13:30:27 +00:00
|
|
|
/* ERROR Correction */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x01);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_id == AV_CODEC_ID_ADPCM_G726 || !par->block_align) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 0x0190);
|
|
|
|
avio_wl16(pb, 0x0190);
|
2013-02-05 23:44:00 +00:00
|
|
|
} else {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_wl16(pb, par->block_align);
|
|
|
|
avio_wl16(pb, par->block_align);
|
2007-02-12 23:32:55 +00:00
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 0x01);
|
|
|
|
avio_w8(pb, 0x00);
|
2004-03-05 21:34:30 +00:00
|
|
|
} else {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_wl32(pb, par->width);
|
|
|
|
avio_wl32(pb, par->height);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 2); /* ??? */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_wl16(pb, 40 + par->extradata_size); /* size */
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
/* BITMAPINFOHEADER header */
|
2020-07-08 12:02:25 +00:00
|
|
|
ff_put_bmp_header(pb, par, 1, 0, 0);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
end_header(pb, hpos);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* media comments */
|
|
|
|
|
2009-02-26 16:17:17 +00:00
|
|
|
hpos = put_header(pb, &ff_asf_codec_comment_header);
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_codec_comment1_header);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, s->nb_streams);
|
2013-02-05 23:44:00 +00:00
|
|
|
for (n = 0; n < s->nb_streams; n++) {
|
2014-04-29 14:13:38 +00:00
|
|
|
const AVCodecDescriptor *codec_desc;
|
2010-02-24 18:09:49 +00:00
|
|
|
const char *desc;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
par = s->streams[n]->codecpar;
|
|
|
|
codec_desc = avcodec_descriptor_get(par->codec_id);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 2);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
else if (par->codec_type == AVMEDIA_TYPE_VIDEO)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 1);
|
2007-03-05 02:41:49 +00:00
|
|
|
else
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, -1);
|
2007-03-05 02:41:49 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_id == AV_CODEC_ID_WMAV2)
|
2010-02-24 18:09:49 +00:00
|
|
|
desc = "Windows Media Audio V8";
|
2007-03-05 02:41:49 +00:00
|
|
|
else
|
2014-04-29 14:13:38 +00:00
|
|
|
desc = codec_desc ? codec_desc->name : NULL;
|
2010-02-25 16:59:55 +00:00
|
|
|
|
2014-04-29 14:13:38 +00:00
|
|
|
if (desc) {
|
|
|
|
AVIOContext *dyn_buf;
|
|
|
|
uint8_t *buf;
|
2019-12-10 21:59:53 +00:00
|
|
|
int len, ret;
|
2010-02-25 16:59:55 +00:00
|
|
|
|
2019-12-10 21:59:53 +00:00
|
|
|
if ((ret = avio_open_dyn_buf(&dyn_buf)) < 0)
|
|
|
|
return ret;
|
2010-02-25 16:59:55 +00:00
|
|
|
|
2014-04-29 14:13:38 +00:00
|
|
|
avio_put_str16le(dyn_buf, desc);
|
|
|
|
len = avio_close_dyn_buf(dyn_buf, &buf);
|
|
|
|
avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2
|
|
|
|
|
|
|
|
avio_write(pb, buf, len);
|
|
|
|
av_freep(&buf);
|
|
|
|
} else
|
|
|
|
avio_wl16(pb, 0);
|
2010-02-25 16:59:55 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 0); /* no parameters */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-03-05 21:34:30 +00:00
|
|
|
/* id */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 2);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_wl16(pb, par->codec_tag);
|
2004-03-05 21:34:30 +00:00
|
|
|
} else {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 4);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_wl32(pb, par->codec_tag);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (!par->codec_tag)
|
2007-01-21 12:55:31 +00:00
|
|
|
return -1;
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
end_header(pb, hpos);
|
|
|
|
|
|
|
|
/* patch the header size fields */
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
cur_pos = avio_tell(pb);
|
2004-03-05 21:34:30 +00:00
|
|
|
header_size = cur_pos - header_offset;
|
|
|
|
if (asf->is_streamed) {
|
2013-09-19 15:50:35 +00:00
|
|
|
header_size += 8 + 30 + DATA_HEADER_SIZE;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, header_offset - 10 - 30, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, header_size);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, header_offset - 2 - 30, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, header_size);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2013-09-19 15:50:35 +00:00
|
|
|
header_size -= 8 + 30 + DATA_HEADER_SIZE;
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
header_size += 24 + 6;
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, header_offset - 14, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, header_size);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, cur_pos, SEEK_SET);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
/* movie chunk, followed by packets of packet_size */
|
|
|
|
asf->data_offset = cur_pos;
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_data_header);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, data_chunk_size);
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_my_guid);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, asf->nb_packets); /* nb packets */
|
|
|
|
avio_w8(pb, 1); /* ??? */
|
|
|
|
avio_w8(pb, 1); /* ??? */
|
2004-03-05 21:34:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asf_write_header(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
s->packet_size = asf->packet_size;
|
2014-04-21 00:39:00 +00:00
|
|
|
s->max_interleave_delta = 0;
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->nb_packets = 0;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2016-02-03 21:53:56 +00:00
|
|
|
if (s->nb_streams > 127) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "ASF can only handle 127 streams\n");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->index_ptr = av_malloc(sizeof(ASFIndex) * ASF_INDEX_BLOCK);
|
2015-04-07 20:29:54 +00:00
|
|
|
if (!asf->index_ptr)
|
|
|
|
return AVERROR(ENOMEM);
|
2005-03-23 13:30:27 +00:00
|
|
|
asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->maximum_packet = 0;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2013-09-19 15:50:35 +00:00
|
|
|
/* the data-chunk-size has to be 50 (DATA_HEADER_SIZE), which is
|
|
|
|
* data_size - asf->data_offset at the moment this function is done.
|
|
|
|
* It is needed to use asf as a streamable format. */
|
|
|
|
if (asf_write_header1(s, 0, DATA_HEADER_SIZE) < 0) {
|
2004-03-05 21:34:30 +00:00
|
|
|
//av_free(asf);
|
2015-03-09 18:31:39 +00:00
|
|
|
av_freep(&asf->index_ptr);
|
2004-03-05 21:34:30 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->packet_nb_payloads = 0;
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->packet_timestamp_start = -1;
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->packet_timestamp_end = -1;
|
2011-02-20 10:04:13 +00:00
|
|
|
ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
|
2013-02-05 23:44:00 +00:00
|
|
|
NULL, NULL, NULL, NULL);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2012-09-28 00:31:07 +00:00
|
|
|
if (s->avoid_negative_ts < 0)
|
|
|
|
s->avoid_negative_ts = 1;
|
|
|
|
|
2004-03-05 21:34:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asf_write_stream_header(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
|
|
|
|
|
|
|
asf->is_streamed = 1;
|
|
|
|
|
|
|
|
return asf_write_header(s);
|
|
|
|
}
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
static int put_payload_parsing_info(AVFormatContext *s,
|
|
|
|
unsigned sendtime, unsigned duration,
|
|
|
|
int nb_payloads, int padsize)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2004-03-05 22:10:50 +00:00
|
|
|
int ppi_size, i;
|
2013-02-05 23:44:00 +00:00
|
|
|
int64_t start = avio_tell(pb);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-02-09 20:49:12 +00:00
|
|
|
padsize -= PACKET_HEADER_MIN_SIZE;
|
2013-02-05 23:44:00 +00:00
|
|
|
if (asf->multi_payloads_present)
|
2007-02-09 20:49:12 +00:00
|
|
|
padsize--;
|
2013-04-07 01:46:50 +00:00
|
|
|
av_assert0(padsize >= 0);
|
2007-02-09 20:49:12 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
|
2013-02-05 23:44:00 +00:00
|
|
|
for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x0);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2004-03-05 22:10:50 +00:00
|
|
|
if (asf->multi_payloads_present)
|
|
|
|
iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
if (padsize > 0) {
|
|
|
|
if (padsize < 256)
|
2004-03-05 22:10:50 +00:00
|
|
|
iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE;
|
2004-03-05 21:34:30 +00:00
|
|
|
else
|
2004-03-05 22:10:50 +00:00
|
|
|
iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, iLengthTypeFlags);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, ASF_PPI_PROPERTY_FLAGS);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, padsize - 2);
|
2004-03-05 22:10:50 +00:00
|
|
|
if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, padsize - 1);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, sendtime);
|
|
|
|
avio_wl16(pb, duration);
|
2004-03-05 22:10:50 +00:00
|
|
|
if (asf->multi_payloads_present)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2011-03-03 19:11:45 +00:00
|
|
|
ppi_size = avio_tell(pb) - start;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2004-03-05 22:10:50 +00:00
|
|
|
return ppi_size;
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void flush_packet(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2004-03-05 22:10:50 +00:00
|
|
|
int packet_hdr_size, packet_filled_size;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2013-04-07 01:46:50 +00:00
|
|
|
av_assert0(asf->packet_timestamp_end >= asf->packet_timestamp_start);
|
2007-12-03 10:24:42 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
if (asf->is_streamed)
|
2009-06-24 23:04:05 +00:00
|
|
|
put_chunk(s, 0x4424, s->packet_size, 0);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
packet_hdr_size = put_payload_parsing_info(s,
|
|
|
|
asf->packet_timestamp_start,
|
2013-02-06 13:10:26 +00:00
|
|
|
asf->packet_timestamp_end - asf->packet_timestamp_start,
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->packet_nb_payloads,
|
|
|
|
asf->packet_size_left);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
packet_filled_size = asf->packet_size - asf->packet_size_left;
|
2013-04-07 01:46:50 +00:00
|
|
|
av_assert0(packet_hdr_size <= asf->packet_size_left);
|
2004-03-05 22:10:50 +00:00
|
|
|
memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2019-12-27 12:53:00 +00:00
|
|
|
avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
|
|
|
|
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->nb_packets++;
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->packet_nb_payloads = 0;
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->packet_timestamp_start = -1;
|
2013-02-05 23:44:00 +00:00
|
|
|
asf->packet_timestamp_end = -1;
|
2011-02-20 10:04:13 +00:00
|
|
|
ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
|
2013-02-05 23:44:00 +00:00
|
|
|
NULL, NULL, NULL, NULL);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
static void put_payload_header(AVFormatContext *s, ASFStream *stream,
|
2013-02-06 13:10:26 +00:00
|
|
|
int64_t presentation_time, int m_obj_size,
|
2013-02-05 23:44:00 +00:00
|
|
|
int m_obj_offset, int payload_len, int flags)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = &asf->pb;
|
2004-03-05 21:34:30 +00:00
|
|
|
int val;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-03-05 21:34:30 +00:00
|
|
|
val = stream->num;
|
2010-03-31 12:29:58 +00:00
|
|
|
if (flags & AV_PKT_FLAG_KEY)
|
2004-03-05 22:10:50 +00:00
|
|
|
val |= ASF_PL_FLAG_KEY_FRAME;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, val);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
avio_w8(pb, stream->seq); // Media object number
|
|
|
|
avio_wl32(pb, m_obj_offset); // Offset Into Media Object
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-03-05 22:10:50 +00:00
|
|
|
// Replicated Data shall be at least 8 bytes long.
|
2005-12-17 18:14:38 +00:00
|
|
|
// The first 4 bytes of data shall contain the
|
2004-03-05 22:10:50 +00:00
|
|
|
// Size of the Media Object that the payload belongs to.
|
2005-12-17 18:14:38 +00:00
|
|
|
// The next 4 bytes of data shall contain the
|
2004-03-05 22:10:50 +00:00
|
|
|
// Presentation Time for the media object that the payload belongs to.
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
avio_wl32(pb, m_obj_size); // Replicated Data - Media Object Size
|
2013-02-06 13:10:26 +00:00
|
|
|
avio_wl32(pb, (uint32_t) presentation_time); // Replicated Data - Presentation Time
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
if (asf->multi_payloads_present) {
|
|
|
|
avio_wl16(pb, payload_len); // payload length
|
2004-03-05 22:10:50 +00:00
|
|
|
}
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
|
2013-02-06 13:10:26 +00:00
|
|
|
int64_t timestamp, const uint8_t *buf,
|
2013-02-05 23:44:00 +00:00
|
|
|
int m_obj_size, int flags)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2004-03-05 22:10:50 +00:00
|
|
|
int m_obj_offset, payload_len, frag_len1;
|
|
|
|
|
|
|
|
m_obj_offset = 0;
|
|
|
|
while (m_obj_offset < m_obj_size) {
|
|
|
|
payload_len = m_obj_size - m_obj_offset;
|
|
|
|
if (asf->packet_timestamp_start == -1) {
|
2016-02-04 00:30:31 +00:00
|
|
|
const int multi_payload_constant = (asf->packet_size - MULTI_PAYLOAD_HEADERS);
|
|
|
|
asf->multi_payloads_present = (payload_len < multi_payload_constant);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
asf->packet_size_left = asf->packet_size;
|
2013-02-05 23:44:00 +00:00
|
|
|
if (asf->multi_payloads_present) {
|
2016-02-04 00:30:31 +00:00
|
|
|
frag_len1 = multi_payload_constant - 1;
|
2013-02-05 23:44:00 +00:00
|
|
|
} else {
|
2016-02-04 00:30:31 +00:00
|
|
|
frag_len1 = asf->packet_size - SINGLE_PAYLOAD_HEADERS;
|
2004-03-05 22:10:50 +00:00
|
|
|
}
|
2007-02-07 23:06:13 +00:00
|
|
|
asf->packet_timestamp_start = timestamp;
|
2013-02-05 23:44:00 +00:00
|
|
|
} else {
|
2004-03-05 22:10:50 +00:00
|
|
|
// multi payloads
|
2013-02-05 23:44:00 +00:00
|
|
|
frag_len1 = asf->packet_size_left -
|
|
|
|
PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS -
|
|
|
|
PACKET_HEADER_MIN_SIZE - 1;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
if (frag_len1 < payload_len &&
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avst->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2007-03-05 17:54:49 +00:00
|
|
|
flush_packet(s);
|
|
|
|
continue;
|
|
|
|
}
|
2016-01-12 17:26:34 +00:00
|
|
|
if (asf->packet_timestamp_start > INT64_MAX - UINT16_MAX ||
|
|
|
|
timestamp > asf->packet_timestamp_start + UINT16_MAX) {
|
|
|
|
flush_packet(s);
|
|
|
|
continue;
|
|
|
|
}
|
2004-03-05 22:10:50 +00:00
|
|
|
}
|
2004-03-05 21:34:30 +00:00
|
|
|
if (frag_len1 > 0) {
|
2004-03-05 22:10:50 +00:00
|
|
|
if (payload_len > frag_len1)
|
|
|
|
payload_len = frag_len1;
|
|
|
|
else if (payload_len == (frag_len1 - 1))
|
2013-02-05 23:44:00 +00:00
|
|
|
payload_len = frag_len1 - 2; // additional byte need to put padding length
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-02-05 23:44:00 +00:00
|
|
|
put_payload_header(s, stream, timestamp + PREROLL_TIME,
|
|
|
|
m_obj_size, m_obj_offset, payload_len, flags);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(&asf->pb, buf, payload_len);
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
if (asf->multi_payloads_present)
|
|
|
|
asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);
|
|
|
|
else
|
|
|
|
asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD);
|
2004-03-05 21:34:30 +00:00
|
|
|
asf->packet_timestamp_end = timestamp;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-03-05 22:10:50 +00:00
|
|
|
asf->packet_nb_payloads++;
|
2004-03-05 21:34:30 +00:00
|
|
|
} else {
|
2004-03-05 22:10:50 +00:00
|
|
|
payload_len = 0;
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
2004-03-05 22:10:50 +00:00
|
|
|
m_obj_offset += payload_len;
|
2013-02-05 23:44:00 +00:00
|
|
|
buf += payload_len;
|
2004-03-05 22:10:50 +00:00
|
|
|
|
|
|
|
if (!asf->multi_payloads_present)
|
|
|
|
flush_packet(s);
|
2007-02-09 20:49:12 +00:00
|
|
|
else if (asf->packet_size_left <= (PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS + PACKET_HEADER_MIN_SIZE + 1))
|
2004-03-05 21:34:30 +00:00
|
|
|
flush_packet(s);
|
2014-05-12 22:54:55 +00:00
|
|
|
else if (asf->packet_nb_payloads == ASF_PAYLOADS_PER_PACKET)
|
|
|
|
flush_packet(s);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
stream->seq++;
|
|
|
|
}
|
|
|
|
|
2013-09-11 08:54:41 +00:00
|
|
|
static int update_index(AVFormatContext *s, int start_sec,
|
2013-09-20 09:43:32 +00:00
|
|
|
uint32_t packet_number, uint16_t packet_count,
|
|
|
|
uint64_t packet_offset)
|
2012-04-04 05:52:27 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
|
|
|
|
|
|
|
if (start_sec > asf->next_start_sec) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!asf->next_start_sec) {
|
|
|
|
asf->next_packet_number = packet_number;
|
|
|
|
asf->next_packet_count = packet_count;
|
2013-09-20 09:43:32 +00:00
|
|
|
asf->next_packet_offset = packet_offset;
|
2012-04-04 05:52:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (start_sec > asf->nb_index_memory_alloc) {
|
2013-09-11 08:54:41 +00:00
|
|
|
int err;
|
2012-04-04 05:52:27 +00:00
|
|
|
asf->nb_index_memory_alloc = (start_sec + ASF_INDEX_BLOCK) & ~(ASF_INDEX_BLOCK - 1);
|
2013-09-11 08:54:41 +00:00
|
|
|
if ((err = av_reallocp_array(&asf->index_ptr,
|
|
|
|
asf->nb_index_memory_alloc,
|
|
|
|
sizeof(*asf->index_ptr))) < 0) {
|
|
|
|
asf->nb_index_memory_alloc = 0;
|
|
|
|
return err;
|
|
|
|
}
|
2012-04-04 05:52:27 +00:00
|
|
|
}
|
|
|
|
for (i = asf->next_start_sec; i < start_sec; i++) {
|
|
|
|
asf->index_ptr[i].packet_number = asf->next_packet_number;
|
|
|
|
asf->index_ptr[i].packet_count = asf->next_packet_count;
|
2013-09-20 09:43:32 +00:00
|
|
|
asf->index_ptr[i].send_time = asf->next_start_sec * INT64_C(10000000);
|
|
|
|
asf->index_ptr[i].offset = asf->next_packet_offset;
|
|
|
|
|
2012-04-04 05:52:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
asf->maximum_packet = FFMAX(asf->maximum_packet, packet_count);
|
|
|
|
asf->next_packet_number = packet_number;
|
|
|
|
asf->next_packet_count = packet_count;
|
2013-09-20 09:43:32 +00:00
|
|
|
asf->next_packet_offset = packet_offset;
|
2012-04-04 05:52:27 +00:00
|
|
|
asf->next_start_sec = start_sec;
|
2013-09-11 08:54:41 +00:00
|
|
|
|
|
|
|
return 0;
|
2012-04-04 05:52:27 +00:00
|
|
|
}
|
|
|
|
|
2004-05-29 02:06:32 +00:00
|
|
|
static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
|
2004-03-05 21:34:30 +00:00
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2013-09-19 15:50:37 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2004-03-05 21:34:30 +00:00
|
|
|
ASFStream *stream;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par;
|
2012-04-04 05:49:47 +00:00
|
|
|
uint32_t packet_number;
|
|
|
|
int64_t pts;
|
2012-04-04 05:52:27 +00:00
|
|
|
int start_sec;
|
2013-02-05 23:44:00 +00:00
|
|
|
int flags = pkt->flags;
|
2013-09-11 08:54:41 +00:00
|
|
|
int ret;
|
2013-09-19 15:50:37 +00:00
|
|
|
uint64_t offset = avio_tell(pb);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
par = s->streams[pkt->stream_index]->codecpar;
|
2004-05-29 02:06:32 +00:00
|
|
|
stream = &asf->streams[pkt->stream_index];
|
2004-03-05 21:34:30 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO)
|
2010-03-31 12:29:58 +00:00
|
|
|
flags &= ~AV_PKT_FLAG_KEY;
|
2007-02-12 19:24:53 +00:00
|
|
|
|
2005-03-23 13:30:27 +00:00
|
|
|
pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
|
2013-04-07 01:46:50 +00:00
|
|
|
av_assert0(pts != AV_NOPTS_VALUE);
|
2016-01-12 17:49:20 +00:00
|
|
|
if ( pts < - PREROLL_TIME
|
|
|
|
|| pts > (INT_MAX-3)/10000LL * ASF_INDEXED_INTERVAL - PREROLL_TIME) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "input pts %"PRId64" is invalid\n", pts);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2012-04-04 05:49:47 +00:00
|
|
|
pts *= 10000;
|
2013-02-06 13:10:26 +00:00
|
|
|
asf->duration = FFMAX(asf->duration, pts + pkt->duration * 10000);
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2012-04-04 05:49:47 +00:00
|
|
|
packet_number = asf->nb_packets;
|
2013-02-05 23:44:00 +00:00
|
|
|
put_frame(s, stream, s->streams[pkt->stream_index],
|
|
|
|
pkt->dts, pkt->data, pkt->size, flags);
|
2005-03-23 13:30:27 +00:00
|
|
|
|
2012-04-04 05:52:27 +00:00
|
|
|
start_sec = (int)((PREROLL_TIME * 10000 + pts + ASF_INDEXED_INTERVAL - 1)
|
|
|
|
/ ASF_INDEXED_INTERVAL);
|
|
|
|
|
2005-03-23 13:30:27 +00:00
|
|
|
/* check index */
|
2010-03-31 12:29:58 +00:00
|
|
|
if ((!asf->is_streamed) && (flags & AV_PKT_FLAG_KEY)) {
|
2012-04-04 05:50:05 +00:00
|
|
|
uint16_t packet_count = asf->nb_packets - packet_number;
|
2013-09-20 09:43:32 +00:00
|
|
|
ret = update_index(s, start_sec, packet_number, packet_count, offset);
|
|
|
|
if (ret < 0)
|
2013-09-11 08:54:41 +00:00
|
|
|
return ret;
|
2005-03-23 13:30:27 +00:00
|
|
|
}
|
2012-04-04 05:52:27 +00:00
|
|
|
asf->end_sec = start_sec;
|
|
|
|
|
2005-03-23 13:30:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-22 16:53:44 +00:00
|
|
|
static int asf_write_index(AVFormatContext *s, const ASFIndex *index,
|
2013-02-05 23:44:00 +00:00
|
|
|
uint16_t max, uint32_t count)
|
2005-03-23 13:30:27 +00:00
|
|
|
{
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2005-03-23 13:30:27 +00:00
|
|
|
int i;
|
|
|
|
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_simple_index_header);
|
2013-02-05 23:44:00 +00:00
|
|
|
avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2) * count);
|
2011-11-05 05:09:34 +00:00
|
|
|
ff_put_guid(pb, &ff_asf_my_guid);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl64(pb, ASF_INDEXED_INTERVAL);
|
|
|
|
avio_wl32(pb, max);
|
|
|
|
avio_wl32(pb, count);
|
2013-02-05 23:44:00 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, index[i].packet_number);
|
|
|
|
avio_wl16(pb, index[i].packet_count);
|
2005-03-23 13:30:27 +00:00
|
|
|
}
|
|
|
|
|
2004-03-05 21:34:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asf_write_trailer(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
ASFContext *asf = s->priv_data;
|
2013-02-05 23:44:00 +00:00
|
|
|
int64_t file_size, data_size;
|
2013-09-11 08:54:41 +00:00
|
|
|
int ret;
|
2004-03-05 21:34:30 +00:00
|
|
|
|
|
|
|
/* flush the current packet */
|
|
|
|
if (asf->pb.buf_ptr > asf->pb.buffer)
|
|
|
|
flush_packet(s);
|
|
|
|
|
2005-03-23 13:30:27 +00:00
|
|
|
/* write index */
|
2011-03-03 19:11:45 +00:00
|
|
|
data_size = avio_tell(s->pb);
|
2012-04-04 05:52:27 +00:00
|
|
|
if (!asf->is_streamed && asf->next_start_sec) {
|
2013-09-20 09:43:32 +00:00
|
|
|
if ((ret = update_index(s, asf->end_sec + 1, 0, 0, 0)) < 0)
|
2013-09-11 08:54:41 +00:00
|
|
|
return ret;
|
2012-04-04 05:52:27 +00:00
|
|
|
asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->next_start_sec);
|
2005-03-23 13:30:27 +00:00
|
|
|
}
|
|
|
|
|
2016-09-27 14:26:37 +00:00
|
|
|
if (asf->is_streamed || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
|
2004-03-05 21:34:30 +00:00
|
|
|
put_chunk(s, 0x4524, 0, 0); /* end of stream */
|
|
|
|
} else {
|
|
|
|
/* rewrite an updated header */
|
2011-03-03 19:11:45 +00:00
|
|
|
file_size = avio_tell(s->pb);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(s->pb, 0, SEEK_SET);
|
2005-03-23 13:30:27 +00:00
|
|
|
asf_write_header1(s, file_size, data_size - asf->data_offset);
|
2004-03-05 21:34:30 +00:00
|
|
|
}
|
|
|
|
|
2013-09-11 11:18:17 +00:00
|
|
|
av_freep(&asf->index_ptr);
|
2004-03-05 21:34:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-04 00:30:31 +00:00
|
|
|
static const AVOption asf_options[] = {
|
|
|
|
{ "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 },
|
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
2009-01-13 23:44:16 +00:00
|
|
|
#if CONFIG_ASF_MUXER
|
2016-02-03 23:26:58 +00:00
|
|
|
static const AVClass asf_muxer_class = {
|
|
|
|
.class_name = "ASF muxer",
|
|
|
|
.item_name = av_default_item_name,
|
2016-02-04 00:30:31 +00:00
|
|
|
.option = asf_options,
|
2016-02-03 23:26:58 +00:00
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
};
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVOutputFormat ff_asf_muxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "asf",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.mime_type = "video/x-ms-asf",
|
|
|
|
.extensions = "asf,wmv,wma",
|
|
|
|
.priv_data_size = sizeof(ASFContext),
|
2012-08-07 20:45:46 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_WMAV2,
|
2012-08-05 09:11:04 +00:00
|
|
|
.video_codec = AV_CODEC_ID_MSMPEG4V3,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = asf_write_header,
|
|
|
|
.write_packet = asf_write_packet,
|
|
|
|
.write_trailer = asf_write_trailer,
|
2012-04-06 14:50:48 +00:00
|
|
|
.flags = AVFMT_GLOBALHEADER,
|
2021-02-18 00:24:24 +00:00
|
|
|
.codec_tag = asf_codec_tags,
|
2016-02-03 23:26:58 +00:00
|
|
|
.priv_class = &asf_muxer_class,
|
2004-03-05 21:34:30 +00:00
|
|
|
};
|
2013-02-05 23:44:00 +00:00
|
|
|
#endif /* CONFIG_ASF_MUXER */
|
2004-03-05 21:34:30 +00:00
|
|
|
|
2009-01-13 23:44:16 +00:00
|
|
|
#if CONFIG_ASF_STREAM_MUXER
|
2016-02-03 23:26:58 +00:00
|
|
|
static const AVClass asf_stream_muxer_class = {
|
|
|
|
.class_name = "ASF stream muxer",
|
|
|
|
.item_name = av_default_item_name,
|
2016-02-04 00:30:31 +00:00
|
|
|
.option = asf_options,
|
2016-02-03 23:26:58 +00:00
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
};
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVOutputFormat ff_asf_stream_muxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "asf_stream",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.mime_type = "video/x-ms-asf",
|
|
|
|
.extensions = "asf,wmv,wma",
|
|
|
|
.priv_data_size = sizeof(ASFContext),
|
2012-08-07 20:45:46 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_WMAV2,
|
2012-08-05 09:11:04 +00:00
|
|
|
.video_codec = AV_CODEC_ID_MSMPEG4V3,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = asf_write_stream_header,
|
|
|
|
.write_packet = asf_write_packet,
|
|
|
|
.write_trailer = asf_write_trailer,
|
2012-04-06 14:50:48 +00:00
|
|
|
.flags = AVFMT_GLOBALHEADER,
|
2021-02-18 00:24:24 +00:00
|
|
|
.codec_tag = asf_codec_tags,
|
2016-02-03 23:26:58 +00:00
|
|
|
.priv_class = &asf_stream_muxer_class,
|
2004-03-05 21:34:30 +00:00
|
|
|
};
|
2013-02-05 23:44:00 +00:00
|
|
|
#endif /* CONFIG_ASF_STREAM_MUXER */
|