X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Flibctfcopytrace%2Fctfcopytrace.c;h=a65b05032a84efcdb79123fe91c3cb88ba174aec;hb=5552377ac6051ce8ff79fc44c446a23b13f265a8;hp=2b408ace8d1765bb73ecdaa4d379a8a71d232e2e;hpb=40b9ea676c5490358df4955d4938999d1814d9b2;p=babeltrace.git

diff --git a/plugins/libctfcopytrace/ctfcopytrace.c b/plugins/libctfcopytrace/ctfcopytrace.c
index 2b408ace..a65b0503 100644
--- a/plugins/libctfcopytrace/ctfcopytrace.c
+++ b/plugins/libctfcopytrace/ctfcopytrace.c
@@ -26,157 +26,103 @@
  * SOFTWARE.
  */
 
-#include <babeltrace/ctf-ir/event.h>
-#include <babeltrace/ctf-ir/packet.h>
-#include <babeltrace/ctf-ir/event-class.h>
-#include <babeltrace/ctf-ir/stream.h>
-#include <babeltrace/ctf-ir/stream-class.h>
-#include <babeltrace/ctf-ir/clock-class.h>
-#include <babeltrace/ctf-ir/fields.h>
-#include <babeltrace/ctf-writer/stream.h>
-#include <assert.h>
+#define BT_LOG_TAG "PLUGIN-CTFCOPYTRACE-LIB"
+#include "logging.h"
+
+#include <babeltrace/babeltrace.h>
+#include <babeltrace/assert-internal.h>
 
 #include "ctfcopytrace.h"
-#include "clock-fields.h"
+#include "clock-field.h"
 
 BT_HIDDEN
-struct bt_ctf_clock_class *ctf_copy_clock_class(FILE *err,
-		struct bt_ctf_clock_class *clock_class)
+const bt_clock_class *ctf_copy_clock_class(FILE *err,
+		const bt_clock_class *clock_class)
 {
 	int64_t offset, offset_s;
 	int int_ret;
 	uint64_t u64_ret;
 	const char *name, *description;
-	struct bt_ctf_clock_class *writer_clock_class = NULL;
+	const bt_clock_class *writer_clock_class = NULL;
 
-	assert(err && clock_class);
+	BT_ASSERT(err && clock_class);
 
-	name = bt_ctf_clock_class_get_name(clock_class);
-	if (!name) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end;
-	}
+	name = bt_clock_class_get_name(clock_class);
+	BT_ASSERT(name);
 
-	writer_clock_class = bt_ctf_clock_class_create(name,
-		bt_ctf_clock_class_get_frequency(clock_class));
+	writer_clock_class = bt_clock_class_create(name,
+		bt_clock_class_get_frequency(clock_class));
 	if (!writer_clock_class) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to create clock class.");
 		goto end;
 	}
 
