[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);

    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) {
        blkalign = frame_size;
    } else if (enc->codec_id == AV_CODEC_ID_MP3) {
        blkalign = 576 * (enc->sample_rate <= (24000 + 32000)/2 ? 1 : 2);
    } 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);
2ba45a60 DM	71
	72	waveformatextensible = (enc->channels > 2 && enc->channel_layout) \|\|
	73	enc->sample_rate > 48000 \|\|
	74	enc->codec_id == AV_CODEC_ID_EAC3 \|\|
	75	av_get_bits_per_sample(enc->codec_id) > 16;
	76
	77	if (waveformatextensible)
	78	avio_wl16(pb, 0xfffe);
	79	else
	80	avio_wl16(pb, enc->codec_tag);
	81
	82	avio_wl16(pb, enc->channels);
	83	avio_wl32(pb, enc->sample_rate);
	84	if (enc->codec_id == AV_CODEC_ID_ATRAC3 \|\|
	85	enc->codec_id == AV_CODEC_ID_G723_1 \|\|
	86	enc->codec_id == AV_CODEC_ID_MP2 \|\|
	87	enc->codec_id == AV_CODEC_ID_MP3 \|\|
	88	enc->codec_id == AV_CODEC_ID_GSM_MS) {
	89	bps = 0;
	90	} else {
	91	if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
	92	if (enc->bits_per_coded_sample)
	93	bps = enc->bits_per_coded_sample;
	94	else
	95	bps = 16; // default to 16
	96	}
	97	}
	98	if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
	99	av_log(enc, AV_LOG_WARNING,
	100	"requested bits_per_coded_sample (%d) "
	101	"and actually stored (%d) differ\n",
	102	enc->bits_per_coded_sample, bps);
	103	}
	104
