diff --git a/minitube-fix-for-upstream-missing-qthelper.hpp-in-newer-mpv-version.patch b/minitube-fix-for-upstream-missing-qthelper.hpp-in-newer-mpv-version.patch
new file mode 100644
index 0000000..a79e4fe
--- /dev/null
+++ b/minitube-fix-for-upstream-missing-qthelper.hpp-in-newer-mpv-version.patch
@@ -0,0 +1,414 @@
+diff -Nur minitube-3.3/lib/media/src/mpv/mediampv.cpp new/lib/media/src/mpv/mediampv.cpp
+--- minitube-3.3/lib/media/src/mpv/mediampv.cpp	2019-12-21 01:57:27.000000000 +0100
++++ new/lib/media/src/mpv/mediampv.cpp	2020-03-18 18:02:54.101895593 +0100
+@@ -1,7 +1,7 @@
+ #include "mediampv.h"
+ 
+ #include <clocale>
+-#include <mpv/qthelper.hpp>
++#include <qthelper.hpp>
+ 
+ #ifndef MEDIA_AUDIOONLY
+ #include "mpvwidget.h"
+diff -Nur minitube-3.3/lib/media/src/mpv/mpvwidget.h new/lib/media/src/mpv/mpvwidget.h
+--- minitube-3.3/lib/media/src/mpv/mpvwidget.h	2019-12-21 01:57:27.000000000 +0100
++++ new/lib/media/src/mpv/mpvwidget.h	2020-03-18 18:03:18.141699378 +0100
+@@ -3,7 +3,7 @@
+ 
+ #include <QtWidgets>
+ #include <mpv/client.h>
+-#include <mpv/qthelper.hpp>
++#include <qthelper.hpp>
+ #include <mpv/render_gl.h>
+ 
+ class MpvWidget Q_DECL_FINAL : public QOpenGLWidget {
+diff -Nur minitube-3.3/lib/media/src/mpv/qthelper.hpp new/lib/media/src/mpv/qthelper.hpp
+--- minitube-3.3/lib/media/src/mpv/qthelper.hpp	1970-01-01 01:00:00.000000000 +0100
++++ new/lib/media/src/mpv/qthelper.hpp	2020-03-18 17:57:01.084816366 +0100
+@@ -0,0 +1,386 @@
++/* Copyright (C) 2017 the mpv developers
++ *
++ * Permission to use, copy, modify, and/or distribute this software for any
++ * purpose with or without fee is hereby granted, provided that the above
++ * copyright notice and this permission notice appear in all copies.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
++ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
++ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
++ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
++ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
++ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
++ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ */
++
++#ifndef MPV_CLIENT_API_QTHELPER_H_
++#define MPV_CLIENT_API_QTHELPER_H_
++
++#include <mpv/client.h>
++
++#if !MPV_ENABLE_DEPRECATED
++#error "This helper is deprecated. Copy it into your project instead."
++#else
++
++/**
++ * Note: these helpers are provided for convenience for C++/Qt applications.
++ * This is based on the public API in client.h, and it does not encode any
++ * knowledge that is not known or guaranteed outside of the C client API. You
++ * can even copy and modify this code as you like, or implement similar things
++ * for other languages.
++ */
++
++#include <cstring>
++
++#include <QVariant>
++#include <QString>
++#include <QList>
++#include <QHash>
++#include <QSharedPointer>
++#include <QMetaType>
++
++namespace mpv {
++namespace qt {
++
++// Wrapper around mpv_handle. Does refcounting under the hood.
++class Handle
++{
++    struct container {
++        container(mpv_handle *h) : mpv(h) {}
++        ~container() { mpv_terminate_destroy(mpv); }
++        mpv_handle *mpv;
++    };
++    QSharedPointer<container> sptr;
++public:
++    // Construct a new Handle from a raw mpv_handle with refcount 1. If the
++    // last Handle goes out of scope, the mpv_handle will be destroyed with
++    // mpv_terminate_destroy().
++    // Never destroy the mpv_handle manually when using this wrapper. You
++    // will create dangling pointers. Just let the wrapper take care of
++    // destroying the mpv_handle.
++    // Never create multiple wrappers from the same raw mpv_handle; copy the
++    // wrapper instead (that's what it's for).
++    static Handle FromRawHandle(mpv_handle *handle) {
++        Handle h;
++        h.sptr = QSharedPointer<container>(new container(handle));
++        return h;
++    }
++
++    // Return the raw handle; for use with the libmpv C API.
++    operator mpv_handle*() const { return sptr ? (*sptr).mpv : 0; }
++};
++
++static inline QVariant node_to_variant(const mpv_node *node)
++{
++    switch (node->format) {
++    case MPV_FORMAT_STRING:
++        return QVariant(QString::fromUtf8(node->u.string));
++    case MPV_FORMAT_FLAG:
++        return QVariant(static_cast<bool>(node->u.flag));
++    case MPV_FORMAT_INT64:
++        return QVariant(static_cast<qlonglong>(node->u.int64));
++    case MPV_FORMAT_DOUBLE:
++        return QVariant(node->u.double_);
++    case MPV_FORMAT_NODE_ARRAY: {
++        mpv_node_list *list = node->u.list;
++        QVariantList qlist;
++        for (int n = 0; n < list->num; n++)
++            qlist.append(node_to_variant(&list->values[n]));
++        return QVariant(qlist);
++    }
++    case MPV_FORMAT_NODE_MAP: {
++        mpv_node_list *list = node->u.list;
++        QVariantMap qmap;
++        for (int n = 0; n < list->num; n++) {
++            qmap.insert(QString::fromUtf8(list->keys[n]),
++                        node_to_variant(&list->values[n]));
++        }
++        return QVariant(qmap);
++    }
++    default: // MPV_FORMAT_NONE, unknown values (e.g. future extensions)
++        return QVariant();
++    }
++}
++
++struct node_builder {
++    node_builder(const QVariant& v) {
++        set(&node_, v);
++    }
++    ~node_builder() {
++        free_node(&node_);
++    }
++    mpv_node *node() { return &node_; }
++private:
++    Q_DISABLE_COPY(node_builder)
++    mpv_node node_;
++    mpv_node_list *create_list(mpv_node *dst, bool is_map, int num) {
++        dst->format = is_map ? MPV_FORMAT_NODE_MAP : MPV_FORMAT_NODE_ARRAY;
++        mpv_node_list *list = new mpv_node_list();
++        dst->u.list = list;
++        if (!list)
++            goto err;
++        list->values = new mpv_node[num]();
++        if (!list->values)
++            goto err;
++        if (is_map) {
++            list->keys = new char*[num]();
++            if (!list->keys)
++                goto err;
++        }
++        return list;
++    err:
++        free_node(dst);
++        return NULL;
++    }
++    char *dup_qstring(const QString &s) {
++        QByteArray b = s.toUtf8();
++        char *r = new char[b.size() + 1];
++        if (r)
++            std::memcpy(r, b.data(), b.size() + 1);
++        return r;
++    }
++    bool test_type(const QVariant &v, QMetaType::Type t) {
++        // The Qt docs say: "Although this function is declared as returning
++        // "QVariant::Type(obsolete), the return value should be interpreted
++        // as QMetaType::Type."
++        // So a cast really seems to be needed to avoid warnings (urgh).
++        return static_cast<int>(v.type()) == static_cast<int>(t);
++    }
++    void set(mpv_node *dst, const QVariant &src) {
++        if (test_type(src, QMetaType::QString)) {
++            dst->format = MPV_FORMAT_STRING;
++            dst->u.string = dup_qstring(src.toString());
++            if (!dst->u.string)
++                goto fail;
++        } else if (test_type(src, QMetaType::Bool)) {
++            dst->format = MPV_FORMAT_FLAG;
++            dst->u.flag = src.toBool() ? 1 : 0;
++        } else if (test_type(src, QMetaType::Int) ||
++                   test_type(src, QMetaType::LongLong) ||
++                   test_type(src, QMetaType::UInt) ||
++                   test_type(src, QMetaType::ULongLong))
++        {
++            dst->format = MPV_FORMAT_INT64;
++            dst->u.int64 = src.toLongLong();
++        } else if (test_type(src, QMetaType::Double)) {
++            dst->format = MPV_FORMAT_DOUBLE;
++            dst->u.double_ = src.toDouble();
++        } else if (src.canConvert<QVariantList>()) {
++            QVariantList qlist = src.toList();
++            mpv_node_list *list = create_list(dst, false, qlist.size());
++            if (!list)
++                goto fail;
++            list->num = qlist.size();
++            for (int n = 0; n < qlist.size(); n++)
++                set(&list->values[n], qlist[n]);
++        } else if (src.canConvert<QVariantMap>()) {
++            QVariantMap qmap = src.toMap();
++            mpv_node_list *list = create_list(dst, true, qmap.size());
++            if (!list)
++                goto fail;
++            list->num = qmap.size();
++            for (int n = 0; n < qmap.size(); n++) {
++                list->keys[n] = dup_qstring(qmap.keys()[n]);
++                if (!list->keys[n]) {
++                    free_node(dst);
++                    goto fail;
++                }
++                set(&list->values[n], qmap.values()[n]);
++            }
++        } else {
++            goto fail;
++        }
++        return;
++    fail:
++        dst->format = MPV_FORMAT_NONE;
++    }
++    void free_node(mpv_node *dst) {
++        switch (dst->format) {
++        case MPV_FORMAT_STRING:
++            delete[] dst->u.string;
++            break;
++        case MPV_FORMAT_NODE_ARRAY:
++        case MPV_FORMAT_NODE_MAP: {
++            mpv_node_list *list = dst->u.list;
++            if (list) {
++                for (int n = 0; n < list->num; n++) {
++                    if (list->keys)
++                        delete[] list->keys[n];
++                    if (list->values)
++                        free_node(&list->values[n]);
++                }
++                delete[] list->keys;
++                delete[] list->values;
++            }
++            delete list;
++            break;
++        }
++        default: ;
++        }
++        dst->format = MPV_FORMAT_NONE;
++    }
++};
++
++/**
++ * RAII wrapper that calls mpv_free_node_contents() on the pointer.
++ */
++struct node_autofree {
++    mpv_node *ptr;
++    node_autofree(mpv_node *a_ptr) : ptr(a_ptr) {}
++    ~node_autofree() { mpv_free_node_contents(ptr); }
++};
++
++#if MPV_ENABLE_DEPRECATED
++
++/**
++ * Return the given property as mpv_node converted to QVariant, or QVariant()
++ * on error.
++ *
++ * @deprecated use get_property() instead
++ *
++ * @param name the property name
++ */
++static inline QVariant get_property_variant(mpv_handle *ctx, const QString &name)
++{
++    mpv_node node;
++    if (mpv_get_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, &node) < 0)
++        return QVariant();
++    node_autofree f(&node);
++    return node_to_variant(&node);
++}
++
++/**
++ * Set the given property as mpv_node converted from the QVariant argument.
++
++ * @deprecated use set_property() instead
++ */
++static inline int set_property_variant(mpv_handle *ctx, const QString &name,
++                                       const QVariant &v)
++{
++    node_builder node(v);
++    return mpv_set_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node());
++}
++
++/**
++ * Set the given option as mpv_node converted from the QVariant argument.
++ *
++ * @deprecated use set_property() instead
++ */
++static inline int set_option_variant(mpv_handle *ctx, const QString &name,
++                                     const QVariant &v)
++{
++    node_builder node(v);
++    return mpv_set_option(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node());
++}
++
++/**
++ * mpv_command_node() equivalent. Returns QVariant() on error (and
++ * unfortunately, the same on success).
++ *
++ * @deprecated use command() instead
++ */
++static inline QVariant command_variant(mpv_handle *ctx, const QVariant &args)
++{
++    node_builder node(args);
++    mpv_node res;
++    if (mpv_command_node(ctx, node.node(), &res) < 0)
++        return QVariant();
++    node_autofree f(&res);
++    return node_to_variant(&res);
++}
++
++#endif
++
++/**
++ * This is used to return error codes wrapped in QVariant for functions which
++ * return QVariant.
++ *
++ * You can use get_error() or is_error() to extract the error status from a
++ * QVariant value.
++ */
++struct ErrorReturn
++{
++    /**
++     * enum mpv_error value (or a value outside of it if ABI was extended)
++     */
++    int error;
++
++    ErrorReturn() : error(0) {}
++    explicit ErrorReturn(int err) : error(err) {}
++};
++
++/**
++ * Return the mpv error code packed into a QVariant, or 0 (success) if it's not
++ * an error value.
++ *
++ * @return error code (<0) or success (>=0)
++ */
++static inline int get_error(const QVariant &v)
++{
++    if (!v.canConvert<ErrorReturn>())
++        return 0;
++    return v.value<ErrorReturn>().error;
++}
++
++/**
++ * Return whether the QVariant carries a mpv error code.
++ */
++static inline bool is_error(const QVariant &v)
++{
++    return get_error(v) < 0;
++}
++
++/**
++ * Return the given property as mpv_node converted to QVariant, or QVariant()
++ * on error.
++ *
++ * @param name the property name
++ * @return the property value, or an ErrorReturn with the error code
++ */
++static inline QVariant get_property(mpv_handle *ctx, const QString &name)
++{
++    mpv_node node;
++    int err = mpv_get_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, &node);
++    if (err < 0)
++        return QVariant::fromValue(ErrorReturn(err));
++    node_autofree f(&node);
++    return node_to_variant(&node);
++}
++
++/**
++ * Set the given property as mpv_node converted from the QVariant argument.
++ *
++ * @return mpv error code (<0 on error, >= 0 on success)
++ */
++static inline int set_property(mpv_handle *ctx, const QString &name,
++                                       const QVariant &v)
++{
++    node_builder node(v);
++    return mpv_set_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node());
++}
++
++/**
++ * mpv_command_node() equivalent.
++ *
++ * @param args command arguments, with args[0] being the command name as string
++ * @return the property value, or an ErrorReturn with the error code
++ */
++static inline QVariant command(mpv_handle *ctx, const QVariant &args)
++{
++    node_builder node(args);
++    mpv_node res;
++    int err = mpv_command_node(ctx, node.node(), &res);
++    if (err < 0)
++        return QVariant::fromValue(ErrorReturn(err));
++    node_autofree f(&res);
++    return node_to_variant(&res);
++}
++
++}
++}
++
++Q_DECLARE_METATYPE(mpv::qt::ErrorReturn)
++
++#endif /* else #if MPV_ENABLE_DEPRECATED */
++
++#endif
diff --git a/minitube.changes b/minitube.changes
index 7739a51..406cfed 100644
--- a/minitube.changes
+++ b/minitube.changes
@@ -1,3 +1,12 @@
+-------------------------------------------------------------------
+Wed Mar 18 17:27:59 UTC 2020 - Carsten Ziepke <kieltux@gmail.com>
+
+- Added fix for building with newer mpv versions:
+  minitube-fix-for-upstream-missing-qthelper.hpp-in-newer-mpv-version.patch
+  The qthelper.hpp header file is removed in the git version of mpv
+  because it is depreceated
+- Fix german translation (symlink DE_de -> de).
+
 -------------------------------------------------------------------
 Sun Feb  2 07:30:21 UTC 2020 - Carsten Ziepke <kieltux@gmail.com>
 
