void check_maca(void) {
safe_irq_disable(MACA);
static volatile uint32_t last_time;
static volatile uint32_t last_entry;
volatile uint32_t i;
#if DEBUG_MACA
volatile uint32_t count;
#endif
/* if *MACA_CLK == last_time */
/* try waiting for one clock period */
/* since maybe check_maca is getting called quickly */
for(i=0; (i < 1024) && (*MACA_CLK == last_time); i++) {
continue;
}
if(*MACA_CLK == last_time) {
PRINTF("check maca: maca_clk stopped, restarting\n");
/* clock isn't running */
ResumeMACASync();
*INTFRC = (1<<INT_NUM_MACA);
} else {
if((last_time > (*MACA_SFTCLK + RECV_SOFTIMEOUT)) &&
(last_time > (*MACA_CPLCLK + CPL_TIMEOUT))) {
PRINTF("check maca: complete clocks expired\n");
/* all complete clocks have expired */
/* check that maca entry is changing */
/* if not, do call the isr to restart the cycle */
if(last_entry == maca_entry) {
PRINTF("check maca: forcing isr\n");
*INTFRC = (1<<INT_NUM_MACA);
}
}
}
last_entry = maca_entry;
last_time = *MACA_CLK;
#if DEBUG_MACA
if((count = count_packets()) != NUM_PACKETS) {
PRINTF("check maca: count_packets %d\n", count);
Print_Packets("check_maca");
#if PACKET_STATS
for(i=0; i<NUM_PACKETS; i++) {
printf("packet 0x%lx seen %d post_tx %d get_free %d rxd %d\n",
(uint32_t) &packet_pool[i],
packet_pool[i].seen,
packet_pool[i].post_tx,
packet_pool[i].get_free,
packet_pool[i].rxd);
}
#endif
if(bit_is_set(*NIPEND, INT_NUM_MACA)) {
*INTFRC = (1 << INT_NUM_MACA);
}
}
#endif /* DEBUG_MACA */
irq_restore();
}
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;
}
}
