receiver.c

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/prctl.h>
#include <sys/signalfd.h>
#include <sys/timerfd.h>
#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>

#include <ortp/ortp.h>
#include <mediastreamer2/mscommon.h>
#include <mediastreamer2/mssndcard.h>
#include <mediastreamer2/msfilter.h>
#include <mediastreamer2/msrtp.h>
#include <mediastreamer2/msticker.h>

void on_ssrc_changed(RtpSession *session, ...)
{
//        printf ("%s\n", __func__);
        rtp_session_reset(session);
}

void on_payload_type_changed (RtpSession *session, ...) { (void) session; /* printf ("%s\n", __func__); */ }
void on_network_error        (RtpSession *session, ...) { (void) session; /* printf ("%s\n", __func__); */ }
void on_timestamp_jump       (RtpSession *session, ...) { (void) session; /* printf ("%s\n", __func__); */ }

static RtpSession *rtp_init(const char *addr, const int port, const char *sendaddr)
{
        RtpSession *rtpsession;
        char *ssrc;
        int rc;

        ortp_init();
        ortp_scheduler_init();
        //ortp_set_log_level_mask(ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR);
        ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR);
        rtpsession=rtp_session_new(RTP_SESSION_RECVONLY);

        printf("Jitter compensation was %s\n",
                        rtp_session_adaptive_jitter_compensation_enabled (rtpsession)?
                        "ON":"OFF");
        rtp_session_enable_adaptive_jitter_compensation (rtpsession, true);

        rc = rtp_session_signal_connect (rtpsession , "ssrc_changed"         , (RtpCallback) on_ssrc_changed         , 0);
        if (rc < 0) {
                printf ("rtp_session_signal_connect failed %s:%d\n", __func__, __LINE__);
        }
        rc = rtp_session_signal_connect (rtpsession , "payload_type_changed" , (RtpCallback) on_payload_type_changed , 0);
        if (rc < 0) {
                printf ("rtp_session_signal_connect failed %s:%d\n", __func__, __LINE__);
        }
        rc = rtp_session_signal_connect (rtpsession , "network_error"        , (RtpCallback) on_network_error        , 0);
        if (rc < 0) {
                printf ("rtp_session_signal_connect failed %s:%d\n", __func__, __LINE__);
        }
        rc = rtp_session_signal_connect (rtpsession , "timestamp_jump"       , (RtpCallback) on_timestamp_jump       , 0);
        if (rc < 0) {
                printf ("rtp_session_signal_connect failed %s:%d\n", __func__, __LINE__);
        }

        rtp_session_set_scheduling_mode(rtpsession,1);
        rtp_session_set_blocking_mode(rtpsession,1);
        rtp_session_set_connected_mode(rtpsession,FALSE);
        rtp_session_set_multicast_loopback(rtpsession,TRUE);
        rtp_session_set_multicast_ttl(rtpsession,15);
        rtp_session_set_ssrc_changed_threshold(rtpsession, 1);

        if (sendaddr) {
                rtp_session_set_remote_addr(rtpsession,sendaddr,port);
        }
        rtp_session_set_local_addr(rtpsession,addr,port);
        rtp_session_set_payload_type(rtpsession,0);

        ssrc=getenv("SSRC");
        if (ssrc!=NULL) {
                printf("using SSRC=%i.\n",atoi(ssrc));
                rtp_session_set_ssrc(rtpsession,atoi(ssrc));
        }

        return rtpsession;
}


static void rtp_exit(RtpSession *rtpsession)
{
        rtp_session_destroy(rtpsession);
        ortp_exit();
        ortp_global_stats_display();
}

int main(int argc, char **argv)
{
    const char *alsacard = argv[1];
    const char *addr = "239.0.0.1";
    const char *sendaddr = "239.0.0.1";
    int         port = atoi(argv[2]);
    int sr = 8000;
    char *enc = "PCMU";

    ms_init();

    RtpSession *rtpsession = rtp_init ( addr, port, sendaddr);
    MSSndCard *card=ms_alsa_card_new_custom(alsacard,alsacard);
    ms_snd_card_manager_add_card(ms_snd_card_manager_get(),card);

    /* audio capture filter */
    MSFilter *soundwrite=ms_snd_card_create_writer(card);

    MSFilter *decoder=ms_filter_create_decoder(enc);
    if (!decoder) {
            ms_error ("Cannot find decoder");
            exit(1);
    }

    MSFilter *rtprecv=ms_filter_new(MS_RTP_RECV_ID);

    ms_filter_call_method(rtprecv,MS_RTP_RECV_SET_SESSION,rtpsession);

    int chan=1;
    ms_filter_call_method(soundwrite,MS_FILTER_SET_SAMPLE_RATE,&sr);
    ms_filter_call_method(decoder,MS_FILTER_SET_SAMPLE_RATE,&sr);

    int br = 8 * sr;
    ms_filter_call_method(soundwrite,MS_FILTER_SET_BITRATE,&br);
    ms_filter_call_method(decoder,MS_FILTER_SET_BITRATE,&br);

    ms_filter_call_method(soundwrite,MS_FILTER_SET_NCHANNELS, &chan);

    ms_filter_link(rtprecv,0,decoder,0);
    ms_filter_link(decoder,0,soundwrite,0);

    /* create ticker */
    MSTicker *ticker=ms_ticker_new();

    ms_ticker_attach(ticker,soundwrite);


    /*********** MAIN LOOP *************/
    while(1) {
        sleep(1);
    }

    ms_ticker_detach(ticker, soundwrite);
    ms_ticker_destroy(ticker);

    ms_filter_unlink(decoder,0,soundwrite,0);
    ms_filter_unlink(rtprecv,0,decoder,0);

    ms_filter_destroy(decoder);
    ms_filter_destroy(soundwrite);
    ms_filter_destroy(rtprecv);

    // Deallocate resources
    rtp_exit (rtpsession);

    return 0;
}