FFmpeg coverage

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