/*! \fn void mpegEncapSetPacketHeader(encap_out_stream_t *out_stream,
Uint8* mac_src_addr,
Uint8* mac_dst_addr,
Uint32 ip4_src_addr,
Uint32 ip4_dst_addr,
Uint16 udp_src_port,
Uint16 udp_dst_port,
encapHeaderType_e encap_type,
udpCsum_e udp_csum,
Uint32 rtp_ssrc)
**************************************************************************
* \brief Set Mpeg Encap IP packet header API
* \return 0 or error code
*/
void mpegEncapSetPacketHeader(encap_out_stream_t *out_stream,
Uint8* mac_src_addr,
Uint8* mac_dst_addr,
Uint32 ip4_src_addr,
Uint32 ip4_dst_addr,
Uint16 udp_src_port,
Uint16 udp_dst_port,
encapHeaderType_e encap_type,
udpCsum_e udp_csum,
Uint32 rtp_ssrc)
{
memcpy(out_stream->eth_dst_addr, mac_dst_addr, ETH_ALEN);
out_stream->ip_id = 0;
out_stream->rtp_seq_num = 0;
out_stream->pcr2pcr_frames_counter = -1;
out_stream->old_sysclk = 0;
out_stream->old_90K_clk = 0;
set_packet_header(&(out_stream->encap_header),
mac_src_addr, mac_dst_addr,
ip4_src_addr, ip4_dst_addr,
udp_src_port, udp_dst_port,
rtp_ssrc);
out_stream->encap_header_type = encap_type;
out_stream->udp_csum = udp_csum;
out_stream->encap_frame_headers_size = sizeof(out_stream->encap_header.eth_header) +
sizeof(out_stream->encap_header.ip_header) +
sizeof(out_stream->encap_header.udp_header);
if (MPEG_ENCAP_RTP_HEADER==out_stream->encap_header_type)
out_stream->encap_frame_headers_size += sizeof(out_stream->encap_header.rtp_header);
}
static void set_hf_send_packet(int fd_out, int fd_in, unsigned char buffer[], unsigned char len, unsigned char *seq, unsigned char type, unsigned char response[], int *response_length) {
set_packet_header(buffer, len, *seq, type);
crc_packet(tabel, buffer, len);
send_packet(fd_out, fd_in, buffer, len + 2, response, response_length);
increment_counter(seq);
}
static void format_packet(struct strbuf *out, const char *fmt, va_list args)
{
size_t orig_len, n;
orig_len = out->len;
strbuf_addstr(out, "0000");
strbuf_vaddf(out, fmt, args);
n = out->len - orig_len;
if (n > LARGE_PACKET_MAX)
die("protocol error: impossibly long line");
set_packet_header(&out->buf[orig_len], n);
packet_trace(out->buf + orig_len + 4, n - 4, 1);
}
static int packet_write_gently(const int fd_out, const char *buf, size_t size)
{
static char packet_write_buffer[LARGE_PACKET_MAX];
size_t packet_size;
if (size > sizeof(packet_write_buffer) - 4)
return error("packet write failed - data exceeds max packet size");
packet_trace(buf, size, 1);
packet_size = size + 4;
set_packet_header(packet_write_buffer, packet_size);
memcpy(packet_write_buffer + 4, buf, size);
if (write_in_full(fd_out, packet_write_buffer, packet_size) == packet_size)
return 0;
return error("packet write failed");
}
BT_HIDDEN
struct bt_ctf_stream *bt_ctf_stream_create(
struct bt_ctf_stream_class *stream_class,
struct bt_ctf_trace *trace)
{
int ret;
struct bt_ctf_stream *stream = NULL;
if (!stream_class || !trace) {
goto end;
}
stream = g_new0(struct bt_ctf_stream, 1);
if (!stream) {
goto end;
}
/* A stream has no ownership of its trace (weak ptr) */
stream->trace = trace;
bt_object_init(stream, bt_ctf_stream_destroy);
stream->packet_context = bt_ctf_field_create(
stream_class->packet_context_type);
if (!stream->packet_context) {
goto error;
}
/*
* A stream class may not have a stream event context defined
* in which case this stream will never have a stream_event_context
* member since, after a stream's creation, the parent stream class
* is "frozen" (immutable).
*/
if (stream_class->event_context_type) {
stream->event_context = bt_ctf_field_create(
stream_class->event_context_type);
if (!stream->packet_context) {
goto error;
}
}
/* Initialize events_discarded */
ret = set_structure_field_integer(stream->packet_context,
"events_discarded", 0);
if (ret) {
goto error;
}
stream->pos.fd = -1;
stream->id = stream_class->next_stream_id++;
stream->stream_class = stream_class;
bt_get(stream_class);
stream->events = g_ptr_array_new_with_free_func(
(GDestroyNotify) put_event);
if (!stream->events) {
goto error;
}
if (stream_class->event_context_type) {
stream->event_contexts = g_ptr_array_new_with_free_func(
(GDestroyNotify) bt_ctf_field_put);
if (!stream->event_contexts) {
goto error;
}
}
/* A trace is not allowed to have a NULL packet header */
assert(trace->packet_header_type);
stream->packet_header = bt_ctf_field_create(trace->packet_header_type);
if (!stream->packet_header) {
goto error;
}
/*
* Attempt to populate the default trace packet header fields
* (magic, uuid and stream_id). This will _not_ fail shall the
* fields not be found or be of an incompatible type; they will
* simply not be populated automatically. The user will have to
* make sure to set the trace packet header fields himself before
* flushing.
*/
ret = set_packet_header(stream);
if (ret) {
goto error;
}
end:
return stream;
error:
BT_PUT(stream);
return stream;
}
struct bt_ctf_stream *bt_ctf_stream_create(
struct bt_ctf_stream_class *stream_class,
const char *name)
{
int ret;
struct bt_ctf_stream *stream = NULL;
struct bt_ctf_trace *trace = NULL;
struct bt_ctf_writer *writer = NULL;
if (!stream_class) {
goto error;
}
trace = bt_ctf_stream_class_get_trace(stream_class);
if (!trace) {
goto error;
}
stream = g_new0(struct bt_ctf_stream, 1);
if (!stream) {
goto error;
}
bt_object_init(stream, bt_ctf_stream_destroy);
/*
* Acquire reference to parent since stream will become publicly
* reachable; it needs its parent to remain valid.
*/
bt_object_set_parent(stream, trace);
stream->id = stream_class->next_stream_id++;
stream->stream_class = stream_class;
stream->pos.fd = -1;
if (name) {
stream->name = g_string_new(name);
if (!stream->name) {
goto error;
}
}
if (trace->is_created_by_writer) {
int fd;
writer = (struct bt_ctf_writer *)
bt_object_get_parent(trace);
assert(writer);
stream->packet_context = bt_ctf_field_create(
stream_class->packet_context_type);
if (!stream->packet_context) {
goto error;
}
/* Initialize events_discarded */
ret = set_structure_field_integer(stream->packet_context,
"events_discarded", 0);
if (ret) {
goto error;
}
stream->events = g_ptr_array_new_with_free_func(
(GDestroyNotify) release_event);
if (!stream->events) {
goto error;
}
/* A trace is not allowed to have a NULL packet header */
assert(trace->packet_header_type);
stream->packet_header =
bt_ctf_field_create(trace->packet_header_type);
if (!stream->packet_header) {
goto error;
}
/*
* Attempt to populate the default trace packet header fields
* (magic, uuid and stream_id). This will _not_ fail shall the
* fields not be found or be of an incompatible type; they will
* simply not be populated automatically. The user will have to
* make sure to set the trace packet header fields himself
* before flushing.
*/
ret = set_packet_header(stream);
if (ret) {
goto error;
}
/* Create file associated with this stream */
fd = create_stream_file(writer, stream);
if (fd < 0) {
goto error;
}
ret = set_stream_fd(stream, fd);
if (ret) {
goto error;
}
/* Freeze the writer */
bt_ctf_writer_freeze(writer);
} else {
/* Non-writer stream indicated by a negative FD */
ret = set_stream_fd(stream, -1);
if (ret) {
goto error;
}
stream->clock_values = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL, g_free);
}
/* Add this stream to the trace's streams */
g_ptr_array_add(trace->streams, stream);
BT_PUT(trace);
BT_PUT(writer);
return stream;
error:
BT_PUT(stream);
BT_PUT(trace);
BT_PUT(writer);
return stream;
}
