diff --git a/subprojects/gst-plugins-bad/gst/mxf/mxfaes-bwf.c b/subprojects/gst-plugins-bad/gst/mxf/mxfaes-bwf.c
index ca59a662a4..93d433bf0c 100644
--- a/subprojects/gst-plugins-bad/gst/mxf/mxfaes-bwf.c
+++ b/subprojects/gst-plugins-bad/gst/mxf/mxfaes-bwf.c
@@ -375,136 +375,124 @@ mxf_metadata_wave_audio_essence_descriptor_write_tags (MXFMetadataBase * m,
     0x04, 0x02, 0x03, 0x01, 0x0E, 0x00, 0x00, 0x00
   };
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, &block_align_ul, 16);
   t->size = 2;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT16_BE (t->data, self->block_align);
   mxf_primer_pack_add_mapping (primer, 0x3d0a, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->sequence_offset) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &sequence_offset_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->sequence_offset);
     mxf_primer_pack_add_mapping (primer, 0x3d0b, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, &avg_bps_ul, 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->avg_bps);
   mxf_primer_pack_add_mapping (primer, 0x3d09, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (!mxf_ul_is_zero (&self->channel_assignment)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &channel_assignment_ul, 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->channel_assignment, 16);
     mxf_primer_pack_add_mapping (primer, 0x3d32, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_envelope_version) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_envelope_version_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->peak_envelope_version);
     mxf_primer_pack_add_mapping (primer, 0x3d29, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_envelope_format) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_envelope_format_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->peak_envelope_format);
     mxf_primer_pack_add_mapping (primer, 0x3d2a, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->points_per_peak_value) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &points_per_peak_value_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->points_per_peak_value);
     mxf_primer_pack_add_mapping (primer, 0x3d2b, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_envelope_block_size) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_envelope_block_size_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->peak_envelope_block_size);
     mxf_primer_pack_add_mapping (primer, 0x3d2c, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_channels) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_channels_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->peak_channels);
     mxf_primer_pack_add_mapping (primer, 0x3d2d, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_frames) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_frames_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->peak_frames);
     mxf_primer_pack_add_mapping (primer, 0x3d2e, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_of_peaks_position) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_of_peaks_position_ul, 16);
     t->size = 8;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT64_BE (t->data, self->peak_of_peaks_position);
     mxf_primer_pack_add_mapping (primer, 0x3d2f, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_timestamp_is_unknown (&self->peak_envelope_timestamp)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_envelope_timestamp_ul, 16);
     t->size = 8;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     mxf_timestamp_write (&self->peak_envelope_timestamp, t->data);
     mxf_primer_pack_add_mapping (primer, 0x3d30, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->peak_envelope_data) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &peak_envelope_data_ul, 16);
     t->size = self->peak_envelope_data_length;
     t->data = g_memdup2 (self->peak_envelope_data, t->size);
@@ -976,44 +964,40 @@ mxf_metadata_aes3_audio_essence_descriptor_write_tags (MXFMetadataBase * m,
   };
 
   if (self->emphasis) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &emphasis_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->emphasis);
     mxf_primer_pack_add_mapping (primer, 0x3d0d, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->block_start_offset) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &block_start_offset_ul, 16);
     t->size = 2;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT16_BE (t->data, self->block_start_offset);
     mxf_primer_pack_add_mapping (primer, 0x3d0f, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->auxiliary_bits_mode) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &auxiliary_bits_mode_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->auxiliary_bits_mode);
     mxf_primer_pack_add_mapping (primer, 0x3d08, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->channel_status_mode) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &channel_status_mode_ul, 16);
     t->size = 8 + self->n_channel_status_mode;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_channel_status_mode);
     GST_WRITE_UINT32_BE (t->data + 4, 1);
     memcpy (t->data + 8, self->channel_status_mode, t->size);
@@ -1024,11 +1008,10 @@ mxf_metadata_aes3_audio_essence_descriptor_write_tags (MXFMetadataBase * m,
   if (self->fixed_channel_status_data) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &fixed_channel_status_data_ul, 16);
     t->size = 8 + 24 * self->n_fixed_channel_status_data;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_fixed_channel_status_data);
     GST_WRITE_UINT32_BE (t->data + 4, 24);
     for (i = 0; i < self->n_fixed_channel_status_data; i++)
@@ -1038,11 +1021,10 @@ mxf_metadata_aes3_audio_essence_descriptor_write_tags (MXFMetadataBase * m,
   }
 
   if (self->user_data_mode) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &user_data_mode_ul, 16);
     t->size = 8 + self->n_user_data_mode;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_user_data_mode);
     GST_WRITE_UINT32_BE (t->data + 4, 1);
     memcpy (t->data + 8, self->user_data_mode, t->size);
@@ -1053,11 +1035,10 @@ mxf_metadata_aes3_audio_essence_descriptor_write_tags (MXFMetadataBase * m,
   if (self->fixed_user_data) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &fixed_user_data_ul, 16);
     t->size = 8 + 24 * self->n_fixed_user_data;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_fixed_user_data);
     GST_WRITE_UINT32_BE (t->data + 4, 24);
     for (i = 0; i < self->n_fixed_user_data; i++)
