[deb_ffmpeg.git] / ffmpeg / libavformat / riffenc.c

/*
 * RIFF muxing functions
 * Copyright (c) 2000 Fabrice Bellard
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/dict.h"
#include "libavutil/log.h"
#include "libavutil/mathematics.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/bytestream.h"
#include "avformat.h"
#include "avio_internal.h"
#include "riff.h"

int64_t ff_start_tag(AVIOContext *pb, const char *tag)
{
    ffio_wfourcc(pb, tag);
    avio_wl32(pb, -1);
    return avio_tell(pb);
}

void ff_end_tag(AVIOContext *pb, int64_t start)
{
    int64_t pos;

    av_assert0((start&1) == 0);

    pos = avio_tell(pb);
    if (pos & 1)
        avio_w8(pb, 0);
    avio_seek(pb, start - 4, SEEK_SET);
    avio_wl32(pb, (uint32_t)(pos - start));
    avio_seek(pb, FFALIGN(pos, 2), SEEK_SET);
}

/* WAVEFORMATEX header */
/* returns the size or -1 on error */
int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc, int flags)
{
    int bps, blkalign, bytespersec, frame_size;
    int hdrsize;
    int64_t hdrstart = avio_tell(pb);
    int waveformatextensible;
    uint8_t temp[256];
    uint8_t *riff_extradata       = temp;
    uint8_t *riff_extradata_start = temp;

    if (!enc->codec_tag || enc->codec_tag > 0xffff)
        return -1;

    /* We use the known constant frame size for the codec if known, otherwise
     * fall back on using AVCodecContext.frame_size, which is not as reliable
     * for indicating packet duration. */
    frame_size = av_get_audio_frame_duration(enc, enc->block_align);
    if (!frame_size)
        frame_size = enc->frame_size;

    waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
                           enc->sample_rate > 48000 ||
                           enc->codec_id == AV_CODEC_ID_EAC3 ||
                           av_get_bits_per_sample(enc->codec_id) > 16;

    if (waveformatextensible)
        avio_wl16(pb, 0xfffe);
    else
        avio_wl16(pb, enc->codec_tag);

    avio_wl16(pb, enc->channels);
    avio_wl32(pb, enc->sample_rate);
    if (enc->codec_id == AV_CODEC_ID_ATRAC3 ||
        enc->codec_id == AV_CODEC_ID_G723_1 ||
        enc->codec_id == AV_CODEC_ID_MP2    ||
        enc->codec_id == AV_CODEC_ID_MP3    ||
        enc->codec_id == AV_CODEC_ID_GSM_MS) {
        bps = 0;
    } else {
        if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
            if (enc->bits_per_coded_sample)
                bps = enc->bits_per_coded_sample;
            else
                bps = 16;  // default to 16
        }
    }
    if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
        av_log(enc, AV_LOG_WARNING,
               "requested bits_per_coded_sample (%d) "
               "and actually stored (%d) differ\n",
               enc->bits_per_coded_sample, bps);
    }

    if (enc->codec_id == AV_CODEC_ID_MP2 ||
        enc->codec_id == AV_CODEC_ID_MP3) {
        /* This is wrong, but it seems many demuxers do not work if this
         * is set correctly. */
        blkalign = frame_size;
        // blkalign = 144 * enc->bit_rate/enc->sample_rate;
    } else if (enc->codec_id == AV_CODEC_ID_AC3) {
        blkalign = 3840;                /* maximum bytes per frame */
    } else if (enc->codec_id == AV_CODEC_ID_AAC) {
        blkalign = 768 * enc->channels; /* maximum bytes per frame */
    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
        blkalign = 24;
    } else if (enc->block_align != 0) { /* specified by the codec */
        blkalign = enc->block_align;
    } else
        blkalign = bps * enc->channels / av_gcd(8, bps);
    if (enc->codec_id == AV_CODEC_ID_PCM_U8 ||
        enc->codec_id == AV_CODEC_ID_PCM_S24LE ||
        enc->codec_id == AV_CODEC_ID_PCM_S32LE ||
        enc->codec_id == AV_CODEC_ID_PCM_F32LE ||
        enc->codec_id == AV_CODEC_ID_PCM_F64LE ||
        enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
        bytespersec = enc->sample_rate * blkalign;
    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
        bytespersec = 800;
    } else {
        bytespersec = enc->bit_rate / 8;
    }
    avio_wl32(pb, bytespersec); /* bytes per second */
    avio_wl16(pb, blkalign);    /* block align */
    avio_wl16(pb, bps);         /* bits per sample */
    if (enc->codec_id == AV_CODEC_ID_MP3) {
        bytestream_put_le16(&riff_extradata, 1);    /* wID */
        bytestream_put_le32(&riff_extradata, 2);    /* fdwFlags */
        bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
        bytestream_put_le16(&riff_extradata, 1);    /* nFramesPerBlock */
        bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
    } else if (enc->codec_id == AV_CODEC_ID_MP2) {
        /* fwHeadLayer */
        bytestream_put_le16(&riff_extradata, 2);
        /* dwHeadBitrate */
        bytestream_put_le32(&riff_extradata, enc->bit_rate);
        /* fwHeadMode */
        bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
        /* fwHeadModeExt */
        bytestream_put_le16(&riff_extradata, 0);
        /* wHeadEmphasis */
        bytestream_put_le16(&riff_extradata, 1);
        /* fwHeadFlags */
        bytestream_put_le16(&riff_extradata, 16);
        /* dwPTSLow */
        bytestream_put_le32(&riff_extradata, 0);
        /* dwPTSHigh */
        bytestream_put_le32(&riff_extradata, 0);
    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
        bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
        bytestream_put_le32(&riff_extradata, 0xaea2f732);
        bytestream_put_le16(&riff_extradata, 0xacde);
    } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
               enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
        /* wSamplesPerBlock */
        bytestream_put_le16(&riff_extradata, frame_size);
    } else if (enc->extradata_size) {
        riff_extradata_start = enc->extradata;
        riff_extradata       = enc->extradata + enc->extradata_size;
    }
    /* write WAVEFORMATEXTENSIBLE extensions */
    if (waveformatextensible) {
        int write_channel_mask = enc->strict_std_compliance < FF_COMPLIANCE_NORMAL ||
                                 enc->channel_layout < 0x40000;
        /* 22 is WAVEFORMATEXTENSIBLE size */
        avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
        /* ValidBitsPerSample || SamplesPerBlock || Reserved */
        avio_wl16(pb, bps);
        /* dwChannelMask */
        avio_wl32(pb, write_channel_mask ? enc->channel_layout : 0);
        /* GUID + next 3 */
        if (enc->codec_id == AV_CODEC_ID_EAC3) {
            ff_put_guid(pb, get_codec_guid(enc->codec_id, ff_codec_wav_guids));
        } else {
        avio_wl32(pb, enc->codec_tag);
        avio_wl32(pb, 0x00100000);
        avio_wl32(pb, 0xAA000080);
        avio_wl32(pb, 0x719B3800);
        }
    } else if ((flags & FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX) ||
               enc->codec_tag != 0x0001 /* PCM */ ||
               riff_extradata - riff_extradata_start) {
        /* WAVEFORMATEX */
        avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
    } /* else PCMWAVEFORMAT */
    avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
    hdrsize = avio_tell(pb) - hdrstart;
    if (hdrsize & 1) {
        hdrsize++;
        avio_w8(pb, 0);
    }

    return hdrsize;
}

