예제 #1
0
static void
packet_print (struct rtp *session, rtp_packet * p)
{
  call_t *ca = (call_t *) rtp_get_userdata (session);

#ifdef USE_PCM
  char data_in_dec[1280];
#endif
  fprintf (stderr, "Received data (payload %d timestamp %06d size %d)\n",
           p->pt, p->ts, p->data_len);
  if (ca == NULL)
    {
      fprintf (stderr, "No call for current session\n");
      return;
    }
#ifdef USE_PCM

  if (p->pt == 8)               /* A-Law */
    alaw_dec (p->data, data_in_dec, p->data_len);
  if (p->pt == 0)               /* Mu-Law */
    mulaw_dec (p->data, data_in_dec, p->data_len);

  write (ca->fd, data_in_dec, p->data_len * 2);

#else
  write (ca->fd, p->data, p->data_len);
  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL,
                          "received %i data written to the audio driver\n",
                          p->data_len));
#endif

  /*Unless filtering is enabled we are likely to see
     out packets if sending to a multicast group. */
  /*
     if (p->ssrc == rtp_my_ssrc(session)) {
     fprintf(stderr, "that I just sent.\n");
     } else {
     fprintf(stderr, "from SSRC 0x%08x\n", p->ssrc); 
     } 
   */
}
예제 #2
0
void rtp_recv_callback(struct rtp *session, rtp_event * e)
{
        rtcp_app *pckt_app = (rtcp_app *) e->data;
        rtp_packet *pckt_rtp = (rtp_packet *) e->data;
        struct pdb *participants = (struct pdb *)rtp_get_userdata(session);
        struct pdb_e *state = pdb_get(participants, e->ssrc);
        struct timeval curr_time;

        switch (e->type) {
        case RX_RTP:
                if (pckt_rtp->data_len > 0) {   /* Only process packets that contain data... */
                        pbuf_insert(state->playout_buffer, pckt_rtp);
                }
                gettimeofday(&curr_time, NULL);
                tfrc_recv_data(state->tfrc_state, curr_time, pckt_rtp->seq,
                               pckt_rtp->data_len + 40);
                break;
        case RX_TFRC_RX:
                /* compute TCP friendly data rate */
                break;
        case RX_RTCP_START:
                break;
        case RX_RTCP_FINISH:
                break;
        case RX_SR:
                break;
        case RX_RR:
                process_rr(session, e);
                break;
        case RX_RR_EMPTY:
                break;
        case RX_SDES:
                process_sdes(participants, e->ssrc, (rtcp_sdes_item *) e->data);
                break;
        case RX_APP:
                pckt_app = (rtcp_app *) e->data;
                if (strncmp(pckt_app->name, "RTT_", 4) == 0) {
                        assert(pckt_app->length == 3);
                        assert(pckt_app->subtype == 0);
                        gettimeofday(&curr_time, NULL);
//                      tfrc_recv_rtt(state->tfrc_state, curr_time, ntohl(*((int *) pckt_app->data)));
                }
                break;
        case RX_BYE:
                break;
        case SOURCE_DELETED:
                {
                        struct pdb_e *pdb_item = NULL;
                        if(pdb_remove(participants, e->ssrc, &pdb_item) == 0) {
                                if (pdb_item->decoder_state_deleter) {
                                        pdb_item->decoder_state_deleter(pdb_item->decoder_state);
                                }
                        }
                }
                break;
        case SOURCE_CREATED:
                pdb_add(participants, e->ssrc);
                break;
        case RR_TIMEOUT:
                break;
        default:
                debug_msg("Unknown RTP event (type=%d)\n", e->type);
        }
}