Exemple #1
0
static int single_parse(rtp_vorbis * vorb, rtp_pkt * pkt, rtp_frame * fr,
            rtp_buff * config, rtp_ssrc * ssrc)
{
    uint8_t * this_pkt = RTP_PKT_DATA(pkt) + vorb->offset;
    unsigned len = nms_consume_BE2(&this_pkt);

    if (vorb->id != RTP_XIPH_ID(pkt) &&    //not the current id
        //  !cfg_cache_find(vorb,RTP_XIPH_ID(pkt)) || //XXX
        (RTP_XIPH_T(pkt) != 1)    //not a config packet
       ) {
        nms_printf(NMSML_ERR, "Id %0x unknown, expected %0x\n",
                   (unsigned)RTP_XIPH_ID(pkt), (unsigned)vorb->id);
        return RTP_PARSE_ERROR;
    }

    fr->data = vorb->buf = realloc(vorb->buf, len);
    fr->len = vorb->len = len;

    memcpy(fr->data, this_pkt, fr->len);
    vorb->pkts--;
    if (vorb->pkts == 0) {
        rtp_rm_pkt(ssrc);
    }

    if (RTP_XIPH_T(pkt) == 1)
        return -1; //cfg_fixup(vorb, fr, config, RTP_XIPH_ID(pkt));
    else {
        config->data = vorb->conf[0].conf;
        config->len  = vorb->conf[0].len;
    }

    return 0;
}
Exemple #2
0
static void
rtp_packet_send_eof(RTP_session *session, time_t time_now)
{
    gsize packet_size = sizeof(RTP_packet) + 32;
    RTP_packet *packet = g_malloc0(packet_size);
    Track *tr = session->track;
    guint32 timestamp = time_now + 1;
    j_rtp_extend_header_t *ext_hdr;

    packet->version = 2;
    packet->padding = 0;
    packet->extension = 1;
    packet->csrc_len = 0;
    packet->marker = 1;
    packet->payload = tr->properties.payload_type & 0x7f;
    packet->seq_no = htons(++session->seq_no);
    packet->timestamp = htonl(timestamp);
    packet->ssrc = htons(session->ssrc);

	ext_hdr = (j_rtp_extend_header_t*)(gchar*)RTP_PKT_DATA(packet);
	ext_hdr->frame_type = 15;//end frame.
	ext_hdr->version = 0x1;
	ext_hdr->length = htons(sizeof(j_rtp_extend_info_t)/4);

	__rtp_pkt_send(session, &session->transport, packet, packet_size);
	g_free(packet);
}
static int h263_parse(rtp_ssrc * ssrc, rtp_frame * fr, rtp_buff * config)
{
        rtp_pkt *pkt;
        uint8_t *buf;
        rtp_h263 *priv = ssrc->rtp_sess->ptdefs[fr->pt]->priv;
        size_t len; /* payload size, minus additional headers,
                 * plus the 2 zeroed bytes
                 */
        size_t start = 2; /* how many bytes we are going to skip from the start */
        int err = RTP_FILL_OK;
        int p_bit;

        if (!(pkt = rtp_get_pkt(ssrc, &len)))
                return RTP_BUFF_EMPTY;

        buf = RTP_PKT_DATA(pkt);
        len = RTP_PAYLOAD_SIZE(pkt, len);

        if (priv->len && (RTP_PKT_TS(pkt) != priv->timestamp)) {
                //incomplete packet without final fragment
                priv->len = 0;
                return RTP_PKT_UNKNOWN;
        }

        p_bit = buf[0] & 0x4;

        if (p_bit) { // p bit - we overwrite the first 2 bytes with zero
                start = 0;
        }

        if (!priv->len && !p_bit) {
                //incomplete packet without initial fragment
                rtp_rm_pkt(ssrc);
                return RTP_PKT_UNKNOWN;
        }

        if (buf[0]&0x2) // v bit - skip one more
                ++start;

        start += (buf[1]>>3)|((buf[0]&0x1)<<5); // plen - skip that many bytes

        len -= start;

        if (nms_alloc_data(&priv->data, &priv->data_size, len + priv->len)) {
                return RTP_ERRALLOC;
        }
        nms_append_data(priv->data, priv->len, buf + start, len);

        if (p_bit) // p bit - we overwrite the first 2 bytes with zero
                memset(priv->data + priv->len, 0, 2);

        priv->len += len;

        if (!RTP_PKT_MARK(pkt)) {
                priv->timestamp = RTP_PKT_TS(pkt);
                err = EAGAIN;
        } else {
                fr->data = priv->data;
                fr->len  = priv->len;
                priv->len = 0;
        }

        memset(config, 0, sizeof(rtp_buff));

        rtp_rm_pkt(ssrc);
        return err;
}