1/* 2 * QDesign Music 2 (QDM2) payload for RTP 3 * Copyright (c) 2010 Ronald S. Bultje 4 * 5 * This file is part of Libav. 6 * 7 * Libav 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 * Libav 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 Libav; 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/intreadwrite.h" 30#include "libavcodec/avcodec.h" 31#include "rtp.h" 32#include "rtpdec.h" 33#include "rtpdec_formats.h" 34 35struct PayloadContext { 36 /** values read from the config header, used as packet headers */ 37 //@{ 38 int block_type; ///< superblock type, value 2 .. 8 39 int block_size; ///< from extradata, used as pkt length 40 int subpkts_per_block; ///< max. nr. of subpackets to add per output buffer 41 //@} 42 43 /** Temporary storage for superblock restoring, per packet ID (0x80 total) */ 44 //@{ 45 uint16_t len[0x80]; ///< how much the temporary buffer is filled 46 uint8_t buf[0x80][0x800]; ///< the temporary storage buffer 47 48 unsigned int cache; ///< number of data packets that we have cached right now 49 unsigned int n_pkts; ///< number of RTP packets received since last packet output / config 50 uint32_t timestamp; ///< timestamp of next-to-be-returned packet 51 //@} 52}; 53 54/** 55 * Parse configuration (basically the codec-specific extradata) from 56 * an RTP config subpacket (starts with 0xff). 57 * 58 * Layout of the config subpacket (in bytes): 59 * 1: 0xFF <- config ID 60 * then an array { 61 * 1: size <- of the current item 62 * 1: item type <- 0 .. 4 63 * size-2: data <- data depends on the item type 64 * } 65 * 66 * Item 0 implies the end of the config subpacket, and has no data. 67 * Item 1 implies a stream configuration without extradata. 68 * Item 2 max. nr. of subpackets per superblock 69 * Item 3 superblock type for the stream 70 * Item 4 implies a stream configuration with extradata (size >= 0x1c). 71 * 72 * @return <0 on error, otherwise the number of bytes parsed from the 73 * input buffer. 74 */ 75static int qdm2_parse_config(PayloadContext *qdm, AVStream *st, 76 const uint8_t *buf, const uint8_t *end) 77{ 78 const uint8_t *p = buf; 79 80 while (end - p >= 2) { 81 unsigned int item_len = p[0], config_item = p[1]; 82 83 if (item_len < 2 || end - p < item_len || config_item > 4) 84 return AVERROR_INVALIDDATA; 85 86 switch (config_item) { 87 case 0: /* end of config block */ 88 return p - buf + item_len; 89 case 1: /* stream without extradata */ 90 /* FIXME: set default qdm->block_size */ 91 break; 92 case 2: /**< subpackets per block */ 93 if (item_len < 3) 94 return AVERROR_INVALIDDATA; 95 qdm->subpkts_per_block = p[2]; 96 break; 97 case 3: /* superblock type */ 98 if (item_len < 4) 99 return AVERROR_INVALIDDATA; 100 qdm->block_type = AV_RB16(p + 2); 101 break; 102 case 4: /* stream with extradata */ 103 if (item_len < 30) 104 return AVERROR_INVALIDDATA; 105 av_freep(&st->codec->extradata); 106 st->codec->extradata_size = 26 + item_len; 107 if (!(st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE))) { 108 st->codec->extradata_size = 0; 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 */ 152static 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 */ 186static 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 assert(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... */ 237static int qdm2_parse_packet(AVFormatContext *s, PayloadContext *qdm, 238 AVStream *st, AVPacket *pkt, 239 uint32_t *timestamp, 240 const uint8_t *buf, int len, int flags) 241{ 242 int res = AVERROR_INVALIDDATA, n; 243 const uint8_t *end = buf + len, *p = buf; 244 245 if (len > 0) { 246 if (len < 2) 247 return AVERROR_INVALIDDATA; 248 249 /* configuration block */ 250 if (*p == 0xff) { 251 if (qdm->n_pkts > 0) { 252 av_log(s, AV_LOG_WARNING, 253 "Out of sequence config - dropping queue\n"); 254 qdm->n_pkts = 0; 255 memset(qdm->len, 0, sizeof(qdm->len)); 256 } 257 258 if ((res = qdm2_parse_config(qdm, st, ++p, end)) < 0) 259 return res; 260 p += res; 261 262 /* We set codec_id to CODEC_ID_NONE initially to 263 * delay decoder initialization since extradata is 264 * carried within the RTP stream, not SDP. Here, 265 * by setting codec_id to CODEC_ID_QDM2, we are signalling 266 * to the decoder that it is OK to initialize. */ 267 st->codec->codec_id = CODEC_ID_QDM2; 268 } 269 if (st->codec->codec_id == CODEC_ID_NONE) 270 return AVERROR(EAGAIN); 271 272 /* subpackets */ 273 while (end - p >= 4) { 274 if ((res = qdm2_parse_subpacket(qdm, st, p, end)) < 0) 275 return res; 276 p += res; 277 } 278 279 qdm->timestamp = *timestamp; 280 if (++qdm->n_pkts < qdm->subpkts_per_block) 281 return AVERROR(EAGAIN); 282 qdm->cache = 0; 283 for (n = 0; n < 0x80; n++) 284 if (qdm->len[n] > 0) 285 qdm->cache++; 286 } 287 288 /* output the subpackets into freshly created superblock structures */ 289 if (!qdm->cache || (res = qdm2_restore_block(qdm, st, pkt)) < 0) 290 return res; 291 if (--qdm->cache == 0) 292 qdm->n_pkts = 0; 293 294 *timestamp = qdm->timestamp; 295 qdm->timestamp = RTP_NOTS_VALUE; 296 297 return (qdm->cache > 0) ? 1 : 0; 298} 299 300static PayloadContext *qdm2_extradata_new(void) 301{ 302 return av_mallocz(sizeof(PayloadContext)); 303} 304 305static void qdm2_extradata_free(PayloadContext *qdm) 306{ 307 av_free(qdm); 308} 309 310RTPDynamicProtocolHandler ff_qdm2_dynamic_handler = { 311 .enc_name = "X-QDM", 312 .codec_type = AVMEDIA_TYPE_AUDIO, 313 .codec_id = CODEC_ID_NONE, 314 .alloc = qdm2_extradata_new, 315 .free = qdm2_extradata_free, 316 .parse_packet = qdm2_parse_packet, 317}; 318