diff --git a/subprojects/gst-plugins-bad/gst/mxf/mxfmetadata.c b/subprojects/gst-plugins-bad/gst/mxf/mxfmetadata.c
index a56d436445..6c88aec7e7 100644
--- a/subprojects/gst-plugins-bad/gst/mxf/mxfmetadata.c
+++ b/subprojects/gst-plugins-bad/gst/mxf/mxfmetadata.c
@@ -247,13 +247,8 @@ mxf_metadata_base_to_buffer (MXFMetadataBase * self, MXFPrimerPack * primer)
 
     while (g_hash_table_iter_next (&iter, NULL, (gpointer) & t)) {
       mxf_primer_pack_add_mapping (primer, 0x0000, &t->ul);
-      tmp = g_slice_dup (MXFLocalTag, t);
-      if (t->g_slice) {
-        tmp->data = g_slice_alloc (t->size);
-        memcpy (tmp->data, t->data, t->size);
-      } else {
-        tmp->data = g_memdup2 (t->data, t->size);
-      }
+      tmp = g_memdup2 (t, sizeof (MXFLocalTag));
+      tmp->data = g_memdup2 (t->data, t->size);
       tags = g_list_prepend (tags, tmp);
     }
   }
@@ -370,26 +365,24 @@ mxf_metadata_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   klass = MXF_METADATA_GET_CLASS (self);
 
   /* Last element contains the metadata key */
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (METADATA), 16);
   GST_WRITE_UINT16_BE (&t->ul.u[13], klass->type);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (INSTANCE_UID), 16);
   t->size = 16;
-  t->data = g_slice_alloc (16);
-  t->g_slice = TRUE;
+  t->data = g_malloc (16);
   memcpy (t->data, &self->parent.instance_uid, 16);
   mxf_primer_pack_add_mapping (primer, 0x3c0a, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (!mxf_uuid_is_zero (&self->parent.generation_uid)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (GENERATION_UID), 16);
     t->size = 16;
-    t->data = g_slice_alloc (16);
-    t->g_slice = TRUE;
+    t->data = g_malloc (16);
     memcpy (t->data, &self->parent.generation_uid, 16);
     mxf_primer_pack_add_mapping (primer, 0x0102, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -847,51 +840,46 @@ mxf_metadata_preface_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   MXFLocalTag *t;
   guint i;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (LAST_MODIFIED_DATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (8);
-  t->g_slice = TRUE;
+  t->data = g_malloc (8);
   mxf_timestamp_write (&self->last_modified_date, t->data);
   mxf_primer_pack_add_mapping (primer, 0x3b02, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (VERSION), 16);
   t->size = 2;
-  t->data = g_slice_alloc (2);
-  t->g_slice = TRUE;
+  t->data = g_malloc (2);
   GST_WRITE_UINT16_BE (t->data, self->version);
   mxf_primer_pack_add_mapping (primer, 0x3b05, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->object_model_version) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (OBJECT_MODEL_VERSION), 16);
     t->size = 4;
-    t->data = g_slice_alloc (4);
-    t->g_slice = TRUE;
+    t->data = g_malloc (4);
     GST_WRITE_UINT32_BE (t->data, self->object_model_version);
     mxf_primer_pack_add_mapping (primer, 0x3b07, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_uuid_is_zero (&self->primary_package_uid)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PRIMARY_PACKAGE), 16);
     t->size = 16;
-    t->data = g_slice_alloc (16);
-    t->g_slice = TRUE;
+    t->data = g_malloc (16);
     memcpy (t->data, &self->primary_package_uid, 16);
     mxf_primer_pack_add_mapping (primer, 0x3b08, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (IDENTIFICATIONS), 16);
   t->size = 8 + 16 * self->n_identifications;
-  t->data = g_slice_alloc0 (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc0 (t->size);
   mxf_primer_pack_add_mapping (primer, 0x3b06, &t->ul);
   GST_WRITE_UINT32_BE (t->data, self->n_identifications);
   GST_WRITE_UINT32_BE (t->data + 4, 16);
@@ -904,30 +892,27 @@ mxf_metadata_preface_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   }
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (CONTENT_STORAGE), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   mxf_primer_pack_add_mapping (primer, 0x3b03, &t->ul);
   memcpy (t->data, &MXF_METADATA_BASE (self->content_storage)->instance_uid,
       16);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (OPERATIONAL_PATTERN), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   mxf_primer_pack_add_mapping (primer, 0x3b09, &t->ul);
   memcpy (t->data, &self->operational_pattern, 16);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (ESSENCE_CONTAINERS), 16);
   t->size = 8 + 16 * self->n_essence_containers;
-  t->data = g_slice_alloc0 (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc0 (t->size);
   mxf_primer_pack_add_mapping (primer, 0x3b0a, &t->ul);
   GST_WRITE_UINT32_BE (t->data, self->n_essence_containers);
   GST_WRITE_UINT32_BE (t->data + 4, 16);
@@ -936,11 +921,10 @@ mxf_metadata_preface_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   }
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (DM_SCHEMES), 16);
   t->size = 8 + 16 * self->n_dm_schemes;
