| c732d49e |
*
* Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
*
* This file is part of MCOP MCPTT Client
*
* This 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 3
* of the License, or (at your option) any later version.
*
* This 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.
*/
#include "tinyrtp/rtcp/trtp_rtcp_report_app.h"
#include "tinyrtp/rtcp/trtp_rtcp_report_fb.h"
#include "tinyrtp/rtcp/trtp_rtcp_header.h"
#include "tnet_endianness.h"
#include "tsk_memory.h"
#include "tsk_debug.h"
#include "tsk_string.h"
#define TRTP_RTCP_PACKET_APP_MIN_SIZE (TRTP_RTCP_HEADER_SIZE + 0/* could have no data */)
static tsk_object_t* trtp_rtcp_report_app_ctor(tsk_object_t * self, va_list * app)
{
trtp_rtcp_report_app_t *rtcp_app = self;
if(rtcp_app){
rtcp_app->payload_size = 0;
rtcp_app->payload = tsk_null;
}
return self;
}
static tsk_object_t* trtp_rtcp_report_app_dtor(tsk_object_t * self)
{
trtp_rtcp_report_app_t *rtcp_app = self;
if(rtcp_app){
if(rtcp_app->payload)
{
TSK_FREE(rtcp_app->payload);
rtcp_app->payload = tsk_null;
}
rtcp_app->payload_size = 0;
// deinit base
trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(rtcp_app));
}
return self;
}
static const tsk_object_def_t trtp_rtcp_report_app_def_s =
{
sizeof(trtp_rtcp_report_app_t),
trtp_rtcp_report_app_ctor,
trtp_rtcp_report_app_dtor,
tsk_null,
};
const tsk_object_def_t *trtp_rtcp_report_app_def_t = &trtp_rtcp_report_app_def_s;
trtp_rtcp_report_app_t* trtp_rtcp_report_app_create_null()
{
trtp_rtcp_report_app_t* rtcp_app;
if((rtcp_app = (trtp_rtcp_report_app_t*)tsk_object_new(trtp_rtcp_report_app_def_t))){
trtp_rtcp_packet_init(TRTP_RTCP_PACKET(rtcp_app), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_app, TRTP_RTCP_HEADER_SIZE);
}
return rtcp_app;
}
trtp_rtcp_report_app_t* trtp_rtcp_report_app_create(struct trtp_rtcp_header_s* header)
{
trtp_rtcp_report_app_t* rtcp_app;
if((rtcp_app = (trtp_rtcp_report_app_t*)tsk_object_new(trtp_rtcp_report_app_def_t))){
TRTP_RTCP_PACKET(rtcp_app)->header = tsk_object_ref(header);
}
return rtcp_app;
}
trtp_rtcp_report_app_t* trtp_rtcp_report_app_create_2(const char* app_name, uint8_t subtype, uint32_t ssrc, const char* data, tsk_size_t size)
{
trtp_rtcp_report_app_t* rtcp_app = tsk_null;
uint16_t total_length = 0;
if(data){
if((rtcp_app = (trtp_rtcp_report_app_t*)tsk_object_new(trtp_rtcp_report_app_def_t))){
total_length = TRTP_RTCP_HEADER_SIZE + 4*sizeof(char) + sizeof(uint32_t) + (uint16_t)size;
total_length = ((total_length % 4) == 0)?total_length:(total_length + (4-(total_length % 4)));
trtp_rtcp_packet_init(TRTP_RTCP_PACKET(rtcp_app), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, subtype, trtp_rtcp_packet_type_app, total_length);
memcpy(rtcp_app->name, app_name, 4*sizeof(char));
rtcp_app->ssrc = ssrc;
#if HAVE_CRT //Debug memory
rtcp_app->payload = (uint8_t*)malloc(size*sizeof(uint8_t));
#else
rtcp_app->payload = (uint8_t*)tsk_malloc(size*sizeof(uint8_t));
#endif //HAVE_CRT
if(rtcp_app->payload){
memcpy(rtcp_app->payload, data, size);
rtcp_app->payload_size = (uint16_t)size;
}
rtcp_app->subtype = subtype;
}
return rtcp_app;
}
return tsk_null;
}
trtp_rtcp_report_app_t* trtp_rtcp_report_app_deserialize(const void* data, tsk_size_t _size)
{
trtp_rtcp_report_app_t* rtcp_app = tsk_null;
trtp_rtcp_header_t* header = tsk_null;
const uint8_t* pdata = (const uint8_t*)data;
int32_t size = (int32_t)_size;
if(!data || size < TRTP_RTCP_PACKET_APP_MIN_SIZE){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
if(!(header = trtp_rtcp_header_deserialize(pdata, size))){
TSK_DEBUG_ERROR("Failed to deserialize the header");
goto bail;
}
if(header->length_in_bytes < TRTP_RTCP_PACKET_APP_MIN_SIZE){
TSK_DEBUG_ERROR("Too short");
goto bail;
}
if(!(rtcp_app = trtp_rtcp_report_app_create(header))){
TSK_DEBUG_ERROR("Failed to create object");
goto bail;
}
rtcp_app->subtype = header->rc;
pdata += (TRTP_RTCP_HEADER_SIZE);
size -= (TRTP_RTCP_HEADER_SIZE);
rtcp_app->ssrc = tnet_ntohl_2(pdata);
pdata += sizeof(uint32_t);
size -= sizeof(uint32_t);
memcpy(rtcp_app->name, pdata, 4*sizeof(char));
pdata += 4*sizeof(char);
size -= 4*sizeof(char);
#if HAVE_CRT //Debug memory
rtcp_app->payload = (uint8_t*)malloc(size*sizeof(uint8_t));
#else
rtcp_app->payload = (uint8_t*)tsk_malloc(size*sizeof(uint8_t));
#endif //HAVE_CRT
if(rtcp_app->payload){
memcpy(rtcp_app->payload, pdata, size);
rtcp_app->payload_size = size;
}
bail:
TSK_OBJECT_SAFE_FREE(header);
return rtcp_app;
}
int trtp_rtcp_report_app_serialize_to(const trtp_rtcp_report_app_t* self, void* data, tsk_size_t size)
{
int ret;
uint8_t* pdata = (uint8_t*)data;
uint32_t ssrc_net = 0;
if(!self || !data || size < trtp_rtcp_report_app_get_size(self)){
return -1;
}
if((ret = trtp_rtcp_header_serialize_to(TRTP_RTCP_PACKET(self)->header, pdata, size))){
TSK_DEBUG_ERROR("Failed to serialize the header");
return ret;
}
pdata += (TRTP_RTCP_HEADER_SIZE);
size -= (TRTP_RTCP_HEADER_SIZE);
ssrc_net = tnet_htonl_2(&self->ssrc);
memcpy(pdata, &ssrc_net, sizeof(uint32_t));
pdata += sizeof(uint32_t);
size -= sizeof(uint32_t);
memcpy(pdata, self->name, 4*sizeof(char));
pdata += 4*sizeof(char);
size -= 4*sizeof(char);
memcpy(pdata, self->payload, self->payload_size);
pdata += self->payload_size;
size -= self->payload_size;
if(size > 0)
memset(pdata, 0, size);
return ret;
}
tsk_size_t trtp_rtcp_report_app_get_size(const trtp_rtcp_report_app_t* self)
{
tsk_size_t size;
if(!self || !TRTP_RTCP_PACKET(self)->header){
TSK_DEBUG_ERROR("Invalid parameter");
return 0;
}
size = TRTP_RTCP_PACKET(self)->header->length_in_bytes;
return size;
} |