snailed
/
void-packages
2
0
Fork 0
Code Issues 1 Pull Requests 1 Actions Activity

libopenshot: fix build.

This commit is contained in:
maxice8 2018-08-02 20:20:11 -03:00
parent 421ece5dfe
commit 0b9eeea646
3 changed files with 82 additions and 883 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

809
srcpkgs/libopenshot/patches/cppzmq.patch
View File

@ -1,809 +0,0 @@
diff -urN -p1 libopenshot-0.1.2.orig/include/ZmqLogger.h libopenshot-0.1.2/include/ZmqLogger.h
--- include/ZmqLogger.h 2016-08-30 06:23:13.000000000 +0200
+++ include/ZmqLogger.h 2016-09-04 08:18:03.032562903 +0200
@@ -40,3 +40,3 @@
#include <time.h>
-#include <zmq.hpp>
+#include "zmq.hpp"
#include <unistd.h>
diff -urN -p1 libopenshot-0.1.2.orig/include/zmq.hpp libopenshot-0.1.2/include/zmq.hpp
--- include/zmq.hpp 1970-01-01 01:00:00.000000000 +0100
+++ include/zmq.hpp 2016-09-04 08:17:58.280562658 +0200
@@ -0,0 +1,797 @@
+/*
+ Copyright (c) 2009-2011 250bpm s.r.o.
+ Copyright (c) 2011 Botond Ballo
+ Copyright (c) 2007-2009 iMatix Corporation
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to
+ deal in the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ IN THE SOFTWARE.
+*/
+
+#ifndef __ZMQ_HPP_INCLUDED__
+#define __ZMQ_HPP_INCLUDED__
+
+#if __cplusplus >= 201103L
+#define ZMQ_CPP11
+#define ZMQ_NOTHROW noexcept
+#define ZMQ_EXPLICIT explicit
+#else
+ #define ZMQ_CPP03
+ #define ZMQ_NOTHROW
+ #define ZMQ_EXPLICIT
+#endif
+
+#include <zmq.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <string>
+#include <exception>
+#include <vector>
+#include <iterator>
+
+#ifdef ZMQ_CPP11
+#include <chrono>
+#include <tuple>
+#endif
+
+// Detect whether the compiler supports C++11 rvalue references.
+#if (defined(__GNUC__) && (__GNUC__ > 4 || \
+ (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && \
+ defined(__GXX_EXPERIMENTAL_CXX0X__))
+ #define ZMQ_HAS_RVALUE_REFS
+ #define ZMQ_DELETED_FUNCTION = delete
+#elif defined(__clang__)
+ #if __has_feature(cxx_rvalue_references)
+ #define ZMQ_HAS_RVALUE_REFS
+ #endif
+
+ #if __has_feature(cxx_deleted_functions)
+ #define ZMQ_DELETED_FUNCTION = delete
+ #else
+ #define ZMQ_DELETED_FUNCTION
+ #endif
+#elif defined(_MSC_VER) && (_MSC_VER >= 1600)
+ #define ZMQ_HAS_RVALUE_REFS
+ #define ZMQ_DELETED_FUNCTION
+#else
+ #define ZMQ_DELETED_FUNCTION
+#endif
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 3, 0)
+#define ZMQ_NEW_MONITOR_EVENT_LAYOUT
+#endif
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
+#define ZMQ_HAS_PROXY_STEERABLE
+/* Socket event data */
+typedef struct {
+ uint16_t event; // id of the event as bitfield
+ int32_t value ; // value is either error code, fd or reconnect interval
+} zmq_event_t;
+#endif
+
+// Avoid using deprecated message receive function when possible
+#if ZMQ_VERSION < ZMQ_MAKE_VERSION(3, 2, 0)
+# define zmq_msg_recv(msg, socket, flags) zmq_recvmsg(socket, msg, flags)
+#endif
+
+
+// In order to prevent unused variable warnings when building in non-debug
+// mode use this macro to make assertions.
+#ifndef NDEBUG
+# define ZMQ_ASSERT(expression) assert(expression)
+#else
+# define ZMQ_ASSERT(expression) (void)(expression)
+#endif
+
+namespace zmq
+{
+
+ typedef zmq_free_fn free_fn;
+ typedef zmq_pollitem_t pollitem_t;
+
+ class error_t : public std::exception
+ {
+ public:
+
+ error_t () : errnum (zmq_errno ()) {}
+
+ virtual const char *what () const throw ()
+ {
+ return zmq_strerror (errnum);
+ }
+
+ int num () const
+ {
+ return errnum;
+ }
+
+ private:
+
+ int errnum;
+ };
+
+ inline int poll (zmq_pollitem_t const* items_, size_t nitems_, long timeout_ = -1)
+ {
+ int rc = zmq_poll (const_cast<zmq_pollitem_t*>(items_), static_cast<int>(nitems_), timeout_);
+ if (rc < 0)
+ throw error_t ();
+ return rc;
+ }
+
+ inline int poll(zmq_pollitem_t const* items, size_t nitems)
+ {
+ return poll(items, nitems, -1);
+ }
+
+ #ifdef ZMQ_CPP11
+ inline int poll(zmq_pollitem_t const* items, size_t nitems, std::chrono::milliseconds timeout)
+ {
+ return poll(items, nitems, timeout.count() );
+ }
+
+ inline int poll(std::vector<zmq_pollitem_t> const& items, std::chrono::milliseconds timeout)
+ {
+ return poll(items.data(), items.size(), timeout.count() );
+ }
+
+ inline int poll(std::vector<zmq_pollitem_t> const& items, long timeout_ = -1)
+ {
+ return poll(items.data(), items.size(), timeout_);
+ }
+ #endif
+
+
+
+ inline void proxy (void *frontend, void *backend, void *capture)
+ {
+ int rc = zmq_proxy (frontend, backend, capture);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+#ifdef ZMQ_HAS_PROXY_STEERABLE
+ inline void proxy_steerable (void *frontend, void *backend, void *capture, void *control)
+ {
+ int rc = zmq_proxy_steerable (frontend, backend, capture, control);
+ if (rc != 0)
+ throw error_t ();
+ }
+#endif
+
+ inline void version (int *major_, int *minor_, int *patch_)
+ {
+ zmq_version (major_, minor_, patch_);
+ }
+
+ #ifdef ZMQ_CPP11
+ inline std::tuple<int, int, int> version()
+ {
+ std::tuple<int, int, int> v;
+ zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v) );
+ return v;
+ }
+ #endif
+
+ class message_t
+ {
+ friend class socket_t;
+
+ public:
+
+ inline message_t ()
+ {
+ int rc = zmq_msg_init (&msg);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline explicit message_t (size_t size_)
+ {
+ int rc = zmq_msg_init_size (&msg, size_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ template<typename I> message_t(I first, I last):
+ msg()
+ {
+ typedef typename std::iterator_traits<I>::difference_type size_type;
+ typedef typename std::iterator_traits<I>::value_type value_t;
+
+ size_type const size_ = std::distance(first, last)*sizeof(value_t);
+ int const rc = zmq_msg_init_size (&msg, size_);
+ if (rc != 0)
+ throw error_t ();
+ value_t* dest = data<value_t>();
+ while (first != last)
+ {
+ *dest = *first;
+ ++dest; ++first;
+ }
+ }
+
+ inline message_t (const void *data_, size_t size_)
+ {
+ int rc = zmq_msg_init_size (&msg, size_);
+ if (rc != 0)
+ throw error_t ();
+ memcpy(data(), data_, size_);
+ }
+
+ inline message_t (void *data_, size_t size_, free_fn *ffn_,
+ void *hint_ = NULL)
+ {
+ int rc = zmq_msg_init_data (&msg, data_, size_, ffn_, hint_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ inline message_t (message_t &&rhs): msg (rhs.msg)
+ {
+ int rc = zmq_msg_init (&rhs.msg);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline message_t &operator = (message_t &&rhs) ZMQ_NOTHROW
+ {
+ std::swap (msg, rhs.msg);
+ return *this;
+ }
+#endif
+
+ inline ~message_t () ZMQ_NOTHROW
+ {
+ int rc = zmq_msg_close (&msg);
+ ZMQ_ASSERT (rc == 0);
+ }
+
+ inline void rebuild ()
+ {
+ int rc = zmq_msg_close (&msg);
+ if (rc != 0)
+ throw error_t ();
+ rc = zmq_msg_init (&msg);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void rebuild (size_t size_)
+ {
+ int rc = zmq_msg_close (&msg);
+ if (rc != 0)
+ throw error_t ();
+ rc = zmq_msg_init_size (&msg, size_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void rebuild (const void *data_, size_t size_)
+ {
+ int rc = zmq_msg_close (&msg);
+ if (rc != 0)
+ throw error_t ();
+ rc = zmq_msg_init_size (&msg, size_);
+ if (rc != 0)
+ throw error_t ();
+ memcpy(data(), data_, size_);
+ }
+
+ inline void rebuild (void *data_, size_t size_, free_fn *ffn_,
+ void *hint_ = NULL)
+ {
+ int rc = zmq_msg_close (&msg);
+ if (rc != 0)
+ throw error_t ();
+ rc = zmq_msg_init_data (&msg, data_, size_, ffn_, hint_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void move (message_t const *msg_)
+ {
+ int rc = zmq_msg_move (&msg, const_cast<zmq_msg_t*>(&(msg_->msg)));
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void copy (message_t const *msg_)
+ {
+ int rc = zmq_msg_copy (&msg, const_cast<zmq_msg_t*>(&(msg_->msg)));
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline bool more () const ZMQ_NOTHROW
+ {
+ int rc = zmq_msg_more (const_cast<zmq_msg_t*>(&msg) );
+ return rc != 0;
+ }
+
+ inline void *data () ZMQ_NOTHROW
+ {
+ return zmq_msg_data (&msg);
+ }
+
+ inline const void* data () const ZMQ_NOTHROW
+ {
+ return zmq_msg_data (const_cast<zmq_msg_t*>(&msg));
+ }
+
+ inline size_t size () const ZMQ_NOTHROW
+ {
+ return zmq_msg_size (const_cast<zmq_msg_t*>(&msg));
+ }
+
+ template<typename T> T* data() ZMQ_NOTHROW
+ {
+ return static_cast<T*>( data() );
+ }
+
+ template<typename T> T const* data() const ZMQ_NOTHROW
+ {
+ return static_cast<T const*>( data() );
+ }
+
+ inline bool equal(const message_t* other) const ZMQ_NOTHROW
+ {
+ if (size() != other->size())
+ return false;
+ std::string a(data<char>(), size());
+ std::string b(other->data<char>(), other->size());
+ return a == b;
+ }
+
+ private:
+ // The underlying message
+ zmq_msg_t msg;
+
+ // Disable implicit message copying, so that users won't use shared
+ // messages (less efficient) without being aware of the fact.
+ message_t (const message_t&) ZMQ_DELETED_FUNCTION;
+ void operator = (const message_t&) ZMQ_DELETED_FUNCTION;
+ };
+
+ class context_t
+ {
+ friend class socket_t;
+
+ public:
+ inline context_t ()
+ {
+ ptr = zmq_ctx_new ();
+ if (ptr == NULL)
+ throw error_t ();
+ }
+
+
+ inline explicit context_t (int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
+ {
+ ptr = zmq_ctx_new ();
+ if (ptr == NULL)
+ throw error_t ();
+
+ int rc = zmq_ctx_set (ptr, ZMQ_IO_THREADS, io_threads_);
+ ZMQ_ASSERT (rc == 0);
+
+ rc = zmq_ctx_set (ptr, ZMQ_MAX_SOCKETS, max_sockets_);
+ ZMQ_ASSERT (rc == 0);
+ }
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ inline context_t (context_t &&rhs) ZMQ_NOTHROW : ptr (rhs.ptr)
+ {
+ rhs.ptr = NULL;
+ }
+ inline context_t &operator = (context_t &&rhs) ZMQ_NOTHROW
+ {
+ std::swap (ptr, rhs.ptr);
+ return *this;
+ }
+#endif
+
+ inline ~context_t () ZMQ_NOTHROW
+ {
+ int rc = zmq_ctx_destroy (ptr);
+ ZMQ_ASSERT (rc == 0);
+ }
+
+ inline void close() ZMQ_NOTHROW
+ {
+ int rc = zmq_ctx_destroy (ptr);
+ ZMQ_ASSERT (rc == 0);
+ }
+
+ // Be careful with this, it's probably only useful for
+ // using the C api together with an existing C++ api.
+ // Normally you should never need to use this.
+ inline ZMQ_EXPLICIT operator void* () ZMQ_NOTHROW
+ {
+ return ptr;
+ }
+
+ inline ZMQ_EXPLICIT operator void const* () const ZMQ_NOTHROW
+ {
+ return ptr;
+ }
+ private:
+
+ void *ptr;
+
+ context_t (const context_t&) ZMQ_DELETED_FUNCTION;
+ void operator = (const context_t&) ZMQ_DELETED_FUNCTION;
+ };
+
+ #ifdef ZMQ_CPP11
+ enum class socket_type: int
+ {
+ req = ZMQ_REQ,
+ rep = ZMQ_REP,
+ dealer = ZMQ_DEALER,
+ router = ZMQ_ROUTER,
+ pub = ZMQ_PUB,
+ sub = ZMQ_SUB,
+ xpub = ZMQ_XPUB,
+ xsub = ZMQ_XSUB,
+ push = ZMQ_PUSH,
+ pull = ZMQ_PULL,
+#if ZMQ_VERSION_MAJOR < 4
+ pair = ZMQ_PAIR
+#else
+ pair = ZMQ_PAIR,
+ stream = ZMQ_STREAM
+#endif
+ };
+ #endif
+
+ class socket_t
+ {
+ friend class monitor_t;
+ public:
+ inline socket_t(context_t& context_, int type_)
+ {
+ init(context_, type_);
+ }
+
+ #ifdef ZMQ_CPP11
+ inline socket_t(context_t& context_, socket_type type_)
+ {
+ init(context_, static_cast<int>(type_));
+ }
+ #endif
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ inline socket_t(socket_t&& rhs) ZMQ_NOTHROW : ptr(rhs.ptr)
+ {
+ rhs.ptr = NULL;
+ }
+ inline socket_t& operator=(socket_t&& rhs) ZMQ_NOTHROW
+ {
+ std::swap(ptr, rhs.ptr);
+ return *this;
+ }
+#endif
+
+ inline ~socket_t () ZMQ_NOTHROW
+ {
+ close();
+ }
+
+ inline operator void* () ZMQ_NOTHROW
+ {
+ return ptr;
+ }
+
+ inline operator void const* () const ZMQ_NOTHROW
+ {
+ return ptr;
+ }
+
+ inline void close() ZMQ_NOTHROW
+ {
+ if(ptr == NULL)
+ // already closed
+ return ;
+ int rc = zmq_close (ptr);
+ ZMQ_ASSERT (rc == 0);
+ ptr = 0 ;
+ }
+
+ template<typename T> void setsockopt(int option_, T const& optval)
+ {
+ setsockopt(option_, &optval, sizeof(T) );
+ }
+
+ inline void setsockopt (int option_, const void *optval_,
+ size_t optvallen_)
+ {
+ int rc = zmq_setsockopt (ptr, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void getsockopt (int option_, void *optval_,
+ size_t *optvallen_) const
+ {
+ int rc = zmq_getsockopt (ptr, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ template<typename T> T getsockopt(int option_) const
+ {
+ T optval;
+ size_t optlen = sizeof(T);
+ getsockopt(option_, &optval, &optlen );
+ return optval;
+ }
+
+ inline void bind(std::string const& addr)
+ {
+ bind(addr.c_str());
+ }
+
+ inline void bind (const char *addr_)
+ {
+ int rc = zmq_bind (ptr, addr_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void unbind(std::string const& addr)
+ {
+ unbind(addr.c_str());
+ }
+
+ inline void unbind (const char *addr_)
+ {
+ int rc = zmq_unbind (ptr, addr_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void connect(std::string const& addr)
+ {
+ connect(addr.c_str());
+ }
+
+ inline void connect (const char *addr_)
+ {
+ int rc = zmq_connect (ptr, addr_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline void disconnect(std::string const& addr)
+ {
+ disconnect(addr.c_str());
+ }
+
+ inline void disconnect (const char *addr_)
+ {
+ int rc = zmq_disconnect (ptr, addr_);
+ if (rc != 0)
+ throw error_t ();
+ }
+
+ inline bool connected() const ZMQ_NOTHROW
+ {
+ return(ptr != NULL);
+ }
+
+ inline size_t send (const void *buf_, size_t len_, int flags_ = 0)
+ {
+ int nbytes = zmq_send (ptr, buf_, len_, flags_);
+ if (nbytes >= 0)
+ return (size_t) nbytes;
+ if (zmq_errno () == EAGAIN)
+ return 0;
+ throw error_t ();
+ }
+
+ inline bool send (message_t &msg_, int flags_ = 0)
+ {
+ int nbytes = zmq_msg_send (&(msg_.msg), ptr, flags_);
+ if (nbytes >= 0)
+ return true;
+ if (zmq_errno () == EAGAIN)
+ return false;
+ throw error_t ();
+ }
+
+ template<typename I> bool send(I first, I last, int flags_=0)
+ {
+ zmq::message_t msg(first, last);
+ return send(msg, flags_);
+ }
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ inline bool send (message_t &&msg_, int flags_ = 0)
+ {
+ return send(msg_, flags_);
+ }
+#endif
+
+ inline size_t recv (void *buf_, size_t len_, int flags_ = 0)
+ {
+ int nbytes = zmq_recv (ptr, buf_, len_, flags_);
+ if (nbytes >= 0)
+ return (size_t) nbytes;
+ if (zmq_errno () == EAGAIN)
+ return 0;
+ throw error_t ();
+ }
+
+ inline bool recv (message_t *msg_, int flags_ = 0)
+ {
+ int nbytes = zmq_msg_recv (&(msg_->msg), ptr, flags_);
+ if (nbytes >= 0)
+ return true;
+ if (zmq_errno () == EAGAIN)
+ return false;
+ throw error_t ();
+ }
+
+ private:
+ inline void init(context_t& context_, int type_)
+ {
+ ctxptr = context_.ptr;
+ ptr = zmq_socket (context_.ptr, type_ );
+ if (ptr == NULL)
+ throw error_t ();
+ }
+
+ void *ptr;
+ void *ctxptr;
+
+ socket_t (const socket_t&) ZMQ_DELETED_FUNCTION;
+ void operator = (const socket_t&) ZMQ_DELETED_FUNCTION;
+ };
+
+ class monitor_t
+ {
+ public:
+ monitor_t() : socketPtr(NULL) {}
+ virtual ~monitor_t() {}
+
+ void monitor(socket_t &socket, std::string const& addr, int events = ZMQ_EVENT_ALL)
+ {
+ monitor(socket, addr.c_str(), events);
+ }
+
+ void monitor(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)
+ {
+ int rc = zmq_socket_monitor(socket.ptr, addr_, events);
+ if (rc != 0)
+ throw error_t ();
+
+ socketPtr = socket.ptr;
+ void *s = zmq_socket (socket.ctxptr, ZMQ_PAIR);
+ assert (s);
+
+ rc = zmq_connect (s, addr_);
+ assert (rc == 0);
+
+ on_monitor_started();
+
+ while (true) {
+ zmq_msg_t eventMsg;
+ zmq_msg_init (&eventMsg);
+ rc = zmq_msg_recv (&eventMsg, s, 0);
+ if (rc == -1 && zmq_errno() == ETERM)
+ break;
+ assert (rc != -1);
+#if ZMQ_VERSION_MAJOR >= 4
+ const char* data = static_cast<const char*>(zmq_msg_data(&eventMsg));
+ zmq_event_t msgEvent;
+ memcpy(&msgEvent.event, data, sizeof(uint16_t)); data += sizeof(uint16_t);
+ memcpy(&msgEvent.value, data, sizeof(int32_t));
+ zmq_event_t* event = &msgEvent;
+#else
+ zmq_event_t* event = static_cast<zmq_event_t*>(zmq_msg_data(&eventMsg));
+#endif
+
+#ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT
+ zmq_msg_t addrMsg;
+ zmq_msg_init (&addrMsg);
+ rc = zmq_msg_recv (&addrMsg, s, 0);
+ if (rc == -1 && zmq_errno() == ETERM)
+ break;
+ assert (rc != -1);
+ const char* str = static_cast<const char*>(zmq_msg_data (&addrMsg));
+ std::string address(str, str + zmq_msg_size(&addrMsg));
+ zmq_msg_close (&addrMsg);
+#else
+ // Bit of a hack, but all events in the zmq_event_t union have the same layout so this will work for all event types.
+ std::string address = event->data.connected.addr;
+#endif
+
+#ifdef ZMQ_EVENT_MONITOR_STOPPED
+ if (event->event == ZMQ_EVENT_MONITOR_STOPPED)
+ break;
+#endif
+
+ switch (event->event) {
+ case ZMQ_EVENT_CONNECTED:
+ on_event_connected(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CONNECT_DELAYED:
+ on_event_connect_delayed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CONNECT_RETRIED:
+ on_event_connect_retried(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_LISTENING:
+ on_event_listening(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_BIND_FAILED:
+ on_event_bind_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_ACCEPTED:
+ on_event_accepted(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_ACCEPT_FAILED:
+ on_event_accept_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CLOSED:
+ on_event_closed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CLOSE_FAILED:
+ on_event_close_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_DISCONNECTED:
+ on_event_disconnected(*event, address.c_str());
+ break;
+ default:
+ on_event_unknown(*event, address.c_str());
+ break;
+ }
+ zmq_msg_close (&eventMsg);
+ }
+ zmq_close (s);
+ socketPtr = NULL;
+ }
+
+#ifdef ZMQ_EVENT_MONITOR_STOPPED
+ void abort()
+ {
+ if (socketPtr)
+ zmq_socket_monitor(socketPtr, NULL, 0);
+ }
+#endif
+ virtual void on_monitor_started() {}
+ virtual void on_event_connected(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_connect_delayed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_connect_retried(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_listening(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_bind_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_accepted(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_accept_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_closed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_close_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_disconnected(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ virtual void on_event_unknown(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
+ private:
+ void* socketPtr;
+ };
+}
+
+#endif

156
srcpkgs/libopenshot/patches/ffmpeg4.patch → srcpkgs/libopenshot/patches/ffmpeg-4.0.patch
View File

@ -1,26 +1,96 @@
source: https://pkgs.rpmfusion.org/cgit/free/libopenshot.git/plain/ffmpeg35_buildfix.patch
--- src/FFmpegWriter.cpp
+++ src/FFmpegWriter.cpp
@@ -544,8 +544,10 @@
{
if (info.has_audio && audio_codec && AV_GET_CODEC_TYPE(audio_st) == AVMEDIA_TYPE_AUDIO && AV_GET_CODEC_ATTRIBUTES(audio_st, audio_codec)->frame_size <= 1)
return;
+#ifdef AVFMT_RAWPICTURE
if (info.has_video && video_codec && AV_GET_CODEC_TYPE(video_st) == AVMEDIA_TYPE_VIDEO && (oc->oformat->flags & AVFMT_RAWPICTURE) && AV_FIND_DECODER_CODEC_ID(video_st) == AV_CODEC_ID_RAWVIDEO)
return;
+#endif
int error_code = 0;
int stop_encoding = 1;
@@ -958,7 +960,11 @@
if (strcmp(fmt->name, "gif") != 0)
// If not GIF format, skip the encoding process
// Set raw picture flag (so we don't encode this video)
+#ifdef AVFMT_RAWPICTURE
oc->oformat->flags |= AVFMT_RAWPICTURE;
+#else
+ ((void)0);
+#endif
} else {
// Set the default codec
c->pix_fmt = PIX_FMT_YUV420P;
@@ -966,7 +972,9 @@
}
AV_COPY_PARAMS_FROM_CONTEXT(st, c);
+#ifdef AVFMT_RAWPICTURE
ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::add_video_stream (" + (string)fmt->name + " : " + (string)av_get_pix_fmt_name(c->pix_fmt) + ")", "c->codec_id", c->codec_id, "c->bit_rate", c->bit_rate, "c->pix_fmt", c->pix_fmt, "oc->oformat->flags", oc->oformat->flags, "AVFMT_RAWPICTURE", AVFMT_RAWPICTURE, "", -1);
+#endif
return st;
}
@@ -1519,9 +1527,13 @@
// write video frame
bool FFmpegWriter::write_video_packet(std::shared_ptr<Frame> frame, AVFrame* frame_final)
{
+#ifdef AVFMT_RAWPICTURE
ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::write_video_packet", "frame->number", frame->number, "oc->oformat->flags & AVFMT_RAWPICTURE", oc->oformat->flags & AVFMT_RAWPICTURE, "", -1, "", -1, "", -1, "", -1);
if (oc->oformat->flags & AVFMT_RAWPICTURE) {
+#else
+ if (0) {
+#endif
// Raw video case.
AVPacket pkt;
av_init_packet(&pkt);
--- src/FFmpegReader.cpp
+++ src/FFmpegReader.cpp
@@ -978,7 +978,7 @@ void FFmpegReader::ProcessAudioPacket(int64_t requested_frame, int64_t target_fr
int data_size = 0;
// re-initialize buffer size (it gets changed in the avcodec_decode_audio2 method call)
- int buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE;
+ int buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE + AV_INPUT_BUFFER_PADDING_SIZE;
#pragma omp critical (ProcessAudioPacket)
{
#if IS_FFMPEG_3_2
@@ -1083,7 +1083,7 @@ void FFmpegReader::ProcessAudioPacket(int64_t requested_frame, int64_t target_fr
// Allocate audio buffer
- int16_t *audio_buf = new int16_t[AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+ int16_t *audio_buf = new int16_t[AVCODEC_MAX_AUDIO_FRAME_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
ZmqLogger::Instance()->AppendDebugMethod("FFmpegReader::ProcessAudioPacket (ReSample)", "packet_samples", packet_samples, "info.channels", info.channels, "info.sample_rate", info.sample_rate, "aCodecCtx->sample_fmt", AV_GET_SAMPLE_FORMAT(aStream, aCodecCtx), "AV_SAMPLE_FMT_S16", AV_SAMPLE_FMT_S16, "", -1);
--- src/FFmpegWriter.cpp
+++ src/FFmpegWriter.cpp
@@ -543,7 +543,7 @@
{
if (info.has_audio && audio_codec && audio_st->codec->codec_type == AVMEDIA_TYPE_AUDIO && audio_codec->frame_size <= 1)
return;
- if (info.has_video && video_st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (oc->oformat->flags & AVFMT_RAWPICTURE) && video_codec->codec->id == AV_CODEC_ID_RAWVIDEO)
+ if (info.has_video && video_st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (oc->oformat->flags & AVFMT_NOFILE) && video_codec->codec->id == AV_CODEC_ID_RAWVIDEO)
return;
@@ -1064,7 +1064,7 @@ void FFmpegWriter::open_audio(AVFormatContext *oc, AVStream *st)
av_dict_set(&st->metadata, iter->first.c_str(), iter->second.c_str(), 0);
}
int error_code = 0;
@@ -858,7 +858,7 @@
- ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::open_audio", "audio_codec->thread_count", audio_codec->thread_count, "audio_input_frame_size", audio_input_frame_size, "buffer_size", AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE, "", -1, "", -1, "", -1);
+ ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::open_audio", "audio_codec->thread_count", audio_codec->thread_count, "audio_input_frame_size", audio_input_frame_size, "buffer_size", AVCODEC_MAX_AUDIO_FRAME_SIZE + AV_INPUT_BUFFER_PADDING_SIZE, "", -1, "", -1, "", -1);
}
--- src/FFmpegWriter.cpp
+++ src/FFmpegWriter.cpp
@@ -883,7 +883,7 @@ AVStream* FFmpegWriter::add_audio_stream()
// some formats want stream headers to be separate
if (oc->oformat->flags & AVFMT_GLOBALHEADER)
- c->flags |= CODEC_FLAG_GLOBAL_HEADER;
+ c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
AV_COPY_PARAMS_FROM_CONTEXT(st, c);
ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::add_audio_stream", "c->codec_id", c->codec_id, "c->bit_rate", c->bit_rate, "c->channels", c->channels, "c->sample_fmt", c->sample_fmt, "c->channel_layout", c->channel_layout, "c->sample_rate", c->sample_rate);
@@ -931,7 +931,7 @@
@@ -955,7 +955,7 @@ AVStream* FFmpegWriter::add_video_stream()
c->mb_decision = 2;
// some formats want stream headers to be separate
if (oc->oformat->flags & AVFMT_GLOBALHEADER)
@ -29,65 +99,3 @@ source: https://pkgs.rpmfusion.org/cgit/free/libopenshot.git/plain/ffmpeg35_buil
// Find all supported pixel formats for this codec
const PixelFormat* supported_pixel_formats = codec->pix_fmts;
@@ -951,14 +951,14 @@
if (strcmp(fmt->name, "gif") != 0)
// If not GIF format, skip the encoding process
// Set raw picture flag (so we don't encode this video)
- oc->oformat->flags |= AVFMT_RAWPICTURE;
+ oc->oformat->flags |= AVFMT_NOFILE;
} else {
// Set the default codec
c->pix_fmt = PIX_FMT_YUV420P;
}
}
- ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::add_video_stream (" + (string)fmt->name + " : " + (string)av_get_pix_fmt_name(c->pix_fmt) + ")", "c->codec_id", c->codec_id, "c->bit_rate", c->bit_rate, "c->pix_fmt", c->pix_fmt, "oc->oformat->flags", oc->oformat->flags, "AVFMT_RAWPICTURE", AVFMT_RAWPICTURE, "", -1);
+ ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::add_video_stream (" + (string)fmt->name + " : " + (string)av_get_pix_fmt_name(c->pix_fmt) + ")", "c->codec_id", c->codec_id, "c->bit_rate", c->bit_rate, "c->pix_fmt", c->pix_fmt, "oc->oformat->flags", oc->oformat->flags, "AVFMT_NOFILE", AVFMT_NOFILE, "", -1);
return st;
}
@@ -1018,7 +1018,7 @@
audio_encoder_buffer_size = AUDIO_PACKET_ENCODING_SIZE;
audio_encoder_buffer = new uint8_t[audio_encoder_buffer_size];
- ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::open_audio", "audio_codec->thread_count", audio_codec->thread_count, "audio_input_frame_size", audio_input_frame_size, "buffer_size", AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE, "", -1, "", -1, "", -1);
+ ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::open_audio", "audio_codec->thread_count", audio_codec->thread_count, "audio_input_frame_size", audio_input_frame_size, "buffer_size", AVCODEC_MAX_AUDIO_FRAME_SIZE + AV_INPUT_BUFFER_PADDING_SIZE, "", -1, "", -1, "", -1);
}
@@ -1473,9 +1473,9 @@
// write video frame
bool FFmpegWriter::write_video_packet(std::shared_ptr<Frame> frame, AVFrame* frame_final)
{
- ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::write_video_packet", "frame->number", frame->number, "oc->oformat->flags & AVFMT_RAWPICTURE", oc->oformat->flags & AVFMT_RAWPICTURE, "", -1, "", -1, "", -1, "", -1);
-
- if (oc->oformat->flags & AVFMT_RAWPICTURE) {
+ ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::write_video_packet", "frame->number", frame->number, "oc->oformat->flags & AVFMT_NOFILE", oc->oformat->flags & AVFMT_NOFILE, "", -1, "", -1, "", -1, "", -1);
+
+ if (oc->oformat->flags & AVFMT_NOFILE) {
// Raw video case.
AVPacket pkt;
av_init_packet(&pkt);
--- src/FFmpegReader.cpp
+++ src/FFmpegReader.cpp
@@ -903,7 +903,7 @@
int data_size = 0;
// re-initialize buffer size (it gets changed in the avcodec_decode_audio2 method call)
- int buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE;
+ int buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE + AV_INPUT_BUFFER_PADDING_SIZE;
int used = avcodec_decode_audio4(aCodecCtx, audio_frame, &frame_finished, packet);
if (frame_finished) {
@@ -976,7 +976,7 @@
// Allocate audio buffer
- int16_t *audio_buf = new int16_t[AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+ int16_t *audio_buf = new int16_t[AVCODEC_MAX_AUDIO_FRAME_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
ZmqLogger::Instance()->AppendDebugMethod("FFmpegReader::ProcessAudioPacket (ReSample)", "packet_samples", packet_samples, "info.channels", info.channels, "info.sample_rate", info.sample_rate, "aCodecCtx->sample_fmt", aCodecCtx->sample_fmt, "AV_SAMPLE_FMT_S16", AV_SAMPLE_FMT_S16, "", -1);

2
srcpkgs/libopenshot/template
View File

@ -9,7 +9,7 @@ configure_args="-DENABLE_RUBY=OFF" # Builds fail with Ruby-2.4.1
hostmakedepends="swig doxygen ruby python3"
makedepends="python3-devel ffmpeg-devel libmagick-devel qt5-devel libgomp-devel
libopenshot-audio-devel qt5-multimedia-devel x264-devel x265-devel unittest-cpp
zeromq-devel"
zeromq-devel cppzmq"
depends="python3"
short_desc="Library files for the OpenShot video editor"
maintainer="Spencer Hill <spencernh77@gmail.com>"