forked from KolibriOS/kolibrios
308 lines
10 KiB
C
308 lines
10 KiB
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 */
|
||
|
|
av_assert0(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;
|
||
|
|
}
|
||
|
|
|
||
|
|
RTPDynamicProtocolHandler ff_qdm2_dynamic_handler = {
|
||
|
|
.enc_name = "X-QDM",
|
||
|
|
.codec_type = AVMEDIA_TYPE_AUDIO,
|
||
|
|
.codec_id = AV_CODEC_ID_NONE,
|
||
|
|
.priv_data_size = sizeof(PayloadContext),
|
||
|
|
.parse_packet = qdm2_parse_packet,
|
||
|
|
};
|