-	description = bt_ctf_clock_class_get_description(clock_class);
+	description = bt_clock_class_get_description(clock_class);
 	if (description) {
-		int_ret = bt_ctf_clock_class_set_description(writer_clock_class,
+		int_ret = bt_clock_class_set_description(writer_clock_class,
 				description);
-		if (int_ret != 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
-			goto end_destroy;
-		}
+		BT_ASSERT(!int_ret);
 	}
 
-	u64_ret = bt_ctf_clock_class_get_precision(clock_class);
-	if (u64_ret == -1ULL) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
-	int_ret = bt_ctf_clock_class_set_precision(writer_clock_class,
-		u64_ret);
-	if (int_ret != 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	u64_ret = bt_clock_class_get_precision(clock_class);
+	BT_ASSERT(u64_ret != -1ULL);
 
-	int_ret = bt_ctf_clock_class_get_offset_s(clock_class, &offset_s);
-	if (int_ret != 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	int_ret = bt_clock_class_set_precision(writer_clock_class,
+		u64_ret);
+	BT_ASSERT(!int_ret);
 
-	int_ret = bt_ctf_clock_class_set_offset_s(writer_clock_class, offset_s);
-	if (int_ret != 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	int_ret = bt_clock_class_get_offset_s(clock_class, &offset_s);
+	BT_ASSERT(!int_ret);
 
-	int_ret = bt_ctf_clock_class_get_offset_cycles(clock_class, &offset);
-	if (int_ret != 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	int_ret = bt_clock_class_set_offset_s(writer_clock_class, offset_s);
+	BT_ASSERT(!int_ret);
 
-	int_ret = bt_ctf_clock_class_set_offset_cycles(writer_clock_class, offset);
-	if (int_ret != 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	int_ret = bt_clock_class_get_offset_cycles(clock_class, &offset);
+	BT_ASSERT(!int_ret);
 
-	int_ret = bt_ctf_clock_class_is_absolute(clock_class);
-	if (int_ret == -1) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	int_ret = bt_clock_class_set_offset_cycles(writer_clock_class, offset);
+	BT_ASSERT(!int_ret);
 
-	int_ret = bt_ctf_clock_class_set_is_absolute(writer_clock_class, int_ret);
-	if (int_ret != 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto end_destroy;
-	}
+	int_ret = bt_clock_class_origin_is_unix_epoch(clock_class);
+	BT_ASSERT(int_ret >= 0);
 
-	goto end;
+	int_ret = bt_clock_class_set_origin_is_unix_epoch(writer_clock_class, int_ret);
+	BT_ASSERT(!int_ret);
 
-end_destroy:
-	BT_PUT(writer_clock_class);
 end:
 	return writer_clock_class;
 }
 
 BT_HIDDEN
-enum bt_component_status ctf_copy_clock_classes(FILE *err,
-		struct bt_ctf_trace *writer_trace,
-		struct bt_ctf_stream_class *writer_stream_class,
-		struct bt_ctf_trace *trace)
+bt_component_status ctf_copy_clock_classes(FILE *err,
+		const bt_trace *writer_trace,
+		const bt_stream_class *writer_stream_class,
+		const bt_trace *trace)
 {
-	enum bt_component_status ret;
+	bt_component_status ret;
 	int int_ret, clock_class_count, i;
 
-	clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
+	clock_class_count = bt_trace_get_clock_class_count(trace);
 
 	for (i = 0; i < clock_class_count; i++) {
-		struct bt_ctf_clock_class *writer_clock_class;
-		struct bt_ctf_clock_class *clock_class =
-			bt_ctf_trace_get_clock_class_by_index(trace, i);
+		const bt_clock_class *writer_clock_class;
+		const bt_clock_class *clock_class =
+			bt_trace_get_clock_class_by_index(trace, i);
 
-		if (!clock_class) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
-			ret = BT_COMPONENT_STATUS_ERROR;
-			goto end;
-		}
+		BT_ASSERT(clock_class);
 
 		writer_clock_class = ctf_copy_clock_class(err, clock_class);
-		bt_put(clock_class);
+		bt_clock_class_put_ref(clock_class);
 		if (!writer_clock_class) {
-			fprintf(err, "Failed to copy clock class");
+			BT_LOGE_STR("Failed to copy clock class.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}
 
-		int_ret = bt_ctf_trace_add_clock_class(writer_trace, writer_clock_class);
+		int_ret = bt_trace_add_clock_class(writer_trace, writer_clock_class);
 		if (int_ret != 0) {
-			BT_PUT(writer_clock_class);
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
+			BT_CLOCK_CLASS_PUT_REF_AND_RESET(writer_clock_class);
+			BT_LOGE_STR("Failed to add clock class.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}
@@ -184,7 +130,7 @@ enum bt_component_status ctf_copy_clock_classes(FILE *err,
 		/*
 		 * Ownership transferred to the trace.
 		 */
-		bt_put(writer_clock_class);
+		bt_clock_class_put_ref(writer_clock_class);
 	}
 
 	ret = BT_COMPONENT_STATUS_OK;
@@ -193,91 +139,194 @@ end:
 	return ret;
 }
 
+static
+void replace_clock_classes(const bt_trace *trace_copy,
+		bt_field_type *field_type)
+{
+	int ret;
+
+	BT_ASSERT(trace_copy);
+	BT_ASSERT(field_type);
+
+	switch (bt_field_type_get_type_id(field_type)) {
+	case BT_FIELD_TYPE_ID_INTEGER:
+	{
+		const bt_clock_class *mapped_clock_class =
+			bt_field_type_integer_get_mapped_clock_class(field_type);
+		const bt_clock_class *clock_class_copy = NULL;
+		const char *name;
+
+		if (!mapped_clock_class) {
+			break;
+		}
+
+		name = bt_clock_class_get_name(mapped_clock_class);
+		BT_ASSERT(name);
+		clock_class_copy = bt_trace_get_clock_class_by_name(
+			trace_copy, name);
+		BT_ASSERT(clock_class_copy);
+		ret = bt_field_type_integer_set_mapped_clock_class(
+			field_type, clock_class_copy);
+		BT_ASSERT(ret == 0);
+		bt_clock_class_put_ref(mapped_clock_class);
+		bt_clock_class_put_ref(clock_class_copy);
+		break;
+	}
+	case BT_FIELD_TYPE_ID_ENUM:
+	case BT_FIELD_TYPE_ID_ARRAY:
+	case BT_FIELD_TYPE_ID_SEQUENCE:
+	{
+		bt_field_type *subtype = NULL;
+
+		switch (bt_field_type_get_type_id(field_type)) {
+		case BT_FIELD_TYPE_ID_ENUM:
+			subtype = bt_field_type_enumeration_get_container_type(
+				field_type);
+			break;
+		case BT_FIELD_TYPE_ID_ARRAY:
+			subtype = bt_field_type_array_get_element_type(
+				field_type);
+			break;
+		case BT_FIELD_TYPE_ID_SEQUENCE:
+			subtype = bt_field_type_sequence_get_element_type(
+				field_type);
+			break;
+		default:
+			BT_LOGF("Unexpected field type ID: id=%d",
+				bt_field_type_get_type_id(field_type));
+			abort();
+		}
+
+		BT_ASSERT(subtype);
+		replace_clock_classes(trace_copy, subtype);
+		bt_object_put_ref(subtype);
+		break;
+	}
+	case BT_FIELD_TYPE_ID_STRUCT:
+	{
+		uint64_t i;
+		int64_t count = bt_field_type_structure_get_field_count(
+			field_type);
+
+		for (i = 0; i < count; i++) {
+			const char *name;
+			bt_field_type *member_type;
+
+			ret = bt_field_type_structure_get_field_by_index(
+				field_type, &name, &member_type, i);
+			BT_ASSERT(ret == 0);
+			replace_clock_classes(trace_copy, member_type);
+			bt_object_put_ref(member_type);
+		}
+
+		break;
+	}
+	case BT_FIELD_TYPE_ID_VARIANT:
+	{
+		uint64_t i;
+		int64_t count = bt_field_type_variant_get_field_count(
+			field_type);
+
+		for (i = 0; i < count; i++) {
+			const char *name;
+			bt_field_type *member_type;
+
+			ret = bt_field_type_variant_get_field_by_index(
+				field_type, &name, &member_type, i);
+			BT_ASSERT(ret == 0);
+			replace_clock_classes(trace_copy, member_type);
+			bt_object_put_ref(member_type);
+		}
+
+		break;
+	}
+	default:
+		break;
+	}
+}
+
 BT_HIDDEN
-struct bt_ctf_event_class *ctf_copy_event_class(FILE *err,
-		struct bt_ctf_event_class *event_class)
+const bt_event_class *ctf_copy_event_class(FILE *err,
+		const bt_trace *trace_copy,
+		const bt_event_class *event_class)
 {
-	struct bt_ctf_event_class *writer_event_class = NULL;
-	struct bt_ctf_field_type *context, *payload_type;
+	const bt_event_class *writer_event_class = NULL;
+	bt_field_type *context = NULL, *payload_type = NULL;
 	const char *name;
 	int ret;
 	int64_t id;
-	enum bt_ctf_event_class_log_level log_level;
+	bt_event_class_log_level log_level;
 	const char *emf_uri;
 
-	name = bt_ctf_event_class_get_name(event_class);
-	if (!name) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
-		goto end;
-	}
+	name = bt_event_class_get_name(event_class);
 
-	writer_event_class = bt_ctf_event_class_create(name);
-	if (!writer_event_class) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
-		goto end;
-	}
+	writer_event_class = bt_event_class_create(name);
+	BT_ASSERT(writer_event_class);
 
-	id = bt_ctf_event_class_get_id(event_class);
-	if (id < 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
-		goto error;
-	}
+	id = bt_event_class_get_id(event_class);
+	BT_ASSERT(id >= 0);
 
-	ret = bt_ctf_event_class_set_id(writer_event_class, id);
+	ret = bt_event_class_set_id(writer_event_class, id);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
+		BT_LOGE_STR("Failed to set event_class id.");
 		goto error;
 	}
 
-	log_level = bt_ctf_event_class_get_log_level(event_class);
+	log_level = bt_event_class_get_log_level(event_class);
 	if (log_level < 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
+		BT_LOGE_STR("Failed to get log_level.");
 		goto error;
 	}
 
-	ret = bt_ctf_event_class_set_log_level(writer_event_class, log_level);
+	ret = bt_event_class_set_log_level(writer_event_class, log_level);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
+		BT_LOGE_STR("Failed to set log_level.");
 		goto error;
 	}
 
-	emf_uri = bt_ctf_event_class_get_emf_uri(event_class);
+	emf_uri = bt_event_class_get_emf_uri(event_class);
 	if (emf_uri) {
-		ret = bt_ctf_event_class_set_emf_uri(writer_event_class,
+		ret = bt_event_class_set_emf_uri(writer_event_class,
 			emf_uri);
 		if (ret) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set emf uri.");
 			goto error;
 		}
 	}
 
-	payload_type = bt_ctf_event_class_get_payload_type(event_class);
+	payload_type = bt_event_class_get_payload_type(event_class);
 	if (payload_type) {
-		ret = bt_ctf_event_class_set_payload_type(writer_event_class,
-				payload_type);
+		bt_field_type *ft_copy =
+			bt_field_type_copy(payload_type);
+
+		if (!ft_copy) {
+			BT_LOGE_STR("Cannot copy payload field type.");
+		}
+
+		replace_clock_classes(trace_copy, ft_copy);
+		ret = bt_event_class_set_payload_type(writer_event_class,
+				ft_copy);
+		bt_object_put_ref(ft_copy);
 		if (ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set payload type.");
 			goto error;
 		}
-		BT_PUT(payload_type);
 	}
 
-	context = bt_ctf_event_class_get_context_type(event_class);
+	context = bt_event_class_get_context_type(event_class);
 	if (context) {
-		ret = bt_ctf_event_class_set_context_type(
-				writer_event_class, context);
-		BT_PUT(context);
+		bt_field_type *ft_copy =
+			bt_field_type_copy(context);
+
+		if (!ft_copy) {
+			BT_LOGE_STR("Cannot copy context field type.");
+		}
+
+		ret = bt_event_class_set_context_type(
+				writer_event_class, ft_copy);
+		bt_object_put_ref(ft_copy);
 		if (ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
+			BT_LOGE_STR("Failed to set context type.");
 			goto error;
 		}
 	}
@@ -285,40 +334,37 @@ struct bt_ctf_event_class *ctf_copy_event_class(FILE *err,
 	goto end;
 
 error:
-	BT_PUT(writer_event_class);
+	BT_EVENT_CLASS_PUT_REF_AND_RESET(writer_event_class);
 end:
+	BT_OBJECT_PUT_REF_AND_RESET(context);
+	BT_OBJECT_PUT_REF_AND_RESET(payload_type);
 	return writer_event_class;
 }
 
 BT_HIDDEN
-enum bt_component_status ctf_copy_event_classes(FILE *err,
-		struct bt_ctf_stream_class *stream_class,
-		struct bt_ctf_stream_class *writer_stream_class)
+bt_component_status ctf_copy_event_classes(FILE *err,
+		const bt_stream_class *stream_class,
+		const bt_stream_class *writer_stream_class)
 {
-	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
-	struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
+	bt_component_status ret = BT_COMPONENT_STATUS_OK;
+	const bt_event_class *event_class = NULL, *writer_event_class = NULL;
 	int count, i;
+	const bt_trace *writer_trace =
+		bt_stream_class_get_trace(writer_stream_class);
 
-	count = bt_ctf_stream_class_get_event_class_count(stream_class);
-	if (count < 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
-		goto end;
-	}
+	BT_ASSERT(writer_trace);
+	count = bt_stream_class_get_event_class_count(stream_class);
+	BT_ASSERT(count >= 0);
 
 	for (i = 0; i < count; i++) {
 		int int_ret;
 
-		event_class = bt_ctf_stream_class_get_event_class_by_index(
+		event_class = bt_stream_class_get_event_class_by_index(
 				stream_class, i);
-		if (!event_class) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
-			ret = BT_COMPONENT_STATUS_ERROR;
-			goto error;
-		}
-		if (i < bt_ctf_stream_class_get_event_class_count(writer_stream_class)) {
-			writer_event_class = bt_ctf_stream_class_get_event_class_by_index(
+		BT_ASSERT(event_class);
+
+		if (i < bt_stream_class_get_event_class_count(writer_stream_class)) {
+			writer_event_class = bt_stream_class_get_event_class_by_index(
 					writer_stream_class, i);
 			if (writer_event_class) {
 				/*
@@ -327,155 +373,164 @@ enum bt_component_status ctf_copy_event_classes(FILE *err,
 				 * event_classes after a trace has become
 				 * static.
 				 */
-				BT_PUT(writer_event_class);
-				BT_PUT(event_class);
+				BT_EVENT_CLASS_PUT_REF_AND_RESET(writer_event_class);
+				BT_EVENT_CLASS_PUT_REF_AND_RESET(event_class);
 				continue;
 			}
 		}
 
-		writer_event_class = ctf_copy_event_class(err, event_class);
+		writer_event_class = ctf_copy_event_class(err, writer_trace,
+			event_class);
 		if (!writer_event_class) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to copy event_class.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto error;
 		}
 
-		int_ret = bt_ctf_stream_class_add_event_class(writer_stream_class,
+		int_ret = bt_stream_class_add_event_class(writer_stream_class,
 				writer_event_class);
 		if (int_ret < 0) {
-			fprintf(err, "[error] Failed to add event class\n");
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to add event class.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto error;
 		}
-		BT_PUT(writer_event_class);
-		BT_PUT(event_class);
+		BT_EVENT_CLASS_PUT_REF_AND_RESET(writer_event_class);
+		BT_EVENT_CLASS_PUT_REF_AND_RESET(event_class);
 	}
 
 	goto end;
 
 error:
-	bt_put(event_class);
-	bt_put(writer_event_class);
+	bt_event_class_put_ref(event_class);
+	bt_event_class_put_ref(writer_event_class);
 end:
+	bt_trace_put_ref(writer_trace);
 	return ret;
 }
 
 BT_HIDDEN
-struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
-		struct bt_ctf_stream_class *stream_class,
-		struct bt_ctf_trace *writer_trace,
+const bt_stream_class *ctf_copy_stream_class(FILE *err,
+		const bt_stream_class *stream_class,
+		const bt_trace *writer_trace,
 		bool override_ts64)
 {
-	struct bt_ctf_field_type *type = NULL;
-	struct bt_ctf_stream_class *writer_stream_class = NULL;
+	bt_field_type *type = NULL;
+	bt_field_type *type_copy = NULL;
+	const bt_stream_class *writer_stream_class = NULL;
 	int ret_int;
-	const char *name = bt_ctf_stream_class_get_name(stream_class);
+	const char *name = bt_stream_class_get_name(stream_class);
 
-	writer_stream_class = bt_ctf_stream_class_create_empty(name);
-	if (!writer_stream_class) {
-		fprintf(err, "[error] %s in %s:%d\n",
-				__func__, __FILE__, __LINE__);
-		goto end;
-	}
+	writer_stream_class = bt_stream_class_create_empty(name);
+	BT_ASSERT(writer_stream_class);
 
-	type = bt_ctf_stream_class_get_packet_context_type(stream_class);
+	type = bt_stream_class_get_packet_context_type(stream_class);
 	if (type) {
-		ret_int = bt_ctf_stream_class_set_packet_context_type(
-				writer_stream_class, type);
+		type_copy = bt_field_type_copy(type);
+		if (!type_copy) {
+			BT_LOGE_STR("Cannot copy packet context field type.");
+		}
+
+		replace_clock_classes(writer_trace, type_copy);
+		ret_int = bt_stream_class_set_packet_context_type(
+				writer_stream_class, type_copy);
+		BT_OBJECT_PUT_REF_AND_RESET(type_copy);
 		if (ret_int < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set packet_context type.");
 			goto error;
 		}
-		BT_PUT(type);
+		BT_OBJECT_PUT_REF_AND_RESET(type);
 	}
 
-	type = bt_ctf_stream_class_get_event_header_type(stream_class);
+	type = bt_stream_class_get_event_header_type(stream_class);
 	if (type) {
-		ret_int = bt_ctf_trace_get_clock_class_count(writer_trace);
-		if (ret_int < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
-			goto error;
+		type_copy = bt_field_type_copy(type);
+		if (!type_copy) {
+			BT_LOGE_STR("Cannot copy event header field type.");
 		}
+
+		ret_int = bt_trace_get_clock_class_count(writer_trace);
+		BT_ASSERT(ret_int >= 0);
 		if (override_ts64 && ret_int > 0) {
-			struct bt_ctf_field_type *new_event_header_type;
+			bt_field_type *new_event_header_type;
 
-			new_event_header_type = override_header_type(err, type,
+			new_event_header_type = override_header_type(err, type_copy,
 					writer_trace);
 			if (!new_event_header_type) {
-				fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-						__LINE__);
+				BT_LOGE_STR("Failed to override header type.");
 				goto error;
 			}
-			ret_int = bt_ctf_stream_class_set_event_header_type(
+			replace_clock_classes(writer_trace, type_copy);
+			ret_int = bt_stream_class_set_event_header_type(
 					writer_stream_class, new_event_header_type);
-			BT_PUT(new_event_header_type);
+			BT_OBJECT_PUT_REF_AND_RESET(type_copy);
+			BT_OBJECT_PUT_REF_AND_RESET(new_event_header_type);
 			if (ret_int < 0) {
-				fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-						__LINE__);
+				BT_LOGE_STR("Failed to set event_header type.");
 				goto error;
 			}
 		} else {
-			ret_int = bt_ctf_stream_class_set_event_header_type(
-					writer_stream_class, type);
+			replace_clock_classes(writer_trace, type_copy);
+			ret_int = bt_stream_class_set_event_header_type(
+					writer_stream_class, type_copy);
+			BT_OBJECT_PUT_REF_AND_RESET(type_copy);
 			if (ret_int < 0) {
-				fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-						__LINE__);
+				BT_LOGE_STR("Failed to set event_header type.");
 				goto error;
 			}
 		}
-		BT_PUT(type);
+		BT_OBJECT_PUT_REF_AND_RESET(type);
 	}
 
-	type = bt_ctf_stream_class_get_event_context_type(stream_class);
+	type = bt_stream_class_get_event_context_type(stream_class);
 	if (type) {
-		ret_int = bt_ctf_stream_class_set_event_context_type(
-				writer_stream_class, type);
+		type_copy = bt_field_type_copy(type);
+		if (!type_copy) {
+			BT_LOGE_STR("Cannot copy event context field type.");
+		}
+
+		replace_clock_classes(writer_trace, type_copy);
+		ret_int = bt_stream_class_set_event_context_type(
+				writer_stream_class, type_copy);
+		BT_OBJECT_PUT_REF_AND_RESET(type_copy);
 		if (ret_int < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
+			BT_LOGE_STR("Failed to set event_contexttype.");
 			goto error;
 		}
 	}
-	BT_PUT(type);
+	BT_OBJECT_PUT_REF_AND_RESET(type);
 
 	goto end;
 
 error:
-	BT_PUT(writer_stream_class);
+	BT_STREAM_CLASS_PUT_REF_AND_RESET(writer_stream_class);
 end:
-	bt_put(type);
+	bt_object_put_ref(type);
+	bt_object_put_ref(type_copy);
 	return writer_stream_class;
 }
 
 BT_HIDDEN
-int ctf_stream_copy_packet_header(FILE *err, struct bt_ctf_packet *packet,
-		struct bt_ctf_stream *writer_stream)
+int ctf_stream_copy_packet_header(FILE *err, const bt_packet *packet,
+		const bt_stream *writer_stream)
 {
-	struct bt_ctf_field *packet_header = NULL, *writer_packet_header = NULL;
+	const bt_field *packet_header = NULL, *writer_packet_header = NULL;
 	int ret = 0;
 
-	packet_header = bt_ctf_packet_get_header(packet);
+	packet_header = bt_packet_get_header(packet);
 	if (!packet_header) {
 		goto end;
 	}
 
-	writer_packet_header = bt_ctf_field_copy(packet_header);
+	writer_packet_header = bt_field_copy(packet_header);
 	if (!writer_packet_header) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to copy field from stream packet header.");
 		goto error;
 	}
 
-	ret = bt_ctf_stream_set_packet_header(writer_stream,
+	ret = bt_stream_set_packet_header(writer_stream,
 			writer_packet_header);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to set stream packet header.");
 		goto error;
 	}
 
@@ -484,34 +539,32 @@ int ctf_stream_copy_packet_header(FILE *err, struct bt_ctf_packet *packet,
 error:
 	ret = -1;
 end:
-	bt_put(writer_packet_header);
-	bt_put(packet_header);
+	bt_object_put_ref(writer_packet_header);
+	bt_object_put_ref(packet_header);
 	return ret;
 }
 
 BT_HIDDEN
-int ctf_packet_copy_header(FILE *err, struct bt_ctf_packet *packet,
-		struct bt_ctf_packet *writer_packet)
+int ctf_packet_copy_header(FILE *err, const bt_packet *packet,
+		const bt_packet *writer_packet)
 {
-	struct bt_ctf_field *packet_header = NULL, *writer_packet_header = NULL;
+	const bt_field *packet_header = NULL, *writer_packet_header = NULL;
 	int ret = 0;
 
-	packet_header = bt_ctf_packet_get_header(packet);
+	packet_header = bt_packet_get_header(packet);
 	if (!packet_header) {
 		goto end;
 	}
 
-	writer_packet_header = bt_ctf_field_copy(packet_header);
+	writer_packet_header = bt_field_copy(packet_header);
 	if (!writer_packet_header) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to copy field from packet header.");
 		goto error;
 	}
 
-	ret = bt_ctf_packet_set_header(writer_packet, writer_packet_header);
+	ret = bt_packet_set_header(writer_packet, writer_packet_header);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to set packet header.");
 		goto error;
 	}
 
@@ -520,35 +573,33 @@ int ctf_packet_copy_header(FILE *err, struct bt_ctf_packet *packet,
 error:
 	ret = -1;
 end:
-	bt_put(packet_header);
-	bt_put(writer_packet_header);
+	bt_object_put_ref(packet_header);
+	bt_object_put_ref(writer_packet_header);
 	return ret;
 }
 
 BT_HIDDEN
-int ctf_stream_copy_packet_context(FILE *err, struct bt_ctf_packet *packet,
-		struct bt_ctf_stream *writer_stream)
+int ctf_stream_copy_packet_context(FILE *err, const bt_packet *packet,
+		const bt_stream *writer_stream)
 {
-	struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL;
+	const bt_field *packet_context = NULL, *writer_packet_context = NULL;
 	int ret = 0;
 
-	packet_context = bt_ctf_packet_get_context(packet);
+	packet_context = bt_packet_get_context(packet);
 	if (!packet_context) {
 		goto end;
 	}
 
-	writer_packet_context = bt_ctf_field_copy(packet_context);
+	writer_packet_context = bt_field_copy(packet_context);
 	if (!writer_packet_context) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to copy field from stream packet context.");
 		goto error;
 	}
 
-	ret = bt_ctf_stream_set_packet_context(writer_stream,
+	ret = bt_stream_set_packet_context(writer_stream,
 			writer_packet_context);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to set stream packet context.");
 		goto error;
 	}
 
@@ -557,35 +608,33 @@ int ctf_stream_copy_packet_context(FILE *err, struct bt_ctf_packet *packet,
 error:
 	ret = -1;
 end:
-	bt_put(packet_context);
-	bt_put(writer_packet_context);
+	bt_object_put_ref(packet_context);
+	bt_object_put_ref(writer_packet_context);
 	return ret;
 }
 
 BT_HIDDEN
-int ctf_packet_copy_context(FILE *err, struct bt_ctf_packet *packet,
-		struct bt_ctf_stream *writer_stream,
-		struct bt_ctf_packet *writer_packet)
+int ctf_packet_copy_context(FILE *err, const bt_packet *packet,
+		const bt_stream *writer_stream,
+		const bt_packet *writer_packet)
 {
-	struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL;
+	const bt_field *packet_context = NULL, *writer_packet_context = NULL;
 	int ret = 0;
 
-	packet_context = bt_ctf_packet_get_context(packet);
+	packet_context = bt_packet_get_context(packet);
 	if (!packet_context) {
 		goto end;
 	}
 
-	writer_packet_context = bt_ctf_field_copy(packet_context);
+	writer_packet_context = bt_field_copy(packet_context);
 	if (!writer_packet_context) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to copy field from packet context.");
 		goto error;
 	}
 
-	ret = bt_ctf_packet_set_context(writer_packet, writer_packet_context);
+	ret = bt_packet_set_context(writer_packet, writer_packet_context);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to set packet context.");
 		goto error;
 	}
 
@@ -594,82 +643,71 @@ int ctf_packet_copy_context(FILE *err, struct bt_ctf_packet *packet,
 error:
 	ret = -1;
 end:
-	bt_put(writer_packet_context);
-	bt_put(packet_context);
+	bt_object_put_ref(writer_packet_context);
+	bt_object_put_ref(packet_context);
 	return ret;
 }
 
 BT_HIDDEN
-int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
-		struct bt_ctf_event_class *writer_event_class,
-		struct bt_ctf_event *writer_event,
-		struct bt_ctf_field *event_header)
+int ctf_copy_event_header(FILE *err, const bt_event *event,
+		const bt_event_class *writer_event_class,
+		const bt_event *writer_event,
+		const bt_field *event_header)
 {
-	struct bt_ctf_clock_class *clock_class = NULL, *writer_clock_class = NULL;
-	struct bt_ctf_clock_value *clock_value = NULL, *writer_clock_value = NULL;
+	const bt_clock_class *clock_class = NULL, *writer_clock_class = NULL;
+	bt_clock_snapshot *clock_snapshot = NULL, *writer_clock_snapshot = NULL;
 
 	int ret;
-	struct bt_ctf_field *writer_event_header = NULL;
+	const bt_field *writer_event_header = NULL;
 	uint64_t value;
 
 	clock_class = event_get_clock_class(err, event);
 	if (!clock_class) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to get event clock_class.");
 		goto error;
 	}
 
-	clock_value = bt_ctf_event_get_clock_value(event, clock_class);
-	BT_PUT(clock_class);
-	if (!clock_value) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto error;
-	}
+	clock_snapshot = bt_event_get_clock_snapshot(event, clock_class);
+	BT_CLOCK_CLASS_PUT_REF_AND_RESET(clock_class);
+	BT_ASSERT(clock_snapshot);
 
-	ret = bt_ctf_clock_value_get_value(clock_value, &value);
-	BT_PUT(clock_value);
+	ret = bt_clock_snapshot_get_value(clock_snapshot, &value);
+	BT_OBJECT_PUT_REF_AND_RESET(clock_snapshot);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to get clock value.");
 		goto error;
 	}
 
 	writer_clock_class = event_get_clock_class(err, writer_event);
 	if (!writer_clock_class) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to get event clock_class.");
 		goto error;
 	}
 
-	writer_clock_value = bt_ctf_clock_value_create(writer_clock_class, value);
-	BT_PUT(writer_clock_class);
-	if (!writer_clock_value) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+	writer_clock_snapshot = bt_clock_snapshot_create(writer_clock_class, value);
+	BT_CLOCK_CLASS_PUT_REF_AND_RESET(writer_clock_class);
+	if (!writer_clock_snapshot) {
+		BT_LOGE_STR("Failed to create clock value.");
 		goto error;
 	}
 
-	ret = bt_ctf_event_set_clock_value(writer_event, writer_clock_value);
-	BT_PUT(writer_clock_value);
+	ret = bt_event_set_clock_snapshot(writer_event, writer_clock_snapshot);
+	BT_OBJECT_PUT_REF_AND_RESET(writer_clock_snapshot);
 	if (ret) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to set clock value.");
 		goto error;
 	}
 
-	writer_event_header = bt_ctf_field_copy(event_header);
+	writer_event_header = bt_field_copy(event_header);
 	if (!writer_event_header) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
+		BT_LOGE_STR("Failed to copy event_header.");
 		goto end;
 	}
 
