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

/*
 * Raw TAK demuxer
 * Copyright (c) 2012 Paul B Mahol
 *
 * 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/crc.h"
#include "libavcodec/tak.h"
#include "avformat.h"
#include "avio_internal.h"
#include "internal.h"
#include "rawdec.h"
#include "apetag.h"

typedef struct TAKDemuxContext {
    int     mlast_frame;
    int64_t data_end;
} TAKDemuxContext;

static int tak_probe(AVProbeData *p)
{
    if (!memcmp(p->buf, "tBaK", 4))
        return AVPROBE_SCORE_EXTENSION;
    return 0;
}

static unsigned long tak_check_crc(unsigned long checksum, const uint8_t *buf,
                                   unsigned int len)
{
    return av_crc(av_crc_get_table(AV_CRC_24_IEEE), checksum, buf, len);
}

static int tak_read_header(AVFormatContext *s)
{
    TAKDemuxContext *tc = s->priv_data;
    AVIOContext *pb     = s->pb;
    GetBitContext gb;
    AVStream *st;
    uint8_t *buffer = NULL;
    int ret;

    st = avformat_new_stream(s, 0);
    if (!st)
        return AVERROR(ENOMEM);

    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
    st->codec->codec_id   = AV_CODEC_ID_TAK;
    st->need_parsing      = AVSTREAM_PARSE_FULL_RAW;

    tc->mlast_frame = 0;
    if (avio_rl32(pb) != MKTAG('t', 'B', 'a', 'K')) {
        avio_seek(pb, -4, SEEK_CUR);
        return 0;
    }

    while (!avio_feof(pb)) {
        enum TAKMetaDataType type;
        int size;

        type = avio_r8(pb) & 0x7f;
        size = avio_rl24(pb);

        switch (type) {
        case TAK_METADATA_STREAMINFO:
        case TAK_METADATA_LAST_FRAME:
        case TAK_METADATA_ENCODER:
            if (size <= 3)
                return AVERROR_INVALIDDATA;

            buffer = av_malloc(size - 3 + FF_INPUT_BUFFER_PADDING_SIZE);
            if (!buffer)
                return AVERROR(ENOMEM);
            memset(buffer + size - 3, 0, FF_INPUT_BUFFER_PADDING_SIZE);

            ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);
            if (avio_read(pb, buffer, size - 3) != size - 3) {
                av_freep(&buffer);
                return AVERROR(EIO);
            }
            if (ffio_get_checksum(s->pb) != avio_rb24(pb)) {
                av_log(s, AV_LOG_ERROR, "%d metadata block CRC error.\n", type);
                if (s->error_recognition & AV_EF_EXPLODE) {
                    av_freep(&buffer);
                    return AVERROR_INVALIDDATA;
                }
            }

            init_get_bits8(&gb, buffer, size - 3);
            break;
        case TAK_METADATA_MD5: {
            uint8_t md5[16];
            int i;

            if (size != 19)
                return AVERROR_INVALIDDATA;
            ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);
            avio_read(pb, md5, 16);
            if (ffio_get_checksum(s->pb) != avio_rb24(pb)) {
                av_log(s, AV_LOG_ERROR, "MD5 metadata block CRC error.\n");
                if (s->error_recognition & AV_EF_EXPLODE)
                    return AVERROR_INVALIDDATA;
            }

            av_log(s, AV_LOG_VERBOSE, "MD5=");
            for (i = 0; i < 16; i++)
                av_log(s, AV_LOG_VERBOSE, "%02x", md5[i]);
            av_log(s, AV_LOG_VERBOSE, "\n");
            break;
        }
        case TAK_METADATA_END: {
            int64_t curpos = avio_tell(pb);

            if (pb->seekable) {
                ff_ape_parse_tag(s);
                avio_seek(pb, curpos, SEEK_SET);
            }

            tc->data_end += curpos;
            return 0;
        }
        default:
            ret = avio_skip(pb, size);
            if (ret < 0)
                return ret;
        }

        if (type == TAK_METADATA_STREAMINFO) {
            TAKStreamInfo ti;

            avpriv_tak_parse_streaminfo(&gb, &ti);
            if (ti.samples > 0)
                st->duration = ti.samples;
            st->codec->bits_per_coded_sample = ti.bps;
            if (ti.ch_layout)
                st->codec->channel_layout = ti.ch_layout;
            st->codec->sample_rate           = ti.sample_rate;
            st->codec->channels              = ti.channels;
            st->start_time                   = 0;
            avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
            st->codec->extradata             = buffer;
            st->codec->extradata_size        = size - 3;
            buffer                           = NULL;
        } else if (type == TAK_METADATA_LAST_FRAME) {
            if (size != 11)
                return AVERROR_INVALIDDATA;
            tc->mlast_frame = 1;
            tc->data_end    = get_bits64(&gb, TAK_LAST_FRAME_POS_BITS) +
                              get_bits(&gb, TAK_LAST_FRAME_SIZE_BITS);
            av_freep(&buffer);
        } else if (type == TAK_METADATA_ENCODER) {
            av_log(s, AV_LOG_VERBOSE, "encoder version: %0X\n",
                   get_bits_long(&gb, TAK_ENCODER_VERSION_BITS));
            av_freep(&buffer);
        }
    }

    return AVERROR_EOF;
}

static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    TAKDemuxContext *tc = s->priv_data;
    int ret;

    if (tc->mlast_frame) {
        AVIOContext *pb = s->pb;
        int64_t size, left;

        left = tc->data_end - avio_tell(pb);
        size = FFMIN(left, 1024);
        if (size <= 0)
            return AVERROR_EOF;

        ret = av_get_packet(pb, pkt, size);
        if (ret < 0)
            return ret;

        pkt->stream_index = 0;
    } else {
        ret = ff_raw_read_partial_packet(s, pkt);
    }

    return ret;
}

AVInputFormat ff_tak_demuxer = {
    .name           = "tak",
    .long_name      = NULL_IF_CONFIG_SMALL("raw TAK"),
    .priv_data_size = sizeof(TAKDemuxContext),
    .read_probe     = tak_probe,
    .read_header    = tak_read_header,
    .read_packet    = raw_read_packet,
    .flags          = AVFMT_GENERIC_INDEX,
    .extensions     = "tak",
    .raw_codec_id   = AV_CODEC_ID_TAK,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Raw TAK demuxer
	3	* Copyright (c) 2012 Paul B Mahol
	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/crc.h"
	23	#include "libavcodec/tak.h"
	24	#include "avformat.h"
	25	#include "avio_internal.h"
	26	#include "internal.h"
	27	#include "rawdec.h"
	28	#include "apetag.h"
	29
	30	typedef struct TAKDemuxContext {
	31	int mlast_frame;
	32	int64_t data_end;
	33	} TAKDemuxContext;
	34
	35	static int tak_probe(AVProbeData *p)
	36	{
	37	if (!memcmp(p->buf, "tBaK", 4))
	38	return AVPROBE_SCORE_EXTENSION;
	39	return 0;
	40	}
	41
	42	static unsigned long tak_check_crc(unsigned long checksum, const uint8_t *buf,
	43	unsigned int len)
	44	{
	45	return av_crc(av_crc_get_table(AV_CRC_24_IEEE), checksum, buf, len);
	46	}
	47
	48	static int tak_read_header(AVFormatContext *s)
	49	{
	50	TAKDemuxContext *tc = s->priv_data;
	51	AVIOContext *pb = s->pb;
	52	GetBitContext gb;
	53	AVStream *st;
	54	uint8_t *buffer = NULL;
	55	int ret;
	56
	57	st = avformat_new_stream(s, 0);
	58	if (!st)
	59	return AVERROR(ENOMEM);
	60
	61	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
	62	st->codec->codec_id = AV_CODEC_ID_TAK;
	63	st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
	64
65	tc->mlast_frame = 0;
66	if (avio_rl32(pb) != MKTAG('t', 'B', 'a', 'K')) {
67	avio_seek(pb, -4, SEEK_CUR);
68	return 0;
69	}
70
71	while (!avio_feof(pb)) {
72	enum TAKMetaDataType type;
73	int size;
74
75	type = avio_r8(pb) & 0x7f;
76	size = avio_rl24(pb);
77
78	switch (type) {
79	case TAK_METADATA_STREAMINFO:
80	case TAK_METADATA_LAST_FRAME:
81	case TAK_METADATA_ENCODER:
82	if (size <= 3)
83	return AVERROR_INVALIDDATA;
84
85	buffer = av_malloc(size - 3 + FF_INPUT_BUFFER_PADDING_SIZE);
86	if (!buffer)
87	return AVERROR(ENOMEM);
88	memset(buffer + size - 3, 0, FF_INPUT_BUFFER_PADDING_SIZE);
89
90	ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);
91	if (avio_read(pb, buffer, size - 3) != size - 3) {
92	av_freep(&buffer);
93	return AVERROR(EIO);
94	}
95	if (ffio_get_checksum(s->pb) != avio_rb24(pb)) {
96	av_log(s, AV_LOG_ERROR, "%d metadata block CRC error.\n", type);
97	if (s->error_recognition & AV_EF_EXPLODE) {
98	av_freep(&buffer);
99	return AVERROR_INVALIDDATA;
100	}
101	}
102
103	init_get_bits8(&gb, buffer, size - 3);
104	break;
105	case TAK_METADATA_MD5: {
106	uint8_t md5[16];
107	int i;
108
109	if (size != 19)
110	return AVERROR_INVALIDDATA;
111	ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);
112	avio_read(pb, md5, 16);
113	if (ffio_get_checksum(s->pb) != avio_rb24(pb)) {
114	av_log(s, AV_LOG_ERROR, "MD5 metadata block CRC error.\n");
115	if (s->error_recognition & AV_EF_EXPLODE)
116	return AVERROR_INVALIDDATA;
117	}
118
119	av_log(s, AV_LOG_VERBOSE, "MD5=");
120	for (i = 0; i < 16; i++)
121	av_log(s, AV_LOG_VERBOSE, "%02x", md5[i]);
122	av_log(s, AV_LOG_VERBOSE, "\n");
123	break;
124	}
125	case TAK_METADATA_END: {
126	int64_t curpos = avio_tell(pb);
127
128	if (pb->seekable) {
129	ff_ape_parse_tag(s);
130	avio_seek(pb, curpos, SEEK_SET);
131	}
132
133	tc->data_end += curpos;
134	return 0;
135	}
136	default:
137	ret = avio_skip(pb, size);
138	if (ret < 0)
139	return ret;
140	}
141
142	if (type == TAK_METADATA_STREAMINFO) {
143	TAKStreamInfo ti;
144
145	avpriv_tak_parse_streaminfo(&gb, &ti);
146	if (ti.samples > 0)
147	st->duration = ti.samples;
148	st->codec->bits_per_coded_sample = ti.bps;
149	if (ti.ch_layout)
150	st->codec->channel_layout = ti.ch_layout;
151	st->codec->sample_rate = ti.sample_rate;
152	st->codec->channels = ti.channels;
153	st->start_time = 0;
154	avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
155	st->codec->extradata = buffer;
156	st->codec->extradata_size = size - 3;
157	buffer = NULL;
158	} else if (type == TAK_METADATA_LAST_FRAME) {
159	if (size != 11)
160	return AVERROR_INVALIDDATA;
161	tc->mlast_frame = 1;
162	tc->data_end = get_bits64(&gb, TAK_LAST_FRAME_POS_BITS) +
163	get_bits(&gb, TAK_LAST_FRAME_SIZE_BITS);
164	av_freep(&buffer);
165	} else if (type == TAK_METADATA_ENCODER) {
166	av_log(s, AV_LOG_VERBOSE, "encoder version: %0X\n",
167	get_bits_long(&gb, TAK_ENCODER_VERSION_BITS));
168	av_freep(&buffer);
169	}
170	}
171
172	return AVERROR_EOF;
173	}
174
175	static int raw_read_packet(AVFormatContext s, AVPacket pkt)
176	{
177	TAKDemuxContext *tc = s->priv_data;
178	int ret;
179
180	if (tc->mlast_frame) {
181	AVIOContext *pb = s->pb;
182	int64_t size, left;
183
184	left = tc->data_end - avio_tell(pb);
185	size = FFMIN(left, 1024);
186	if (size <= 0)
187	return AVERROR_EOF;
188
189	ret = av_get_packet(pb, pkt, size);
190	if (ret < 0)
191	return ret;
192
193	pkt->stream_index = 0;
194	} else {
195	ret = ff_raw_read_partial_packet(s, pkt);
196	}
197
198	return ret;
199	}
200
201	AVInputFormat ff_tak_demuxer = {
202	.name = "tak",
203	.long_name = NULL_IF_CONFIG_SMALL("raw TAK"),
204	.priv_data_size = sizeof(TAKDemuxContext),
205	.read_probe = tak_probe,
206	.read_header = tak_read_header,
207	.read_packet = raw_read_packet,
208	.flags = AVFMT_GENERIC_INDEX,
209	.extensions = "tak",
210	.raw_codec_id = AV_CODEC_ID_TAK,
211	};