/* BITMAPINFOHEADER header */
void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc,
                       const AVCodecTag *tags, int for_asf, int ignore_extradata)
{
    int keep_height = enc->extradata_size >= 9 &&
                      !memcmp(enc->extradata + enc->extradata_size - 9, "BottomUp", 9);
    int extradata_size = enc->extradata_size - 9*keep_height;

    /* size */
    avio_wl32(pb, 40 + (ignore_extradata ? 0 :extradata_size));
    avio_wl32(pb, enc->width);
    //We always store RGB TopDown
    avio_wl32(pb, enc->codec_tag || keep_height ? enc->height : -enc->height);
    /* planes */
    avio_wl16(pb, 1);
    /* depth */
    avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
    /* compression type */
    avio_wl32(pb, enc->codec_tag);
    avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
    avio_wl32(pb, 0);
    avio_wl32(pb, 0);
    avio_wl32(pb, 0);
    avio_wl32(pb, 0);

    if (!ignore_extradata) {
        avio_write(pb, enc->extradata, extradata_size);

        if (!for_asf && extradata_size & 1)
            avio_w8(pb, 0);
    }
}

void ff_parse_specific_params(AVStream *st, int *au_rate,
                              int *au_ssize, int *au_scale)
{
    AVCodecContext *codec = st->codec;
    int gcd;
    int audio_frame_size;

    /* We use the known constant frame size for the codec if known, otherwise
     * fall back on using AVCodecContext.frame_size, which is not as reliable
     * for indicating packet duration. */
    audio_frame_size = av_get_audio_frame_duration(codec, 0);
    if (!audio_frame_size)
        audio_frame_size = codec->frame_size;

    *au_ssize = codec->block_align;
    if (audio_frame_size && codec->sample_rate) {
        *au_scale = audio_frame_size;
        *au_rate  = codec->sample_rate;
    } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
               codec->codec_type == AVMEDIA_TYPE_DATA ||
               codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
        *au_scale = st->time_base.num;
        *au_rate  = st->time_base.den;
    } else {
        *au_scale = codec->block_align ? codec->block_align * 8 : 8;
        *au_rate  = codec->bit_rate ? codec->bit_rate :
                    8 * codec->sample_rate;
    }
    gcd        = av_gcd(*au_scale, *au_rate);
    *au_scale /= gcd;
    *au_rate  /= gcd;
}

