rtp.h

00001 /**
00002  * @file rtp.h
00003  * @Synopsis Esta classe visa gerenciar o tratamento dos pacotes de RTP, ou seja, os pacotes de audio trocados entre o Call_Box, Header
00004  * servidor.
00005  * @author Jhonatan Casale
00006  * @version 1
00007  * @date 2014-11-05
00008  * \class RTP
00009  */
00010 
00011 #ifndef __RTP_H__
00012 #define __RTP_H__
00013 
00014 #include "mbed.h"
00015 #include "shared_variables.h"
00016 #include "vz_protocol.h"
00017 #include "debug.h"
00018 
00019 class RTP_Header{
00020     private :
00021         uint32_t ss_id;
00022         uint16_t seq_number;
00023         uint32_t timestamp;
00024     public  :
00025                 /**
00026                  * @Synopsis Cria um objeto da classe RTP_Header. Esta classe visa gerenciar a criação do cabeçalhoo RTP
00027                  *
00028                  * @param cb_ext Vincula o objeto recem criado com o ramal do Call_Box solicitante
00029                  *
00030                  * Exemplo:
00031                  * @code
00032                  * ...
00033                  *  int ext = 0x54;
00034                  *  RTP_Header * rtp_header = new RTP_Header( ext );
00035                  * ...
00036                  * @endcode
00037                  */
00038         RTP_Header( int cb_ext );
00039 
00040                 /**
00041                  * @Synopsis Destroi o objeto RTP_Header.
00042                  *
00043                  * Exemplo:
00044                  * @code
00045                  * ...
00046                  *  delete( rtp_header );
00047                  * ...
00048                  * @endcode
00049                  */
00050         ~RTP_Header();
00051 
00052                 /**
00053                  * @Synopsis Informa o tamanho ( em bytes ) do cabeçalho rtp.
00054                  *
00055                  * @return O numero ( em bytes ) ocupados pelo cabeçãolho do rtp.
00056                  *
00057                  * Exemplo:
00058                  * @code
00059                  * ...
00060                  *  size_t size = rtp_header->size();
00061                  * ...
00062                  * @endcode
00063                  */
00064         size_t size( void );
00065 
00066             /**
00067                  * @Synopsis Cria o cabeçalho rtp usado neste aplicação. Porém, fora de uso no momento.
00068                  *
00069                  * @param pkg Um ponteiro para a posição de memória onde será montado o pacote.
00070                  *
00071                  * @return Um ponteiro para o inicio do pacote montado.
00072                  *
00073                  * @code
00074                  *  uint8_t * build_header( uint8_t * buffer_header ){
00075                  *          // função não implementada.
00076                  *  }
00077                  * @endcode
00078                  */
00079         uint8_t * build_header( uint8_t * buffer_header );
00080 
00081                 /**
00082                  * @Synopsis Cria o cabeçalho rtp usado neste aplicação.
00083                  *
00084                  * @param pkg Um ponteiro para a posição de memória onde será montado o pacote.
00085                  *
00086                  * @return Um ponteiro para o inicio do pacote montado.
00087                  *
00088                  * Exemplo:
00089                  * @code
00090                  * ...
00091                  *  char pkg[ 512 ]; 
00092                  *  rtp_header->build_header( pkg );
00093                  * ...
00094                  * @endcode
00095                  */
00096         char * build_header( char * pkg );
00097         int get_ss_id ( void ) { return this->ss_id; }
00098         int get_seq_number ( void ) { return this->seq_number; }
00099         int get_timestamp ( void ) { return this->timestamp; }
00100 };
00101 
00102 class RTP_Body{
00103     private :
00104     public  :
00105             /**
00106              * @Synopsis Constroi um objeto RTP_Body.
00107              *
00108              * Exemplo:
00109              * @code
00110              * ...
00111              *  RTP_Body * rtp_body = new RTP_Body();
00112              * ...
00113              * @endcode
00114              */
00115         RTP_Body();
00116 
00117                 /**
00118                  * @Synopsis Destroi o objeto RTP_Body.
00119                  *
00120                  * Exemplo:
00121                  * @code
00122                  * ...
00123                  *  delete( rtp_body );
00124                  * ...
00125                  * @endcode
00126                  */
00127         ~RTP_Body();
00128 
00129                 /**
00130                  * @Synopsis Informa o tamanho ( em bytes ) ocupados pelo corpo da mensagem.
00131                  *
00132                  * @return Retorna o numero de bytes ocupados pelo corpo da mensagem.
00133                  *
00134                  * Exemplo:
00135                  * @code
00136                  * ...
00137                  *  size_t size = rtp_body->size();
00138                  * ...
00139                  * @endcode
00140                  */
00141         size_t size( void );
00142 
00143                 /**
00144                  * @Synopsis Cria o corpo do pacote. 
00145                  *
00146                  * @param dest Ponteiro para posição de memória onde será montado o pacote.
00147                  * @param buffer Ponteiro para a posição de memória com os dados originias.
00148                  *
00149                  * @return Um ponteiro para posição de memória contendo o corpo da mensagem.
00150                  *
00151                  * Exemplo:
00152                  * @code
00153                  * ...
00154                  *  // assumindo que buffer é onde foi armazenado os dados que precisam ser enviados.
00155                  *  rtp_body->build_body( pkg , buffer ); 
00156                  * ...
00157                  * @endcode
00158                  */
00159         char * build_body( char * dest, char * buffer );
00160 };
00161 class RTP{
00162     private :
00163         uint8_t buffer[ 512 ];
00164         char pkg[ 512 ];
00165         RTP_Header * rtp_header;
00166         RTP_Body * rtp_body;
00167     public  :
00168                 /**
00169                  * @Synopsis Cria um objeto RTP.
00170                  *
00171                  * @param ext Vincula o objeto RTP ao ramal passado como parâmetro.
00172                  *
00173                  * Exemplo:
00174                  * @code
00175                  * ...
00176                  *  int ext = 1918;
00177                  *  RTP * rtp = new RTP( ext );
00178                  * ...
00179                  * @endcode
00180                  */
00181         RTP( int ext );
00182 
00183                 /**
00184                  * @Synopsis Destroi o objeto RTP.
00185                  *
00186                  * Exemplo:
00187                  * @code
00188                  * ...
00189                  *  delete( rtp );
00190                  * ...
00191                  * @endcode
00192                  */
00193         ~RTP();
00194 
00195                 /**
00196                  * @Synopsis Informa o tamanho ocupado pelo cabeçalho.
00197                  *
00198                  * @return O numero em bytes ocupados pelo cabeçalho.
00199                  *
00200                  * Exemplo:
00201                  * @code
00202                  * ...
00203                  *  size_t size = rtp->header_size();
00204                  * ...
00205                  * @endcode
00206                  */
00207         size_t header_size( void );
00208 
00209                 /**
00210                  * @Synopsis Constroi efetivamente o pacote seguindo o protocolo rtp.
00211                  *
00212                  * @param buffer Posição de memória onde será montado o pacote.
00213                  *
00214                  * @return Um ponteiro para o inicio do pacote montado, pronto para envio.
00215                  *
00216                  * Exemplo:
00217                  * @code
00218                  * ...
00219                  *  // assumindo que buffer é onde foi armazenado os dados que precisam ser enviados.
00220                  *  return this->rtp->build_eth_package( buffer );
00221                  * ...
00222                  * @endcode
00223                  */
00224         char * build_eth_package( char * buffer );
00225 
00226         int print_yourself ( void );
00227 };
00228 #endif