-	ret = bt_ctf_event_set_header(writer_event, writer_event_header);
-	BT_PUT(writer_event_header);
+	ret = bt_event_set_header(writer_event, writer_event_header);
+	BT_OBJECT_PUT_REF_AND_RESET(writer_event_header);
 	if (ret < 0) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__,
-				__FILE__, __LINE__);
+		BT_LOGE_STR("Failed to set event_header.");
 		goto error;
 	}
 
@@ -684,221 +722,176 @@ end:
 }
 
 static
-struct bt_ctf_trace *event_class_get_trace(FILE *err,
-		struct bt_ctf_event_class *event_class)
+const bt_trace *event_class_get_trace(FILE *err,
+		const bt_event_class *event_class)
 {
-	struct bt_ctf_trace *trace = NULL;
-	struct bt_ctf_stream_class *stream_class = NULL;
+	const bt_trace *trace = NULL;
+	const bt_stream_class *stream_class = NULL;
 
-	stream_class = bt_ctf_event_class_get_stream_class(event_class);
-	if (!stream_class) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto error;
-	}
-
-	trace = bt_ctf_stream_class_get_trace(stream_class);
-	if (!trace) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
-		goto error;
-	}
+	stream_class = bt_event_class_get_stream_class(event_class);
+	BT_ASSERT(stream_class);
 
