Browser to Browser VOIP Solution

Document Sample
Browser to Browser VOIP Solution Powered By Docstoc
					   CENG/ELEC 499A
     Final Report

Browser to Browser VOIP
        Solution

    Andrew Mastracci
    Robert MacNeill
     Shawn Balding
Table of Contents
Table of Contents................................................................................................................ 2
List of Figures ..................................................................................................................... 3
Design Problem................................................................................................................... 4
System Overview ................................................................................................................ 4
  Use Case Model .............................................................................................................. 4
  Account Manager............................................................................................................ 5
     Persistent Storage Module .......................................................................................... 5
     User Account Module ................................................................................................. 9
     Web Interface Module .............................................................................................. 17
  Ramrod Web Applet ..................................................................................................... 18
  SocketSIP Component .................................................................................................. 19
     SIP Signaling Protocol.............................................................................................. 19
     Implementation of the SIP protocol.......................................................................... 21
     SIP Packets................................................................................................................ 21
     Future SocketSIP Improvements .............................................................................. 21
  Sound Capture and Playback ........................................................................................ 22
     CaptureAudio Method .............................................................................................. 22
     PlayAudio Method .................................................................................................... 22
     Future Audio Improvements ..................................................................................... 23
Conclusion ........................................................................................................................ 24
Appendix A – Source Code .............................................................................................. 25




                                                                  2
List of Figures
Figure 1 System Overview.................................................................................................. 4
Figure 2 Ramrod Use Case Diagram .................................................................................. 5
Figure 3 DataBase Module Class Diagram......................................................................... 6
Figure 4 Get (Persistent Storage) Sequence Diagram......................................................... 7
Figure 5 Get (Persistent Storage) Activity Diagram........................................................... 8
Figure 6 Put (Persistent Storage) Sequence Diagram ......................................................... 8
Figure 7 Put (Persistent Storage) Activity Diagram ........................................................... 9
Figure 8 Data Storage Objects .......................................................................................... 10
Figure 9 User Account Module......................................................................................... 11
Figure 10 Login Sequence Diagram ................................................................................. 12
Figure 11 Login Activity Diagram ................................................................................... 12
Figure 12 Create New Account Sequence Diagram ......................................................... 13
Figure 13 Create New Account Activity Diagram ........................................................... 13
Figure 14 Edit Account Sequence Diagram...................................................................... 14
Figure 15 Edit Account Activity Diagram........................................................................ 14
Figure 16 Add Account Sequence Diagram ..................................................................... 15
Figure 17 Add Account Activity Diagram........................................................................ 15
Figure 18 Remove Contact Sequence Diagram ................................................................ 16
Figure 19 Remove Contact Activity Diagram .................................................................. 16
Figure 20 Web page generated by ContactListServlet ..................................................... 17
Figure 21 Ramrod Web Applet instance........................................................................... 18
Figure 22 Ramrod Web Applet......................................................................................... 19
Figure 23 Session Initiation Protocol................................................................................ 20




                                                             3
Design Problem
The project will involve the realization of a complete java based server
application which will serve as a hub for person to person web based browser to
browser voice communication. For complete functionality at the end of the
design cycle, our Browser to Browser Voice over Internet Protocol (BBVoIP) will
provide the general public with a means of voice communication over the internet
without the need for downloading any proprietary software.


System Overview
With the Ramrod BBVoIP system, the user (caller and callee) will log on via the
Ramrod website and be able to manage their contact list and information. The
user can then place or receive calls directly to and from their contacts and begin
peer to peer communication. No call traffic is routed through the Ramrod server
or any other proxy server, freeing the Ramrod BBVoIP system from possible
consequences of high volume system traffic.

                                     Peer to Peer Voice
                                      Communication




                     Update and
                   Receive Contact
                     Information                            Update and
                                                          Receive Contact
                                                            Information




                                                               MySQL
                                                              Database


                                 Ramrod Server

Figure 1 System Overview