-  t->data = g_slice_alloc0 (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc0 (t->size);
   mxf_primer_pack_add_mapping (primer, 0x3b0b, &t->ul);
   GST_WRITE_UINT32_BE (t->data, self->n_dm_schemes);
   GST_WRITE_UINT32_BE (t->data + 4, 16);
@@ -1163,7 +1147,7 @@ mxf_metadata_identification_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->company_name) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (COMPANY_NAME), 16);
     t->data = mxf_utf8_to_utf16 (self->company_name, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x3c01, &t->ul);
@@ -1171,7 +1155,7 @@ mxf_metadata_identification_write_tags (MXFMetadataBase * m,
   }
 
   if (self->product_name) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PRODUCT_NAME), 16);
     t->data = mxf_utf8_to_utf16 (self->product_name, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x3c02, &t->ul);
@@ -1179,18 +1163,17 @@ mxf_metadata_identification_write_tags (MXFMetadataBase * m,
   }
 
   if (!mxf_product_version_is_valid (&self->product_version)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PRODUCT_VERSION), 16);
     t->size = 10;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     mxf_product_version_write (&self->product_version, t->data);
     mxf_primer_pack_add_mapping (primer, 0x3c03, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->version_string) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (VERSION_STRING), 16);
     t->data = mxf_utf8_to_utf16 (self->version_string, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x3c04, &t->ul);
@@ -1198,40 +1181,37 @@ mxf_metadata_identification_write_tags (MXFMetadataBase * m,
   }
 
   if (!mxf_uuid_is_zero (&self->product_uid)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PRODUCT_UID), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->product_uid, 16);
     mxf_primer_pack_add_mapping (primer, 0x3c05, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_timestamp_is_unknown (&self->modification_date)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (MODIFICATION_DATE), 16);
     t->size = 8;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     mxf_timestamp_write (&self->modification_date, t->data);
     mxf_primer_pack_add_mapping (primer, 0x3c06, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_product_version_is_valid (&self->toolkit_version)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (TOOLKIT_VERSION), 16);
     t->size = 10;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     mxf_product_version_write (&self->toolkit_version, t->data);
     mxf_primer_pack_add_mapping (primer, 0x3c07, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->platform) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PLATFORM), 16);
     t->data = mxf_utf8_to_utf16 (self->platform, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x3c08, &t->ul);
@@ -1239,11 +1219,10 @@ mxf_metadata_identification_write_tags (MXFMetadataBase * m,
   }
 
   if (!mxf_uuid_is_zero (&self->this_generation_uid)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (THIS_GENERATION_UID), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->this_generation_uid, 16);
     mxf_primer_pack_add_mapping (primer, 0x3c09, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -1510,11 +1489,10 @@ mxf_metadata_content_storage_write_tags (MXFMetadataBase * m,
   guint i;
 
   if (self->packages) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PACKAGES), 16);
     t->size = 8 + 16 * self->n_packages;
-    t->data = g_slice_alloc0 (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc0 (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_packages);
     GST_WRITE_UINT32_BE (t->data + 4, 16);
     for (i = 0; i < self->n_packages; i++) {
@@ -1530,11 +1508,10 @@ mxf_metadata_content_storage_write_tags (MXFMetadataBase * m,
   }
 
   if (self->essence_container_data) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ESSENCE_CONTAINER_DATA), 16);
     t->size = 8 + 16 * self->n_essence_container_data;