-	goto end;
+	trace = bt_stream_class_get_trace(stream_class);
+	BT_ASSERT(trace);
 
-error:
-	BT_PUT(trace);
-end:
-	bt_put(stream_class);
+	bt_stream_class_put_ref(stream_class);
 	return trace;
 }
 
 BT_HIDDEN
-struct bt_ctf_event *ctf_copy_event(FILE *err, struct bt_ctf_event *event,
-		struct bt_ctf_event_class *writer_event_class,
+const bt_event *ctf_copy_event(FILE *err, const bt_event *event,
+		const bt_event_class *writer_event_class,
 		bool override_ts64)
 {
-	struct bt_ctf_event *writer_event = NULL;
-	struct bt_ctf_field *field = NULL, *copy_field = NULL;
-	struct bt_ctf_trace *writer_trace = NULL;
+	const bt_event *writer_event = NULL;
+	const bt_field *field = NULL, *copy_field = NULL;
+	const bt_trace *writer_trace = NULL;
 	int ret;
 
-	writer_event = bt_ctf_event_create(writer_event_class);
+	writer_event = bt_event_create(writer_event_class);
 	if (!writer_event) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to create event.");
 		goto error;
 	}
 
 	writer_trace = event_class_get_trace(err, writer_event_class);
 	if (!writer_trace) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-				__LINE__);