Use Case Model
In order to describe the scope of the RamRod project a use case model was
devised. Figure 1 outlines the use cases involved in the Ramrod system.


                                             4
                                     Place Call

        Caller                                              <<include>>
                                   EditContactList

                                                      <<include>>



                                      Login                               Validation
                                              <<include>>

                                                         <<include>>
         User
                               CreateAccount                              Maintainance



                                                                                         Administrator
                                   EditAccount
                                                                             Startup


                                   Recieve Call

        Callee



Figure 2 Ramrod Use Case Diagram


Account Manager
The website will provide the public with everything needed to start voice
communication over the internet. This information will have to be collected from
the user, stored as objects, so the information can be used by the system and
backed up persistently.

The BBVoIP account management system can be broken down into three main
modules. At the top level is the user interface module consisting of Java Servlet
classes. The intermediate levels are the user account classes and their
corresponding controller classes. Finally a database module is used to create
persistent storage of all the user accounts or contacts.


Persistent Storage Module
For the BBVoIP system, a MySQL database was used. The motivation behind
this decision was the availability of MySQL as a completely free and complete


                                                  5
open source database. Also a prime factor in this decision was based on the
availability of a Java compliant driver. The driver provided the database module
with all the interfaces needed to connect to and access the MySQL database.
The class diagram of the system is shown in Figure 3.



                                                                     PersistanceFacade
                                                                        (from DataBase)

                                                                PersistanceFacade()
                                                                getInstance()
                                                                get()
                                                                put()
                                                                find()
                                             +theConnectionManager
                                                                delete()
                                                                                          -$instance
                  ConnectionManager
                     (from DataBase)
                                                                         +theMapperFactory
     connections : Logical View::java::util::Stack                             MapperFactory
                                                      -$instance
                                                                                  (from DataBase)
     ConnectionManager()
     getInstance()
     getConnection()                                                            MapperFactory() +$instance
     returnConnection()                                                         getInstance()
                                                                                getMapper()

                -theConnectionManager      -theConnectionManager
                             ContactMapper
        CallMapper                  (from DataBase)
       (from DataBase)
                                                                   ContactListMapper
                              ContactMapper()                        (from DataBase)
                              getInstance()
       CallMapper()
                              delete()                           ContactListMapper()
       getInstance() -$instance
                              find()                             getInstance()
       delete()
                              get()                              delete()
       find()
                              getMaxId()                         find()          -$instance
       get()
                              put()                              get()
       getMaxId()
       put()                                -$instance           getMaxId()
                                                                 put()




                                      IMapper
                                     (from Da...)

                                         get()
                                         put()
                                      getMaxId()
                                        find()
                                       delete()



Figure 3 DataBase Module Class Diagram

A Mapper interface was first created to provide the functionality for an object that
will be backed up to the database. Each implementation of a Mapper will provide
a set of methods to read and write data to and from the database. The two
objects in the Account Management system which needed to be placed in the



                                                             6
database were the Contact (containing user information) and the ContactLists
(containing a list of which users a contact can make calls to). These are realized
in the ContactListMapper class and the ContactMapper class.

The connection to the database was accomplished with the ConnectionManager
class which would maintain a stack of connection. When a Mapper wished to use
the database it would request a connection to the database through the
ConnectionManager, which will connect to the database using the MySQL driver
and return a reference to a connection that the requesting object can use to
make changes to the database. This class implemented the singleton pattern as
there was no need for multiple connections managers.

The database module was designed to be as transparent as possible to the user
account layer which is accessing it. This transparency is accomplished through
the use of the PersistanceFacade and MapperFactory classes. The
MapperFactory will return a reference to the appropriate mapper based on the
object which is passed to it. The PersistanceFacade contains all the functionality
of the Mappers and using the MapperFactory Classes, other modules wishing to
use the database only need reference to this Façade.

