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 | }; |