/* * Adaptive stream format encoder * Copyright (c) 2000, 2001 Fabrice Bellard. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * 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 * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */#include "avformat.h"#include "avi.h"#include "asf.h"#undef NDEBUG#include <assert.h>#ifdef CONFIG_ENCODERS#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2#define ASF_PACKET_ERROR_CORRECTION_FLAGS (\                                        ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \                                        ASF_PACKET_ERROR_CORRECTION_DATA_SIZE\                                        )#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#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 \                        )#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#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*/ \                        )// Replicated Data shall be at least 8 bytes long.#define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08#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 \                        )#define SINGLE_PAYLOAD_DATA_LENGTH (\                        PACKET_SIZE - \                        PACKET_HEADER_MIN_SIZE - \                        PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \                        )#define MULTI_PAYLOAD_CONSTANT (\                        PACKET_SIZE - \                        PACKET_HEADER_MIN_SIZE - \                        1 - /*Payload Flags*/ \                        2*PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \                        )static int preroll_time = 2000;static void put_guid(ByteIOContext *s, const GUID *g){    int i;    put_le32(s, g->v1);    put_le16(s, g->v2);    put_le16(s, g->v3);    for(i=0;i<8;i++)        put_byte(s, g->v4[i]);}static void put_str16(ByteIOContext *s, const char *tag){    int c;    put_le16(s,strlen(tag) + 1);    for(;;) {        c = (uint8_t)*tag++;        put_le16(s, c);        if (c == '\0')            break;    }}static void put_str16_nolen(ByteIOContext *s, const char *tag){    int c;    for(;;) {        c = (uint8_t)*tag++;        put_le16(s, c);        if (c == '\0')            break;    }}static int64_t put_header(ByteIOContext *pb, const GUID *g){    int64_t pos;    pos = url_ftell(pb);    put_guid(pb, g);    put_le64(pb, 24);    return pos;}/* update header size */static void end_header(ByteIOContext *pb, int64_t pos){    int64_t pos1;    pos1 = url_ftell(pb);    url_fseek(pb, pos + 16, SEEK_SET);    put_le64(pb, pos1 - pos);    url_fseek(pb, pos1, SEEK_SET);}/* write an asf chunk (only used in streaming case) */static void put_chunk(AVFormatContext *s, int type, int payload_length, int flags){    ASFContext *asf = s->priv_data;    ByteIOContext *pb = &s->pb;    int length;    length = payload_length + 8;    put_le16(pb, type);    put_le16(pb, length);    //size    put_le32(pb, asf->seqno);//sequence number    put_le16(pb, flags); /* unknown bytes */    put_le16(pb, length);    //size_confirm    asf->seqno++;}/* convert from unix to windows time */static int64_t unix_to_file_time(int ti){    int64_t t;    t = ti * int64_t_C(10000000);    t += int64_t_C(116444736000000000);    return t;}/* write the header (used two times if non streamed) */static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size){    ASFContext *asf = s->priv_data;    ByteIOContext *pb = &s->pb;    int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;    int has_title;    AVCodecContext *enc;    int64_t header_offset, cur_pos, hpos;    int bit_rate;    has_title = (s->title[0] || s->author[0] || s->copyright[0] || s->comment[0]);    bit_rate = 0;    for(n=0;n<s->nb_streams;n++) {        enc = &s->streams[n]->codec;        bit_rate += enc->bit_rate;    }    if (asf->is_streamed) {        put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */    }    put_guid(pb, &asf_header);    put_le64(pb, -1); /* header length, will be patched after */    put_le32(pb, 3 + has_title + s->nb_streams); /* number of chunks in header */    put_byte(pb, 1); /* ??? */    put_byte(pb, 2); /* ??? */    /* file header */    header_offset = url_ftell(pb);    hpos = put_header(pb, &file_header);    put_guid(pb, &my_guid);    put_le64(pb, file_size);    file_time = 0;    put_le64(pb, unix_to_file_time(file_time));    put_le64(pb, asf->nb_packets); /* number of packets */    put_le64(pb, asf->duration); /* end time stamp (in 100ns units) */    put_le64(pb, asf->duration); /* duration (in 100ns units) */    put_le32(pb, 0); /* start time stamp */    put_le32(pb, 0); /* ??? */    put_le32(pb, asf->is_streamed ? 1 : 0); /* ??? */    put_le32(pb, asf->packet_size); /* packet size */    put_le32(pb, asf->packet_size); /* packet size */    put_le32(pb, bit_rate); /* Nominal data rate in bps */    end_header(pb, hpos);    /* unknown headers */    hpos = put_header(pb, &head1_guid);    put_guid(pb, &head2_guid);    put_le32(pb, 6);    put_le16(pb, 0);    end_header(pb, hpos);    /* title and other infos */    if (has_title) {        hpos = put_header(pb, &comment_header);        put_le16(pb, 2 * (strlen(s->title) + 1));        put_le16(pb, 2 * (strlen(s->author) + 1));        put_le16(pb, 2 * (strlen(s->copyright) + 1));        put_le16(pb, 2 * (strlen(s->comment) + 1));        put_le16(pb, 0);        put_str16_nolen(pb, s->title);        put_str16_nolen(pb, s->author);        put_str16_nolen(pb, s->copyright);        put_str16_nolen(pb, s->comment);        end_header(pb, hpos);    }    /* stream headers */    for(n=0;n<s->nb_streams;n++) {        int64_t es_pos;        //        ASFStream *stream = &asf->streams[n];        enc = &s->streams[n]->codec;        asf->streams[n].num = n + 1;        asf->streams[n].seq = 0;        switch(enc->codec_type) {        case CODEC_TYPE_AUDIO:            wav_extra_size = 0;            extra_size = 18 + wav_extra_size;            extra_size2 = 0;            break;        default:        case CODEC_TYPE_VIDEO:            wav_extra_size = 0;            extra_size = 0x33;            extra_size2 = 0;            break;        }        hpos = put_header(pb, &stream_header);        if (enc->codec_type == CODEC_TYPE_AUDIO) {            put_guid(pb, &audio_stream);            put_guid(pb, &audio_conceal_none);        } else {            put_guid(pb, &video_stream);            put_guid(pb, &video_conceal_none);        }        put_le64(pb, 0); /* ??? */        es_pos = url_ftell(pb);        put_le32(pb, extra_size); /* wav header len */        put_le32(pb, extra_size2); /* additional data len */        put_le16(pb, n + 1); /* stream number */        put_le32(pb, 0); /* ??? */        if (enc->codec_type == CODEC_TYPE_AUDIO) {            /* WAVEFORMATEX header */            int wavsize = put_wav_header(pb, enc);            if (wavsize < 0)                return -1;            if (wavsize != extra_size) {