Figures 4-7 outlines the relationship between the classes in the database module
when an object is put in the database or retrieved from the database.



 : ContactManager             : PersistanceFacade        : MapperFactory                               : ConnectionManager




                    1: get(int, Class)

                                          2: getMapper(Class)

                                                                          3:   : ContactMapper
                                                    4:


                                                            5: get(int)

                                                                                          6: getConnection( )

                                                                                                                        7:     conn :
                                                                                                                             Connection
                                                                                                  8:

                                                                                                   9: prepareStatement( )

                                                                                     10: returnConnection(Connection)


                                                                                                 11:

                                                                12:

                      13:




Figure 4 Get (Persistent Storage) Sequence Diagram




                                                                      7
         : ContactManager


                1: get(int, Class)
               13:

             : PersistanceFacade
                                                                      2: getMapper(Class)


              12:                                                                4:                                        : MapperFactory
                     5: get(int)


        : ContactMapper                                                     3:

                                              9: prepareStatement( )

                     6: getConnection( )
             10: returnConnection(Connection)
                                                                                             conn :
                                                                                           Connection
                         8:
                        11:                                         7:




                              : ConnectionManager



Figure 5 Get (Persistent Storage) Activity Diagram


: ContactManager              : PersistanceFacade             : MapperFactory                                          : ConnectionManager




         1: put(Logical View::java::lang::Object)

                                            2: getMapper(Class)

                                                                                 3:            : ContactMapper
                                                       4:


                                                    5: put(Logical View::java::lang::Object)

                                                                                                          6: getConnection( )

                                                                                                                                        7:     conn :
                                                                                                                                             Connection
                                                                                                                  8:

                                                                                                                   9: prepareStatement( )

                                                                                                     10: returnConnection(Connection)


                                                                                                                 11:

                                                                      12:

                      13:




Figure 6 Put (Persistent Storage) Sequence Diagram




                                                                            8
         : ContactManager
                                                                 : ContactMapper
                      5: put(Logical View::java::lang::Object)
                                                                                   9: prepareStatement( )

    1: put(Logical View::java::lang::Object)
             13:

                                                12:                                                           conn :
                                                                                                            Connection
         : PersistanceFacade
                                           3:                            6: getConnection( )
                                                                 10: returnConnection(Connection)
                                                                         8:
                                                                       11:
                                                                                           7:

               2: getMapper(Class)
                4:




               : MapperFactory                                         : ConnectionManager




Figure 7 Put (Persistent Storage) Activity Diagram



User Account Module
The User Account module is responsible for manipulating two primary data
storage classes. The first is the Contact object which contains an identifier and all
the pertinent information needed for a user to sign on to the system and make
calls. The second object is the ContactList which contains the list of other
contacts which can be called by the contact. These objects are shown in Figure
3.




                                                           9
                           Contact
                   (from AccountManager)
      maxID : int = 0
      contactID : int
      uname : Logical View::java::lang::String               ContactList
      passwd : Logical View::java::lang::String
                                                        (from AccountManager)
      email : Logical View::java::lang::String
      contactListID : int                              maxID : int = 0
      port : int                                       ContactListID : int
                                                       contacts : Vector = null
      Contact()
      getID()                                          ContactList()
      getMaxID()                                       getID()
      getUname()                                       getContacts()
      getPasswd()                                      add()
      getEmail()                                       delete()
      getContactListID()                               toString()
      setID()
      setCListID()
      toString()


Figure 8 Data Storage Objects

