#include <stdlib.h>
#include <string.h>
+#include "muxer.h"
+
#define ASSUME_ABSOLUTE_CLOCK_CLASSES_PARAM_NAME "assume-absolute-clock-classes"
struct muxer_comp {
- /*
- * Array of struct
- * bt_self_message_iterator *
- * (weak refs)
- */
- GPtrArray *muxer_msg_iters;
-
/* Weak ref */
bt_self_component_filter *self_comp;
*/
GPtrArray *muxer_upstream_msg_iters;
- /*
- * List of "recently" connected input ports (weak) to
- * handle by this muxer message iterator.
- * muxer_port_connected() adds entries to this list, and the
- * entries are removed when a message iterator is created
- * on the port's connection and put into
- * muxer_upstream_msg_iters above by
- * muxer_msg_iter_handle_newly_connected_ports().
- */
- GList *newly_connected_self_ports;
-
/* Last time returned in a message */
int64_t last_returned_ts_ns;
}
static
-bt_self_component_status ensure_available_input_port(
+bt_self_component_status add_available_input_port(
bt_self_component_filter *self_comp)
{
struct muxer_comp *muxer_comp = bt_self_component_get_data(
GString *port_name = NULL;
BT_ASSERT(muxer_comp);
-
- if (muxer_comp->available_input_ports >= 1) {
- goto end;
- }
-
port_name = g_string_new("in");
if (!port_name) {
BT_LOGE_STR("Failed to allocate a GString.");
BT_LOGD("Added one input port to muxer component: "
"port-name=\"%s\", comp-addr=%p",
port_name->str, self_comp);
+
end:
if (port_name) {
g_string_free(port_name, TRUE);
return;
}
- BT_LOGD("Destroying muxer component: muxer-comp-addr=%p, "
- "muxer-msg-iter-count=%u", muxer_comp,
- muxer_comp->muxer_msg_iters ?
- muxer_comp->muxer_msg_iters->len : 0);
-
- if (muxer_comp->muxer_msg_iters) {
- g_ptr_array_free(muxer_comp->muxer_msg_iters, TRUE);
- }
-
g_free(muxer_comp);
}
BT_HIDDEN
bt_self_component_status muxer_init(
bt_self_component_filter *self_comp,
- bt_value *params, void *init_data)
+ const bt_value *params, void *init_data)
{
int ret;
bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
goto error;
}
- muxer_comp->muxer_msg_iters = g_ptr_array_new();
- if (!muxer_comp->muxer_msg_iters) {
- BT_LOGE_STR("Failed to allocate a GPtrArray.");
- goto error;
- }
-
muxer_comp->self_comp = self_comp;
bt_self_component_set_data(
bt_self_component_filter_as_self_component(self_comp),
muxer_comp);
- status = ensure_available_input_port(self_comp);
+ status = add_available_input_port(self_comp);
if (status != BT_SELF_COMPONENT_STATUS_OK) {
BT_LOGE("Cannot ensure that at least one muxer component's input port is available: "
"muxer-comp-addr=%p, status=%s",
static
bt_self_component_port_input_message_iterator *
-create_msg_iter_on_input_port(
- bt_self_component_port_input *self_port, int *ret)
+create_msg_iter_on_input_port(bt_self_component_port_input *self_port)
{
const bt_port *port = bt_self_component_port_as_port(
bt_self_component_port_input_as_self_component_port(
bt_self_component_port_input_message_iterator *msg_iter =
NULL;
- BT_ASSERT(ret);
- *ret = 0;
BT_ASSERT(port);
BT_ASSERT(bt_port_is_connected(port));
BT_LOGE("Cannot create upstream message iterator on input port: "
"port-addr=%p, port-name=\"%s\"",
port, bt_port_get_name(port));
- *ret = -1;
goto end;
}
}
static
-bt_message_iterator_status muxer_upstream_msg_iter_next(
+bt_self_message_iterator_status muxer_upstream_msg_iter_next(
struct muxer_upstream_msg_iter *muxer_upstream_msg_iter)
{
- bt_message_iterator_status status;
+ bt_self_message_iterator_status status;
+ bt_message_iterator_status input_port_iter_status;
bt_message_array_const msgs;
uint64_t i;
uint64_t count;
"muxer-upstream-msg-iter-wrap-addr=%p, msg-iter-addr=%p",
muxer_upstream_msg_iter,
muxer_upstream_msg_iter->msg_iter);
- status = bt_self_component_port_input_message_iterator_next(
+ input_port_iter_status = bt_self_component_port_input_message_iterator_next(
muxer_upstream_msg_iter->msg_iter, &msgs, &count);
BT_LOGV("Upstream message iterator's \"next\" method returned: "
- "status=%s", bt_message_iterator_status_string(status));
+ "status=%s", bt_message_iterator_status_string(input_port_iter_status));
- switch (status) {
+ switch (input_port_iter_status) {
case BT_MESSAGE_ITERATOR_STATUS_OK:
/*
* Message iterator's current message is
g_queue_push_tail(muxer_upstream_msg_iter->msgs,
(void *) msgs[i]);
}
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
break;
case BT_MESSAGE_ITERATOR_STATUS_AGAIN:
/*
* valid anymore. Return
* BT_MESSAGE_ITERATOR_STATUS_AGAIN immediately.
*/
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_AGAIN;
break;
case BT_MESSAGE_ITERATOR_STATUS_END: /* Fall-through. */
/*
* message.
*/
BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(muxer_upstream_msg_iter->msg_iter);
- status = BT_MESSAGE_ITERATOR_STATUS_OK;
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
break;
default:
/* Error or unsupported status code */
BT_LOGE("Error or unsupported status code: "
- "status-code=%d", status);
- status = BT_MESSAGE_ITERATOR_STATUS_ERROR;
+ "status-code=%d", input_port_iter_status);
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
break;
}
return status;
}
-static
-int muxer_msg_iter_handle_newly_connected_ports(
- struct muxer_msg_iter *muxer_msg_iter)
-{
- int ret = 0;
-
- BT_LOGV("Handling newly connected ports: "
- "muxer-msg-iter-addr=%p", muxer_msg_iter);
-
- /*
- * Here we create one upstream message iterator for each
- * newly connected port. We do NOT perform an initial "next" on
- * those new upstream message iterators: they are
- * invalidated, to be validated later. The list of newly
- * connected ports to handle here is updated by
- * muxer_port_connected().
- */
- while (true) {
- GList *node = muxer_msg_iter->newly_connected_self_ports;
- bt_self_component_port_input *self_port;
- const bt_port *port;
- bt_self_component_port_input_message_iterator *
- upstream_msg_iter = NULL;
- struct muxer_upstream_msg_iter *muxer_upstream_msg_iter;
-
- if (!node) {
- break;
- }
-
- self_port = node->data;
- port = bt_self_component_port_as_port(
- bt_self_component_port_input_as_self_component_port(
- (self_port)));
- BT_ASSERT(port);
-
- if (!bt_port_is_connected(port)) {
- /*
- * Looks like this port is not connected
- * anymore: we can't create an upstream
- * message iterator on its (non-existing)
- * connection in this case.
- */
- goto remove_node;
- }
-
- upstream_msg_iter = create_msg_iter_on_input_port(
- self_port, &ret);
- if (ret) {
- /* create_msg_iter_on_input_port() logs errors */
- BT_ASSERT(!upstream_msg_iter);
- goto error;
- }
-
- muxer_upstream_msg_iter =
- muxer_msg_iter_add_upstream_msg_iter(
- muxer_msg_iter, upstream_msg_iter);
- BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(upstream_msg_iter);
- if (!muxer_upstream_msg_iter) {
- /*
- * muxer_msg_iter_add_upstream_msg_iter()
- * logs errors.
- */
- goto error;
- }
-
-remove_node:
- bt_self_component_port_input_message_iterator_put_ref(upstream_msg_iter);
- muxer_msg_iter->newly_connected_self_ports =
- g_list_delete_link(
- muxer_msg_iter->newly_connected_self_ports,
- node);
- }
-
- goto end;
-
-error:
- if (ret >= 0) {
- ret = -1;
- }
-
-end:
- return ret;
-}
-
static
int get_msg_ts_ns(struct muxer_comp *muxer_comp,
struct muxer_msg_iter *muxer_msg_iter,
{
const bt_clock_class *clock_class = NULL;
const bt_clock_snapshot *clock_snapshot = NULL;
- const bt_event *event = NULL;
int ret = 0;
const unsigned char *cc_uuid;
const char *cc_name;
bt_clock_snapshot_state cs_state = BT_CLOCK_SNAPSHOT_STATE_KNOWN;
+ bt_message_stream_activity_clock_snapshot_state sa_cs_state;
BT_ASSERT(msg);
BT_ASSERT(ts_ns);
switch (bt_message_get_type(msg)) {
case BT_MESSAGE_TYPE_EVENT:
- event = bt_message_event_borrow_event_const(msg);
- BT_ASSERT(event);
- cs_state = bt_event_borrow_default_clock_snapshot_const(event,
- &clock_snapshot);
+ clock_class =
+ bt_message_event_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+
+ cs_state = bt_message_event_borrow_default_clock_snapshot_const(
+ msg, &clock_snapshot);
+ break;
+ case BT_MESSAGE_TYPE_PACKET_BEGINNING:
+ bt_message_packet_beginning_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+
+ cs_state = bt_message_packet_beginning_borrow_default_clock_snapshot_const(
+ msg, &clock_snapshot);
break;
+ case BT_MESSAGE_TYPE_PACKET_END:
+ bt_message_packet_end_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+ cs_state = bt_message_packet_end_borrow_default_clock_snapshot_const(
+ msg, &clock_snapshot);
+ break;
+ case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
+ bt_message_discarded_events_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+
+ cs_state = bt_message_discarded_events_borrow_default_beginning_clock_snapshot_const(
+ msg, &clock_snapshot);
+ break;
+ case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
+ bt_message_discarded_packets_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+
+ cs_state = bt_message_discarded_packets_borrow_default_beginning_clock_snapshot_const(
+ msg, &clock_snapshot);
+ break;
+ case BT_MESSAGE_TYPE_STREAM_ACTIVITY_BEGINNING:
+ bt_message_stream_activity_beginning_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+
+ sa_cs_state = bt_message_stream_activity_beginning_borrow_default_clock_snapshot_const(
+ msg, &clock_snapshot);
+ if (sa_cs_state != BT_MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN) {
+ goto no_clock_snapshot;
+ }
+
+ break;
+ case BT_MESSAGE_TYPE_STREAM_ACTIVITY_END:
+ bt_message_stream_activity_end_borrow_stream_class_default_clock_class_const(
+ msg);
+ if (!clock_class) {
+ goto no_clock_snapshot;
+ }
+
+ sa_cs_state = bt_message_stream_activity_end_borrow_default_clock_snapshot_const(
+ msg, &clock_snapshot);
+ if (sa_cs_state != BT_MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN) {
+ goto no_clock_snapshot;
+ }
+
+ break;
case BT_MESSAGE_TYPE_INACTIVITY:
cs_state =
bt_message_inactivity_borrow_default_clock_snapshot_const(
goto end;
}
- /*
- * If the clock snapshot is missing, then we consider that this
- * message has no time. In this case it's always the
- * youngest.
- */
- if (!clock_snapshot) {
- BT_LOGV_STR("Message's default clock snapshot is missing: "
- "using the last returned timestamp.");
- *ts_ns = last_returned_ts_ns;
- goto end;
- }
-
clock_class = bt_clock_snapshot_borrow_clock_class_const(clock_snapshot);
BT_ASSERT(clock_class);
cc_uuid = bt_clock_class_get_uuid(clock_class);
* the iterator without a true
* `assume-absolute-clock-classes` parameter.
*/
- if (bt_clock_class_is_absolute(clock_class)) {
+ if (bt_clock_class_origin_is_unix_epoch(clock_class)) {
/* Expect absolute clock classes */
muxer_msg_iter->clock_class_expectation =
MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_ABSOLUTE;
if (!muxer_comp->assume_absolute_clock_classes) {
switch (muxer_msg_iter->clock_class_expectation) {
case MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_ABSOLUTE:
- if (!bt_clock_class_is_absolute(clock_class)) {
+ if (!bt_clock_class_origin_is_unix_epoch(clock_class)) {
BT_LOGE("Expecting an absolute clock class, "
"but got a non-absolute one: "
"clock-class-addr=%p, clock-class-name=\"%s\"",
}
break;
case MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_NOT_ABS_NO_UUID:
- if (bt_clock_class_is_absolute(clock_class)) {
+ if (bt_clock_class_origin_is_unix_epoch(clock_class)) {
BT_LOGE("Expecting a non-absolute clock class with no UUID, "
"but got an absolute one: "
"clock-class-addr=%p, clock-class-name=\"%s\"",
}
break;
case MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_NOT_ABS_SPEC_UUID:
- if (bt_clock_class_is_absolute(clock_class)) {
+ if (bt_clock_class_origin_is_unix_epoch(clock_class)) {
BT_LOGE("Expecting a non-absolute clock class with a specific UUID, "
"but got an absolute one: "
"clock-class-addr=%p, clock-class-name=\"%s\"",
goto end;
+no_clock_snapshot:
+ BT_LOGV_STR("Message's default clock snapshot is missing: "
+ "using the last returned timestamp.");
+ *ts_ns = last_returned_ts_ns;
+ goto end;
+
error:
ret = -1;
* This function does NOT:
*
* * Update any upstream message iterator.
- * * Check for newly connected ports.
* * Check the upstream message iterators to retry.
*
* On sucess, this function sets *muxer_upstream_msg_iter to the
* the youngest, and sets *ts_ns to its time.
*/
static
-bt_message_iterator_status
+bt_self_message_iterator_status
muxer_msg_iter_youngest_upstream_msg_iter(
struct muxer_comp *muxer_comp,
struct muxer_msg_iter *muxer_msg_iter,
size_t i;
int ret;
int64_t youngest_ts_ns = INT64_MAX;
- bt_message_iterator_status status =
- BT_MESSAGE_ITERATOR_STATUS_OK;
+ bt_self_message_iterator_status status =
+ BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
BT_ASSERT(muxer_comp);
BT_ASSERT(muxer_msg_iter);
if (ret) {
/* get_msg_ts_ns() logs errors */
*muxer_upstream_msg_iter = NULL;
- status = BT_MESSAGE_ITERATOR_STATUS_ERROR;
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
goto end;
}
}
if (!*muxer_upstream_msg_iter) {
- status = BT_MESSAGE_ITERATOR_STATUS_END;
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_END;
*ts_ns = INT64_MIN;
}
}
static
-bt_message_iterator_status validate_muxer_upstream_msg_iter(
+bt_self_message_iterator_status validate_muxer_upstream_msg_iter(
struct muxer_upstream_msg_iter *muxer_upstream_msg_iter)
{
- bt_message_iterator_status status =
- BT_MESSAGE_ITERATOR_STATUS_OK;
+ bt_self_message_iterator_status status =
+ BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
BT_LOGV("Validating muxer's upstream message iterator wrapper: "
"muxer-upstream-msg-iter-wrap-addr=%p",
}
static
-bt_message_iterator_status validate_muxer_upstream_msg_iters(
+bt_self_message_iterator_status validate_muxer_upstream_msg_iters(
struct muxer_msg_iter *muxer_msg_iter)
{
- bt_message_iterator_status status =
- BT_MESSAGE_ITERATOR_STATUS_OK;
+ bt_self_message_iterator_status status =
+ BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
size_t i;
BT_LOGV("Validating muxer's upstream message iterator wrappers: "
status = validate_muxer_upstream_msg_iter(
muxer_upstream_msg_iter);
- if (status != BT_MESSAGE_ITERATOR_STATUS_OK) {
+ if (status != BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
if (status < 0) {
BT_LOGE("Cannot validate muxer's upstream message iterator wrapper: "
"muxer-msg-iter-addr=%p, "
}
static inline
-bt_message_iterator_status muxer_msg_iter_do_next_one(
+bt_self_message_iterator_status muxer_msg_iter_do_next_one(
struct muxer_comp *muxer_comp,
struct muxer_msg_iter *muxer_msg_iter,
const bt_message **msg)
{
- bt_message_iterator_status status =
- BT_MESSAGE_ITERATOR_STATUS_OK;
+ bt_self_message_iterator_status status;
struct muxer_upstream_msg_iter *muxer_upstream_msg_iter = NULL;
int64_t next_return_ts;
- while (true) {
- int ret = muxer_msg_iter_handle_newly_connected_ports(
- muxer_msg_iter);
-
- if (ret) {
- BT_LOGE("Cannot handle newly connected input ports for muxer's message iterator: "
- "muxer-comp-addr=%p, muxer-msg-iter-addr=%p, "
- "ret=%d",
- muxer_comp, muxer_msg_iter, ret);
- status = BT_MESSAGE_ITERATOR_STATUS_ERROR;
- goto end;
- }
-
- status = validate_muxer_upstream_msg_iters(muxer_msg_iter);
- if (status != BT_MESSAGE_ITERATOR_STATUS_OK) {
- /* validate_muxer_upstream_msg_iters() logs details */
- goto end;
- }
-
- /*
- * At this point, we know that all the existing upstream
- * message iterators are valid. However the
- * operations to validate them (during
- * validate_muxer_upstream_msg_iters()) may have
- * connected new ports. If no ports were connected
- * during this operation, exit the loop.
- */
- if (!muxer_msg_iter->newly_connected_self_ports) {
- BT_LOGV("Not breaking this loop: muxer's message iterator still has newly connected input ports to handle: "
- "muxer-comp-addr=%p", muxer_comp);
- break;
- }
+ status = validate_muxer_upstream_msg_iters(muxer_msg_iter);
+ if (status != BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
+ /* validate_muxer_upstream_msg_iters() logs details */
+ goto end;
}
- BT_ASSERT(!muxer_msg_iter->newly_connected_self_ports);
-
/*
* At this point we know that all the existing upstream
* message iterators are valid. We can find the one,
status = muxer_msg_iter_youngest_upstream_msg_iter(muxer_comp,
muxer_msg_iter, &muxer_upstream_msg_iter,
&next_return_ts);
- if (status < 0 || status == BT_MESSAGE_ITERATOR_STATUS_END) {
+ if (status < 0 || status == BT_SELF_MESSAGE_ITERATOR_STATUS_END) {
if (status < 0) {
BT_LOGE("Cannot find the youngest upstream message iterator wrapper: "
"status=%s",
- bt_message_iterator_status_string(status));
+ bt_self_message_iterator_status_string(status));
} else {
BT_LOGV("Cannot find the youngest upstream message iterator wrapper: "
"status=%s",
- bt_message_iterator_status_string(status));
+ bt_self_message_iterator_status_string(status));
}
goto end;
"last-returned-ts=%" PRId64,
muxer_msg_iter, next_return_ts,
muxer_msg_iter->last_returned_ts_ns);
- status = BT_MESSAGE_ITERATOR_STATUS_ERROR;
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
goto end;
}
"muxer-upstream-msg-iter-wrap-addr=%p, "
"ts=%" PRId64,
muxer_msg_iter, muxer_upstream_msg_iter, next_return_ts);
- BT_ASSERT(status == BT_MESSAGE_ITERATOR_STATUS_OK);
+ BT_ASSERT(status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK);
BT_ASSERT(muxer_upstream_msg_iter);
/*
}
static
-bt_message_iterator_status muxer_msg_iter_do_next(
+bt_self_message_iterator_status muxer_msg_iter_do_next(
struct muxer_comp *muxer_comp,
struct muxer_msg_iter *muxer_msg_iter,
bt_message_array_const msgs, uint64_t capacity,
uint64_t *count)
{
- bt_message_iterator_status status =
- BT_MESSAGE_ITERATOR_STATUS_OK;
+ bt_self_message_iterator_status status =
+ BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
uint64_t i = 0;
- while (i < capacity && status == BT_MESSAGE_ITERATOR_STATUS_OK) {
+ while (i < capacity && status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
status = muxer_msg_iter_do_next_one(muxer_comp,
muxer_msg_iter, &msgs[i]);
- if (status == BT_MESSAGE_ITERATOR_STATUS_OK) {
+ if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
i++;
}
}
* message, in which case we'll return it.
*/
*count = i;
- status = BT_MESSAGE_ITERATOR_STATUS_OK;
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
}
return status;
muxer_msg_iter->muxer_upstream_msg_iters, TRUE);
}
- g_list_free(muxer_msg_iter->newly_connected_self_ports);
g_free(muxer_msg_iter);
}
static
-int muxer_msg_iter_init_newly_connected_ports(struct muxer_comp *muxer_comp,
+int muxer_msg_iter_init_upstream_iterators(struct muxer_comp *muxer_comp,
struct muxer_msg_iter *muxer_msg_iter)
{
int64_t count;
int64_t i;
int ret = 0;
- /*
- * Add the connected input ports to this muxer message
- * iterator's list of newly connected ports. They will be
- * handled by muxer_msg_iter_handle_newly_connected_ports().
- */
count = bt_component_filter_get_input_port_count(
bt_self_component_filter_as_component_filter(
muxer_comp->self_comp));
}
for (i = 0; i < count; i++) {
+ bt_self_component_port_input_message_iterator *upstream_msg_iter;
+ struct muxer_upstream_msg_iter *muxer_upstream_msg_iter;
bt_self_component_port_input *self_port =
bt_self_component_filter_borrow_input_port_by_index(
muxer_comp->self_comp, i);
BT_ASSERT(port);
if (!bt_port_is_connected(port)) {
- BT_LOGD("Skipping input port: not connected: "
- "muxer-comp-addr=%p, port-addr=%p, port-name\"%s\"",
- muxer_comp, port, bt_port_get_name(port));
+ /* Skip non-connected port */
continue;
}
- muxer_msg_iter->newly_connected_self_ports =
- g_list_append(
- muxer_msg_iter->newly_connected_self_ports,
- self_port);
- if (!muxer_msg_iter->newly_connected_self_ports) {
- BT_LOGE("Cannot append port to muxer's message iterator list of newly connected input ports: "
- "port-addr=%p, port-name=\"%s\", "
- "muxer-msg-iter-addr=%p", port,
- bt_port_get_name(port), muxer_msg_iter);
+ upstream_msg_iter = create_msg_iter_on_input_port(self_port);
+ if (!upstream_msg_iter) {
+ /* create_msg_iter_on_input_port() logs errors */
+ BT_ASSERT(!upstream_msg_iter);
ret = -1;
goto end;
}
- BT_LOGD("Appended port to muxer's message iterator list of newly connected input ports: "
- "port-addr=%p, port-name=\"%s\", "
- "muxer-msg-iter-addr=%p", port,
- bt_port_get_name(port), muxer_msg_iter);
+ muxer_upstream_msg_iter =
+ muxer_msg_iter_add_upstream_msg_iter(
+ muxer_msg_iter, upstream_msg_iter);
+ bt_self_component_port_input_message_iterator_put_ref(
+ upstream_msg_iter);
+ if (!muxer_upstream_msg_iter) {
+ /* muxer_msg_iter_add_upstream_msg_iter() logs errors */
+ ret = -1;
+ goto end;
+ }
}
end:
struct muxer_comp *muxer_comp = NULL;
struct muxer_msg_iter *muxer_msg_iter = NULL;
bt_self_message_iterator_status status =
- BT_MESSAGE_ITERATOR_STATUS_OK;
+ BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
int ret;
muxer_comp = bt_self_component_get_data(
goto error;
}
- /*
- * Add the muxer message iterator to the component's array
- * of muxer message iterators here because
- * muxer_msg_iter_init_newly_connected_ports() can cause
- * muxer_port_connected() to be called, which adds the newly
- * connected port to each muxer message iterator's list of
- * newly connected ports.
- */
- g_ptr_array_add(muxer_comp->muxer_msg_iters, muxer_msg_iter);
- ret = muxer_msg_iter_init_newly_connected_ports(muxer_comp,
+ ret = muxer_msg_iter_init_upstream_iterators(muxer_comp,
muxer_msg_iter);
if (ret) {
- BT_LOGE("Cannot initialize newly connected input ports for muxer component's message iterator: "
+ BT_LOGE("Cannot initialize connected input ports for muxer component's message iterator: "
"comp-addr=%p, muxer-comp-addr=%p, "
"muxer-msg-iter-addr=%p, msg-iter-addr=%p, ret=%d",
self_comp, muxer_comp, muxer_msg_iter,
goto error;
}
- bt_self_message_iterator_set_data(self_msg_iter,
- muxer_msg_iter);
+ bt_self_message_iterator_set_data(self_msg_iter, muxer_msg_iter);
BT_LOGD("Initialized muxer component's message iterator: "
"comp-addr=%p, muxer-comp-addr=%p, muxer-msg-iter-addr=%p, "
"msg-iter-addr=%p",
goto end;
error:
- if (g_ptr_array_index(muxer_comp->muxer_msg_iters,
- muxer_comp->muxer_msg_iters->len - 1) == muxer_msg_iter) {
- g_ptr_array_remove_index(muxer_comp->muxer_msg_iters,
- muxer_comp->muxer_msg_iters->len - 1);
- }
-
destroy_muxer_msg_iter(muxer_msg_iter);
- bt_self_message_iterator_set_data(self_msg_iter,
- NULL);
- status = BT_MESSAGE_ITERATOR_STATUS_ERROR;
+ bt_self_message_iterator_set_data(self_msg_iter, NULL);
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
end:
muxer_comp->initializing_muxer_msg_iter = false;
"msg-iter-addr=%p",
self_comp, muxer_comp, muxer_msg_iter, self_msg_iter);
- if (muxer_comp) {
- (void) g_ptr_array_remove_fast(muxer_comp->muxer_msg_iters,
- muxer_msg_iter);
+ if (muxer_msg_iter) {
destroy_muxer_msg_iter(muxer_msg_iter);
}
}
BT_HIDDEN
-bt_message_iterator_status muxer_msg_iter_next(
+bt_self_message_iterator_status muxer_msg_iter_next(
bt_self_message_iterator *self_msg_iter,
bt_message_array_const msgs, uint64_t capacity,
uint64_t *count)
{
- bt_message_iterator_status status;
+ bt_self_message_iterator_status status;
struct muxer_msg_iter *muxer_msg_iter =
bt_self_message_iterator_get_data(self_msg_iter);
bt_self_component *self_comp = NULL;
"comp-addr=%p, muxer-comp-addr=%p, muxer-msg-iter-addr=%p, "
"msg-iter-addr=%p, status=%s",
self_comp, muxer_comp, muxer_msg_iter, self_msg_iter,
- bt_message_iterator_status_string(status));
+ bt_self_message_iterator_status_string(status));
} else {
BT_LOGV("Returning from muxer component's message iterator's \"next\" method: "
"status=%s",
- bt_message_iterator_status_string(status));
+ bt_self_message_iterator_status_string(status));
}
return status;
bt_self_component_port_input *self_port,
const bt_port_output *other_port)
{
- bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
- const bt_port *port = bt_self_component_port_as_port(
- bt_self_component_port_input_as_self_component_port(
- self_port));
- struct muxer_comp *muxer_comp =
- bt_self_component_get_data(
- bt_self_component_filter_as_self_component(
- self_comp));
- size_t i;
- int ret;
-
- BT_ASSERT(port);
- BT_ASSERT(muxer_comp);
- BT_LOGD("Port connected: "
- "comp-addr=%p, muxer-comp-addr=%p, "
- "port-addr=%p, port-name=\"%s\", "
- "other-port-addr=%p, other-port-name=\"%s\"",
- self_comp, muxer_comp, self_port, bt_port_get_name(port),
- other_port,
- bt_port_get_name(bt_port_output_as_port_const(other_port)));
-
- for (i = 0; i < muxer_comp->muxer_msg_iters->len; i++) {
- struct muxer_msg_iter *muxer_msg_iter =
- g_ptr_array_index(muxer_comp->muxer_msg_iters, i);
-
- /*
- * Add this port to the list of newly connected ports
- * for this muxer message iterator. We append at
- * the end of this list while
- * muxer_msg_iter_handle_newly_connected_ports()
- * removes the nodes from the beginning.
- */
- muxer_msg_iter->newly_connected_self_ports =
- g_list_append(
- muxer_msg_iter->newly_connected_self_ports,
- self_port);
- if (!muxer_msg_iter->newly_connected_self_ports) {
- BT_LOGE("Cannot append port to muxer's message iterator list of newly connected input ports: "
- "port-addr=%p, port-name=\"%s\", "
- "muxer-msg-iter-addr=%p", self_port,
- bt_port_get_name(port), muxer_msg_iter);
- status = BT_SELF_COMPONENT_STATUS_ERROR;
- goto end;
- }
+ bt_self_component_status status;
- BT_LOGD("Appended port to muxer's message iterator list of newly connected input ports: "
- "port-addr=%p, port-name=\"%s\", "
- "muxer-msg-iter-addr=%p", self_port,
- bt_port_get_name(port), muxer_msg_iter);
- }
-
- /* One less available input port */
- muxer_comp->available_input_ports--;
- ret = ensure_available_input_port(self_comp);
- if (ret) {
+ status = add_available_input_port(self_comp);
+ if (status) {
/*
* Only way to report an error later since this
* method does not return anything.
*/
- BT_LOGE("Cannot ensure that at least one muxer component's input port is available: "
- "muxer-comp-addr=%p, status=%s",
- muxer_comp, bt_self_component_status_string(ret));
- status = BT_SELF_COMPONENT_STATUS_ERROR;
+ BT_LOGE("Cannot add one muxer component's input port: "
+ "status=%s",
+ bt_self_component_status_string(status));
goto end;
}
}
BT_HIDDEN
-void muxer_input_port_disconnected(
- bt_self_component_filter *self_component,
- bt_self_component_port_input *self_port)
+bt_bool muxer_msg_iter_can_seek_beginning(
+ bt_self_message_iterator *self_msg_iter)
{
- struct muxer_comp *muxer_comp =
- bt_self_component_get_data(
- bt_self_component_filter_as_self_component(
- self_component));
- const bt_port *port =
- bt_self_component_port_as_port(
- bt_self_component_port_input_as_self_component_port(
- self_port));
+ struct muxer_msg_iter *muxer_msg_iter =
+ bt_self_message_iterator_get_data(self_msg_iter);
+ uint64_t i;
+ bt_bool ret = BT_TRUE;
- BT_ASSERT(port);
- BT_ASSERT(muxer_comp);
+ for (i = 0; i < muxer_msg_iter->muxer_upstream_msg_iters->len; i++) {
+ struct muxer_upstream_msg_iter *upstream_msg_iter =
+ muxer_msg_iter->muxer_upstream_msg_iters->pdata[i];
- /* One more available input port */
- muxer_comp->available_input_ports++;
- BT_LOGD("Leaving disconnected input port available for future connections: "
- "comp-addr=%p, muxer-comp-addr=%p, port-addr=%p, "
- "port-name=\"%s\", avail-input-port-count=%zu",
- self_component, muxer_comp, port, bt_port_get_name(port),
- muxer_comp->available_input_ports);
+ if (!bt_self_component_port_input_message_iterator_can_seek_beginning(
+ upstream_msg_iter->msg_iter)) {
+ ret = BT_FALSE;
+ goto end;
+ }
+ }
+
+end:
+ return ret;
+}
+
+BT_HIDDEN
+bt_self_message_iterator_status muxer_msg_iter_seek_beginning(
+ bt_self_message_iterator *self_msg_iter)
+{
+ struct muxer_msg_iter *muxer_msg_iter =
+ bt_self_message_iterator_get_data(self_msg_iter);
+ int status;
+ uint64_t i;
+
+ for (i = 0; i < muxer_msg_iter->muxer_upstream_msg_iters->len; i++) {
+ struct muxer_upstream_msg_iter *upstream_msg_iter =
+ muxer_msg_iter->muxer_upstream_msg_iters->pdata[i];
+
+ status = bt_self_component_port_input_message_iterator_seek_beginning(
+ upstream_msg_iter->msg_iter);
+ if (status != BT_MESSAGE_ITERATOR_STATUS_OK) {
+ goto end;
+ }
+ }
+
+ muxer_msg_iter->last_returned_ts_ns = INT64_MIN;
+
+end:
+ return status;
}
projects / babeltrace.git / blobdiff