void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
{
    int len = strlen(str);
    if (len > 0) {
        len++;
        ffio_wfourcc(pb, tag);
        avio_wl32(pb, len);
        avio_put_str(pb, str);
        if (len & 1)
            avio_w8(pb, 0);
    }
}

static const char riff_tags[][5] = {
    "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
    "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
    "IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
    { 0 }
};

static int riff_has_valid_tags(AVFormatContext *s)
{
    int i;

    for (i = 0; *riff_tags[i]; i++)
        if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
            return 1;

    return 0;
}

void ff_riff_write_info(AVFormatContext *s)
{
    AVIOContext *pb = s->pb;
    int i;
    int64_t list_pos;
    AVDictionaryEntry *t = NULL;

    ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);

    /* writing empty LIST is not nice and may cause problems */
    if (!riff_has_valid_tags(s))
        return;

    list_pos = ff_start_tag(pb, "LIST");
    ffio_wfourcc(pb, "INFO");
    for (i = 0; *riff_tags[i]; i++)
        if ((t = av_dict_get(s->metadata, riff_tags[i],
                             NULL, AV_DICT_MATCH_CASE)))
            ff_riff_write_info_tag(s->pb, t->key, t->value);
    ff_end_tag(pb, list_pos);
}

void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
{
    av_assert0(sizeof(*g) == 16);
    avio_write(s, *g, sizeof(*g));
}