A list of all data storage objects currently in memory is stored in a corresponding
manager class. The manager classes are also responsible for creating new
Contacts and ContactLists, adding them to there own lists in memory and
updating the database. The ability to search the lists based on some criteria
provided is also implemented by these manager classes. The class diagram for
the User Account module can be seen is Figure 9.




                                                  10
                                        ContactListController
                                         (from AccountManager)                                                  SearchController
                                                                                                               (from AccountManager)
                                        ContactListController()
                                                                           LoginController
          NewContactController          getInstance()
                                                                         (from AccountManager)                 SearchController()
                                        addContact()
           (from AccountManager)                                                                               getInstance()
                                        removeContact()
                                                                         LoginController()                     search()           -$instance
                                        findID()                                                 -$instance
         createNewContact()                                              getInstance()
         NewContactController()                           +$instance     login()
         getInstance()                                                   validatePassword()
         editContact()          -$instance

    -theContactListManager                                                                           -theContactManager
                                                              -theContactManager
                                                                            -theContactManager
                          -theContactListManager

                                                                         ContactManager
                                          -theContactListManager
                                                     -theContactManager(from AccountManager)
                ContactListManager                                          userList : Vector
                (from AccountManager)
                                                                            ContactManager()
              contactLists : Vector                                         toString()
                                                                            createNewContact()
              ContactListManager()                                          editContact()
              getInstance()                                                 getInstance()
              getContactLists()                                             addContact() -$instance
              findID()                                                      find()
              createNewContactList()                                        find()
              addContactList()                                              find()
                                                                            setContactInfo()




Figure 9 User Account Module



Four controller classes provide external interfaces for other modules to access
the manager classes. These classes are the LoginController,
NewAccountController, ContactListController and SearchController. Each
provides a different set of functionality to the user interface layer of the
application.

The LoginController is solely responsible for verifying a users email and
password at the time of login. It then provides the Contact information when the
login is successful. The interaction between classes for this functionality is
outlined in Figure 10 and 11.




                                                                  11
                            : LoginController                  : ContactManager
         : User

              1: login(Logical View::java::lang::String, Logical View::java::lang::String)

                                                          2:




                                     3: validatePassword(Contact, Logical View::java::lang::String)

                       4:




Figure 10 Login Sequence Diagram


1: login(Logical View::java::lang::String, Logical View::java::lang::String)


                                                3: validatePassword(Contact, Logical View::java::lang::String)
     : User

                                      4:
                                                                         : LoginController




                                                     2:
          : ContactManager


Figure 11 Login Activity Diagram



The NewContactController is responsible for providing the interfaces required to
create a new contact and edit an existing contact. The functionality of the
methods in these classes is outlined in Figures 12-15.




                                                     12
                        : NewContactController                   : ContactManager                                          : ContactListManager
        : User

          1: createNewContact(Logical View::java::lang::String, Logical View::java::lang::String, Logical View::java::lang::String)

                                                                         2: createNewContactList( )




                                                                                                                                             3:         ContactList :
                                                                                                                                                         ContactList
                                                                                                                                        4: addContactList(ContactList)


                                                                                      5:
                                           6: createNewContact(Logical View::java::lang::String, Logical View::java::lang::String, Logical View::java::lang::String, int)




                                                                                7: Contact(Logical View::java::lang::String, Logical View::java::lang::String, Logical View::java::lang::String)
                                                                                                    Contact :
                                                                                                     Contact
                                                                            8: ValidateContact()



                                                                                           9:

                                                        10:

                      11:




Figure 12 Create New Account Sequence Diagram



                                      : User


                                     11:
                                                1: createNewContact(Logical View::jav a::lang::String, Logical View::jav a::lang::String, Logical View::jav a::lang::String)


                                 : NewContactController                                         Contact :
                                                                                                 Contact


                                                                       7: Contact(Logical View::jav a::lang::String, Logical View::jav a::lang::String, Logical View::jav a::lang::String)




                                           5:                          6: createNewContact(Logical View::jav a::lang::String, Logical View::jav a::lang::String, Logical View::jav a::lang::String, int)
                                                             10:
                                                 2: createNewContactList( )

                                                                         8: ValidateContact()
                                 4: addContactList(ContactList)                   9:
      ContactList :
       ContactList


                            3:                                                  : ContactManager
                                    : ContactListManager