+		BT_LOGE_STR("Failed to get trace from event_class.");
 		goto error;
 	}
 
-	field = bt_ctf_event_get_header(event);
+	field = bt_event_get_header(event);
 	if (field) {
 		/*
 		 * If override_ts64, we override all integer fields mapped to a
 		 * clock to a uint64_t field type, otherwise, we just copy it as
 		 * is.
 		 */
-		ret = bt_ctf_trace_get_clock_class_count(writer_trace);
-		if (ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
-			goto error;
-		}
+		ret = bt_trace_get_clock_class_count(writer_trace);
+		BT_ASSERT(ret >= 0);
+
 		if (override_ts64 && ret > 0) {
-			copy_field = bt_ctf_event_get_header(writer_event);
-			if (!copy_field) {
-				fprintf(err, "[error] %s in %s:%d\n", __func__,
-						__FILE__, __LINE__);
-				goto error;
-			}
+			copy_field = bt_event_get_header(writer_event);
+			BT_ASSERT(copy_field);
 
 			ret = copy_override_field(err, event, writer_event, field,
 					copy_field);
 			if (ret) {
-				fprintf(err, "[error] %s in %s:%d\n", __func__,
-						__FILE__, __LINE__);
+				BT_LOGE_STR("Failed to copy and override field.");
 				goto error;
 			}
-			BT_PUT(copy_field);
+			BT_OBJECT_PUT_REF_AND_RESET(copy_field);
 		} else {
 			ret = ctf_copy_event_header(err, event, writer_event_class,
 					writer_event, field);
 			if (ret) {
-				fprintf(err, "[error] %s in %s:%d\n", __func__,
-						__FILE__, __LINE__);
+				BT_LOGE_STR("Failed to copy event_header.");
 				goto error;
 			}
 		}
-		BT_PUT(field);
+		BT_OBJECT_PUT_REF_AND_RESET(field);
 	}
 
 	/* Optional field, so it can fail silently. */
