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

/*
 * QDesign Music 2 (QDM2) payload for RTP
 * Copyright (c) 2010 Ronald S. Bultje
 *
 * 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
 */

/**
 * @file
 * @brief RTP support for the QDM2 payload (todo: wiki)
 * @author Ronald S. Bultje <rbultje@ronald.bitfreak.net>
 */

#include <string.h>
#include "libavutil/avassert.h"
#include "libavutil/intreadwrite.h"
#include "libavcodec/avcodec.h"
#include "internal.h"
#include "rtp.h"
#include "rtpdec.h"
#include "rtpdec_formats.h"

struct PayloadContext {
    /** values read from the config header, used as packet headers */
    //@{
    int block_type;            ///< superblock type, value 2 .. 8
    int block_size;            ///< from extradata, used as pkt length
    int subpkts_per_block;     ///< max. nr. of subpackets to add per output buffer
    //@}

    /** Temporary storage for superblock restoring, per packet ID (0x80 total) */
    //@{
    uint16_t len[0x80];        ///< how much the temporary buffer is filled
    uint8_t  buf[0x80][0x800]; ///< the temporary storage buffer

    unsigned int cache;        ///< number of data packets that we have cached right now
    unsigned int n_pkts;       ///< number of RTP packets received since last packet output / config
    uint32_t timestamp;        ///< timestamp of next-to-be-returned packet
    //@}
};

/**
 * Parse configuration (basically the codec-specific extradata) from
 * an RTP config subpacket (starts with 0xff).
 *
 * Layout of the config subpacket (in bytes):
 * 1: 0xFF          <- config ID
 * then an array {
 *     1: size      <- of the current item
 *     1: item type <- 0 .. 4
 *     size-2: data <- data depends on the item type
 * }
 *
 * Item 0 implies the end of the config subpacket, and has no data.
 * Item 1 implies a stream configuration without extradata.
 * Item 2 max. nr. of subpackets per superblock
 * Item 3 superblock type for the stream
 * Item 4 implies a stream configuration with extradata (size >= 0x1c).
 *
 * @return <0 on error, otherwise the number of bytes parsed from the
 *         input buffer.
 */
static int qdm2_parse_config(PayloadContext *qdm, AVStream *st,
                             const uint8_t *buf, const uint8_t *end)
{
    const uint8_t *p = buf;

    while (end - p >= 2) {
        unsigned int item_len = p[0], config_item = p[1];

        if (item_len < 2 || end - p < item_len || config_item > 4)
            return AVERROR_INVALIDDATA;

        switch (config_item) {
            case 0: /* end of config block */
                return p - buf + item_len;
            case 1: /* stream without extradata */
                /* FIXME: set default qdm->block_size */
                break;
            case 2: /**< subpackets per block */
                if (item_len < 3)
                    return AVERROR_INVALIDDATA;
                qdm->subpkts_per_block = p[2];
                break;
            case 3: /* superblock type */
                if (item_len < 4)
                    return AVERROR_INVALIDDATA;
                qdm->block_type = AV_RB16(p + 2);
                break;
            case 4: /* stream with extradata */
                if (item_len < 30)
                    return AVERROR_INVALIDDATA;
                av_freep(&st->codec->extradata);
                if (ff_alloc_extradata(st->codec, 26 + item_len)) {
                    return AVERROR(ENOMEM);
                }
                AV_WB32(st->codec->extradata, 12);
                memcpy(st->codec->extradata + 4, "frma", 4);
                memcpy(st->codec->extradata + 8, "QDM2", 4);
                AV_WB32(st->codec->extradata + 12, 6 + item_len);
                memcpy(st->codec->extradata + 16, "QDCA", 4);
                memcpy(st->codec->extradata + 20, p + 2, item_len - 2);
                AV_WB32(st->codec->extradata + 18 + item_len, 8);
                AV_WB32(st->codec->extradata + 22 + item_len, 0);

                qdm->block_size = AV_RB32(p + 26);
                break;
        }

        p += item_len;
    }

    return AVERROR(EAGAIN); /* not enough data */
}

