diff --git a/debian/changelog b/debian/changelog
index a6bba5f..5de2256 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+gstreamer1.0 (1.5.2-1) experimental; urgency=medium
+
+  * New unstable upstream release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 24 Jun 2015 22:47:31 +0200
+
 gstreamer1.0 (1.5.1-3) experimental; urgency=medium
 
   * debian/rules,
diff --git a/debian/libgstreamer.symbols b/debian/libgstreamer.symbols
index 5f72953..7bc5a41 100644
--- a/debian/libgstreamer.symbols
+++ b/debian/libgstreamer.symbols
@@ -18,7 +18,7 @@
  gst_adapter_take@Base 1.0.0
  gst_adapter_take_buffer@Base 1.0.0
  gst_adapter_take_buffer_fast@Base 1.2.0
- gst_adapter_take_buffer_list@Base 1.5.1
+ gst_adapter_take_buffer_list@Base 1.5.2
  gst_adapter_take_list@Base 1.0.0
  gst_adapter_unmap@Base 1.0.0
  gst_base_parse_add_index_entry@Base 1.0.0
@@ -403,6 +403,7 @@
  gst_control_point_get_type@Base 1.5.0.1+git20150316
  gst_direct_control_binding_get_type@Base 1.0.0
  gst_direct_control_binding_new@Base 1.0.0
+ gst_direct_control_binding_new_absolute@Base 1.5.2
  gst_interpolation_control_source_get_type@Base 1.0.0
  gst_interpolation_control_source_new@Base 1.0.0
  gst_interpolation_mode_get_type@Base 1.0.0
@@ -438,16 +439,16 @@
  gst_net_time_packet_serialize@Base 1.0.0
  gst_net_time_provider_get_type@Base 1.0.0
  gst_net_time_provider_new@Base 1.0.0
- gst_ntp_clock_get_type@Base 1.5.1
- gst_ntp_clock_new@Base 1.5.1
- gst_ptp_clock_get_type@Base 1.5.1
- gst_ptp_clock_new@Base 1.5.1
- gst_ptp_deinit@Base 1.5.1
- gst_ptp_init@Base 1.5.1
- gst_ptp_is_initialized@Base 1.5.1
- gst_ptp_is_supported@Base 1.5.1
- gst_ptp_statistics_callback_add@Base 1.5.1
- gst_ptp_statistics_callback_remove@Base 1.5.1
+ gst_ntp_clock_get_type@Base 1.5.2
+ gst_ntp_clock_new@Base 1.5.2
+ gst_ptp_clock_get_type@Base 1.5.2
+ gst_ptp_clock_new@Base 1.5.2
+ gst_ptp_deinit@Base 1.5.2
+ gst_ptp_init@Base 1.5.2
+ gst_ptp_is_initialized@Base 1.5.2
+ gst_ptp_is_supported@Base 1.5.2
+ gst_ptp_statistics_callback_add@Base 1.5.2
+ gst_ptp_statistics_callback_remove@Base 1.5.2
 libgstreamer-1.0.so.0 libgstreamer1.0-0 #MINVER#
  GST_CAT_BUFFER@Base 1.0.0
  GST_CAT_BUFFER_LIST@Base 1.0.0
@@ -503,7 +504,7 @@
  _gst_double_range_type@Base 1.4.0
  _gst_element_error_printf@Base 1.0.0
  _gst_event_type@Base 1.0.0
- _gst_flagset_type@Base 1.5.1
+ _gst_flagset_type@Base 1.5.2
  _gst_fraction_range_type@Base 1.4.0
  _gst_fraction_type@Base 1.4.0
  _gst_int64_range_type@Base 1.4.0
@@ -563,6 +564,7 @@
  gst_bin_sync_children_states@Base 1.5.0.1+git20150316
  gst_bitmask_get_type@Base 1.0.0
  gst_buffer_add_meta@Base 1.0.0
+ gst_buffer_add_parent_buffer_meta@Base 1.5.2
  gst_buffer_add_protection_meta@Base 1.5.0.1+git20150513
  gst_buffer_append@Base 1.0.0
  gst_buffer_append_memory@Base 1.0.0
@@ -590,6 +592,7 @@
  gst_buffer_is_all_memory_writable@Base 1.4.0
  gst_buffer_is_memory_range_writable@Base 1.4.0
  gst_buffer_iterate_meta@Base 1.0.0
