rtphello.cpp

A basic example of how to use RTPPacket

// rtphello
// A very simple program for testing and illustrating basic features of ccRTP.
// Copyright (C) 2001,2002  Federico Montesino <fedemp@altern.org>
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//  
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//  
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


// This is an introductory example file that illustrates basic usage
// of ccRTP. You will also see a bit on how to use other classes from
// CommonC++.

// I am a typical hello world program. I consist of a sender thread,
// that sends the salutation message on RTP packets; and a receiver
// thread, that prints the messages. This is a program with an unsual
// structure, the receiver just tries to process the first available
// packet periodically, and both are in the same program. Thus, it
// should not be seen as an example for typical applications but as a
// test of some functions of ccRTP.

#include <cstdio>
#include <ctime>
// In order to use ccRTP, the RTP stack of CommonC++, just include...
#include <ccrtp/rtp.h>

#ifdef  CCXX_NAMESPACES
using namespace ost;
using namespace std;
#endif

// base ports
const int RECEIVER_BASE = 33634;
const int TRANSMITTER_BASE = 32522;

// For this example, this is irrelevant. 
//const int TIMESTAMP_RATE = 90000;

class ccRTP_Hello_Rx: public Thread
{

private:
        // socket to receive packets
        RTPSession *socket;
        // loopback network address
        InetHostAddress local_ip;
        // identifier of this sender
        uint32 ssrc;
        
public:
        ccRTP_Hello_Rx(){
                // Before using ccRTP you should learn something about other
                // CommonC++ classes. We need InetHostAddress...

                // Construct loopback address
                local_ip = "127.0.0.1";

                // Is that correct?
                if( ! local_ip ){  
                        // this is equivalent to `! local_ip.isInetAddress()'
                        cerr << "Rx: IP address is not correct!" << endl;
                        exit();
                }

                // create socket for RTP connection and get a random
                // SSRC identifier
                socket = new RTPSession(local_ip,RECEIVER_BASE);
                ssrc = socket->getLocalSSRC();
        }
        
        ~ccRTP_Hello_Rx(){
                cout << endl << "Destroying receiver -ID: " << hex
                     << (int)ssrc;
                terminate();
                delete socket;
                cout << "... " << "destroyed.";
        }

        // This method does almost everything.
        void run(void){    

                cout << "Hello, " << defaultApplication().
                        getSDESItem(SDESItemTypeCNAME)
                     << " ..." << endl;
                // redefined from Thread.
                // Set up connection
                socket->setSchedulingTimeout(20000);
                socket->setExpireTimeout(3000000);
                //socket->UDPTransmit::setTypeOfService(SOCKET_IPTOS_LOWDELAY);
                if( !socket->addDestination(local_ip,TRANSMITTER_BASE) )
                        cerr << "Rx (" << hex << (int)ssrc 
                             << "): could not connect to port." 
                             << TRANSMITTER_BASE;
                
                cout << "Rx (" << hex << (int)ssrc
                     << "): " << local_ip.getHostname() 
                     << " is waiting for salutes in port "
                     << RECEIVER_BASE << "..." << endl;
                
                socket->setPayloadFormat(StaticPayloadFormat(sptMP2T));
                socket->startRunning();
                // Let's check the queues  (you should read the documentation
                // so that you know what the queues are for).
                cout << "Rx (" << hex << (int)ssrc 
                     << "): The queue is " 
                     << ( socket->isActive() ? "" : "in") 
                     << "active." << endl;              

                // This is the main loop, where packets are received.
                for( int i = 0 ; true ; i++ ){
                        
                        // Wait for an RTP packet.
                        const AppDataUnit *adu = NULL;
                        while ( NULL == adu ) {
                                Thread::sleep(10);
                                adu = socket->getData(socket->getFirstTimestamp());
                        }
                        
                        // Print content (likely a salute :))
                        // Note we are sure the data is an asciiz string.
                        time_t receiving_time = time(NULL);
                        char tmstring[30];
                        strftime(tmstring,30,"%X",localtime(&receiving_time));
                        cout << "Rx (" << hex << (int)ssrc 
                             << "): [receiving at " << tmstring << "]: " 
                             << adu->getData() << endl;
                        delete adu;
                }
        }
};