const ff_asf_guid *get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
{
    int i;
    for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
        if (id == av_guid[i].id)
            return &(av_guid[i].guid);
    }
    return NULL;
}
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* RIFF muxing functions
	3	* Copyright (c) 2000 Fabrice Bellard
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include "libavutil/dict.h"
	23	#include "libavutil/log.h"
	24	#include "libavutil/mathematics.h"
	25	#include "libavcodec/avcodec.h"
	26	#include "libavcodec/bytestream.h"
	27	#include "avformat.h"
	28	#include "avio_internal.h"
	29	#include "riff.h"
	30
	31	int64_t ff_start_tag(AVIOContext pb, const char tag)
	32	{
	33	ffio_wfourcc(pb, tag);
	34	avio_wl32(pb, -1);
	35	return avio_tell(pb);
	36	}
	37
	38	void ff_end_tag(AVIOContext *pb, int64_t start)
	39	{
	40	int64_t pos;
	41
	42	av_assert0((start&1) == 0);
	43
	44	pos = avio_tell(pb);
	45	if (pos & 1)
	46	avio_w8(pb, 0);
	47	avio_seek(pb, start - 4, SEEK_SET);
	48	avio_wl32(pb, (uint32_t)(pos - start));
	49	avio_seek(pb, FFALIGN(pos, 2), SEEK_SET);
	50	}
	51
	52	/* WAVEFORMATEX header */
	53	/* returns the size or -1 on error */
	54	int ff_put_wav_header(AVIOContext pb, AVCodecContext enc, int flags)
	55	{
	56	int bps, blkalign, bytespersec, frame_size;
	57	int hdrsize;
	58	int64_t hdrstart = avio_tell(pb);
	59	int waveformatextensible;
	60	uint8_t temp[256];
	61	uint8_t *riff_extradata = temp;
	62	uint8_t *riff_extradata_start = temp;
	63
	64	if (!enc->codec_tag \|\| enc->codec_tag > 0xffff)
65	return -1;
66
67	/* We use the known constant frame size for the codec if known, otherwise
68	* fall back on using AVCodecContext.frame_size, which is not as reliable
69	* for indicating packet duration. */
70	frame_size = av_get_audio_frame_duration(enc, enc->block_align);
71	if (!frame_size)
72	frame_size = enc->frame_size;
73
74	waveformatextensible = (enc->channels > 2 && enc->channel_layout) \|\|
75	enc->sample_rate > 48000 \|\|
76	enc->codec_id == AV_CODEC_ID_EAC3 \|\|
77	av_get_bits_per_sample(enc->codec_id) > 16;
78
79	if (waveformatextensible)
80	avio_wl16(pb, 0xfffe);
81	else
82	avio_wl16(pb, enc->codec_tag);
83
84	avio_wl16(pb, enc->channels);
85	avio_wl32(pb, enc->sample_rate);
86	if (enc->codec_id == AV_CODEC_ID_ATRAC3 \|\|
87	enc->codec_id == AV_CODEC_ID_G723_1 \|\|
88	enc->codec_id == AV_CODEC_ID_MP2 \|\|
89	enc->codec_id == AV_CODEC_ID_MP3 \|\|
90	enc->codec_id == AV_CODEC_ID_GSM_MS) {
91	bps = 0;
92	} else {
93	if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
94	if (enc->bits_per_coded_sample)
95	bps = enc->bits_per_coded_sample;
96	else
97	bps = 16; // default to 16
98	}
99	}
100	if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
101	av_log(enc, AV_LOG_WARNING,
102	"requested bits_per_coded_sample (%d) "
103	"and actually stored (%d) differ\n",
104	enc->bits_per_coded_sample, bps);
105	}
106
107	if (enc->codec_id == AV_CODEC_ID_MP2 \|\|
108	enc->codec_id == AV_CODEC_ID_MP3) {
109	/* This is wrong, but it seems many demuxers do not work if this
110	* is set correctly. */
111	blkalign = frame_size;
112	// blkalign = 144 * enc->bit_rate/enc->sample_rate;
113	} else if (enc->codec_id == AV_CODEC_ID_AC3) {
114	blkalign = 3840; /* maximum bytes per frame */
115	} else if (enc->codec_id == AV_CODEC_ID_AAC) {
116	blkalign = 768 * enc->channels; /* maximum bytes per frame */
117	} else if (enc->codec_id == AV_CODEC_ID_G723_1) {
118	blkalign = 24;
119	} else if (enc->block_align != 0) { /* specified by the codec */
120	blkalign = enc->block_align;
121	} else
122	blkalign = bps * enc->channels / av_gcd(8, bps);
123	if (enc->codec_id == AV_CODEC_ID_PCM_U8 \|\|
124	enc->codec_id == AV_CODEC_ID_PCM_S24LE \|\|
125	enc->codec_id == AV_CODEC_ID_PCM_S32LE \|\|
126	enc->codec_id == AV_CODEC_ID_PCM_F32LE \|\|
127	enc->codec_id == AV_CODEC_ID_PCM_F64LE \|\|
128	enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
129	bytespersec = enc->sample_rate * blkalign;
130	} else if (enc->codec_id == AV_CODEC_ID_G723_1) {
131	bytespersec = 800;
132	} else {
133	bytespersec = enc->bit_rate / 8;
134	}
135	avio_wl32(pb, bytespersec); /* bytes per second */
136	avio_wl16(pb, blkalign); /* block align */
137	avio_wl16(pb, bps); /* bits per sample */
138	if (enc->codec_id == AV_CODEC_ID_MP3) {
139	bytestream_put_le16(&riff_extradata, 1); /* wID */
140	bytestream_put_le32(&riff_extradata, 2); /* fdwFlags */
141	bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
142	bytestream_put_le16(&riff_extradata, 1); /* nFramesPerBlock */
143	bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
144	} else if (enc->codec_id == AV_CODEC_ID_MP2) {
145	/* fwHeadLayer */
146	bytestream_put_le16(&riff_extradata, 2);
147	/* dwHeadBitrate */
148	bytestream_put_le32(&riff_extradata, enc->bit_rate);
149	/* fwHeadMode */
150	bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
151	/* fwHeadModeExt */
152	bytestream_put_le16(&riff_extradata, 0);
153	/* wHeadEmphasis */
154	bytestream_put_le16(&riff_extradata, 1);
155	/* fwHeadFlags */
156	bytestream_put_le16(&riff_extradata, 16);
157	/* dwPTSLow */
158	bytestream_put_le32(&riff_extradata, 0);
159	/* dwPTSHigh */
160	bytestream_put_le32(&riff_extradata, 0);
161	} else if (enc->codec_id == AV_CODEC_ID_G723_1) {
162	bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
163	bytestream_put_le32(&riff_extradata, 0xaea2f732);
164	bytestream_put_le16(&riff_extradata, 0xacde);
165	} else if (enc->codec_id == AV_CODEC_ID_GSM_MS \|\|
166	enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
167	/* wSamplesPerBlock */
168	bytestream_put_le16(&riff_extradata, frame_size);
169	} else if (enc->extradata_size) {
170	riff_extradata_start = enc->extradata;
171	riff_extradata = enc->extradata + enc->extradata_size;
172	}
173	/* write WAVEFORMATEXTENSIBLE extensions */
174	if (waveformatextensible) {
175	int write_channel_mask = enc->strict_std_compliance < FF_COMPLIANCE_NORMAL \|\|
176	enc->channel_layout < 0x40000;
177	/* 22 is WAVEFORMATEXTENSIBLE size */
178	avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
179	/* ValidBitsPerSample \|\| SamplesPerBlock \|\| Reserved */
180	avio_wl16(pb, bps);
181	/* dwChannelMask */
182	avio_wl32(pb, write_channel_mask ? enc->channel_layout : 0);
183	/* GUID + next 3 */
184	if (enc->codec_id == AV_CODEC_ID_EAC3) {
185	ff_put_guid(pb, get_codec_guid(enc->codec_id, ff_codec_wav_guids));
186	} else {
187	avio_wl32(pb, enc->codec_tag);
188	avio_wl32(pb, 0x00100000);
189	avio_wl32(pb, 0xAA000080);
190	avio_wl32(pb, 0x719B3800);
191	}
192	} else if ((flags & FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX) \|\|
193	enc->codec_tag != 0x0001 /* PCM */ \|\|
194	riff_extradata - riff_extradata_start) {
195	/* WAVEFORMATEX */
196	avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
197	} /* else PCMWAVEFORMAT */
198	avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
199	hdrsize = avio_tell(pb) - hdrstart;
200	if (hdrsize & 1) {
201	hdrsize++;
202	avio_w8(pb, 0);
203	}
204
205	return hdrsize;
206	}
207
208	/* BITMAPINFOHEADER header */
209	void ff_put_bmp_header(AVIOContext pb, AVCodecContext enc,
210	const AVCodecTag *tags, int for_asf, int ignore_extradata)
211	{
212	int keep_height = enc->extradata_size >= 9 &&
213	!memcmp(enc->extradata + enc->extradata_size - 9, "BottomUp", 9);
214	int extradata_size = enc->extradata_size - 9*keep_height;
215
216	/* size */
217	avio_wl32(pb, 40 + (ignore_extradata ? 0 :extradata_size));
218	avio_wl32(pb, enc->width);
219	//We always store RGB TopDown
220	avio_wl32(pb, enc->codec_tag \|\| keep_height ? enc->height : -enc->height);
221	/* planes */
222	avio_wl16(pb, 1);
223	/* depth */
224	avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
225	/* compression type */
226	avio_wl32(pb, enc->codec_tag);
227	avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
228	avio_wl32(pb, 0);
229	avio_wl32(pb, 0);
230	avio_wl32(pb, 0);
231	avio_wl32(pb, 0);
232
233	if (!ignore_extradata) {
234	avio_write(pb, enc->extradata, extradata_size);
235
236	if (!for_asf && extradata_size & 1)
237	avio_w8(pb, 0);
238	}
239	}
240
241	void ff_parse_specific_params(AVStream st, int au_rate,
242	int au_ssize, int au_scale)
243	{
244	AVCodecContext *codec = st->codec;
245	int gcd;
246	int audio_frame_size;
247
248	/* We use the known constant frame size for the codec if known, otherwise
249	* fall back on using AVCodecContext.frame_size, which is not as reliable
250	* for indicating packet duration. */
251	audio_frame_size = av_get_audio_frame_duration(codec, 0);
252	if (!audio_frame_size)
253	audio_frame_size = codec->frame_size;
254
255	*au_ssize = codec->block_align;
256	if (audio_frame_size && codec->sample_rate) {
257	*au_scale = audio_frame_size;
258	*au_rate = codec->sample_rate;
259	} else if (codec->codec_type == AVMEDIA_TYPE_VIDEO \|\|
260	codec->codec_type == AVMEDIA_TYPE_DATA \|\|
261	codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
262	*au_scale = st->time_base.num;
263	*au_rate = st->time_base.den;
264	} else {
265	au_scale = codec->block_align ? codec->block_align 8 : 8;
266	*au_rate = codec->bit_rate ? codec->bit_rate :
267	8 * codec->sample_rate;
268	}
269	gcd = av_gcd(au_scale, au_rate);
270	*au_scale /= gcd;
271	*au_rate /= gcd;
272	}
273
274	void ff_riff_write_info_tag(AVIOContext pb, const char tag, const char *str)
275	{
276	int len = strlen(str);
277	if (len > 0) {
278	len++;
279	ffio_wfourcc(pb, tag);
280	avio_wl32(pb, len);
281	avio_put_str(pb, str);
282	if (len & 1)
283	avio_w8(pb, 0);
284	}
285	}
286
287	static const char riff_tags[][5] = {
288	"IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
289	"IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
290	"IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
291	{ 0 }
292	};
293
294	static int riff_has_valid_tags(AVFormatContext *s)
295	{
296	int i;
297
298	for (i = 0; *riff_tags[i]; i++)
299	if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
300	return 1;
301
302	return 0;
303	}
304
305	void ff_riff_write_info(AVFormatContext *s)
306	{
307	AVIOContext *pb = s->pb;
308	int i;
309	int64_t list_pos;
310	AVDictionaryEntry *t = NULL;
311
312	ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
313
314	/* writing empty LIST is not nice and may cause problems */
315	if (!riff_has_valid_tags(s))
316	return;
317
318	list_pos = ff_start_tag(pb, "LIST");
319	ffio_wfourcc(pb, "INFO");
320	for (i = 0; *riff_tags[i]; i++)
321	if ((t = av_dict_get(s->metadata, riff_tags[i],
322	NULL, AV_DICT_MATCH_CASE)))
323	ff_riff_write_info_tag(s->pb, t->key, t->value);
324	ff_end_tag(pb, list_pos);
325	}
326
327	void ff_put_guid(AVIOContext s, const ff_asf_guid g)
328	{
329	av_assert0(sizeof(*g) == 16);
330	avio_write(s, g, sizeof(g));
331	}
332
333	const ff_asf_guid get_codec_guid(enum AVCodecID id, const AVCodecGuid av_guid)
334	{
335	int i;
336	for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
337	if (id == av_guid[i].id)
338	return &(av_guid[i].guid);
339	}
340	return NULL;
341	}