+ gst_buffer_list_copy_deep@Base 1.5.2
  gst_buffer_list_foreach@Base 1.0.0
  gst_buffer_list_get@Base 1.0.0
  gst_buffer_list_get_type@Base 1.0.0
@@ -771,7 +774,7 @@
  gst_clock_id_unschedule@Base 1.0.0
  gst_clock_id_wait@Base 1.0.0
  gst_clock_id_wait_async@Base 1.0.0
- gst_clock_is_synced@Base 1.5.1
+ gst_clock_is_synced@Base 1.5.2
  gst_clock_new_periodic_id@Base 1.0.0
  gst_clock_new_single_shot_id@Base 1.0.0
  gst_clock_periodic_id_reinit@Base 1.0.0
@@ -779,12 +782,12 @@
  gst_clock_set_calibration@Base 1.0.0
  gst_clock_set_master@Base 1.0.0
  gst_clock_set_resolution@Base 1.0.0
- gst_clock_set_synced@Base 1.5.1
+ gst_clock_set_synced@Base 1.5.2
  gst_clock_set_timeout@Base 1.0.0
  gst_clock_single_shot_id_reinit@Base 1.0.0
  gst_clock_type_get_type@Base 1.0.0
  gst_clock_unadjust_unlocked@Base 1.0.0
- gst_clock_wait_for_sync@Base 1.5.1
+ gst_clock_wait_for_sync@Base 1.5.2
  gst_context_get_context_type@Base 1.2.0
  gst_context_get_structure@Base 1.2.0
  gst_context_get_type@Base 1.2.0
@@ -1055,8 +1058,8 @@
  gst_event_type_to_quark@Base 1.0.0
  gst_event_writable_structure@Base 1.0.0
  gst_filename_to_uri@Base 1.0.0
- gst_flagset_get_type@Base 1.5.1
- gst_flagset_register@Base 1.5.1
+ gst_flagset_get_type@Base 1.5.2
+ gst_flagset_register@Base 1.5.2
  gst_flow_get_name@Base 1.0.0
  gst_flow_return_get_type@Base 1.0.0
  gst_flow_to_quark@Base 1.0.0
@@ -1237,9 +1240,9 @@
  gst_object_get_value_array@Base 1.0.0
  gst_object_has_active_control_bindings@Base 1.0.0
  gst_object_has_ancestor@Base 1.0.0
- gst_object_has_as_ancestor@Base 1.5.1
- gst_object_has_as_parent@Base 1.5.1
-#MISSING: 1.5.1# gst_object_has_parent@Base 1.5.0.1+git20150316
+ gst_object_has_as_ancestor@Base 1.5.2
+ gst_object_has_as_parent@Base 1.5.2
+#MISSING: 1.5.2# gst_object_has_parent@Base 1.5.0.1+git20150316
  gst_object_ref@Base 1.0.0
  gst_object_ref_sink@Base 1.0.0
  gst_object_remove_control_binding@Base 1.0.0
@@ -1354,6 +1357,9 @@
  gst_pad_use_fixed_caps@Base 1.0.0
  gst_param_spec_fraction@Base 1.0.0
  gst_param_spec_fraction_get_type@Base 1.0.0
+ gst_parent_buffer_meta_api_get_type@Base 1.5.2
+ gst_parent_buffer_meta_debug@Base 1.5.2
+ gst_parent_buffer_meta_get_info@Base 1.5.2
  gst_parse_bin_from_description@Base 1.0.0
  gst_parse_bin_from_description_full@Base 1.0.0
  gst_parse_context_free@Base 1.0.0
@@ -1373,12 +1379,14 @@
  gst_pipeline_get_bus@Base 1.0.0
  gst_pipeline_get_clock@Base 1.0.0
  gst_pipeline_get_delay@Base 1.0.0
+ gst_pipeline_get_latency@Base 1.5.2
  gst_pipeline_get_pipeline_clock@Base 1.5.0.1+git20150513
  gst_pipeline_get_type@Base 1.0.0
  gst_pipeline_new@Base 1.0.0
  gst_pipeline_set_auto_flush_bus@Base 1.0.0
  gst_pipeline_set_clock@Base 1.0.0
  gst_pipeline_set_delay@Base 1.0.0
+ gst_pipeline_set_latency@Base 1.5.2
  gst_pipeline_use_clock@Base 1.0.0
  gst_plugin_add_dependency@Base 1.0.0
  gst_plugin_add_dependency_simple@Base 1.0.0