Figure 13 Create New Account Activity Diagram




                                                                                        13
                                   : NewContactController                   : ContactManager
    : User

        1: editContact(int, Logical View::java::lang::String, Logical View::java::lang::String)


                                                 2: editContact(int, Logical View::java::lang::String, Logical View::java::lang::String)

                                                                                        3: find(int)

                                                                                        4: setContactInfo(Contact, Logical View::java::lang::String, Logical View::java::lang::String)

                                                                 5:

                         6:




Figure 14 Edit Account Sequence Diagram
     1: editContact(int, Logical View::java::lang::String, Logical View::java::lang::String)

                                                                                             : NewContactController

                                                      6:
                : User


                                                           2: editContact(int, Logical View::java::lang::String, Logical View::java::lang::String)


                                                                                                       5:

                                                                                                      3: find(int)
                                                              4: setContactInfo(Contact, Logical View::java::lang::String, Logical View::java::lang::String)




                                                                                                  : ContactManager


Figure 15 Edit Account Activity Diagram

The ContactListController and SearchConrtoller are responsible for providing
interfaces to manipulate and create new contact lists. The main function of this
class is to add and remove a specified contact from a specified contact list. The
functionality of these two implementations is shown in Figures 16-19.




                                                                          14
                              : SearchController                    : ContactManager           : ContactListController
        : User

           1: search(Logical View::java::lang::String)

                                                               2:



                                                3: addContact(int, int)

                                                                                          4:

                                                                                                            5: findID(int)

                                                                                                            6: addContact(int, int)

                                                          7:




Figure 16 Add Account Sequence Diagram
                                                                                 5: findID(int)
                                                                            6: addContact(int, int)



                               3: addContact(int, int)
                                                                            : ContactListController

                                           7:
            : User




                                                                                               4:


   1: search(Logical View::java::lang::String)



                                                                                       : ContactManager

                                                         2:



                 : SearchController



Figure 17 Add Account Activity Diagram




                                                                    15
                       : SearchController                 : ContactManager          : ContactListController
 : User

    1: search(Logical View::java::lang::String)
                                                     2:



                                        3: addContact(int, int)

                                                                               4:

                                                                                                 5: findID(int)

                                                                                                6: removeContact(int, int)




Figure 18 Remove Contact Sequence Diagram

                                                          : SearchController
   1: search(Logical View::java::lang::String)




                                                                                        2:
  : User




            3: addContact(int, int)
                                                                                                : ContactManager


                                                                        4:
                                     5: findID(int)
                               6: removeContact(int, int)




                                 : ContactListController



Figure 19 Remove Contact Activity Diagram




                                                                  16
Web Interface Module
The web interface module uses the previously mentioned interfaces provided by the user
account controllers and generates web pages accordingly. The servlets provide users the
ability to login, add accounts, edit contact information, and add contacts to their contact
list. As an example of a servlet generated web page, Figure 20 shows the web page
generated by the ContactListServlet.




Figure 20 Web page generated by ContactListServlet




                                              17
Ramrod Web Applet
Serving as the functional component of the BBVoIP project, the Ramrod Web
Applet handles all the tasks associated with a peer to peer call. Once the user
has logged in, an instance of the Ramrod Web Applet is launched in their
browser as seen in Figure 21.




Figure 21 Ramrod Web Applet instance

The instance contains a vector of all the contact information needed from the
database to begin peer to peer communication with the user’s contacts. The
Ramrod Web Applet operates by using its two major components, the SocketSIP
component which handles the session initiation protocol, and the AudioSlave
component which handles audio capture, transmission, receives, and play back.




                                       18
                            Ramrod Web Applet

                                         SocketSIP

                                                      DatagramSocket
                     Applet GUI
                                                         out_sock



                                                      DatagramSocket
                           SIP Receiver Logic
                                                          in_sock



                                                                       Internet



                                         AudioSlave



                               Target        DatagramSocket
                              DataLine          out_sock
        Microphone


                               Source        DatagramSocket
                              DataLine           in_sock
         Speaker