-    t->data = g_slice_alloc0 (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc0 (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_essence_container_data);
     GST_WRITE_UINT32_BE (t->data + 4, 16);
     for (i = 0; i < self->n_essence_container_data; i++) {
@@ -1705,31 +1682,28 @@ mxf_metadata_essence_container_data_write_tags (MXFMetadataBase * m,
       primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (LINKED_PACKAGE_UID), 16);
   t->size = 32;
-  t->data = g_slice_alloc0 (32);
-  t->g_slice = TRUE;
+  t->data = g_malloc0 (32);
   if (self->linked_package)
     memcpy (t->data, &self->linked_package->parent.package_uid, 32);
   mxf_primer_pack_add_mapping (primer, 0x2701, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (BODY_SID), 16);
   t->size = 4;
-  t->data = g_slice_alloc (4);
-  t->g_slice = TRUE;
+  t->data = g_malloc (4);
   GST_WRITE_UINT32_BE (t->data, self->body_sid);
   mxf_primer_pack_add_mapping (primer, 0x3f07, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->index_sid) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (INDEX_SID), 16);
     t->size = 4;
-    t->data = g_slice_alloc (4);
-    t->g_slice = TRUE;
+    t->data = g_malloc (4);
     GST_WRITE_UINT32_BE (t->data, self->index_sid);
     mxf_primer_pack_add_mapping (primer, 0x3f06, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -1974,37 +1948,34 @@ mxf_metadata_generic_package_write_tags (MXFMetadataBase * m,
       (mxf_metadata_generic_package_parent_class)->write_tags (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (PACKAGE_UID), 16);
   t->size = 32;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   memcpy (t->data, &self->package_uid, 32);
   mxf_primer_pack_add_mapping (primer, 0x4401, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->name) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PACKAGE_NAME), 16);
     t->data = mxf_utf8_to_utf16 (self->name, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x4402, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (PACKAGE_CREATION_DATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   mxf_timestamp_write (&self->package_creation_date, t->data);
   mxf_primer_pack_add_mapping (primer, 0x4405, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (PACKAGE_MODIFIED_DATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   mxf_timestamp_write (&self->package_modified_date, t->data);
   mxf_primer_pack_add_mapping (primer, 0x4404, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -2012,11 +1983,10 @@ mxf_metadata_generic_package_write_tags (MXFMetadataBase * m,
   if (self->tracks) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (TRACKS), 16);
     t->size = 8 + 16 * self->n_tracks;
-    t->data = g_slice_alloc0 (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc0 (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_tracks);
     GST_WRITE_UINT32_BE (t->data + 4, 16);
     for (i = 0; i < self->n_tracks; i++) {
@@ -2341,11 +2311,10 @@ mxf_metadata_source_package_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->descriptor) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DESCRIPTOR), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &MXF_METADATA_BASE (self->descriptor)->instance_uid, 16);
     mxf_primer_pack_add_mapping (primer, 0x4701, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -2526,37 +2495,34 @@ mxf_metadata_track_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
       primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (TRACK_ID), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->track_id);
   mxf_primer_pack_add_mapping (primer, 0x4801, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (TRACK_NUMBER), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->track_number);
   mxf_primer_pack_add_mapping (primer, 0x4804, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->track_name) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (TRACK_NAME), 16);
     t->data = mxf_utf8_to_utf16 (self->track_name, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x4802, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (SEQUENCE), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   memcpy (t->data, &MXF_METADATA_BASE (self->sequence)->instance_uid, 16);
   mxf_primer_pack_add_mapping (primer, 0x4803, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -2695,21 +2661,19 @@ mxf_metadata_timeline_track_write_tags (MXFMetadataBase * m,
       (mxf_metadata_timeline_track_parent_class)->write_tags (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (EDIT_RATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->edit_rate.n);
   GST_WRITE_UINT32_BE (t->data + 4, self->edit_rate.d);
   mxf_primer_pack_add_mapping (primer, 0x4b01, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (ORIGIN), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT64_BE (t->data, self->origin);
   mxf_primer_pack_add_mapping (primer, 0x4b02, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -2802,21 +2766,19 @@ mxf_metadata_event_track_write_tags (MXFMetadataBase * m,
       (mxf_metadata_event_track_parent_class)->write_tags (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (EVENT_EDIT_RATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->event_edit_rate.n);
   GST_WRITE_UINT32_BE (t->data + 4, self->event_edit_rate.d);
   mxf_primer_pack_add_mapping (primer, 0x4901, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (EVENT_ORIGIN), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT64_BE (t->data, self->event_origin);
   mxf_primer_pack_add_mapping (primer, 0x4902, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -3032,31 +2994,28 @@ mxf_metadata_sequence_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
       (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (DATA_DEFINITION), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   memcpy (t->data, &self->data_definition, 16);
   mxf_primer_pack_add_mapping (primer, 0x0201, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (DURATION), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT64_BE (t->data, self->duration);
   mxf_primer_pack_add_mapping (primer, 0x0202, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->structural_components) {
     guint i;
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (STRUCTURAL_COMPONENTS), 16);
     t->size = 8 + 16 * self->n_structural_components;
-    t->data = g_slice_alloc0 (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc0 (t->size);
 
     GST_WRITE_UINT32_BE (t->data, self->n_structural_components);
     GST_WRITE_UINT32_BE (t->data + 4, 16);
@@ -3171,20 +3130,18 @@ mxf_metadata_structural_component_write_tags (MXFMetadataBase * m,
       (mxf_metadata_structural_component_parent_class)->write_tags (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (DATA_DEFINITION), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   memcpy (t->data, &self->data_definition, 16);
   mxf_primer_pack_add_mapping (primer, 0x0201, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (DURATION), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT64_BE (t->data, self->duration);
   mxf_primer_pack_add_mapping (primer, 0x0202, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -3287,29 +3244,26 @@ mxf_metadata_timecode_component_write_tags (MXFMetadataBase * m,
       (mxf_metadata_timecode_component_parent_class)->write_tags (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (ROUNDED_TIMECODE_BASE), 16);
   t->size = 2;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT16_BE (t->data, self->rounded_timecode_base);
   mxf_primer_pack_add_mapping (primer, 0x1502, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (START_TIMECODE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT64_BE (t->data, self->start_timecode);
   mxf_primer_pack_add_mapping (primer, 0x1501, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (DROP_FRAME), 16);
   t->size = 1;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT8 (t->data, (self->drop_frame) ? 1 : 0);
   mxf_primer_pack_add_mapping (primer, 0x1503, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -3463,29 +3417,26 @@ mxf_metadata_source_clip_write_tags (MXFMetadataBase * m,
       (mxf_metadata_source_clip_parent_class)->write_tags (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (START_POSITION), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT64_BE (t->data, self->start_position);
   mxf_primer_pack_add_mapping (primer, 0x1201, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (SOURCE_PACKAGE_ID), 16);
   t->size = 32;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   memcpy (t->data, &self->source_package_id, 32);
   mxf_primer_pack_add_mapping (primer, 0x1101, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (SOURCE_TRACK_ID), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->source_track_id);
   mxf_primer_pack_add_mapping (primer, 0x1102, &t->ul);
   ret = g_list_prepend (ret, t);
@@ -3653,11 +3604,10 @@ mxf_metadata_dm_source_clip_write_tags (MXFMetadataBase * m,
   if (self->track_ids) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DM_SOURCECLIP_TRACK_IDS), 16);
     t->size = 8 + 4 * self->n_track_ids;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_track_ids);
     GST_WRITE_UINT32_BE (t->data + 4, 4);
     for (i = 0; i < self->n_track_ids; i++)
@@ -3881,18 +3831,17 @@ mxf_metadata_dm_segment_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   MXFLocalTag *t;
 
   if (self->event_start_position != -1) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (EVENT_START_POSITION), 16);
     t->size = 8;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT64_BE (t->data, self->event_start_position);
     mxf_primer_pack_add_mapping (primer, 0x0601, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->event_comment) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (EVENT_COMMENT), 16);
     t->data = mxf_utf8_to_utf16 (self->event_comment, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x0602, &t->ul);
@@ -3902,11 +3851,10 @@ mxf_metadata_dm_segment_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   if (self->track_ids) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DM_SEGMENT_TRACK_IDS), 16);
     t->size = 8 + 4 * self->n_track_ids;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_track_ids);
     GST_WRITE_UINT32_BE (t->data + 4, 4);
     for (i = 0; i < self->n_track_ids; i++)
@@ -3916,11 +3864,10 @@ mxf_metadata_dm_segment_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
   }
 
   if (self->dm_framework) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DM_FRAMEWORK), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &MXF_METADATA_BASE (self->dm_framework)->instance_uid, 16);
     mxf_primer_pack_add_mapping (primer, 0x6101, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -4112,11 +4059,10 @@ mxf_metadata_generic_descriptor_write_tags (MXFMetadataBase * m,
   if (self->locators) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (LOCATORS), 16);
     t->size = 8 + 16 * self->n_locators;
-    t->data = g_slice_alloc0 (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc0 (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_locators);
     GST_WRITE_UINT32_BE (t->data + 4, 16);
     for (i = 0; i < self->n_locators; i++) {
@@ -4262,52 +4208,47 @@ mxf_metadata_file_descriptor_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->linked_track_id) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (LINKED_TRACK_ID), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->linked_track_id);
     mxf_primer_pack_add_mapping (primer, 0x3006, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (SAMPLE_RATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->sample_rate.n);
   GST_WRITE_UINT32_BE (t->data + 4, self->sample_rate.d);
   mxf_primer_pack_add_mapping (primer, 0x3001, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->container_duration > 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (CONTAINER_DURATION), 16);
     t->size = 8;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT64_BE (t->data, self->container_duration);
     mxf_primer_pack_add_mapping (primer, 0x3002, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (ESSENCE_CONTAINER), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   memcpy (t->data, &self->essence_container, 16);
   mxf_primer_pack_add_mapping (primer, 0x3004, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (!mxf_ul_is_zero (&self->codec)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (CODEC), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->codec, 16);
     mxf_primer_pack_add_mapping (primer, 0x3005, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -4657,179 +4598,162 @@ mxf_metadata_generic_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->signal_standard != 1) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SIGNAL_STANDARD), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->signal_standard);
     mxf_primer_pack_add_mapping (primer, 0x3215, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (FRAME_LAYOUT), 16);
   t->size = 1;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT8 (t->data, self->frame_layout);
   mxf_primer_pack_add_mapping (primer, 0x320c, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (STORED_WIDTH), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->stored_width);
   mxf_primer_pack_add_mapping (primer, 0x3203, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (STORED_HEIGHT), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->stored_height);
   mxf_primer_pack_add_mapping (primer, 0x3202, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->stored_f2_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (STORED_F2_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->stored_f2_offset);
     mxf_primer_pack_add_mapping (primer, 0x3216, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->sampled_width != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SAMPLED_WIDTH), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->sampled_width);
     mxf_primer_pack_add_mapping (primer, 0x3205, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->sampled_height != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SAMPLED_HEIGHT), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->sampled_height);
     mxf_primer_pack_add_mapping (primer, 0x3204, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->sampled_x_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SAMPLED_X_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->sampled_x_offset);
     mxf_primer_pack_add_mapping (primer, 0x3206, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->sampled_y_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SAMPLED_Y_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->sampled_y_offset);
     mxf_primer_pack_add_mapping (primer, 0x3207, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->display_height != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DISPLAY_HEIGHT), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->display_height);
     mxf_primer_pack_add_mapping (primer, 0x3208, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->display_width != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DISPLAY_WIDTH), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->display_width);
     mxf_primer_pack_add_mapping (primer, 0x3209, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->display_x_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DISPLAY_X_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->display_x_offset);
     mxf_primer_pack_add_mapping (primer, 0x320a, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->display_y_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DISPLAY_Y_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->display_y_offset);
     mxf_primer_pack_add_mapping (primer, 0x320b, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->display_f2_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DISPLAY_F2_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->display_f2_offset);
     mxf_primer_pack_add_mapping (primer, 0x3217, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (ASPECT_RATIO), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->aspect_ratio.n);
   GST_WRITE_UINT32_BE (t->data + 4, self->aspect_ratio.d);
   mxf_primer_pack_add_mapping (primer, 0x320e, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->active_format_descriptor != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ACTIVE_FORMAT_DESCRIPTOR), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->active_format_descriptor);
     mxf_primer_pack_add_mapping (primer, 0x3218, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (VIDEO_LINE_MAP), 16);
   t->size = 16;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, 2);
   GST_WRITE_UINT32_BE (t->data + 4, 4);
   GST_WRITE_UINT32_BE (t->data + 8, self->video_line_map[0]);
@@ -4838,77 +4762,70 @@ mxf_metadata_generic_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
   ret = g_list_prepend (ret, t);
 
   if (self->alpha_transparency != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ALPHA_TRANSPARENCY), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->alpha_transparency);
     mxf_primer_pack_add_mapping (primer, 0x320f, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_ul_is_zero (&self->capture_gamma)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (CAPTURE_GAMMA), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->capture_gamma, 16);
     mxf_primer_pack_add_mapping (primer, 0x3210, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->image_alignment_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (IMAGE_ALIGNMENT_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->image_alignment_offset);
     mxf_primer_pack_add_mapping (primer, 0x3211, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->image_start_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (IMAGE_START_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->image_start_offset);
     mxf_primer_pack_add_mapping (primer, 0x3213, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->image_end_offset != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (IMAGE_END_OFFSET), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->image_end_offset);
     mxf_primer_pack_add_mapping (primer, 0x3214, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->field_dominance != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (FIELD_DOMINANCE), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->field_dominance);
     mxf_primer_pack_add_mapping (primer, 0x3212, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_ul_is_zero (&self->picture_essence_coding)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PICTURE_ESSENCE_CODING), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->picture_essence_coding, 16);
     mxf_primer_pack_add_mapping (primer, 0x3201, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -5225,82 +5142,74 @@ mxf_metadata_generic_sound_essence_descriptor_write_tags (MXFMetadataBase * m,
       (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (AUDIO_SAMPLING_RATE), 16);
   t->size = 8;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->audio_sampling_rate.n);
   GST_WRITE_UINT32_BE (t->data + 4, self->audio_sampling_rate.d);
   mxf_primer_pack_add_mapping (primer, 0x3d03, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (LOCKED), 16);
   t->size = 1;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT8 (t->data, (self->locked) ? 1 : 0);
   mxf_primer_pack_add_mapping (primer, 0x3d02, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->audio_ref_level) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (AUDIO_REF_LEVEL), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->audio_ref_level);
     mxf_primer_pack_add_mapping (primer, 0x3d04, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->electro_spatial_formulation != 255) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ELECTRO_SPATIAL_FORMULATION), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->electro_spatial_formulation);
     mxf_primer_pack_add_mapping (primer, 0x3d05, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (CHANNEL_COUNT), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->channel_count);
   mxf_primer_pack_add_mapping (primer, 0x3d07, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (QUANTIZATION_BITS), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->quantization_bits);
   mxf_primer_pack_add_mapping (primer, 0x3d01, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->dial_norm != 0) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DIAL_NORM), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->dial_norm);
     mxf_primer_pack_add_mapping (primer, 0x3d0c, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (!mxf_ul_is_zero (&self->sound_essence_compression)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SOUND_ESSENCE_COMPRESSION), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->sound_essence_compression, 16);
     mxf_primer_pack_add_mapping (primer, 0x3d06, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -5576,107 +5485,97 @@ mxf_metadata_cdci_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
       (m, primer);
   MXFLocalTag *t;
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (COMPONENT_DEPTH), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->component_depth);
   mxf_primer_pack_add_mapping (primer, 0x3301, &t->ul);
   ret = g_list_prepend (ret, t);
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (HORIZONTAL_SUBSAMPLING), 16);
   t->size = 4;
-  t->data = g_slice_alloc (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc (t->size);
   GST_WRITE_UINT32_BE (t->data, self->horizontal_subsampling);
   mxf_primer_pack_add_mapping (primer, 0x3302, &t->ul);
   ret = g_list_prepend (ret, t);
 
   if (self->vertical_subsampling) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (VERTICAL_SUBSAMPLING), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->vertical_subsampling);
     mxf_primer_pack_add_mapping (primer, 0x3308, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->color_siting != 0xff) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (COLOR_SITING), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->color_siting);
     mxf_primer_pack_add_mapping (primer, 0x3303, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->reversed_byte_order) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (REVERSED_BYTE_ORDER), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, (self->reversed_byte_order) ? 1 : 0);
     mxf_primer_pack_add_mapping (primer, 0x330b, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->padding_bits) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (PADDING_BITS), 16);
     t->size = 2;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT16_BE (t->data, self->padding_bits);
     mxf_primer_pack_add_mapping (primer, 0x3307, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->alpha_sample_depth) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ALPHA_SAMPLE_DEPTH), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->alpha_sample_depth);
     mxf_primer_pack_add_mapping (primer, 0x3309, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->black_ref_level) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (BLACK_REF_LEVEL), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->black_ref_level);
     mxf_primer_pack_add_mapping (primer, 0x3304, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->white_ref_level) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (WHITE_REF_LEVEL), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->white_ref_level);
     mxf_primer_pack_add_mapping (primer, 0x3305, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->color_range) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (COLOR_RANGE), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->color_range);
     mxf_primer_pack_add_mapping (primer, 0x3306, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -5875,65 +5774,59 @@ mxf_metadata_rgba_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->component_max_ref != 255) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (COMPONENT_MAX_REF), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->component_max_ref);
     mxf_primer_pack_add_mapping (primer, 0x3406, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->component_min_ref) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (COMPONENT_MIN_REF), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->component_min_ref);
     mxf_primer_pack_add_mapping (primer, 0x3407, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->alpha_max_ref != 255) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ALPHA_MAX_REF), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->alpha_max_ref);
     mxf_primer_pack_add_mapping (primer, 0x3408, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->alpha_min_ref) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (ALPHA_MIN_REF), 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->alpha_min_ref);
     mxf_primer_pack_add_mapping (primer, 0x3409, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->scanning_direction) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SCANNING_DIRECTION), 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->scanning_direction);
     mxf_primer_pack_add_mapping (primer, 0x3405, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
-  t = g_slice_new0 (MXFLocalTag);
+  t = g_new0 (MXFLocalTag, 1);
   memcpy (&t->ul, MXF_UL (PIXEL_LAYOUT), 16);
   t->size = 16;
-  t->data = g_slice_alloc0 (t->size);
-  t->g_slice = TRUE;
+  t->data = g_malloc0 (t->size);
   if (self->pixel_layout)
     memcpy (t->data, self->pixel_layout, self->n_pixel_layout * 2);
   mxf_primer_pack_add_mapping (primer, 0x3401, &t->ul);
@@ -6046,11 +5939,10 @@ mxf_metadata_generic_data_essence_descriptor_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (!mxf_ul_is_zero (&self->data_essence_coding)) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (DATA_ESSENCE_CODING), 16);
     t->size = 16;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     memcpy (t->data, &self->data_essence_coding, 16);
     mxf_primer_pack_add_mapping (primer, 0x3e01, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -6242,11 +6134,10 @@ mxf_metadata_multiple_descriptor_write_tags (MXFMetadataBase * m,
   if (self->sub_descriptors) {
     guint i;
 
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (SUB_DESCRIPTORS), 16);
     t->size = 8 + 16 * self->n_sub_descriptors;
-    t->data = g_slice_alloc0 (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc0 (t->size);
     GST_WRITE_UINT32_BE (t->data, self->n_sub_descriptors);
     GST_WRITE_UINT32_BE (t->data + 4, 16);
     for (i = 0; i < self->n_sub_descriptors; i++) {
@@ -6363,7 +6254,7 @@ mxf_metadata_text_locator_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->locator_name) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (LOCATOR_NAME), 16);
     t->data = mxf_utf8_to_utf16 (self->locator_name, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x4101, &t->ul);
@@ -6457,7 +6348,7 @@ mxf_metadata_network_locator_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->url_string) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, MXF_UL (URL_STRING), 16);
     t->data = mxf_utf8_to_utf16 (self->url_string, &t->size);
     mxf_primer_pack_add_mapping (primer, 0x4001, &t->ul);