f6fa7814	105	if (enc->codec_id == AV_CODEC_ID_MP2) {
2ba45a60	106	blkalign = frame_size;
f6fa7814 DM	107	} else if (enc->codec_id == AV_CODEC_ID_MP3) {
f6fa7814 DM	108	blkalign = 576 * (enc->sample_rate <= (24000 + 32000)/2 ? 1 : 2);
2ba45a60 DM	109	} else if (enc->codec_id == AV_CODEC_ID_AC3) {
	110	blkalign = 3840; /* maximum bytes per frame */
	111	} else if (enc->codec_id == AV_CODEC_ID_AAC) {
	112	blkalign = 768 * enc->channels; /* maximum bytes per frame */
	113	} else if (enc->codec_id == AV_CODEC_ID_G723_1) {
	114	blkalign = 24;
	115	} else if (enc->block_align != 0) { /* specified by the codec */
	116	blkalign = enc->block_align;
	117	} else
	118	blkalign = bps * enc->channels / av_gcd(8, bps);
	119	if (enc->codec_id == AV_CODEC_ID_PCM_U8 \|\|
	120	enc->codec_id == AV_CODEC_ID_PCM_S24LE \|\|
	121	enc->codec_id == AV_CODEC_ID_PCM_S32LE \|\|
	122	enc->codec_id == AV_CODEC_ID_PCM_F32LE \|\|
	123	enc->codec_id == AV_CODEC_ID_PCM_F64LE \|\|
	124	enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
	125	bytespersec = enc->sample_rate * blkalign;
	126	} else if (enc->codec_id == AV_CODEC_ID_G723_1) {
	127	bytespersec = 800;
	128	} else {
	129	bytespersec = enc->bit_rate / 8;
	130	}
	131	avio_wl32(pb, bytespersec); /* bytes per second */
	132	avio_wl16(pb, blkalign); /* block align */
	133	avio_wl16(pb, bps); /* bits per sample */
	134	if (enc->codec_id == AV_CODEC_ID_MP3) {
	135	bytestream_put_le16(&riff_extradata, 1); /* wID */
	136	bytestream_put_le32(&riff_extradata, 2); /* fdwFlags */
	137	bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
	138	bytestream_put_le16(&riff_extradata, 1); /* nFramesPerBlock */
	139	bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
	140	} else if (enc->codec_id == AV_CODEC_ID_MP2) {
	141	/* fwHeadLayer */
	142	bytestream_put_le16(&riff_extradata, 2);
	143	/* dwHeadBitrate */
	144	bytestream_put_le32(&riff_extradata, enc->bit_rate);
	145	/* fwHeadMode */
	146	bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
	147	/* fwHeadModeExt */
	148	bytestream_put_le16(&riff_extradata, 0);
	149	/* wHeadEmphasis */
	150	bytestream_put_le16(&riff_extradata, 1);
	151	/* fwHeadFlags */
	152	bytestream_put_le16(&riff_extradata, 16);
	153	/* dwPTSLow */
	154	bytestream_put_le32(&riff_extradata, 0);
	155	/* dwPTSHigh */
	156	bytestream_put_le32(&riff_extradata, 0);
	157	} else if (enc->codec_id == AV_CODEC_ID_G723_1) {
	158	bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
	159	bytestream_put_le32(&riff_extradata, 0xaea2f732);
	160	bytestream_put_le16(&riff_extradata, 0xacde);
	161	} else if (enc->codec_id == AV_CODEC_ID_GSM_MS \|\|
	162	enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
	163	/* wSamplesPerBlock */
	164	bytestream_put_le16(&riff_extradata, frame_size);
	165	} else if (enc->extradata_size) {
	166	riff_extradata_start = enc->extradata;
	167	riff_extradata = enc->extradata + enc->extradata_size;
	168	}
	169	/* write WAVEFORMATEXTENSIBLE extensions */
	170	if (waveformatextensible) {
	171	int write_channel_mask = enc->strict_std_compliance < FF_COMPLIANCE_NORMAL \|\|
	172	enc->channel_layout < 0x40000;
173	/* 22 is WAVEFORMATEXTENSIBLE size */
174	avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
175	/* ValidBitsPerSample \|\| SamplesPerBlock \|\| Reserved */
176	avio_wl16(pb, bps);
177	/* dwChannelMask */
178	avio_wl32(pb, write_channel_mask ? enc->channel_layout : 0);
179	/* GUID + next 3 */
180	if (enc->codec_id == AV_CODEC_ID_EAC3) {
181	ff_put_guid(pb, get_codec_guid(enc->codec_id, ff_codec_wav_guids));
182	} else {
183	avio_wl32(pb, enc->codec_tag);
184	avio_wl32(pb, 0x00100000);
185	avio_wl32(pb, 0xAA000080);
186	avio_wl32(pb, 0x719B3800);
187	}
188	} else if ((flags & FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX) \|\|
189	enc->codec_tag != 0x0001 /* PCM */ \|\|
190	riff_extradata - riff_extradata_start) {
191	/* WAVEFORMATEX */
192	avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
193	} /* else PCMWAVEFORMAT */
194	avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
195	hdrsize = avio_tell(pb) - hdrstart;
196	if (hdrsize & 1) {
197	hdrsize++;
198	avio_w8(pb, 0);
199	}
200
201	return hdrsize;
202	}
203
204	/* BITMAPINFOHEADER header */
205	void ff_put_bmp_header(AVIOContext pb, AVCodecContext enc,
206	const AVCodecTag *tags, int for_asf, int ignore_extradata)
207	{
208	int keep_height = enc->extradata_size >= 9 &&
209	!memcmp(enc->extradata + enc->extradata_size - 9, "BottomUp", 9);
210	int extradata_size = enc->extradata_size - 9*keep_height;
211
212	/* size */
213	avio_wl32(pb, 40 + (ignore_extradata ? 0 :extradata_size));
214	avio_wl32(pb, enc->width);
215	//We always store RGB TopDown
216	avio_wl32(pb, enc->codec_tag \|\| keep_height ? enc->height : -enc->height);
217	/* planes */
218	avio_wl16(pb, 1);
219	/* depth */
220	avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
221	/* compression type */
222	avio_wl32(pb, enc->codec_tag);
223	avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
224	avio_wl32(pb, 0);
225	avio_wl32(pb, 0);
226	avio_wl32(pb, 0);
227	avio_wl32(pb, 0);
228
229	if (!ignore_extradata) {
230	avio_write(pb, enc->extradata, extradata_size);
231
232	if (!for_asf && extradata_size & 1)
233	avio_w8(pb, 0);
234	}
235	}
236
237	void ff_parse_specific_params(AVStream st, int au_rate,
238	int au_ssize, int au_scale)
239	{
240	AVCodecContext *codec = st->codec;
241	int gcd;
242	int audio_frame_size;
243
244	/* We use the known constant frame size for the codec if known, otherwise
245	* fall back on using AVCodecContext.frame_size, which is not as reliable
246	* for indicating packet duration. */
247	audio_frame_size = av_get_audio_frame_duration(codec, 0);
248	if (!audio_frame_size)
249	audio_frame_size = codec->frame_size;
250
251	*au_ssize = codec->block_align;
252	if (audio_frame_size && codec->sample_rate) {
253	*au_scale = audio_frame_size;
254	*au_rate = codec->sample_rate;
255	} else if (codec->codec_type == AVMEDIA_TYPE_VIDEO \|\|
256	codec->codec_type == AVMEDIA_TYPE_DATA \|\|
257	codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
258	*au_scale = st->time_base.num;
259	*au_rate = st->time_base.den;
260	} else {
261	au_scale = codec->block_align ? codec->block_align 8 : 8;
262	*au_rate = codec->bit_rate ? codec->bit_rate :
263	8 * codec->sample_rate;
264	}
265	gcd = av_gcd(au_scale, au_rate);
266	*au_scale /= gcd;
267	*au_rate /= gcd;
268	}
269
270	void ff_riff_write_info_tag(AVIOContext pb, const char tag, const char *str)
271	{
272	int len = strlen(str);
273	if (len > 0) {
274	len++;
275	ffio_wfourcc(pb, tag);
276	avio_wl32(pb, len);
277	avio_put_str(pb, str);
278	if (len & 1)
279	avio_w8(pb, 0);
280	}
281	}
282
283	static const char riff_tags[][5] = {
284	"IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
285	"IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
286	"IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
287	{ 0 }
288	};
289
290	static int riff_has_valid_tags(AVFormatContext *s)
291	{
292	int i;
293
294	for (i = 0; *riff_tags[i]; i++)
295	if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
296	return 1;
297
298	return 0;
299	}
300
301	void ff_riff_write_info(AVFormatContext *s)
302	{
303	AVIOContext *pb = s->pb;
304	int i;
305	int64_t list_pos;
306	AVDictionaryEntry *t = NULL;
307
308	ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
309
310	/* writing empty LIST is not nice and may cause problems */
311	if (!riff_has_valid_tags(s))
312	return;
313
314	list_pos = ff_start_tag(pb, "LIST");
315	ffio_wfourcc(pb, "INFO");
316	for (i = 0; *riff_tags[i]; i++)
317	if ((t = av_dict_get(s->metadata, riff_tags[i],
318	NULL, AV_DICT_MATCH_CASE)))
319	ff_riff_write_info_tag(s->pb, t->key, t->value);
320	ff_end_tag(pb, list_pos);
321	}
322
323	void ff_put_guid(AVIOContext s, const ff_asf_guid g)
324	{
325	av_assert0(sizeof(*g) == 16);
326	avio_write(s, g, sizeof(g));
327	}
328
329	const ff_asf_guid get_codec_guid(enum AVCodecID id, const AVCodecGuid av_guid)
330	{
331	int i;
332	for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
333	if (id == av_guid[i].id)
334	return &(av_guid[i].guid);
335	}
336	return NULL;
337	}