Figure 22 Ramrod Web Applet



SocketSIP Component
The SocketSIP component of the Ramrod Web Applet has a graphical user
interface (GUI) to display the user’s contact list and allow the user to initiate a call
(or answer a call). To make a call, the user highlights the name of the contact
that they wish to talk to within the contact list. When the user clicks the “Start
Conversation” button, the IP address and port information of that contact are
fetched, and a session is created with that contact using the SIP Signaling
Protocol.

SIP Signaling Protocol
Before voice data is transmitted between two users, a session is established
between these two users. The session initiation protocol (SIP) is commonly used
for peer to peer applications, such as instant messaging and in this case, voice-
over IP. The SIP protocol is illustrated in Error! Reference source not found.3.




                                                                19
    Caller A                            Receiver B
   1.                      INVITE




                          RINGING
   2.                        OR
                           BUSY




                             OK
   3.                        OR
                          CANCEL



   4.                       ACK



   5.                   VOICE DATA



   6.                       BYE



   7.                        OK



Figure 23 Session Initiation Protocol

Caller A initiates communications by sending an invitation to B. B will
automatically reply with either a RINGING message or a BUSY message,
depending on whether or not B is currently available. If B is not busy, then B is
given the option to accept or decline the call from A. If B chooses to decline,
then a CANCEL signal is sent to A. If B chooses to accept, then B sends an OK
signal to A. Upon receipt of this OK signal, A automatically sends an ACK signal,
thereby completing the session initiation process.

At this point, the session is established, and voice data can be sent and received
to and from both users. Note that the receiver of the initial INVITE message
need not have the sender in their contact list. This is because the receiver will
take the sender’s IP address and port information, as well as their user name,
from the invite packet. This gives the receiver all the information that they need
to send a proper response packet.

When either user decides to end the call, that user may do so by sending the
BYE message to the other user. The receiver of the BYE signal responds by
sending an OK message, and the call is complete.


                                           20
Implementation of the SIP protocol
In the early stages of this project, it was thought that the implementation of the
SIP protocol could be done using the Jain-SIP API, which was developed by Sun
Microsystems and the National Institute of Standards and Technology (NIST) and
is available at https://jain-sip.dev.java.net/.

This solution was found to be overly confusing and difficult to implement
however, and it was realized that the SIP protocol could be emulated quite simply
by using Datagram Packets.

The final result is a stripped-down version of the SIP protocol which makes use
of only the features required for this project.



SIP Packets
The SIP signaling packets utilized for this project are in the following format,
where the constant terms are in bold and the variable terms are italicized:

Message_Type sip: destination_user@dest_user_IP_address SIP/2.0
From: sip: source_user@source_user_IP_address / source_port
To: sip: dest_user@dest_user_IP_address / dest_port
CSeq: Message_Type

When a packet is received, it is parsed by the receiving application so that the
receiver knows what to do with the message, according to the diagram in Figure
23. For instance, when a receiver parses the message, and finds the message
type to be INVITE, the receiving application automatically generates a response
packet, containing either a BUSY or OK message, as well as enabling the
“Accept” and “Decline” buttons for the user.

The packets are assembled using the DatagramPacket class, and are sent and
received using the DatagramSocket class. These Classes are found in the
java.net package, which is standard in the current java SDK. Therefore, no extra
downloads will be required for a user to implement this projects, assuming they
have the current Java JRE.


Future SocketSIP Improvements
Currently the SocketSIP functionality works well to emulate the SIP protocol in its
simplest form. However, some improvements could be made to the process that
could make the Ramrod BBVoIP system significantly more attractive to many
users.

First, security measures should be added to the signaling procedure. As it
stands, any user can add any other user to their contact list and make a call to


                                         21
that contact. Additional functionality could be added that would compare the
username of a caller with the receiver’s list of contacts. If the caller is not on the
list, then the call will be automatically declined. This sort of functionality could be
very desirable as VoIP technology becomes more popular, and starts being
utilized by intrusive strategic marketing.