-	field = bt_ctf_event_get_stream_event_context(event);
+	field = bt_event_get_stream_event_context(event);
 	if (field) {
-		copy_field = bt_ctf_field_copy(field);
+		copy_field = bt_field_copy(field);
 		if (!copy_field) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to copy field.");
 			goto error;
 		}
-		ret = bt_ctf_event_set_stream_event_context(writer_event,
+		ret = bt_event_set_stream_event_context(writer_event,
 				copy_field);
 		if (ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set stream_event_context.");
 			goto error;
 		}
-		BT_PUT(field);
-		BT_PUT(copy_field);
+		BT_OBJECT_PUT_REF_AND_RESET(field);
+		BT_OBJECT_PUT_REF_AND_RESET(copy_field);
 	}
 
 	/* Optional field, so it can fail silently. */
-	field = bt_ctf_event_get_event_context(event);
+	field = bt_event_get_event_context(event);
 	if (field) {
-		copy_field = bt_ctf_field_copy(field);
+		copy_field = bt_field_copy(field);
 		if (!copy_field) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to copy field.");
 			goto error;
 		}
-		ret = bt_ctf_event_set_event_context(writer_event, copy_field);
+		ret = bt_event_set_event_context(writer_event, copy_field);
 		if (ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set event_context.");
 			goto error;
 		}