@@ -1570,11 +1578,13 @@
  gst_resource_error_get_type@Base 1.0.0
  gst_resource_error_quark@Base 1.0.0
  gst_sample_get_buffer@Base 1.0.0
+ gst_sample_get_buffer_list@Base 1.5.2
  gst_sample_get_caps@Base 1.0.0
  gst_sample_get_info@Base 1.0.0
  gst_sample_get_segment@Base 1.0.0
  gst_sample_get_type@Base 1.0.0
  gst_sample_new@Base 1.0.0
+ gst_sample_set_buffer_list@Base 1.5.2
  gst_scheduling_flags_get_type@Base 1.0.0
  gst_search_mode_get_type@Base 1.0.0
  gst_seek_flags_get_type@Base 1.0.0
@@ -1632,7 +1642,7 @@
  gst_structure_get_double@Base 1.0.0
  gst_structure_get_enum@Base 1.0.0
  gst_structure_get_field_type@Base 1.0.0
- gst_structure_get_flagset@Base 1.5.1
+ gst_structure_get_flagset@Base 1.5.2
  gst_structure_get_fraction@Base 1.0.0
  gst_structure_get_int64@Base 1.4.0
  gst_structure_get_int@Base 1.0.0
@@ -1923,8 +1933,8 @@
  gst_value_get_caps_features@Base 1.2.0
  gst_value_get_double_range_max@Base 1.0.0
  gst_value_get_double_range_min@Base 1.0.0
- gst_value_get_flagset_flags@Base 1.5.1
- gst_value_get_flagset_mask@Base 1.5.1
+ gst_value_get_flagset_flags@Base 1.5.2
+ gst_value_get_flagset_mask@Base 1.5.2
  gst_value_get_fraction_denominator@Base 1.0.0
  gst_value_get_fraction_numerator@Base 1.0.0
  gst_value_get_fraction_range_max@Base 1.0.0
@@ -1954,7 +1964,7 @@
  gst_value_set_caps@Base 1.0.0
  gst_value_set_caps_features@Base 1.2.0
  gst_value_set_double_range@Base 1.0.0
- gst_value_set_flagset@Base 1.5.1
+ gst_value_set_flagset@Base 1.5.2
  gst_value_set_fraction@Base 1.0.0
  gst_value_set_fraction_range@Base 1.0.0
  gst_value_set_fraction_range_full@Base 1.0.0
