History

client API: remove deprecated qthelper.hpp header

No replacement. Qt or C++ code has no business in this repository, and new code (even if it uses Qt) should not use it. Get rid of it. We consider the libmpv API itself as stable. Symbols can be deprecated, but not be removed. However, qthelper.hpp was never considered part of the libmpv API. There no ABI implications either, since it's a header- only implementation that uses C API symbols only. It's just a header provided for convenience for Qt/C++ programs (i.e. extremely limited usefulness).

wm4 committed 6 years ago

Commit 575197f1 parent 2337fa43 files · +11 −387Browse files

Unified · Split

3 files
  1. DOCS/client-api-changes.rst +10 −0
  2. libmpv/qthelper.hpp +0 −386
  3. wscript_build.py +1 −1
DOCS/client-api-changes.rst+10−0
@@ -32,6 +32,16 @@ API changes · 31 unmodified lines
3232
3333 ::
3434
35+ --- mpv 0.33.0 ---
36+ 1.107 - Remove the deprecated qthelper.hpp. This was obviously not part of the
37+ libmpv API, only an "additionally" provided helper, thus this is not
38+ considered an API change. If you are maintaining a project that relies
39+ on this header, you can simply download this file and adjust the
40+ include statement to use it instead:
41+
42+ https://raw.githubusercontent.com/mpv-player/mpv/v0.32.0/libmpv/qthelper.hpp
43+
44+ It is a good idea to write better wrappers for your use, though.
3545 --- mpv 0.31.0 ---
3646 1.107 - Deprecate MPV_EVENT_TICK
3747
libmpv/qthelper.hpp+0−386
@@ -1,386 +0,0 @@
1−/* Copyright (C) 2017 the mpv developers
2− *
3− * Permission to use, copy, modify, and/or distribute this software for any
4− * purpose with or without fee is hereby granted, provided that the above
5− * copyright notice and this permission notice appear in all copies.
6− *
7− * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8− * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9− * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
10− * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11− * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
12− * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
13− * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14− */
15−
16−#ifndef MPV_CLIENT_API_QTHELPER_H_
17−#define MPV_CLIENT_API_QTHELPER_H_
18−
19−#include <mpv/client.h>
20−
21−#if !MPV_ENABLE_DEPRECATED
22−#error "This helper is deprecated. Copy it into your project instead."
23−#else
24−
25−/**
26− * Note: these helpers are provided for convenience for C++/Qt applications.
27− * This is based on the public API in client.h, and it does not encode any
28− * knowledge that is not known or guaranteed outside of the C client API. You
29− * can even copy and modify this code as you like, or implement similar things
30− * for other languages.
31− */
32−
33−#include <cstring>
34−
35−#include <QVariant>
36−#include <QString>
37−#include <QList>
38−#include <QHash>
39−#include <QSharedPointer>
40−#include <QMetaType>
41−
42−namespace mpv {
43−namespace qt {
44−
45−// Wrapper around mpv_handle. Does refcounting under the hood.
46−class Handle
47−{
48− struct container {
49− container(mpv_handle *h) : mpv(h) {}
50− ~container() { mpv_terminate_destroy(mpv); }
51− mpv_handle *mpv;
52− };
53− QSharedPointer<container> sptr;
54−public:
55− // Construct a new Handle from a raw mpv_handle with refcount 1. If the
56− // last Handle goes out of scope, the mpv_handle will be destroyed with
57− // mpv_terminate_destroy().
58− // Never destroy the mpv_handle manually when using this wrapper. You
59− // will create dangling pointers. Just let the wrapper take care of
60− // destroying the mpv_handle.
61− // Never create multiple wrappers from the same raw mpv_handle; copy the
62− // wrapper instead (that's what it's for).
63− static Handle FromRawHandle(mpv_handle *handle) {
64− Handle h;
65− h.sptr = QSharedPointer<container>(new container(handle));
66− return h;
67− }
68−
69− // Return the raw handle; for use with the libmpv C API.
70− operator mpv_handle*() const { return sptr ? (*sptr).mpv : 0; }
71−};
72−
73−static inline QVariant node_to_variant(const mpv_node *node)
74−{
75− switch (node->format) {
76− case MPV_FORMAT_STRING:
77− return QVariant(QString::fromUtf8(node->u.string));
78− case MPV_FORMAT_FLAG:
79− return QVariant(static_cast<bool>(node->u.flag));
80− case MPV_FORMAT_INT64:
81− return QVariant(static_cast<qlonglong>(node->u.int64));
82− case MPV_FORMAT_DOUBLE:
83− return QVariant(node->u.double_);
84− case MPV_FORMAT_NODE_ARRAY: {
85− mpv_node_list *list = node->u.list;
86− QVariantList qlist;
87− for (int n = 0; n < list->num; n++)
88− qlist.append(node_to_variant(&list->values[n]));
89− return QVariant(qlist);
90− }
91− case MPV_FORMAT_NODE_MAP: {
92− mpv_node_list *list = node->u.list;
93− QVariantMap qmap;
94− for (int n = 0; n < list->num; n++) {
95− qmap.insert(QString::fromUtf8(list->keys[n]),
96− node_to_variant(&list->values[n]));
97− }
98− return QVariant(qmap);
99− }
100− default: // MPV_FORMAT_NONE, unknown values (e.g. future extensions)
101− return QVariant();
102− }
103−}
104−
105−struct node_builder {
106− node_builder(const QVariant& v) {
107− set(&node_, v);
108− }
109− ~node_builder() {
110− free_node(&node_);
111− }
112− mpv_node *node() { return &node_; }
113−private:
114− Q_DISABLE_COPY(node_builder)
115− mpv_node node_;
116− mpv_node_list *create_list(mpv_node *dst, bool is_map, int num) {
117− dst->format = is_map ? MPV_FORMAT_NODE_MAP : MPV_FORMAT_NODE_ARRAY;
118− mpv_node_list *list = new mpv_node_list();
119− dst->u.list = list;
120− if (!list)
121− goto err;
122− list->values = new mpv_node[num]();
123− if (!list->values)
124− goto err;
125− if (is_map) {
126− list->keys = new char*[num]();
127− if (!list->keys)
128− goto err;
129− }
130− return list;
131− err:
132− free_node(dst);
133− return NULL;
134− }
135− char *dup_qstring(const QString &s) {
136− QByteArray b = s.toUtf8();
137− char *r = new char[b.size() + 1];
138− if (r)
139− std::memcpy(r, b.data(), b.size() + 1);
140− return r;
141− }
142− bool test_type(const QVariant &v, QMetaType::Type t) {
143− // The Qt docs say: "Although this function is declared as returning
144− // "QVariant::Type(obsolete), the return value should be interpreted
145− // as QMetaType::Type."
146− // So a cast really seems to be needed to avoid warnings (urgh).
147− return static_cast<int>(v.type()) == static_cast<int>(t);
148− }
149− void set(mpv_node *dst, const QVariant &src) {
150− if (test_type(src, QMetaType::QString)) {
151− dst->format = MPV_FORMAT_STRING;
152− dst->u.string = dup_qstring(src.toString());
153− if (!dst->u.string)
154− goto fail;
155− } else if (test_type(src, QMetaType::Bool)) {
156− dst->format = MPV_FORMAT_FLAG;
157− dst->u.flag = src.toBool() ? 1 : 0;
158− } else if (test_type(src, QMetaType::Int) ||
159− test_type(src, QMetaType::LongLong) ||
160− test_type(src, QMetaType::UInt) ||
161− test_type(src, QMetaType::ULongLong))
162− {
163− dst->format = MPV_FORMAT_INT64;
164− dst->u.int64 = src.toLongLong();
165− } else if (test_type(src, QMetaType::Double)) {
166− dst->format = MPV_FORMAT_DOUBLE;
167− dst->u.double_ = src.toDouble();
168− } else if (src.canConvert<QVariantList>()) {
169− QVariantList qlist = src.toList();
170− mpv_node_list *list = create_list(dst, false, qlist.size());
171− if (!list)
172− goto fail;
173− list->num = qlist.size();
174− for (int n = 0; n < qlist.size(); n++)
175− set(&list->values[n], qlist[n]);
176− } else if (src.canConvert<QVariantMap>()) {
177− QVariantMap qmap = src.toMap();
178− mpv_node_list *list = create_list(dst, true, qmap.size());
179− if (!list)
180− goto fail;
181− list->num = qmap.size();
182− for (int n = 0; n < qmap.size(); n++) {
183− list->keys[n] = dup_qstring(qmap.keys()[n]);
184− if (!list->keys[n]) {
185− free_node(dst);
186− goto fail;
187− }
188− set(&list->values[n], qmap.values()[n]);
189− }
190− } else {
191− goto fail;
192− }
193− return;
194− fail:
195− dst->format = MPV_FORMAT_NONE;
196− }
197− void free_node(mpv_node *dst) {
198− switch (dst->format) {
199− case MPV_FORMAT_STRING:
200− delete[] dst->u.string;
201− break;
202− case MPV_FORMAT_NODE_ARRAY:
203− case MPV_FORMAT_NODE_MAP: {
204− mpv_node_list *list = dst->u.list;
205− if (list) {
206− for (int n = 0; n < list->num; n++) {
207− if (list->keys)
208− delete[] list->keys[n];
209− if (list->values)
210− free_node(&list->values[n]);
211− }
212− delete[] list->keys;
213− delete[] list->values;
214− }
215− delete list;
216− break;
217− }
218− default: ;
219− }
220− dst->format = MPV_FORMAT_NONE;
221− }
222−};
223−
224−/**
225− * RAII wrapper that calls mpv_free_node_contents() on the pointer.
226− */
227−struct node_autofree {
228− mpv_node *ptr;
229− node_autofree(mpv_node *a_ptr) : ptr(a_ptr) {}
230− ~node_autofree() { mpv_free_node_contents(ptr); }
231−};
232−
233−#if MPV_ENABLE_DEPRECATED
234−
235−/**
236− * Return the given property as mpv_node converted to QVariant, or QVariant()
237− * on error.
238− *
239− * @deprecated use get_property() instead
240− *
241− * @param name the property name
242− */
243−static inline QVariant get_property_variant(mpv_handle *ctx, const QString &name)
244−{
245− mpv_node node;
246− if (mpv_get_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, &node) < 0)
247− return QVariant();
248− node_autofree f(&node);
249− return node_to_variant(&node);
250−}
251−
252−/**
253− * Set the given property as mpv_node converted from the QVariant argument.
254−
255− * @deprecated use set_property() instead
256− */
257−static inline int set_property_variant(mpv_handle *ctx, const QString &name,
258− const QVariant &v)
259−{
260− node_builder node(v);
261− return mpv_set_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node());
262−}
263−
264−/**
265− * Set the given option as mpv_node converted from the QVariant argument.
266− *
267− * @deprecated use set_property() instead
268− */
269−static inline int set_option_variant(mpv_handle *ctx, const QString &name,
270− const QVariant &v)
271−{
272− node_builder node(v);
273− return mpv_set_option(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node());
274−}
275−
276−/**
277− * mpv_command_node() equivalent. Returns QVariant() on error (and
278− * unfortunately, the same on success).
279− *
280− * @deprecated use command() instead
281− */
282−static inline QVariant command_variant(mpv_handle *ctx, const QVariant &args)
283−{
284− node_builder node(args);
285− mpv_node res;
286− if (mpv_command_node(ctx, node.node(), &res) < 0)
287− return QVariant();
288− node_autofree f(&res);
289− return node_to_variant(&res);
290−}
291−
292−#endif
293−
294−/**
295− * This is used to return error codes wrapped in QVariant for functions which
296− * return QVariant.
297− *
298− * You can use get_error() or is_error() to extract the error status from a
299− * QVariant value.
300− */
301−struct ErrorReturn
302−{
303− /**
304− * enum mpv_error value (or a value outside of it if ABI was extended)
305− */
306− int error;
307−
308− ErrorReturn() : error(0) {}
309− explicit ErrorReturn(int err) : error(err) {}
310−};
311−
312−/**
313− * Return the mpv error code packed into a QVariant, or 0 (success) if it's not
314− * an error value.
315− *
316− * @return error code (<0) or success (>=0)
317− */
318−static inline int get_error(const QVariant &v)
319−{
320− if (!v.canConvert<ErrorReturn>())
321− return 0;
322− return v.value<ErrorReturn>().error;
323−}
324−
325−/**
326− * Return whether the QVariant carries a mpv error code.
327− */
328−static inline bool is_error(const QVariant &v)
329−{
330− return get_error(v) < 0;
331−}
332−
333−/**
334− * Return the given property as mpv_node converted to QVariant, or QVariant()
335− * on error.
336− *
337− * @param name the property name
338− * @return the property value, or an ErrorReturn with the error code
339− */
340−static inline QVariant get_property(mpv_handle *ctx, const QString &name)
341−{
342− mpv_node node;
343− int err = mpv_get_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, &node);
344− if (err < 0)
345− return QVariant::fromValue(ErrorReturn(err));
346− node_autofree f(&node);
347− return node_to_variant(&node);
348−}
349−
350−/**
351− * Set the given property as mpv_node converted from the QVariant argument.
352− *
353− * @return mpv error code (<0 on error, >= 0 on success)
354− */
355−static inline int set_property(mpv_handle *ctx, const QString &name,
356− const QVariant &v)
357−{
358− node_builder node(v);
359− return mpv_set_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node());
360−}
361−
362−/**
363− * mpv_command_node() equivalent.
364− *
365− * @param args command arguments, with args[0] being the command name as string
366− * @return the property value, or an ErrorReturn with the error code
367− */
368−static inline QVariant command(mpv_handle *ctx, const QVariant &args)
369−{
370− node_builder node(args);
371− mpv_node res;
372− int err = mpv_command_node(ctx, node.node(), &res);
373− if (err < 0)
374− return QVariant::fromValue(ErrorReturn(err));
375− node_autofree f(&res);
376− return node_to_variant(&res);
377−}
378−
379−}
380−}
381−
382−Q_DECLARE_METATYPE(mpv::qt::ErrorReturn)
383−
384−#endif /* else #if MPV_ENABLE_DEPRECATED */
385−
386−#endif
wscript_build.py+1−1
@@ -718,7 +718,7 @@ def build(ctx): · 717 unmodified lines
718718 PRIV_LIBS = get_deps(),
719719 )
720720
721− headers = ["client.h", "qthelper.hpp", "opengl_cb.h", "render.h",
721+ headers = ["client.h", "opengl_cb.h", "render.h",
722722 "render_gl.h", "stream_cb.h"]
723723 for f in headers:
724724 ctx.install_as(ctx.env.INCLUDEDIR + '/mpv/' + f, 'libmpv/' + f)

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t