-		BT_PUT(field);
-		BT_PUT(copy_field);
+		BT_OBJECT_PUT_REF_AND_RESET(field);
+		BT_OBJECT_PUT_REF_AND_RESET(copy_field);
 	}
 
-	field = bt_ctf_event_get_event_payload(event);
+	field = bt_event_get_event_payload(event);
 	if (field) {
-		copy_field = bt_ctf_field_copy(field);
+		copy_field = bt_field_copy(field);
 		if (!copy_field) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to copy field.");
 			goto error;
 		}
-		ret = bt_ctf_event_set_event_payload(writer_event, copy_field);
+		ret = bt_event_set_event_payload(writer_event, copy_field);
 		if (ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__,
-					__FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set event_payload.");
 			goto error;
 		}
-		BT_PUT(field);
-		BT_PUT(copy_field);
+		BT_OBJECT_PUT_REF_AND_RESET(field);
+		BT_OBJECT_PUT_REF_AND_RESET(copy_field);
 	}
 
 	goto end;
 
 error:
-	BT_PUT(writer_event);
+	BT_OBJECT_PUT_REF_AND_RESET(writer_event);
 end:
-	bt_put(field);
-	bt_put(copy_field);
-	bt_put(writer_trace);
+	bt_object_put_ref(field);
+	bt_object_put_ref(copy_field);
+	bt_trace_put_ref(writer_trace);
 	return writer_event;
 }
 
 BT_HIDDEN
