static void
flush_packets (GstRtpQCELPDepay * depay)
{
guint i, size;
GST_DEBUG_OBJECT (depay, "flushing packets");
size = depay->packets->len;
for (i = 0; i < size; i++) {
GstBuffer *outbuf;
outbuf = g_ptr_array_index (depay->packets, i);
g_ptr_array_index (depay->packets, i) = NULL;
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (depay), outbuf);
}
/* and reset interleaving state */
depay->interleaved = FALSE;
depay->bundling = 0;
}
static GstBuffer *
gst_rtp_qcelp_depay_process (GstRTPBaseDepayload * depayload,
GstRTPBuffer * rtp)
{
GstRtpQCELPDepay *depay;
GstBuffer *outbuf;
GstClockTime timestamp;
guint payload_len, offset, index;
guint8 *payload;
guint LLL, NNN;
depay = GST_RTP_QCELP_DEPAY (depayload);
payload_len = gst_rtp_buffer_get_payload_len (rtp);
if (payload_len < 2)
goto too_small;
timestamp = GST_BUFFER_PTS (rtp->buffer);
payload = gst_rtp_buffer_get_payload (rtp);
/* 0 1 2 3 4 5 6 7
* +-+-+-+-+-+-+-+-+
* |RR | LLL | NNN |
* +-+-+-+-+-+-+-+-+
*/
/* RR = payload[0] >> 6; */
LLL = (payload[0] & 0x38) >> 3;
NNN = (payload[0] & 0x07);
payload_len--;
payload++;
GST_DEBUG_OBJECT (depay, "LLL %u, NNN %u", LLL, NNN);
if (LLL > 5)
goto invalid_lll;
if (NNN > LLL)
goto invalid_nnn;
if (LLL != 0) {
/* we are interleaved */
if (!depay->interleaved) {
guint size;
GST_DEBUG_OBJECT (depay, "starting interleaving group");
/* bundling is not allowed to change in one interleave group */
depay->bundling = count_packets (depay, payload, payload_len);
GST_DEBUG_OBJECT (depay, "got bundling of %u", depay->bundling);
/* we have one bundle where NNN goes from 0 to L, we don't store the index
* 0 frames, so L+1 packets. Each packet has 'bundling - 1' packets */
size = (depay->bundling - 1) * (LLL + 1);
/* create the array to hold the packets */
if (depay->packets == NULL)
depay->packets = g_ptr_array_sized_new (size);
GST_DEBUG_OBJECT (depay, "created packet array of size %u", size);
g_ptr_array_set_size (depay->packets, size);
/* we were previously not interleaved, figure out how much space we
* need to deinterleave */
depay->interleaved = TRUE;
}
} else {
/* we are not interleaved */
if (depay->interleaved) {
GST_DEBUG_OBJECT (depay, "stopping interleaving");
/* flush packets if we were previously interleaved */
flush_packets (depay);
}
depay->bundling = 0;
}
index = 0;
offset = 1;
while (payload_len > 0) {
gint frame_len;
gboolean do_erasure;
frame_len = get_frame_len (depay, payload[0]);
GST_DEBUG_OBJECT (depay, "got frame len %d", frame_len);
if (frame_len == 0)
goto invalid_frame;
if (frame_len < 0) {
/* need to add an erasure frame but we can recover */
frame_len = -frame_len;
do_erasure = TRUE;
} else {
do_erasure = FALSE;
}
if (frame_len > payload_len)
goto invalid_frame;
if (do_erasure) {
/* create erasure frame */
outbuf = create_erasure_buffer (depay);
} else {
/* each frame goes into its buffer */
outbuf = gst_rtp_buffer_get_payload_subbuffer (rtp, offset, frame_len);
}
GST_BUFFER_PTS (outbuf) = timestamp;
GST_BUFFER_DURATION (outbuf) = FRAME_DURATION;
gst_rtp_drop_meta (GST_ELEMENT_CAST (depayload), outbuf,
g_quark_from_static_string (GST_META_TAG_AUDIO_STR));
if (!depay->interleaved || index == 0) {
/* not interleaved or first frame in packet, just push */
gst_rtp_base_depayload_push (depayload, outbuf);
if (timestamp != -1)
timestamp += FRAME_DURATION;
} else {
/* put in interleave buffer */
add_packet (depay, LLL, NNN, index, outbuf);
if (timestamp != -1)
timestamp += (FRAME_DURATION * (LLL + 1));
}
payload_len -= frame_len;
payload += frame_len;
offset += frame_len;
index++;
/* discard excess packets */
if (depay->bundling > 0 && depay->bundling <= index)
break;
}
while (index < depay->bundling) {
GST_DEBUG_OBJECT (depay, "filling with erasure buffer");
/* fill remainder with erasure packets */
outbuf = create_erasure_buffer (depay);
add_packet (depay, LLL, NNN, index, outbuf);
index++;
}
if (depay->interleaved && LLL == NNN) {
GST_DEBUG_OBJECT (depay, "interleave group ended, flushing");
/* we have the complete interleave group, flush */
flush_packets (depay);
}
return NULL;
/* ERRORS */
too_small:
{
GST_ELEMENT_WARNING (depay, STREAM, DECODE,
(NULL), ("QCELP RTP payload too small (%d)", payload_len));
return NULL;
}
invalid_lll:
{
GST_ELEMENT_WARNING (depay, STREAM, DECODE,
(NULL), ("QCELP RTP invalid LLL received (%d)", LLL));
return NULL;
}
invalid_nnn:
{
GST_ELEMENT_WARNING (depay, STREAM, DECODE,
(NULL), ("QCELP RTP invalid NNN received (%d)", NNN));
return NULL;
}
invalid_frame:
{
GST_ELEMENT_WARNING (depay, STREAM, DECODE,
(NULL), ("QCELP RTP invalid frame received"));
return NULL;
}
}
static GstBuffer *
gst_rtp_vraw_depay_process (GstRTPBaseDepayload * depayload, GstBuffer * buf)
{
GstRtpVRawDepay *rtpvrawdepay;
guint8 *payload, *p0, *yp, *up, *vp, *headers;
guint32 timestamp;
guint cont, ystride, uvstride, pgroup, payload_len;
gint width, height, xinc, yinc;
GstRTPBuffer rtp = { NULL };
GstVideoFrame *frame;
gboolean marker;
GstBuffer *outbuf = NULL;
rtpvrawdepay = GST_RTP_VRAW_DEPAY (depayload);
gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp);
timestamp = gst_rtp_buffer_get_timestamp (&rtp);
if (timestamp != rtpvrawdepay->timestamp || rtpvrawdepay->outbuf == NULL) {
GstBuffer *new_buffer;
GstFlowReturn ret;
GST_LOG_OBJECT (depayload, "new frame with timestamp %u", timestamp);
/* new timestamp, flush old buffer and create new output buffer */
if (rtpvrawdepay->outbuf) {
gst_video_frame_unmap (&rtpvrawdepay->frame);
gst_rtp_base_depayload_push (depayload, rtpvrawdepay->outbuf);
rtpvrawdepay->outbuf = NULL;
}
if (gst_pad_check_reconfigure (GST_RTP_BASE_DEPAYLOAD_SRCPAD (depayload))) {
GstCaps *caps;
caps =
gst_pad_get_current_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (depayload));
gst_rtp_vraw_depay_negotiate_pool (rtpvrawdepay, caps,
&rtpvrawdepay->vinfo);
gst_caps_unref (caps);
}
ret =
gst_buffer_pool_acquire_buffer (rtpvrawdepay->pool, &new_buffer, NULL);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto alloc_failed;
/* clear timestamp from alloc... */
GST_BUFFER_TIMESTAMP (new_buffer) = -1;
if (!gst_video_frame_map (&rtpvrawdepay->frame, &rtpvrawdepay->vinfo,
new_buffer, GST_MAP_WRITE | GST_VIDEO_FRAME_MAP_FLAG_NO_REF)) {
gst_buffer_unref (new_buffer);
goto invalid_frame;
}
rtpvrawdepay->outbuf = new_buffer;
rtpvrawdepay->timestamp = timestamp;
}
frame = &rtpvrawdepay->frame;
g_assert (frame->buffer != NULL);
/* get pointer and strides of the planes */
p0 = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
yp = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
up = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
vp = GST_VIDEO_FRAME_COMP_DATA (frame, 2);
ystride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
uvstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1);
pgroup = rtpvrawdepay->pgroup;
width = GST_VIDEO_INFO_WIDTH (&rtpvrawdepay->vinfo);
height = GST_VIDEO_INFO_HEIGHT (&rtpvrawdepay->vinfo);
xinc = rtpvrawdepay->xinc;
yinc = rtpvrawdepay->yinc;
payload = gst_rtp_buffer_get_payload (&rtp);
payload_len = gst_rtp_buffer_get_payload_len (&rtp);
if (payload_len < 3)
goto short_packet;
/* skip extended seqnum */
payload += 2;
payload_len -= 2;
/* remember header position */
headers = payload;
/* find data start */
do {
if (payload_len < 6)
goto short_packet;
cont = payload[4] & 0x80;
payload += 6;
payload_len -= 6;
} while (cont);
while (TRUE) {
guint length, line, offs, plen;
guint8 *datap;
/* stop when we run out of data */
if (payload_len == 0)
break;
/* read length and cont. This should work because we iterated the headers
* above. */
length = (headers[0] << 8) | headers[1];
line = ((headers[2] & 0x7f) << 8) | headers[3];
offs = ((headers[4] & 0x7f) << 8) | headers[5];
cont = headers[4] & 0x80;
headers += 6;
/* length must be a multiple of pgroup */
if (length % pgroup != 0)
goto wrong_length;
if (length > payload_len)
length = payload_len;
/* sanity check */
if (line > (height - yinc)) {
GST_WARNING_OBJECT (depayload, "skipping line %d: out of range", line);
goto next;
}
if (offs > (width - xinc)) {
GST_WARNING_OBJECT (depayload, "skipping offset %d: out of range", offs);
goto next;
}
/* calculate the maximim amount of bytes we can use per line */
if (offs + ((length / pgroup) * xinc) > width) {
plen = ((width - offs) * pgroup) / xinc;
GST_WARNING_OBJECT (depayload, "clipping length %d, offset %d, plen %d",
length, offs, plen);
} else
plen = length;
GST_LOG_OBJECT (depayload,
"writing length %u/%u, line %u, offset %u, remaining %u", plen, length,
line, offs, payload_len);
switch (GST_VIDEO_INFO_FORMAT (&rtpvrawdepay->vinfo)) {
case GST_VIDEO_FORMAT_RGB:
case GST_VIDEO_FORMAT_RGBA:
case GST_VIDEO_FORMAT_BGR:
case GST_VIDEO_FORMAT_BGRA:
case GST_VIDEO_FORMAT_UYVY:
case GST_VIDEO_FORMAT_UYVP:
/* samples are packed just like gstreamer packs them */
offs /= xinc;
datap = p0 + (line * ystride) + (offs * pgroup);
memcpy (datap, payload, plen);
break;
case GST_VIDEO_FORMAT_AYUV:
{
gint i;
guint8 *p;
datap = p0 + (line * ystride) + (offs * 4);
p = payload;
/* samples are packed in order Cb-Y-Cr for both interlaced and
* progressive frames */
for (i = 0; i < plen; i += pgroup) {
*datap++ = 0;
*datap++ = p[1];
*datap++ = p[0];
*datap++ = p[2];
p += pgroup;
}
break;
}
case GST_VIDEO_FORMAT_I420:
{
gint i;
guint uvoff;
guint8 *yd1p, *yd2p, *udp, *vdp, *p;
yd1p = yp + (line * ystride) + (offs);
yd2p = yd1p + ystride;
uvoff = (line / yinc * uvstride) + (offs / xinc);
udp = up + uvoff;
vdp = vp + uvoff;
p = payload;
/* line 0/1: Y00-Y01-Y10-Y11-Cb00-Cr00 Y02-Y03-Y12-Y13-Cb01-Cr01 ... */
for (i = 0; i < plen; i += pgroup) {
*yd1p++ = p[0];
*yd1p++ = p[1];
*yd2p++ = p[2];
*yd2p++ = p[3];
*udp++ = p[4];
*vdp++ = p[5];
p += pgroup;
}
break;
}
case GST_VIDEO_FORMAT_Y41B:
{
gint i;
guint uvoff;
guint8 *ydp, *udp, *vdp, *p;
ydp = yp + (line * ystride) + (offs);
uvoff = (line / yinc * uvstride) + (offs / xinc);
udp = up + uvoff;
vdp = vp + uvoff;
p = payload;
/* Samples are packed in order Cb0-Y0-Y1-Cr0-Y2-Y3 for both interlaced
* and progressive scan lines */
for (i = 0; i < plen; i += pgroup) {
*udp++ = p[0];
*ydp++ = p[1];
*ydp++ = p[2];
*vdp++ = p[3];
*ydp++ = p[4];
*ydp++ = p[5];
p += pgroup;
}
break;
}
default:
goto unknown_sampling;
}
next:
if (!cont)
break;
payload += length;
payload_len -= length;
}
marker = gst_rtp_buffer_get_marker (&rtp);
gst_rtp_buffer_unmap (&rtp);
if (marker) {
GST_LOG_OBJECT (depayload, "marker, flushing frame");
gst_video_frame_unmap (&rtpvrawdepay->frame);
outbuf = rtpvrawdepay->outbuf;
rtpvrawdepay->outbuf = NULL;
rtpvrawdepay->timestamp = -1;
}
return outbuf;
/* ERRORS */
unknown_sampling:
{
GST_ELEMENT_ERROR (depayload, STREAM, FORMAT,
(NULL), ("unimplemented sampling"));
gst_rtp_buffer_unmap (&rtp);
return NULL;
}
alloc_failed:
{
GST_WARNING_OBJECT (depayload, "failed to alloc output buffer");
gst_rtp_buffer_unmap (&rtp);
return NULL;
}
invalid_frame:
{
GST_ERROR_OBJECT (depayload, "could not map video frame");
return NULL;
}
wrong_length:
{
GST_WARNING_OBJECT (depayload, "length not multiple of pgroup");
gst_rtp_buffer_unmap (&rtp);
return NULL;
}
short_packet:
{
GST_WARNING_OBJECT (depayload, "short packet");
gst_rtp_buffer_unmap (&rtp);
return NULL;
}
}
static GstBuffer *
gst_rtp_xqt_depay_process (GstRTPBaseDepayload * depayload, GstBuffer * buf)
{
GstRtpXQTDepay *rtpxqtdepay;
GstBuffer *outbuf = NULL;
gboolean m;
GstRTPBuffer rtp = { NULL };
rtpxqtdepay = GST_RTP_XQT_DEPAY (depayload);
gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp);
if (!gst_rtp_buffer_validate (buf))
goto bad_packet;
if (GST_BUFFER_IS_DISCONT (buf)) {
/* discont, clear adapter and try to find a new packet start */
gst_adapter_clear (rtpxqtdepay->adapter);
rtpxqtdepay->need_resync = TRUE;
GST_DEBUG_OBJECT (rtpxqtdepay, "we need resync");
}
m = gst_rtp_buffer_get_marker (&rtp);
GST_LOG_OBJECT (rtpxqtdepay, "marker: %d", m);
{
gint payload_len;
guint avail;
guint8 *payload;
guint8 ver, pck;
gboolean s, q, l, d;
payload_len = gst_rtp_buffer_get_payload_len (&rtp);
payload = gst_rtp_buffer_get_payload (&rtp);
/* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | VER |PCK|S|Q|L| RES |D| QuickTime Payload ID |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
if (payload_len <= 4)
goto wrong_length;
ver = (payload[0] & 0xf0) >> 4;
if (ver > 1)
goto wrong_version;
pck = (payload[0] & 0x0c) >> 2;
if (pck == 0)
goto pck_reserved;
s = (payload[0] & 0x02) != 0; /* contains sync sample */
q = (payload[0] & 0x01) != 0; /* has payload description */
l = (payload[1] & 0x80) != 0; /* has packet specific information description */
d = (payload[2] & 0x80) != 0; /* don't cache info for payload id */
/* id used for caching info */
rtpxqtdepay->current_id = ((payload[2] & 0x7f) << 8) | payload[3];
GST_LOG_OBJECT (rtpxqtdepay,
"VER: %d, PCK: %d, S: %d, Q: %d, L: %d, D: %d, ID: %d", ver, pck, s, q,
l, d, rtpxqtdepay->current_id);
if (rtpxqtdepay->need_resync) {
/* we need to find the boundary of a new packet after a DISCONT */
if (pck != 3 || q) {
/* non-fragmented packet or payload description present, packet starts
* here. */
rtpxqtdepay->need_resync = FALSE;
} else {
/* fragmented packet without description */
if (m) {
/* marker bit set, next packet is start of new one */
rtpxqtdepay->need_resync = FALSE;
}
goto need_resync;
}
}
payload += 4;
payload_len -= 4;
if (q) {
gboolean k, f, a, z;
guint pdlen, pdpadded;
gint padding;
/* media_type only used for printing */
guint32 G_GNUC_UNUSED media_type;
guint32 timescale;
/* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* |K|F|A|Z| RES | QuickTime Payload Desc Length |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . QuickTime Payload Desc Data ... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
if (payload_len <= 4)
goto wrong_length;
k = (payload[0] & 0x80) != 0; /* keyframe */
f = (payload[0] & 0x40) != 0; /* sparse */
a = (payload[0] & 0x20) != 0; /* start of payload */
z = (payload[0] & 0x10) != 0; /* end of payload */
pdlen = (payload[2] << 8) | payload[3];
if (pdlen < 12)
goto wrong_length;
/* calc padding */
pdpadded = pdlen + 3;
pdpadded -= pdpadded % 4;
if (payload_len < pdpadded)
goto wrong_length;
padding = pdpadded - pdlen;
GST_LOG_OBJECT (rtpxqtdepay,
"K: %d, F: %d, A: %d, Z: %d, len: %d, padding %d", k, f, a, z, pdlen,
padding);
payload += 4;
payload_len -= 4;
/* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | QuickTime Media Type |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Timescale |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . QuickTime TLVs ... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
media_type =
(payload[0] << 24) | (payload[1] << 16) | (payload[2] << 8) |
payload[3];
timescale =
(payload[4] << 24) | (payload[5] << 16) | (payload[6] << 8) |
payload[7];
GST_LOG_OBJECT (rtpxqtdepay, "media_type: %c%c%c%c, timescale %u",
payload[0], payload[1], payload[2], payload[3], timescale);
payload += 8;
payload_len -= 8;
pdlen -= 12;
/* parse TLV (type-length-value triplets */
while (pdlen > 3) {
guint16 tlv_len, tlv_type;
/* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | QuickTime TLV Length | QuickTime TLV Type |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . QuickTime TLV Value ... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
tlv_len = (payload[0] << 8) | payload[1];
tlv_type = (payload[2] << 8) | payload[3];
pdlen -= 4;
if (tlv_len > pdlen)
goto wrong_length;
GST_LOG_OBJECT (rtpxqtdepay, "TLV '%c%c', len %d", payload[2],
payload[3], tlv_len);
payload += 4;
payload_len -= 4;
switch (tlv_type) {
case TLV_sd:
/* Session description */
if (!gst_rtp_quicktime_parse_sd (rtpxqtdepay, payload, tlv_len))
goto unknown_format;
rtpxqtdepay->have_sd = TRUE;
break;
case TLV_qt:
case TLV_ti:
case TLV_ly:
case TLV_vo:
case TLV_mx:
case TLV_tr:
case TLV_tw:
case TLV_th:
case TLV_la:
case TLV_rt:
case TLV_gm:
case TLV_oc:
case TLV_cr:
case TLV_du:
case TLV_po:
default:
break;
}
pdlen -= tlv_len;
payload += tlv_len;
payload_len -= tlv_len;
}
payload += padding;
payload_len -= padding;
}
if (l) {
guint ssilen, ssipadded;
gint padding;
/* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | RES | Sample-Specific Info Length |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . QuickTime TLVs ...
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
if (payload_len <= 4)
goto wrong_length;
ssilen = (payload[2] << 8) | payload[3];
if (ssilen < 4)
goto wrong_length;
/* calc padding */
ssipadded = ssilen + 3;
ssipadded -= ssipadded % 4;
if (payload_len < ssipadded)
goto wrong_length;
padding = ssipadded - ssilen;
GST_LOG_OBJECT (rtpxqtdepay, "len: %d, padding %d", ssilen, padding);
payload += 4;
payload_len -= 4;
ssilen -= 4;
/* parse TLV (type-length-value triplets */
while (ssilen > 3) {
guint16 tlv_len, tlv_type;
/* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | QuickTime TLV Length | QuickTime TLV Type |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . QuickTime TLV Value ... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
tlv_len = (payload[0] << 8) | payload[1];
tlv_type = (payload[2] << 8) | payload[3];
ssilen -= 4;
if (tlv_len > ssilen)
goto wrong_length;
GST_LOG_OBJECT (rtpxqtdepay, "TLV '%c%c', len %d", payload[2],
payload[3], tlv_len);
payload += 4;
payload_len -= 4;
switch (tlv_type) {
case TLV_sd:
case TLV_qt:
case TLV_ti:
case TLV_ly:
case TLV_vo:
case TLV_mx:
case TLV_tr:
case TLV_tw:
case TLV_th:
case TLV_la:
case TLV_rt:
case TLV_gm:
case TLV_oc:
case TLV_cr:
case TLV_du:
case TLV_po:
default:
break;
}
ssilen -= tlv_len;
payload += tlv_len;
payload_len -= tlv_len;
}
payload += padding;
payload_len -= padding;
}
rtpxqtdepay->previous_id = rtpxqtdepay->current_id;
switch (pck) {
case 1:
{
/* multiple samples per packet. */
outbuf = gst_buffer_new_and_alloc (payload_len);
gst_buffer_fill (outbuf, 0, payload, payload_len);
goto done;
}
case 2:
{
guint slen;
/* multiple samples per packet.
* 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* |S| Reserved | Sample Length |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Sample Timestamp |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . Sample Data ... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* |S| Reserved | Sample Length |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Sample Timestamp |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . Sample Data ... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* . ...... .
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
while (payload_len > 8) {
s = (payload[0] & 0x80) != 0; /* contains sync sample */
slen = (payload[2] << 8) | payload[3];
/* timestamp =
* (payload[4] << 24) | (payload[5] << 16) | (payload[6] << 8) |
* payload[7];
*/
payload += 8;
payload_len -= 8;
if (slen > payload_len)
slen = payload_len;
outbuf = gst_buffer_new_and_alloc (slen);
gst_buffer_fill (outbuf, 0, payload, slen);
if (!s)
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
gst_rtp_base_depayload_push (depayload, outbuf);
/* aligned on 32 bit boundary */
slen = GST_ROUND_UP_4 (slen);
payload += slen;
payload_len -= slen;
}
break;
}
case 3:
{
/* one sample per packet, use adapter to combine based on marker bit. */
outbuf = gst_buffer_new_and_alloc (payload_len);
gst_buffer_fill (outbuf, 0, payload, payload_len);
gst_adapter_push (rtpxqtdepay->adapter, outbuf);
if (!m)
goto done;
avail = gst_adapter_available (rtpxqtdepay->adapter);
outbuf = gst_adapter_take_buffer (rtpxqtdepay->adapter, avail);
GST_DEBUG_OBJECT (rtpxqtdepay,
"gst_rtp_xqt_depay_chain: pushing buffer of size %u", avail);
goto done;
}
}
}
done:
gst_rtp_buffer_unmap (&rtp);
return outbuf;
bad_packet:
{
GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
("Packet did not validate."), (NULL));
goto done;
}
need_resync:
{
GST_DEBUG_OBJECT (rtpxqtdepay, "waiting for marker");
goto done;
}
wrong_version:
{
GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
("Unknown payload version."), (NULL));
goto done;
}
pck_reserved:
{
GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
("PCK reserved 0."), (NULL));
goto done;
}
wrong_length:
{
GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
("Wrong payload length."), (NULL));
goto done;
}
unknown_format:
{
GST_ELEMENT_WARNING (rtpxqtdepay, STREAM, DECODE,
("Unknown payload format."), (NULL));
goto done;
}
}
static gboolean
gst_rtp_speex_depay_setcaps (GstRTPBaseDepayload * depayload, GstCaps * caps)
{
GstStructure *structure;
GstRtpSPEEXDepay *rtpspeexdepay;
gint clock_rate, nb_channels;
GstBuffer *buf;
GstMapInfo map;
guint8 *data;
const gchar *params;
GstCaps *srccaps;
gboolean res;
rtpspeexdepay = GST_RTP_SPEEX_DEPAY (depayload);
structure = gst_caps_get_structure (caps, 0);
if (!gst_structure_get_int (structure, "clock-rate", &clock_rate))
goto no_clockrate;
depayload->clock_rate = clock_rate;
if (!(params = gst_structure_get_string (structure, "encoding-params")))
nb_channels = 1;
else {
nb_channels = atoi (params);
}
/* construct minimal header and comment packet for the decoder */
buf = gst_buffer_new_and_alloc (80);
gst_buffer_map (buf, &map, GST_MAP_WRITE);
data = map.data;
memcpy (data, "Speex ", 8);
data += 8;
memcpy (data, "1.1.12", 7);
data += 20;
GST_WRITE_UINT32_LE (data, 1); /* version */
data += 4;
GST_WRITE_UINT32_LE (data, 80); /* header_size */
data += 4;
GST_WRITE_UINT32_LE (data, clock_rate); /* rate */
data += 4;
GST_WRITE_UINT32_LE (data, gst_rtp_speex_depay_get_mode (clock_rate)); /* mode */
data += 4;
GST_WRITE_UINT32_LE (data, 4); /* mode_bitstream_version */
data += 4;
GST_WRITE_UINT32_LE (data, nb_channels); /* nb_channels */
data += 4;
GST_WRITE_UINT32_LE (data, -1); /* bitrate */
data += 4;
GST_WRITE_UINT32_LE (data, 0xa0); /* frame_size */
data += 4;
GST_WRITE_UINT32_LE (data, 0); /* VBR */
data += 4;
GST_WRITE_UINT32_LE (data, 1); /* frames_per_packet */
data += 4;
GST_WRITE_UINT32_LE (data, 0); /* extra_headers */
data += 4;
GST_WRITE_UINT32_LE (data, 0); /* reserved1 */
data += 4;
GST_WRITE_UINT32_LE (data, 0); /* reserved2 */
gst_buffer_unmap (buf, &map);
srccaps = gst_caps_new_empty_simple ("audio/x-speex");
res = gst_pad_set_caps (depayload->srcpad, srccaps);
gst_caps_unref (srccaps);
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtpspeexdepay), buf);
buf = gst_buffer_new_and_alloc (sizeof (gst_rtp_speex_comment));
gst_buffer_fill (buf, 0, gst_rtp_speex_comment,
sizeof (gst_rtp_speex_comment));
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtpspeexdepay), buf);
return res;
/* ERRORS */
no_clockrate:
{
GST_DEBUG_OBJECT (depayload, "no clock-rate specified");
return FALSE;
}
}
static GstFlowReturn
gst_rtp_j2k_depay_flush_frame (GstRTPBaseDepayload * depayload)
{
GstRtpJ2KDepay *rtpj2kdepay;
guint8 end[2];
guint avail;
GstFlowReturn ret = GST_FLOW_OK;
rtpj2kdepay = GST_RTP_J2K_DEPAY (depayload);
/* flush pending tile */
gst_rtp_j2k_depay_flush_tile (depayload);
/* last buffer take all data out of the adapter */
avail = gst_adapter_available (rtpj2kdepay->f_adapter);
if (avail == 0)
goto done;
if (avail > 2) {
GstBuffer *outbuf;
/* take the last bytes of the JPEG 2000 data to see if there is an EOC
* marker */
gst_adapter_copy (rtpj2kdepay->f_adapter, end, avail - 2, 2);
if (end[0] != 0xff && end[1] != 0xd9) {
end[0] = 0xff;
end[1] = 0xd9;
GST_DEBUG_OBJECT (rtpj2kdepay, "no EOC marker, adding one");
/* no EOI marker, add one */
outbuf = gst_buffer_new_and_alloc (2);
gst_buffer_fill (outbuf, 0, end, 2);
gst_adapter_push (rtpj2kdepay->f_adapter, outbuf);
avail += 2;
}
GST_DEBUG_OBJECT (rtpj2kdepay, "pushing buffer of %u bytes", avail);
outbuf = gst_adapter_take_buffer (rtpj2kdepay->f_adapter, avail);
gst_rtp_drop_meta (GST_ELEMENT_CAST (depayload),
outbuf, g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
ret = gst_rtp_base_depayload_push (depayload, outbuf);
} else {
GST_WARNING_OBJECT (rtpj2kdepay, "empty packet");
gst_adapter_clear (rtpj2kdepay->f_adapter);
}
/* we accept any mh_id now */
rtpj2kdepay->last_mh_id = -1;
/* reset state */
rtpj2kdepay->next_frag = 0;
rtpj2kdepay->have_sync = FALSE;
done:
/* we can't keep headers with mh_id of 0 */
store_mheader (rtpj2kdepay, 0, NULL);
return ret;
}
static GstBuffer *
gst_rtp_celt_depay_process (GstRTPBaseDepayload * depayload, GstRTPBuffer * rtp)
{
GstBuffer *outbuf = NULL;
guint8 *payload;
guint offset, pos, payload_len, total_size, size;
guint8 s;
gint clock_rate = 0, frame_size = 0;
GstClockTime framesize_ns = 0, timestamp;
guint n = 0;
GstRtpCELTDepay *rtpceltdepay;
rtpceltdepay = GST_RTP_CELT_DEPAY (depayload);
clock_rate = depayload->clock_rate;
frame_size = rtpceltdepay->frame_size;
framesize_ns = gst_util_uint64_scale_int (frame_size, GST_SECOND, clock_rate);
timestamp = GST_BUFFER_PTS (rtp->buffer);
GST_LOG_OBJECT (depayload,
"got %" G_GSIZE_FORMAT " bytes, mark %d ts %u seqn %d",
gst_buffer_get_size (rtp->buffer), gst_rtp_buffer_get_marker (rtp),
gst_rtp_buffer_get_timestamp (rtp), gst_rtp_buffer_get_seq (rtp));
GST_LOG_OBJECT (depayload, "got clock-rate=%d, frame_size=%d, "
"_ns=%" GST_TIME_FORMAT ", timestamp=%" GST_TIME_FORMAT, clock_rate,
frame_size, GST_TIME_ARGS (framesize_ns), GST_TIME_ARGS (timestamp));
payload = gst_rtp_buffer_get_payload (rtp);
payload_len = gst_rtp_buffer_get_payload_len (rtp);
/* first count how many bytes are consumed by the size headers and make offset
* point to the first data byte */
total_size = 0;
offset = 0;
while (total_size < payload_len) {
do {
s = payload[offset++];
total_size += s + 1;
} while (s == 0xff);
}
/* offset is now pointing to the payload */
total_size = 0;
pos = 0;
while (total_size < payload_len) {
n++;
size = 0;
do {
s = payload[pos++];
size += s;
total_size += s + 1;
} while (s == 0xff);
outbuf = gst_rtp_buffer_get_payload_subbuffer (rtp, offset, size);
offset += size;
if (frame_size != -1 && clock_rate != -1) {
GST_BUFFER_PTS (outbuf) = timestamp + framesize_ns * n;
GST_BUFFER_DURATION (outbuf) = framesize_ns;
}
GST_LOG_OBJECT (depayload, "push timestamp=%"
GST_TIME_FORMAT ", duration=%" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_PTS (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)));
gst_rtp_drop_meta (GST_ELEMENT_CAST (depayload), outbuf,
g_quark_from_static_string (GST_META_TAG_AUDIO_STR));
gst_rtp_base_depayload_push (depayload, outbuf);
}
return NULL;
}
static gboolean
gst_rtp_celt_depay_setcaps (GstRTPBaseDepayload * depayload, GstCaps * caps)
{
GstStructure *structure;
GstRtpCELTDepay *rtpceltdepay;
gint clock_rate, nb_channels = 0, frame_size = 0;
GstBuffer *buf;
GstMapInfo map;
guint8 *ptr;
const gchar *params;
GstCaps *srccaps;
gboolean res;
rtpceltdepay = GST_RTP_CELT_DEPAY (depayload);
structure = gst_caps_get_structure (caps, 0);
if (!gst_structure_get_int (structure, "clock-rate", &clock_rate))
goto no_clockrate;
depayload->clock_rate = clock_rate;
if ((params = gst_structure_get_string (structure, "encoding-params")))
nb_channels = atoi (params);
if (!nb_channels)
nb_channels = DEFAULT_CHANNELS;
if ((params = gst_structure_get_string (structure, "frame-size")))
frame_size = atoi (params);
if (!frame_size)
frame_size = DEFAULT_FRAMESIZE;
rtpceltdepay->frame_size = frame_size;
GST_DEBUG_OBJECT (depayload, "clock-rate=%d channels=%d frame-size=%d",
clock_rate, nb_channels, frame_size);
/* construct minimal header and comment packet for the decoder */
buf = gst_buffer_new_and_alloc (60);
gst_buffer_map (buf, &map, GST_MAP_WRITE);
ptr = map.data;
memcpy (ptr, "CELT ", 8);
ptr += 8;
memcpy (ptr, "1.1.12", 7);
ptr += 20;
GST_WRITE_UINT32_LE (ptr, 0x80000006); /* version */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, 56); /* header_size */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, clock_rate); /* rate */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, nb_channels); /* channels */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, frame_size); /* frame-size */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, -1); /* overlap */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, -1); /* bytes_per_packet */
ptr += 4;
GST_WRITE_UINT32_LE (ptr, 0); /* extra headers */
gst_buffer_unmap (buf, &map);
srccaps = gst_caps_new_empty_simple ("audio/x-celt");
res = gst_pad_set_caps (depayload->srcpad, srccaps);
gst_caps_unref (srccaps);
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtpceltdepay), buf);
buf = gst_buffer_new_and_alloc (sizeof (gst_rtp_celt_comment));
gst_buffer_fill (buf, 0, gst_rtp_celt_comment, sizeof (gst_rtp_celt_comment));
gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtpceltdepay), buf);
return res;
/* ERRORS */
no_clockrate:
{
GST_ERROR_OBJECT (depayload, "no clock-rate specified");
return FALSE;
}
}
/* takes ownership of the input buffer */
static GstFlowReturn
gst_rtp_base_depayload_handle_buffer (GstRTPBaseDepayload * filter,
GstRTPBaseDepayloadClass * bclass, GstBuffer * in)
{
GstBuffer *(*process_rtp_packet_func) (GstRTPBaseDepayload * base,
GstRTPBuffer * rtp_buffer);
GstBuffer *(*process_func) (GstRTPBaseDepayload * base, GstBuffer * in);
GstRTPBaseDepayloadPrivate *priv;
GstFlowReturn ret = GST_FLOW_OK;
GstBuffer *out_buf;
guint32 ssrc;
guint16 seqnum;
guint32 rtptime;
gboolean discont, buf_discont;
gint gap;
GstRTPBuffer rtp = { NULL };
priv = filter->priv;
process_func = bclass->process;
process_rtp_packet_func = bclass->process_rtp_packet;
/* we must have a setcaps first */
if (G_UNLIKELY (!priv->negotiated))
goto not_negotiated;
if (G_UNLIKELY (!gst_rtp_buffer_map (in, GST_MAP_READ, &rtp)))
goto invalid_buffer;
buf_discont = GST_BUFFER_IS_DISCONT (in);
priv->pts = GST_BUFFER_PTS (in);
priv->dts = GST_BUFFER_DTS (in);
priv->duration = GST_BUFFER_DURATION (in);
ssrc = gst_rtp_buffer_get_ssrc (&rtp);
seqnum = gst_rtp_buffer_get_seq (&rtp);
rtptime = gst_rtp_buffer_get_timestamp (&rtp);
priv->last_seqnum = seqnum;
priv->last_rtptime = rtptime;
discont = buf_discont;
GST_LOG_OBJECT (filter, "discont %d, seqnum %u, rtptime %u, pts %"
GST_TIME_FORMAT ", dts %" GST_TIME_FORMAT, buf_discont, seqnum, rtptime,
GST_TIME_ARGS (priv->pts), GST_TIME_ARGS (priv->dts));
/* Check seqnum. This is a very simple check that makes sure that the seqnums
* are strictly increasing, dropping anything that is out of the ordinary. We
* can only do this when the next_seqnum is known. */
if (G_LIKELY (priv->next_seqnum != -1)) {
if (ssrc != priv->last_ssrc) {
GST_LOG_OBJECT (filter,
"New ssrc %u (current ssrc %u), sender restarted",
ssrc, priv->last_ssrc);
discont = TRUE;
} else {
gap = gst_rtp_buffer_compare_seqnum (seqnum, priv->next_seqnum);
/* if we have no gap, all is fine */
if (G_UNLIKELY (gap != 0)) {
GST_LOG_OBJECT (filter, "got packet %u, expected %u, gap %d", seqnum,
priv->next_seqnum, gap);
if (gap < 0) {
/* seqnum > next_seqnum, we are missing some packets, this is always a
* DISCONT. */
GST_LOG_OBJECT (filter, "%d missing packets", gap);
discont = TRUE;
} else {
/* seqnum < next_seqnum, we have seen this packet before, have a
* reordered packet or the sender could be restarted. If the packet
* is not too old, we throw it away as a duplicate. Otherwise we
* mark discont and continue assuming the sender has restarted. See
* also RFC 4737. */
GST_WARNING ("gap %d <= priv->max_reorder %d -> dropping %d",
gap, priv->max_reorder, gap <= priv->max_reorder);
if (gap <= priv->max_reorder)
goto dropping;
GST_LOG_OBJECT (filter,
"%d > %d, packet too old, sender likely restarted", gap,
priv->max_reorder);
discont = TRUE;
}
}
}
}
priv->next_seqnum = (seqnum + 1) & 0xffff;
priv->last_ssrc = ssrc;
if (G_UNLIKELY (discont)) {
priv->discont = TRUE;
if (!buf_discont) {
gpointer old_inbuf = in;
/* we detected a seqnum discont but the buffer was not flagged with a discont,
* set the discont flag so that the subclass can throw away old data. */
GST_LOG_OBJECT (filter, "mark DISCONT on input buffer");
in = gst_buffer_make_writable (in);
GST_BUFFER_FLAG_SET (in, GST_BUFFER_FLAG_DISCONT);
/* depayloaders will check flag on rtpbuffer->buffer, so if the input
* buffer was not writable already we need to remap to make our
* newly-flagged buffer current on the rtpbuffer */
if (in != old_inbuf) {
gst_rtp_buffer_unmap (&rtp);
if (G_UNLIKELY (!gst_rtp_buffer_map (in, GST_MAP_READ, &rtp)))
goto invalid_buffer;
}
}
}
/* prepare segment event if needed */
if (filter->need_newsegment) {
priv->segment_event = create_segment_event (filter, rtptime,
GST_BUFFER_PTS (in));
filter->need_newsegment = FALSE;
}
priv->input_buffer = in;
if (process_rtp_packet_func != NULL) {
out_buf = process_rtp_packet_func (filter, &rtp);
gst_rtp_buffer_unmap (&rtp);
} else if (process_func != NULL) {
gst_rtp_buffer_unmap (&rtp);
out_buf = process_func (filter, in);
} else {
goto no_process;
}
/* let's send it out to processing */
if (out_buf) {
ret = gst_rtp_base_depayload_push (filter, out_buf);
}
gst_buffer_unref (in);
priv->input_buffer = NULL;
return ret;
/* ERRORS */
not_negotiated:
{
/* this is not fatal but should be filtered earlier */
GST_ELEMENT_ERROR (filter, CORE, NEGOTIATION,
("No RTP format was negotiated."),
("Input buffers need to have RTP caps set on them. This is usually "
"achieved by setting the 'caps' property of the upstream source "
"element (often udpsrc or appsrc), or by putting a capsfilter "
"element before the depayloader and setting the 'caps' property "
"on that. Also see http://cgit.freedesktop.org/gstreamer/"
"gst-plugins-good/tree/gst/rtp/README"));
gst_buffer_unref (in);
return GST_FLOW_NOT_NEGOTIATED;
}
invalid_buffer:
{
/* this is not fatal but should be filtered earlier */
GST_ELEMENT_WARNING (filter, STREAM, DECODE, (NULL),
("Received invalid RTP payload, dropping"));
gst_buffer_unref (in);
return GST_FLOW_OK;
}
dropping:
{
gst_rtp_buffer_unmap (&rtp);
GST_WARNING_OBJECT (filter, "%d <= 100, dropping old packet", gap);
gst_buffer_unref (in);
return GST_FLOW_OK;
}
no_process:
{
gst_rtp_buffer_unmap (&rtp);
/* this is not fatal but should be filtered earlier */
GST_ELEMENT_ERROR (filter, STREAM, NOT_IMPLEMENTED, (NULL),
("The subclass does not have a process or process_rtp_packet method"));
gst_buffer_unref (in);
return GST_FLOW_ERROR;
}
}