Similarly, users should be allowed the option to keep a list of contacts that are on
their contact list, but which the user would like to block temporarily from
contacting them. Some text messaging programs contain this functionality and it
has proven to be quite important in some situations, such as when a contact’s
computer contains a virus.

Another improvement that could be made that would really separate the Ramrod
BBVoIP system from other similar products is the addition of a conference call
feature. This would require a more complex signaling procedure to initiate the
session as more clients would be involved; however it would significantly expand
the user base of the system.


Sound Capture and Playback
In order to capture and playback sound within a java application, objects
representing the input and output buffers of the pc’s sound hardware must be
instantiated. When a call has been established between two users, each user’s
application calls two methods within their AudioSlave class: captureAudio() and
playAudio().

CaptureAudio Method
The captureAudio() method creates a TargetDataLine which is a type of DataLine
from which audio data can be read. Within the TargetDataLine object is the
audio information (AudioFormat) settings such as the sample rate and sample bit
size, changes to the format will affect sound quality and data transfer
performance. Once created, the TargetDataLine is opened, binding the object to
the input buffer, and a new thread is spawned, captureAudioThread().

This captureAudioThread() uses the TargetDataLine to continually read and drain
the user’s sound card (or on-board sound device) input buffer. The voice data is
shipped out via UDP through a Datagram Socket (out_sock) which the thread
binds to a random available port.

PlayAudio Method
The playAudio() method creates a SourceDataLine that is a DataLine to which
data may be written. It acts as a source to its mixer. An application writes audio
bytes to a source data line, which handles the buffering of the bytes and delivers
them to the mixer. The mixer may mix the samples with those from other sources
and then deliver the mix to a target such as an output port (which represents the
audio output device on a sound card). For compatibility, the SourceDataLine


                                          22
shares the same AudioFormat as the TargetDataLine and once opened, the
object is bound to the computer’s audio output. playAudio() then spawns a new
thread to run concurrently with captureAudioThread() called playAudioThread().

This playAudioThread() uses the SourceDataLine to continually write to and drain
the user’s sound card (or on-board sound device) output buffer. The voice data
is shipped out via UDP through a Datagram Socket (out_sock) which the thread
binds at one port higher than the SIP output socket, i.e. port 5061 if the default
port 5060 is used for SIP communications.

Future Audio Improvements
There are two distinct targets for audio improvement in future versioning, data
compression and buffer elimination.

There is an obvious advantage in reducing the amount of data being sent, less
bandwidth use. In order to decrease the traffic generated by transmitting voice
over the internet without appreciably decreasing the quality, future versions of
Ramrod will include compression algorithms for audio encoding. The added
processor time for encoding and decoding data will be made up by the
improvements realized through the elimination of the capture and playback
buffers.

The current operation of the CaptureAudio and PlayAudio methods contains data
buffers. These data buffers provide a target for incoming audio data from the
both the sound card mic input (capture) and UDP socket (play). Each buffer is
the size of the actual UDP packet and serves to stabilize communication,
however, they take a finite amount of time to fill. This amount of time is the
largest factor in creating the current noticeable communication delay. With more
time and study, a true streaming implementation of both CaptureAudio and
PlayAudio will greatly improve the system usability.




                                        23
Conclusion
Following a successful implementation of the BBVoIP design, Team Ramrod
received third overall honors at the IEEE sponsored project demonstration at the
University of Victoria. Future versions of the Ramrod system will include the
recommendations outlined in previous sections of the report. For more
information feel free to contact any of the team members below:

Shawn Balding
sbalding@engr.uvic.ca

Robert MacNeill
macneill@engr.uvic.ca

Andrew Mastracci
mastracc@uvic.ca




                                       24
Appendix A – Source Code



See Attached




                           25

				
DOCUMENT INFO
Shared By:
Tags:
Stats:
views:21
posted:10/5/2011
language:English
pages:25