diff --git a/debian/patches/0001-ptp-Check-for-the-actual-API-we-use-instead-of-just-.patch b/debian/patches/0001-ptp-Check-for-the-actual-API-we-use-instead-of-just-.patch
deleted file mode 100644
index 9a6bd3e..0000000
--- a/debian/patches/0001-ptp-Check-for-the-actual-API-we-use-instead-of-just-.patch
+++ /dev/null
@@ -1,133 +0,0 @@
-From 1ae38f7ba738c2adaaebc66576143f96cdd5e962 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
-Date: Tue, 9 Jun 2015 10:59:42 +0200
-Subject: [PATCH] ptp: Check for the actual API we use instead of just looking
- for __APPLE__
-
-Should fix the build on FreeBSD, DragonFly and other BSDs.
-
-https://bugzilla.gnome.org/show_bug.cgi?id=750530
----
- configure.ac                      | 38 ++++++++++++++++++++++++++++++++++++++
- libs/gst/helpers/gst-ptp-helper.c | 14 +++++++++-----
- 2 files changed, 47 insertions(+), 5 deletions(-)
-
-diff --git a/configure.ac b/configure.ac
-index 71309c9..3717518 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -325,6 +325,44 @@ AC_PATH_PROG([SETCAP], [setcap], [no], [$PATH:/usr/bin:/bin:/usr/sbin:/sbin])
- if test "x$HAVE_PTP" = "xyes"; then
- AC_DEFINE(HAVE_PTP, 1, [PTP support available])
- 
-+AC_MSG_CHECKING([for SIOCGIFCONF, SIOCGIFFLAGS and SIOCGIFHWADDR])
-+AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
-+    [[
-+        #include <sys/ioctl.h>
-+        #include <net/if.h>
-+    ]],
-+    [[
-+        struct ifreq ifr;
-+        struct ifconf ifc;
-+        ioctl(0, SIOCGIFCONF, &ifc);
-+        ioctl(0, SIOCGIFFLAGS, &ifr);
-+        ioctl(0, SIOCGIFHWADDR, &ifr);
-+        int dummy = ifr.ifr_hwaddr.sa_data[0];
-+    ]])], [
-+        AC_MSG_RESULT(yes)
-+        AC_DEFINE(HAVE_SIOCGIFCONF_SIOCGIFFLAGS_SIOCGIFHWADDR, 1, [SIOCGIFCONF, SIOCGIFFLAGS and SIOCGIFHWADDR is available])
-+    ], [
-+        AC_MSG_RESULT(no)
-+])
-+
-+AC_MSG_CHECKING([for getifaddrs() and AF_LINK])
-+AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
-+    [[
-+        #include <ifaddrs.h>
-+        #include <net/if.h>
-+        #include <net/if_dl.h>
-+    ]],
-+    [[
-+        struct ifaddrs *ifaddr;
-+        getifaddrs(&ifaddr);
-+        int dummy = (ifaddr->ifa_flags & IFF_LOOPBACK) && ifaddr->ifa_addr->sa_family != AF_LINK;
-+    ]])], [
-+        AC_MSG_RESULT(yes)
-+        AC_DEFINE(HAVE_GETIFADDRS_AF_LINK, 1, [getifaddrs() and AF_LINK is available])
-+    ], [
-+        AC_MSG_RESULT(no)
-+    ])
-+
- AC_MSG_CHECKING([how to install gst-ptp-helper])
- if test "x$with_ptp_helper_permissions" = "xauto"; then
-     if test "x$gst_ptp_have_cap" = "xyes" -a "x$SETCAP" != "xno"; then
-diff --git a/libs/gst/helpers/gst-ptp-helper.c b/libs/gst/helpers/gst-ptp-helper.c
-index 45a0206..6c753df 100644
---- a/libs/gst/helpers/gst-ptp-helper.c
-+++ b/libs/gst/helpers/gst-ptp-helper.c
-@@ -41,7 +41,7 @@
- #include <netinet/in.h>
- #include <string.h>
- 
--#ifdef __APPLE__
-+#ifdef HAVE_GETIFADDRS_AF_LINK
- #include <ifaddrs.h>
- #include <net/if_dl.h>
- #endif
-@@ -240,7 +240,7 @@ setup_sockets (void)
- 
-   /* Probe all non-loopback interfaces */
-   if (!ifaces) {
--#ifndef __APPLE__
-+#if defined(HAVE_SIOCGIFCONF_SIOCGIFFLAGS_SIOCGIFHWADDR)
-     struct ifreq ifr;
-     struct ifconf ifc;
-     gchar buf[8192];
-@@ -269,7 +269,7 @@ setup_sockets (void)
-           ifaces = probed_ifaces;
-       }
-     }
--#else
-+#elif defined(HAVE_GETIFADDRS_AF_LINK)
-     struct ifaddrs *ifaddr, *ifa;
- 
-     if (getifaddrs (&ifaddr) != -1) {
-@@ -291,6 +291,8 @@ setup_sockets (void)
-       g_ptr_array_add (arr, NULL);
-       ifaces = probed_ifaces = (gchar **) g_ptr_array_free (arr, FALSE);
-     }
-+#else
-+#warning "Implement something to list all network interfaces"
- #endif
-   }
- 
-@@ -298,7 +300,7 @@ setup_sockets (void)
-   if (clock_id == (guint64) - 1) {
-     gboolean success = FALSE;
- 
--#ifndef __APPLE__
-+#if defined(HAVE_SIOCGIFCONF_SIOCGIFFLAGS_SIOCGIFHWADDR)
-     struct ifreq ifr;
- 
-     if (ifaces) {
-@@ -356,7 +358,7 @@ setup_sockets (void)
-         }
-       }
-     }
--#else
-+#elif defined(HAVE_GETIFADDRS_AF_LINK)
-     struct ifaddrs *ifaddr, *ifa;
- 
-     if (getifaddrs (&ifaddr) != -1) {
-@@ -405,6 +407,8 @@ setup_sockets (void)
- 
-       freeifaddrs (ifaddr);
-     }
-+#else
-+#warning "Implement something to get MAC addresses of network interfaces"
- #endif
- 
-     if (!success) {
--- 
-2.1.4
-
diff --git a/debian/patches/series b/debian/patches/series
index bf9373f..e69de29 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1 +0,0 @@
-0001-ptp-Check-for-the-actual-API-we-use-instead-of-just-.patch