diff --git a/subprojects/gst-plugins-bad/gst/mxf/mxfmpeg.c b/subprojects/gst-plugins-bad/gst/mxf/mxfmpeg.c
index 2025437d26..fbbe1e6ef2 100644
--- a/subprojects/gst-plugins-bad/gst/mxf/mxfmpeg.c
+++ b/subprojects/gst-plugins-bad/gst/mxf/mxfmpeg.c
@@ -258,110 +258,100 @@ mxf_metadata_mpeg_video_descriptor_write_tags (MXFMetadataBase * m,
   MXFLocalTag *t;
 
   if (self->single_sequence != -1) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_single_sequence_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, (self->single_sequence) ? 1 : 0);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->const_b_frames) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_constant_b_frames_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, (self->const_b_frames) ? 1 : 0);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->coded_content_type) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_coded_content_type_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->coded_content_type);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->low_delay) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_low_delay_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, (self->low_delay) ? 1 : 0);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->closed_gop) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_closed_gop_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, (self->closed_gop) ? 1 : 0);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->identical_gop) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_identical_gop_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, (self->identical_gop) ? 1 : 0);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->max_gop) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_identical_gop_ul, 16);
     t->size = 2;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT16_BE (t->data, self->max_gop);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->b_picture_count) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_b_picture_count_ul, 16);
     t->size = 2;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT16_BE (t->data, self->b_picture_count);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->bitrate) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_bitrate_ul, 16);
     t->size = 4;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT32_BE (t->data, self->bitrate);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
   }
 
   if (self->profile_and_level) {
-    t = g_slice_new0 (MXFLocalTag);
+    t = g_new0 (MXFLocalTag, 1);
     memcpy (&t->ul, &_profile_and_level_ul, 16);
     t->size = 1;
-    t->data = g_slice_alloc (t->size);
-    t->g_slice = TRUE;
+    t->data = g_malloc (t->size);
     GST_WRITE_UINT8 (t->data, self->profile_and_level);
     mxf_primer_pack_add_mapping (primer, 0, &t->ul);
     ret = g_list_prepend (ret, t);
@@ -1315,7 +1305,7 @@ mxf_mpeg_video_get_descriptor (GstPadTemplate * tmpl, GstCaps * caps,
       ret->parent.parent.parent.essence_container.u[13] = 0x04;
       ret->parent.parent.parent.essence_container.u[14] = 0x60;
       if ((v = gst_structure_get_value (s, "codec_data"))) {
-        MXFLocalTag *t = g_slice_new0 (MXFLocalTag);
+        MXFLocalTag *t = g_new0 (MXFLocalTag, 1);
         GstMapInfo map;
 
         codec_data = gst_value_get_buffer (v);
diff --git a/subprojects/gst-plugins-bad/gst/mxf/mxftypes.c b/subprojects/gst-plugins-bad/gst/mxf/mxftypes.c
index 73a8869077..1556a76114 100644
--- a/subprojects/gst-plugins-bad/gst/mxf/mxftypes.c
+++ b/subprojects/gst-plugins-bad/gst/mxf/mxftypes.c
@@ -1452,7 +1452,7 @@ mxf_index_table_segment_to_buffer (const MXFIndexTableSegment * segment)
 static void
 _mxf_mapping_ul_free (MXFUL * ul)
 {
-  g_slice_free (MXFUL, ul);
+  g_free (ul);
 }
 
 gboolean
@@ -1502,7 +1502,7 @@ mxf_primer_pack_parse (const MXFUL * ul, MXFPrimerPack * pack,
     if (g_hash_table_lookup (pack->mappings, GUINT_TO_POINTER (local_tag)))
       continue;
 
-    uid = g_slice_new (MXFUL);
+    uid = g_new (MXFUL, 1);
     memcpy (uid, data, 16);
     data += 16;
 
@@ -1575,13 +1575,13 @@ mxf_primer_pack_add_mapping (MXFPrimerPack * primer, guint16 local_tag,
 
   g_assert (ltag_tmp != 0);
 
-  uid = g_slice_new (MXFUL);
+  uid = g_new (MXFUL, 1);
   memcpy (uid, ul, 16);
 
   GST_DEBUG ("Adding mapping = 0x%04x -> %s", ltag_tmp,
       mxf_ul_to_string (uid, str));
   g_hash_table_insert (primer->mappings, GUINT_TO_POINTER (ltag_tmp), uid);
-  uid = g_slice_dup (MXFUL, uid);
+  uid = g_memdup2 (uid, sizeof (MXFUL));
   g_hash_table_insert (primer->reverse_mappings, uid,
       GUINT_TO_POINTER (ltag_tmp));
 
@@ -1664,11 +1664,8 @@ mxf_local_tag_parse (const guint8 * data, guint size, guint16 * tag,
 void
 mxf_local_tag_free (MXFLocalTag * tag)
 {
-  if (tag->g_slice)
-    g_slice_free1 (tag->size, tag->data);
-  else
-    g_free (tag->data);
-  g_slice_free (MXFLocalTag, tag);
+  g_free (tag->data);
+  g_free (tag);
 }
 
 gboolean
@@ -1703,11 +1700,10 @@ mxf_local_tag_add_to_hash_table (const MXFPrimerPack * primer,
     GST_DEBUG ("Adding local tag 0x%04x with UL %s and size %u", tag,
         mxf_ul_to_string (ul, str), tag_size);
 
-    local_tag = g_slice_new0 (MXFLocalTag);
+    local_tag = g_new0 (MXFLocalTag, 1);
     memcpy (&local_tag->ul, ul, sizeof (MXFUL));
     local_tag->size = tag_size;
     local_tag->data = tag_size == 0 ? NULL : g_memdup2 (tag_data, tag_size);
-    local_tag->g_slice = FALSE;
 
     g_hash_table_insert (*hash_table, &local_tag->ul, local_tag);
   } else {
diff --git a/subprojects/gst-plugins-bad/gst/mxf/mxftypes.h b/subprojects/gst-plugins-bad/gst/mxf/mxftypes.h
index c6f5c15f2a..069257666a 100644
--- a/subprojects/gst-plugins-bad/gst/mxf/mxftypes.h
+++ b/subprojects/gst-plugins-bad/gst/mxf/mxftypes.h
@@ -66,8 +66,6 @@ typedef struct {
   MXFUL ul;
   guint16 size;
   guint8 *data;
-  
-  gboolean g_slice; /* TRUE if data was allocated by GSlice */
 } MXFLocalTag;
 
 /* SMPTE 377M 11.1 */