-enum bt_component_status ctf_copy_trace(FILE *err, struct bt_ctf_trace *trace,
-		struct bt_ctf_trace *writer_trace)
+bt_component_status ctf_copy_trace(FILE *err, const bt_trace *trace,
+		const bt_trace *writer_trace)
 {
-	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
+	bt_component_status ret = BT_COMPONENT_STATUS_OK;
 	int field_count, i, int_ret;
-	struct bt_ctf_field_type *header_type = NULL;
-	enum bt_ctf_byte_order order;
+	bt_field_type *header_type = NULL;
+	bt_byte_order order;
 	const char *trace_name;
 	const unsigned char *trace_uuid;
 
-	field_count = bt_ctf_trace_get_environment_field_count(trace);
+	field_count = bt_trace_get_environment_field_count(trace);
 	for (i = 0; i < field_count; i++) {
 		int ret_int;
 		const char *name;
-		struct bt_value *value = NULL;
+		bt_value *value = NULL;
 
-		name = bt_ctf_trace_get_environment_field_name_by_index(
+		name = bt_trace_get_environment_field_name_by_index(
 			trace, i);
-		if (!name) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
-			ret = BT_COMPONENT_STATUS_ERROR;
-			goto end;
-		}
-		value = bt_ctf_trace_get_environment_field_value_by_index(
+		BT_ASSERT(name);
+
+		value = bt_trace_get_environment_field_value_by_index(
 			trace, i);
-		if (!value) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
-			ret = BT_COMPONENT_STATUS_ERROR;
-			goto end;
-		}
+		BT_ASSERT(value);
 
-		ret_int = bt_ctf_trace_set_environment_field(writer_trace,
+		ret_int = bt_trace_set_environment_field(writer_trace,
 				name, value);
-		BT_PUT(value);
+		BT_VALUE_PUT_REF_AND_RESET(value);
 		if (ret_int < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-					__LINE__);
-			fprintf(err, "[error] Unable to set environment field %s\n",
+			BT_LOGE("Failed to set environment: field-name=\"%s\"",
 					name);
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}
 	}
 
-	order = bt_ctf_trace_get_native_byte_order(trace);
-	if (order == BT_CTF_BYTE_ORDER_UNKNOWN) {
-		fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
-		ret = BT_COMPONENT_STATUS_ERROR;
-		goto end;
-	}
+	order = bt_trace_get_native_byte_order(trace);
+	BT_ASSERT(order != BT_BYTE_ORDER_UNKNOWN);
 
 	/*
 	 * Only explicitly set the writer trace's native byte order if
@@ -906,41 +899,41 @@ enum bt_component_status ctf_copy_trace(FILE *err, struct bt_ctf_trace *trace,
 	 * the CTF writer object chooses, which is the machine's native
 	 * byte order.
 	 */
-	if (order != BT_CTF_BYTE_ORDER_UNSPECIFIED) {
-		ret = bt_ctf_trace_set_native_byte_order(writer_trace, order);
+	if (order != BT_BYTE_ORDER_UNSPECIFIED) {
+		ret = bt_trace_set_native_byte_order(writer_trace, order);
 		if (ret) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set native byte order.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}
 	}
 
-	header_type = bt_ctf_trace_get_packet_header_type(trace);
+	header_type = bt_trace_get_packet_header_type(trace);
 	if (header_type) {
-		int_ret = bt_ctf_trace_set_packet_header_type(writer_trace, header_type);
-		BT_PUT(header_type);
+		int_ret = bt_trace_set_packet_header_type(writer_trace, header_type);
+		BT_OBJECT_PUT_REF_AND_RESET(header_type);
 		if (int_ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set packet header type.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}
 	}
 
-	trace_name = bt_ctf_trace_get_name(trace);
+	trace_name = bt_trace_get_name(trace);
 	if (trace_name) {
-		int_ret = bt_ctf_trace_set_name(writer_trace, trace_name);
+		int_ret = bt_trace_set_name(writer_trace, trace_name);
 		if (int_ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set trace name.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}
 	}
 
-	trace_uuid = bt_ctf_trace_get_uuid(trace);
+	trace_uuid = bt_trace_get_uuid(trace);
 	if (trace_uuid) {
-		int_ret = bt_ctf_trace_set_uuid(writer_trace, trace_uuid);
+		int_ret = bt_trace_set_uuid(writer_trace, trace_uuid);
 		if (int_ret < 0) {
-			fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
+			BT_LOGE_STR("Failed to set trace UUID.");
 			ret = BT_COMPONENT_STATUS_ERROR;
 			goto end;
 		}