/**
 * Parse a single subpacket. We store this subpacket in an intermediate
 * buffer (position depends on the ID (byte[0]). When called, at least
 * 4 bytes are available for reading (see qdm2_parse_packet()).
 *
 * Layout of a single subpacket (RTP packets commonly contain multiple
 * such subpackets) - length in bytes:
 * 1:    ordering ID        <- 0 .. 0x7F
 * 1:    subpacket type     <- 0 .. 0x7F; value & 0x80 means subpacket length = 2 bytes, else 1 byte
 * 1/2:  subpacket length   <- length of the data following the flags/length fields
 * if (subpacket type & 0x7F) == 0x7F
 *   1:  subpacket type, higher bits
 * size: subpacket data
 *
 * The subpackets come in randomly, and should be encapsulated into 1
 * or more superblocks (containing qdm->subpkts_per_block subpackets
 * each) per RTP packet, in order of ascending "ordering ID", see
 * qdm2_restore_block().
 *
 * @return <0 on error, otherwise the number of bytes parsed from the
 *         input buffer.
 */
static int qdm2_parse_subpacket(PayloadContext *qdm, AVStream *st,
                                const uint8_t *buf, const uint8_t *end)
{
    const uint8_t *p = buf;
    unsigned int id, len, type, to_copy;

    /* parse header so we know the size of the header/data */
    id       = *p++;
    type     = *p++;
    if (type & 0x80) {
        len   = AV_RB16(p);
        p    += 2;
        type &= 0x7F;
    } else
        len = *p++;

    if (end - p < len + (type == 0x7F) || id >= 0x80)
        return AVERROR_INVALIDDATA;
    if (type == 0x7F)
        type |= *p++ << 8;

    /* copy data into a temporary buffer */
    to_copy = FFMIN(len + (p - &buf[1]), 0x800 - qdm->len[id]);
    memcpy(&qdm->buf[id][qdm->len[id]], buf + 1, to_copy);
    qdm->len[id] += to_copy;

    return p + len - buf;
}

/**
 * Add a superblock header around a set of subpackets.
 *
 * @return <0 on error, else 0.
 */
static int qdm2_restore_block(PayloadContext *qdm, AVStream *st, AVPacket *pkt)
{
    int to_copy, n, res, include_csum;
    uint8_t *p, *csum_pos = NULL;

    /* create packet to hold subpkts into a superblock */
    assert(qdm->cache > 0);
    for (n = 0; n < 0x80; n++)
        if (qdm->len[n] > 0)
            break;
    av_assert0(n < 0x80);

    if ((res = av_new_packet(pkt, qdm->block_size)) < 0)
        return res;
    memset(pkt->data, 0, pkt->size);
    pkt->stream_index  = st->index;
    p                  = pkt->data;

    /* superblock header */
    if (qdm->len[n] > 0xff) {
        *p++ = qdm->block_type | 0x80;
        AV_WB16(p, qdm->len[n]);
        p   += 2;
    } else {
        *p++ = qdm->block_type;
        *p++ = qdm->len[n];
    }
    if ((include_csum = (qdm->block_type == 2 || qdm->block_type == 4))) {
        csum_pos = p;
        p       += 2;
    }

    /* subpacket data */
    to_copy = FFMIN(qdm->len[n], pkt->size - (p - pkt->data));
    memcpy(p, qdm->buf[n], to_copy);
    qdm->len[n] = 0;

    /* checksum header */
    if (include_csum) {
        unsigned int total = 0;
        uint8_t *q;

        for (q = pkt->data; q < &pkt->data[qdm->block_size]; q++)
            total += *q;
        AV_WB16(csum_pos, (uint16_t) total);
    }

    return 0;
}

/** return 0 on packet, no more left, 1 on packet, -1 on partial packet... */
static int qdm2_parse_packet(AVFormatContext *s, PayloadContext *qdm,
                             AVStream *st, AVPacket *pkt,
                             uint32_t *timestamp,
                             const uint8_t *buf, int len, uint16_t seq,
                             int flags)
{
    int res = AVERROR_INVALIDDATA, n;
    const uint8_t *end = buf + len, *p = buf;

    if (len > 0) {
        if (len < 2)
            return AVERROR_INVALIDDATA;

        /* configuration block */
        if (*p == 0xff) {
            if (qdm->n_pkts > 0) {
                av_log(s, AV_LOG_WARNING,
                       "Out of sequence config - dropping queue\n");
                qdm->n_pkts = 0;
                memset(qdm->len, 0, sizeof(qdm->len));
            }

            if ((res = qdm2_parse_config(qdm, st, ++p, end)) < 0)
                return res;
            p += res;

            /* We set codec_id to AV_CODEC_ID_NONE initially to
             * delay decoder initialization since extradata is
             * carried within the RTP stream, not SDP. Here,
             * by setting codec_id to AV_CODEC_ID_QDM2, we are signalling
             * to the decoder that it is OK to initialize. */
            st->codec->codec_id = AV_CODEC_ID_QDM2;
        }
        if (st->codec->codec_id == AV_CODEC_ID_NONE)
            return AVERROR(EAGAIN);

        /* subpackets */
        while (end - p >= 4) {
            if ((res = qdm2_parse_subpacket(qdm, st, p, end)) < 0)
                return res;
            p += res;
        }

        qdm->timestamp = *timestamp;
        if (++qdm->n_pkts < qdm->subpkts_per_block)
            return AVERROR(EAGAIN);
        qdm->cache = 0;
        for (n = 0; n < 0x80; n++)
            if (qdm->len[n] > 0)
                qdm->cache++;
    }

    /* output the subpackets into freshly created superblock structures */
    if (!qdm->cache || (res = qdm2_restore_block(qdm, st, pkt)) < 0)
        return res;
    if (--qdm->cache == 0)
        qdm->n_pkts = 0;

    *timestamp = qdm->timestamp;
    qdm->timestamp = RTP_NOTS_VALUE;

    return (qdm->cache > 0) ? 1 : 0;
}