diff --git a/minitube.spec b/minitube.spec
index 8f4b72a..2e1990f 100644
--- a/minitube.spec
+++ b/minitube.spec
@@ -28,13 +28,15 @@ Source:         %{name}-%{version}.tar.xz
 Source1:        minitube.1
 # PATCH-FIX-OPENSUSE minitube-no-update-check.patch sur5r@sur5r.net -- Disable update check.
 Patch0:         %{name}-no-update-check.patch
+# PATCH-FIX-UPSTREAM minitube-fix-for-upstream-missing-qthelper.hpp-in-newer-mpv-version.patch
+Patch1:         %{name}-fix-for-upstream-missing-qthelper.hpp-in-newer-mpv-version.patch
 BuildRequires:  fdupes
 BuildRequires:  hicolor-icon-theme
 BuildRequires:  libqt5-linguist
 BuildRequires:  libqt5-qtdeclarative-devel
 BuildRequires:  pkgconfig
 BuildRequires:  update-desktop-files
-BuildRequires:  pkgconfig(Qt5Core) >= 5.10
+BuildRequires:  pkgconfig(Qt5Core)
 BuildRequires:  pkgconfig(Qt5DBus)
 BuildRequires:  pkgconfig(Qt5Network)
 BuildRequires:  pkgconfig(Qt5Script)
@@ -58,6 +60,7 @@ it strives to create a new TV-like experience.
 %prep
 %setup -q
 %patch0 -p1
+%patch1 -p1
 
 # Remove build time references so build-compare can do its work
 FAKE_BUILDDATE="$(LC_ALL=C date -u -d "@${SOURCE_DATE_EPOCH}" '+%%b %%e %%Y')"
@@ -73,6 +76,10 @@ make %{?_smp_mflags} V=1
 %qmake5_install
 install -Dpm 0644 %{SOURCE1} %{buildroot}%{_mandir}/man1/%{name}.1
 %suse_update_desktop_file -r %{name} AudioVideo Video Player
+# symlink for german translation file de_DE -> de
+pushd %{buildroot}%{_datadir}/%{name}/locale
+%{__ln_s} de_DE.qm de.qm
+popd
 %fdupes %{buildroot}%{_datadir}/
 
 %files