class ccRTP_Hello_Tx: public Thread, public TimerPort
{

private:
        // socket to transmit
        RTPSession *socket;
        // loopback network address
        InetHostAddress local_ip;
        // identifier of this sender
        uint32 ssrc;

public:
        ccRTP_Hello_Tx(){
                // Before using ccRTP you should learn something about other
                // CommonC++ classes. We need InetHostAddress...

                // Construct loopback address
                local_ip = "127.0.0.1";
                
                // Is that correct?
                if( ! local_ip ){  
                // this is equivalent to `! local_ip.isInetAddress()'
                        cerr << "Tx: IP address is not correct!" << endl;
                        exit();
                }
                
                socket = new RTPSession(local_ip,TRANSMITTER_BASE);
                ssrc = socket->getLocalSSRC();
        }

        ~ccRTP_Hello_Tx(){
                cout << endl << "Destroying transmitter -ID: " << hex 
                     << (int)ssrc;
                terminate();
                delete socket;
                cout << "... " << "destroyed.";
        }

        // This method does almost everything.
        void run(void){    
                // redefined from Thread.
                cout << "Tx (" << hex << (int)ssrc << "): " << 
                        local_ip.getHostname() 
                     << " is going to salute perself through " 
                     << local_ip << "..." << endl;
                
                // Set up connection
                socket->setSchedulingTimeout(20000);
                socket->setExpireTimeout(3000000);
                if( !socket->addDestination(local_ip,RECEIVER_BASE) )
                        cerr << "Tx (" << hex << (int)ssrc 
                             << "): could not connect to port." 
                             << RECEIVER_BASE;
                
                cout << "Tx (" << hex << (int)ssrc << 
                        "): Transmitting salutes to port "
                     << RECEIVER_BASE << "..." << endl;

                uint32 timestamp = 0;
                // This will be useful for periodic execution
                TimerPort::setTimer(1000);

                // This is the main loop, where packets are sent.
                socket->setPayloadFormat(StaticPayloadFormat(sptMP2T));
                socket->startRunning();
                // Let's check the queues  (you should read the documentation
                // so that you know what the queues are for).
                cout << "Tx (" << hex << (int)ssrc << "): The queue is "
                     << ( socket->isActive()? "" : "in")
                     << "active." << endl;

                for( int i = 0 ; true ;i++ ){

                        // send RTP packets, providing timestamp,
                        // payload type and payload.  
                        // construct salute.
                        unsigned char salute[50];
                        snprintf((char *)salute,50,
                                 "Hello, brave gnu world (#%u)!",i);
                        time_t sending_time = time(NULL);
                        // get timestamp to send salute
                        if ( 0 == i ){
                                timestamp = socket->getCurrentTimestamp();
                                
                        } else {
                                // increment for 1 second
                                timestamp += socket->getCurrentRTPClockRate();
                        }       

                        socket->putData(timestamp,salute,
                                        strlen((char *)salute)+1);
                        // print info
                        char tmstring[30];
                        strftime(tmstring,30,"%X",
                                 localtime(&sending_time));
                        cout << "Tx (" << hex << (int)ssrc 
                             << "): sending salute " << "no " << dec << i 
                             << ", at " << tmstring 
                             << "..." << endl;

                        // Let's wait for the next cycle
                        Thread::sleep(TimerPort::getTimer());
                        TimerPort::incTimer(1000);
                }
        }
};

int main(int argc, char *argv[])
{

        // Construct the two main threads. they will not run yet.
        ccRTP_Hello_Rx *receiver = new ccRTP_Hello_Rx;
        ccRTP_Hello_Tx *transmitter = new ccRTP_Hello_Tx;
        
        cout << "This is rtphello, a very simple test program for ccRTP." << 
                endl << "Strike [Enter] when you are fed up with it." << endl;

        // Start execution of hello now.
        receiver->start();
        transmitter->start();

        cin.get();

        delete transmitter;
        delete receiver;

        cout << endl << "That's all." << endl;
        
        return 0;
}

---