static PayloadContext *qdm2_extradata_new(void)
{
    return av_mallocz(sizeof(PayloadContext));
}

static void qdm2_extradata_free(PayloadContext *qdm)
{
    av_free(qdm);
}

RTPDynamicProtocolHandler ff_qdm2_dynamic_handler = {
    .enc_name         = "X-QDM",
    .codec_type       = AVMEDIA_TYPE_AUDIO,
    .codec_id         = AV_CODEC_ID_NONE,
    .alloc            = qdm2_extradata_new,
    .free             = qdm2_extradata_free,
    .parse_packet     = qdm2_parse_packet,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* QDesign Music 2 (QDM2) payload for RTP
	3	* Copyright (c) 2010 Ronald S. Bultje
	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	/**
	23	* @file
	24	* @brief RTP support for the QDM2 payload (todo: wiki)
	25	* @author Ronald S. Bultje <rbultje@ronald.bitfreak.net>
	26	*/
	27
	28	#include <string.h>
	29	#include "libavutil/avassert.h"
	30	#include "libavutil/intreadwrite.h"
	31	#include "libavcodec/avcodec.h"
	32	#include "internal.h"
	33	#include "rtp.h"
	34	#include "rtpdec.h"
	35	#include "rtpdec_formats.h"
	36
	37	struct PayloadContext {
	38	/** values read from the config header, used as packet headers */
	39	//@{
	40	int block_type; ///< superblock type, value 2 .. 8
	41	int block_size; ///< from extradata, used as pkt length
	42	int subpkts_per_block; ///< max. nr. of subpackets to add per output buffer
	43	//@}
	44
	45	/** Temporary storage for superblock restoring, per packet ID (0x80 total) */
	46	//@{
	47	uint16_t len[0x80]; ///< how much the temporary buffer is filled
	48	uint8_t buf[0x80][0x800]; ///< the temporary storage buffer
	49
	50	unsigned int cache; ///< number of data packets that we have cached right now
	51	unsigned int n_pkts; ///< number of RTP packets received since last packet output / config
	52	uint32_t timestamp; ///< timestamp of next-to-be-returned packet
	53	//@}
	54	};
	55
	56	/**
	57	* Parse configuration (basically the codec-specific extradata) from
	58	* an RTP config subpacket (starts with 0xff).
	59	*
	60	* Layout of the config subpacket (in bytes):
	61	* 1: 0xFF <- config ID
	62	* then an array {
	63	* 1: size <- of the current item
	64	* 1: item type <- 0 .. 4
65	* size-2: data <- data depends on the item type
66	* }
67	*
68	* Item 0 implies the end of the config subpacket, and has no data.
69	* Item 1 implies a stream configuration without extradata.
70	* Item 2 max. nr. of subpackets per superblock
71	* Item 3 superblock type for the stream
72	* Item 4 implies a stream configuration with extradata (size >= 0x1c).
73	*
74	* @return <0 on error, otherwise the number of bytes parsed from the
75	* input buffer.
76	*/
77	static int qdm2_parse_config(PayloadContext qdm, AVStream st,
78	const uint8_t buf, const uint8_t end)
79	{
80	const uint8_t *p = buf;
81
82	while (end - p >= 2) {
83	unsigned int item_len = p[0], config_item = p[1];
84
85	if (item_len < 2 \|\| end - p < item_len \|\| config_item > 4)
86	return AVERROR_INVALIDDATA;
87
88	switch (config_item) {
89	case 0: /* end of config block */
90	return p - buf + item_len;
91	case 1: /* stream without extradata */
92	/* FIXME: set default qdm->block_size */
93	break;
94	case 2: /*< subpackets per block /
95	if (item_len < 3)
96	return AVERROR_INVALIDDATA;
97	qdm->subpkts_per_block = p[2];
98	break;
99	case 3: /* superblock type */
100	if (item_len < 4)
101	return AVERROR_INVALIDDATA;
102	qdm->block_type = AV_RB16(p + 2);
103	break;
104	case 4: /* stream with extradata */
105	if (item_len < 30)
106	return AVERROR_INVALIDDATA;
107	av_freep(&st->codec->extradata);
108	if (ff_alloc_extradata(st->codec, 26 + item_len)) {
109	return AVERROR(ENOMEM);
110	}
111	AV_WB32(st->codec->extradata, 12);
112	memcpy(st->codec->extradata + 4, "frma", 4);
113	memcpy(st->codec->extradata + 8, "QDM2", 4);
114	AV_WB32(st->codec->extradata + 12, 6 + item_len);
115	memcpy(st->codec->extradata + 16, "QDCA", 4);
116	memcpy(st->codec->extradata + 20, p + 2, item_len - 2);
117	AV_WB32(st->codec->extradata + 18 + item_len, 8);
118	AV_WB32(st->codec->extradata + 22 + item_len, 0);
119
120	qdm->block_size = AV_RB32(p + 26);
121	break;
122	}
123
124	p += item_len;
125	}
126
127	return AVERROR(EAGAIN); /* not enough data */
128	}
129
130	/**
131	* Parse a single subpacket. We store this subpacket in an intermediate
132	* buffer (position depends on the ID (byte[0]). When called, at least
133	* 4 bytes are available for reading (see qdm2_parse_packet()).
134	*
135	* Layout of a single subpacket (RTP packets commonly contain multiple
136	* such subpackets) - length in bytes:
137	* 1: ordering ID <- 0 .. 0x7F
138	* 1: subpacket type <- 0 .. 0x7F; value & 0x80 means subpacket length = 2 bytes, else 1 byte
139	* 1/2: subpacket length <- length of the data following the flags/length fields
140	* if (subpacket type & 0x7F) == 0x7F
141	* 1: subpacket type, higher bits
142	* size: subpacket data
143	*
144	* The subpackets come in randomly, and should be encapsulated into 1
145	* or more superblocks (containing qdm->subpkts_per_block subpackets
146	* each) per RTP packet, in order of ascending "ordering ID", see
147	* qdm2_restore_block().
148	*
149	* @return <0 on error, otherwise the number of bytes parsed from the
150	* input buffer.
151	*/
152	static int qdm2_parse_subpacket(PayloadContext qdm, AVStream st,
153	const uint8_t buf, const uint8_t end)
154	{
155	const uint8_t *p = buf;
156	unsigned int id, len, type, to_copy;
157
158	/* parse header so we know the size of the header/data */
159	id = *p++;
160	type = *p++;
161	if (type & 0x80) {
162	len = AV_RB16(p);
163	p += 2;
164	type &= 0x7F;
165	} else
166	len = *p++;
167
168	if (end - p < len + (type == 0x7F) \|\| id >= 0x80)
169	return AVERROR_INVALIDDATA;
170	if (type == 0x7F)
171	type \|= *p++ << 8;
172
173	/* copy data into a temporary buffer */
174	to_copy = FFMIN(len + (p - &buf[1]), 0x800 - qdm->len[id]);
175	memcpy(&qdm->buf[id][qdm->len[id]], buf + 1, to_copy);
176	qdm->len[id] += to_copy;
177
178	return p + len - buf;
179	}
180
181	/**
182	* Add a superblock header around a set of subpackets.
183	*
184	* @return <0 on error, else 0.
185	*/
186	static int qdm2_restore_block(PayloadContext qdm, AVStream st, AVPacket *pkt)
187	{
188	int to_copy, n, res, include_csum;
189	uint8_t p, csum_pos = NULL;
190
191	/* create packet to hold subpkts into a superblock */
192	assert(qdm->cache > 0);
193	for (n = 0; n < 0x80; n++)
194	if (qdm->len[n] > 0)
195	break;
196	av_assert0(n < 0x80);
197
198	if ((res = av_new_packet(pkt, qdm->block_size)) < 0)
199	return res;
200	memset(pkt->data, 0, pkt->size);
201	pkt->stream_index = st->index;
202	p = pkt->data;
203
204	/* superblock header */
205	if (qdm->len[n] > 0xff) {
206	*p++ = qdm->block_type \| 0x80;
207	AV_WB16(p, qdm->len[n]);
208	p += 2;
209	} else {
210	*p++ = qdm->block_type;
211	*p++ = qdm->len[n];
212	}
213	if ((include_csum = (qdm->block_type == 2 \|\| qdm->block_type == 4))) {
214	csum_pos = p;
215	p += 2;
216	}
217
218	/* subpacket data */
219	to_copy = FFMIN(qdm->len[n], pkt->size - (p - pkt->data));
220	memcpy(p, qdm->buf[n], to_copy);
221	qdm->len[n] = 0;
222
223	/* checksum header */
224	if (include_csum) {
225	unsigned int total = 0;
226	uint8_t *q;
227
228	for (q = pkt->data; q < &pkt->data[qdm->block_size]; q++)
229	total += *q;
230	AV_WB16(csum_pos, (uint16_t) total);
231	}
232
233	return 0;
234	}
235
236	/** return 0 on packet, no more left, 1 on packet, -1 on partial packet... */
237	static int qdm2_parse_packet(AVFormatContext s, PayloadContext qdm,
238	AVStream st, AVPacket pkt,
239	uint32_t *timestamp,
240	const uint8_t *buf, int len, uint16_t seq,
241	int flags)
242	{
243	int res = AVERROR_INVALIDDATA, n;
244	const uint8_t end = buf + len, p = buf;
245
246	if (len > 0) {
247	if (len < 2)
248	return AVERROR_INVALIDDATA;
249
250	/* configuration block */
251	if (*p == 0xff) {
252	if (qdm->n_pkts > 0) {
253	av_log(s, AV_LOG_WARNING,
254	"Out of sequence config - dropping queue\n");
255	qdm->n_pkts = 0;
256	memset(qdm->len, 0, sizeof(qdm->len));
257	}
258
259	if ((res = qdm2_parse_config(qdm, st, ++p, end)) < 0)
260	return res;
261	p += res;
262
263	/* We set codec_id to AV_CODEC_ID_NONE initially to
264	* delay decoder initialization since extradata is
265	* carried within the RTP stream, not SDP. Here,
266	* by setting codec_id to AV_CODEC_ID_QDM2, we are signalling
267	* to the decoder that it is OK to initialize. */
268	st->codec->codec_id = AV_CODEC_ID_QDM2;
269	}
270	if (st->codec->codec_id == AV_CODEC_ID_NONE)
271	return AVERROR(EAGAIN);
272
273	/* subpackets */
274	while (end - p >= 4) {
275	if ((res = qdm2_parse_subpacket(qdm, st, p, end)) < 0)
276	return res;
277	p += res;
278	}
279
280	qdm->timestamp = *timestamp;
281	if (++qdm->n_pkts < qdm->subpkts_per_block)
282	return AVERROR(EAGAIN);
283	qdm->cache = 0;
284	for (n = 0; n < 0x80; n++)
285	if (qdm->len[n] > 0)
286	qdm->cache++;
287	}
288
289	/* output the subpackets into freshly created superblock structures */
290	if (!qdm->cache \|\| (res = qdm2_restore_block(qdm, st, pkt)) < 0)
291	return res;
292	if (--qdm->cache == 0)
293	qdm->n_pkts = 0;
294
295	*timestamp = qdm->timestamp;
296	qdm->timestamp = RTP_NOTS_VALUE;
297
298	return (qdm->cache > 0) ? 1 : 0;
299	}
300
301	static PayloadContext *qdm2_extradata_new(void)
302	{
303	return av_mallocz(sizeof(PayloadContext));
304	}
305
306	static void qdm2_extradata_free(PayloadContext *qdm)
307	{
308	av_free(qdm);
309	}
310
311	RTPDynamicProtocolHandler ff_qdm2_dynamic_handler = {
312	.enc_name = "X-QDM",
313	.codec_type = AVMEDIA_TYPE_AUDIO,
314	.codec_id = AV_CODEC_ID_NONE,
315	.alloc = qdm2_extradata_new,
316	.free = qdm2_extradata_free,
317	.parse_packet = qdm2_parse_packet,
318	};