.gitlab-ci.yml

 variables:
   VLC30_IMAGE: registry.videolan.org/medialibrary:20201009131431
-  VLC40_IMAGE: registry.videolan.org/libvlcpp-unstable:20220502070249
+  VLC40_IMAGE: registry.videolan.org/libvlcpp-unstable:20220620081936
 
 .common_build:
   rules:

examples/helloworld/main.cpp

@@ -10,8 +10,13 @@ int main(int ac, char** av)
         return 1;
     }
     auto instance = VLC::Instance(0, nullptr);
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    auto media = VLC::Media(av[1], VLC::Media::FromPath);
+    auto mp = VLC::MediaPlayer(instance, media);
+#else
     auto media = VLC::Media(instance, av[1], VLC::Media::FromPath);
     auto mp = VLC::MediaPlayer(media);
+#endif
     mp.play();
     std::this_thread::sleep_for( std::chrono::seconds( 10 ) );
 #if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)

examples/imem/imem.cpp

@@ -21,7 +21,11 @@ int main(int ac, char**av)
     auto instance = VLC::Instance(0, nullptr);
     auto dummyOpaque = new ImemOpaque{};
     dummyOpaque->path = av[1];
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    auto imemMedia = VLC::Media(
+#else
     auto imemMedia = VLC::Media( instance,
+#endif
         // Open
         [dummyOpaque]( void*, void** opaque, uint64_t* p_size ) -> int {
             dummyOpaque->file = fopen( dummyOpaque->path.c_str(), "rb" );
@@ -55,7 +59,11 @@ int main(int ac, char**av)
 
     // Do not use a user defined opaque
     // This is mostly meant to test that our nullptr overload are functionnal
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    auto imemMedia2 = VLC::Media(
+#else
     auto imemMedia2 = VLC::Media( instance,
+#endif
         nullptr,
         [opaque2]( void* opaque, unsigned char* buf, size_t size ) -> ssize_t {
             assert( opaque == nullptr );
@@ -70,11 +78,19 @@ int main(int ac, char**av)
             return 0;
         }, nullptr );
 
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    auto mp = VLC::MediaPlayer( instance, imemMedia );
+    mp.play();
+
+    auto mp2 = VLC::MediaPlayer( instance, imemMedia2 );
+    mp2.play();
+#else
     auto mp = VLC::MediaPlayer( imemMedia );
     mp.play();
 
     auto mp2 = VLC::MediaPlayer( imemMedia2 );
     mp2.play();
+#endif
 
     std::this_thread::sleep_for( std::chrono::seconds( 10 ) );
 

test/main.cpp

@@ -53,8 +53,13 @@ int main(int ac, char** av)
         std::cout << "Hooked VLC log: " << lvl << ' ' << message << std::endl;
     });
 
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    auto media = VLC::Media(av[1], VLC::Media::FromPath);
+    auto mp = VLC::MediaPlayer(instance, media);
+#else
     auto media = VLC::Media(instance, av[1], VLC::Media::FromPath);
     auto mp = VLC::MediaPlayer(media);
+#endif
     auto eventManager = mp.eventManager();
     eventManager.onPlaying([&media]() {
         std::cout << media.mrl() << " is playing" << std::endl;

vlcpp/Media.hpp

@@ -136,6 +136,61 @@ public:
     };
 #endif
 
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    /**
+     * @brief Media Constructs a libvlc Media instance
+     * @param instance  A libvlc instance
+     * @param mrl       A path, location, or node name, depending on the 3rd parameter
+     * @param type      The type of the 2nd argument. \sa{FromType}
+     */
+    Media(const std::string& mrl, FromType type)
+        : Internal{ libvlc_media_release }
+    {
+        InternalPtr ptr = nullptr;
+        switch (type)
+        {
+        case FromLocation:
+            ptr = libvlc_media_new_location( mrl.c_str() );
+            break;
+        case FromPath:
+            ptr = libvlc_media_new_path( mrl.c_str() );
+            break;
+        case AsNode:
+            ptr = libvlc_media_new_as_node( mrl.c_str() );
+            break;
+        default:
+            break;
+        }
+        if ( ptr == nullptr )
+            throw std::runtime_error("Failed to construct a media");
+        m_obj.reset( ptr, libvlc_media_release );
+    }
+
+    /**
+     * Create a media for an already open file descriptor.
+     * The file descriptor shall be open for reading (or reading and writing).
+     *
+     * Regular file descriptors, pipe read descriptors and character device
+     * descriptors (including TTYs) are supported on all platforms.
+     * Block device descriptors are supported where available.
+     * Directory descriptors are supported on systems that provide fdopendir().
+     * Sockets are supported on all platforms where they are file descriptors,
+     * i.e. all except Windows.
+     *
+     * \note This library will <b>not</b> automatically close the file descriptor
+     * under any circumstance. Nevertheless, a file descriptor can usually only be
+     * rendered once in a media player. To render it a second time, the file
+     * descriptor should probably be rewound to the beginning with lseek().
+     *
+     * \param fd open file descriptor
+     * \return the newly created media
+     */
+    Media( int fd)
+        : Internal { libvlc_media_new_fd( fd ),
+                     libvlc_media_release }
+    {
+    }
+#else
     /**
      * @brief Media Constructs a libvlc Media instance
      * @param instance  A libvlc instance
@@ -190,6 +245,7 @@ public:
                      libvlc_media_release }
     {
     }
+#endif
 
     /**
      * Get media instance from this media list instance. This action will increase
@@ -291,7 +347,35 @@ public:
      *
      * \version LibVLC 3.0.0 and later.
      */
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    template <typename OpenCb, typename ReadCb, typename SeekCb, typename CloseCb>
+    Media( OpenCb&& openCb, ReadCb&& readCb, SeekCb&& seekCb, CloseCb&& closeCb )
+    {
+        static_assert( signature_match_or_nullptr<OpenCb, ExpectedMediaOpenCb>::value, "Mismatched Open callback prototype" );
+        static_assert( signature_match_or_nullptr<SeekCb, ExpectedMediaSeekCb>::value, "Mismatched Seek callback prototype" );
+        static_assert( signature_match_or_nullptr<CloseCb, ExpectedMediaCloseCb>::value, "Mismatched Close callback prototype" );
+        static_assert( signature_match<ReadCb, ExpectedMediaReadCb>::value, "Mismatched Read callback prototype" );
 
+        auto ptr = libvlc_media_new_callbacks(
+            imem::CallbackWrapper<(unsigned int)CallbackIdx::Open, libvlc_media_open_cb>::
+                wrap<imem::GuessBoxingStrategy<OpenCb, imem::BoxingStrategy::Setup>::Strategy>(
+                    *m_callbacks, std::forward<OpenCb>( openCb ) ),
+            imem::CallbackWrapper<(unsigned int)CallbackIdx::Read, libvlc_media_read_cb>::
+                wrap<imem::GuessBoxingStrategy<OpenCb, imem::BoxingStrategy::Unbox>::Strategy>(
+                    *m_callbacks, std::forward<ReadCb>( readCb ) ),
+            imem::CallbackWrapper<(unsigned int)CallbackIdx::Seek, libvlc_media_seek_cb>::
+                wrap<imem::GuessBoxingStrategy<OpenCb, imem::BoxingStrategy::Unbox>::Strategy>(
+                    *m_callbacks, std::forward<SeekCb>( seekCb ) ),
+            imem::CallbackWrapper<(unsigned int)CallbackIdx::Close, libvlc_media_close_cb>::
+                wrap<imem::GuessBoxingStrategy<OpenCb, imem::BoxingStrategy::Cleanup>::Strategy>(
+                    *m_callbacks, std::forward<CloseCb>( closeCb ) ),
+            m_callbacks.get()
+        );
+        if ( ptr == nullptr )
+            throw std::runtime_error( "Failed to create media" );
+        m_obj.reset( ptr, libvlc_media_release );
+    }
+#else
     template <typename OpenCb, typename ReadCb, typename SeekCb, typename CloseCb>
     Media( const Instance& instance, OpenCb&& openCb, ReadCb&& readCb, SeekCb&& seekCb, CloseCb&& closeCb )
     {
@@ -319,7 +403,7 @@ public:
             throw std::runtime_error( "Failed to create media" );
         m_obj.reset( ptr, libvlc_media_release );
     }
-
+#endif
 #endif
 
     explicit Media( Internal::InternalPtr ptr, bool incrementRefCount)
@@ -459,7 +543,17 @@ public:
         libvlc_media_set_meta(*this, e_meta, psz_value.c_str());
     }
 
-
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    /**
+     * Save the meta previously set
+     *
+     * \return true if the write operation was successful
+     */
+    bool saveMeta(const Instance& instance)
+    {
+        return libvlc_media_save_meta(getInternalPtr<libvlc_instance_t>(instance), *this) != 0;
+    }
+#else
     /**
      * Save the meta previously set
      *
@@ -469,6 +563,7 @@ public:
     {
         return libvlc_media_save_meta(*this) != 0;
     }
+#endif
 
 #if LIBVLC_VERSION_INT < LIBVLC_VERSION(4, 0, 0, 0)
     /**
@@ -578,7 +673,7 @@ public:
     {
         return libvlc_media_is_parsed(*this) != 0;
     }
-#else
+#elif LIBVLC_VERSION_INT < LIBVLC_VERSION(4, 0, 0, 0)
     /**
      * Parse the media asynchronously with options.
      *
@@ -620,6 +715,51 @@ public:
     {
         libvlc_media_parse_stop( *this );
     }
+#else
+    /**
+     * Parse the media asynchronously with options.
+     *
+     * This fetches (local or network) art, meta data and/or tracks information.
+     * This method is the extended version of libvlc_media_parse_async().
+     *
+     * To track when this is over you can listen to libvlc_MediaParsedStatus
+     * event. However if this functions returns an error, you will not receive any
+     * events.
+     *
+     * It uses a flag to specify parse options (see libvlc_media_parse_flag_t). All
+     * these flags can be combined. By default, media is parsed if it's a local
+     * file.
+     *
+     * \see ParsedStatus
+     * \see meta()
+     * \see tracks()
+     * \see parsedStatus
+     * \see ParseFlag
+     *
+     * \return true on success, false otherwise
+     * \param flags parse options
+     * \param timeout maximum time allowed to preparse the media. If -1, the
+     *      default "preparse-timeout" option will be used as a timeout. If 0, it will
+     *      wait indefinitely. If > 0, the timeout will be used (in milliseconds).
+     * \version LibVLC 3.0.0 or later
+     */
+    bool parseRequest( const Instance& instance, ParseFlags flags, int timeout )
+    {
+        return libvlc_media_parse_request( getInternalPtr<libvlc_instance_t>( instance ),
+            *this, static_cast<libvlc_media_parse_flag_t>( flags ), timeout ) == 0;
+    }
+
+    ParsedStatus parsedStatus( const Instance& instance )
+    {
+        return static_cast<ParsedStatus>( getInternalPtr<libvlc_instance_t>( instance ),
+                                        libvlc_media_get_parsed_status( *this ) );
+    }
+
+    void parseStop( const Instance& instance )
+    {
+        libvlc_media_parse_stop( getInternalPtr<libvlc_instance_t>( instance ),
+                                 *this );
+    }
 #endif
 
     /**
@@ -772,20 +912,22 @@ public:
         Fast = libvlc_media_thumbnail_seek_fast,
     };
 
-    ThumbnailRequest* thumbnailRequestByTime( libvlc_time_t time, ThumbnailSeekSpeed speed,
+    ThumbnailRequest* thumbnailRequestByTime( const Instance& inst, libvlc_time_t time, ThumbnailSeekSpeed speed,
                                               uint32_t width, uint32_t height, bool crop,
                                               Picture::Type type, libvlc_time_t timeout )
     {
-        return libvlc_media_thumbnail_request_by_time( *this, time,
+        return libvlc_media_thumbnail_request_by_time(
+                    getInternalPtr<libvlc_instance_t>( inst ), *this, time,
                     static_cast<libvlc_thumbnailer_seek_speed_t>( speed ), width,
                     height, crop, static_cast<libvlc_picture_type_t>( type ), timeout );
     }
 
-    ThumbnailRequest* thumbnailRequestByPos( float pos, ThumbnailSeekSpeed speed,
+    ThumbnailRequest* thumbnailRequestByPos( const Instance& inst, float pos, ThumbnailSeekSpeed speed,
                                              uint32_t width, uint32_t height, bool crop,
                                              Picture::Type type, libvlc_time_t timeout )
     {
-        return libvlc_media_thumbnail_request_by_pos( *this, pos,
+        return libvlc_media_thumbnail_request_by_pos(
+                    getInternalPtr<libvlc_instance_t>( inst ), *this, pos,
                     static_cast<libvlc_thumbnailer_seek_speed_t>( speed ), width,
                     height, crop, static_cast<libvlc_picture_type_t>( type ), timeout );
     }

vlcpp/MediaPlayer.hpp

@@ -92,10 +92,25 @@ public:
      * Player should be created.
      */
     MediaPlayer( const Instance& instance )
-        : Internal{ libvlc_media_player_new( instance ), libvlc_media_player_release }
+        : Internal{ libvlc_media_player_new( getInternalPtr<libvlc_instance_t>( instance ) ),
+                    libvlc_media_player_release }
     {
     }
 
+#if LIBVLC_VERSION_INT >= LIBVLC_VERSION(4, 0, 0, 0)
+    /**
+     * Create a Media Player object from a Media
+     *
+     * \param p_md  the media. Afterwards the p_md can be safely destroyed.
+     */
+    MediaPlayer( Instance& inst, Media& md )
+        : Internal{ libvlc_media_player_new_from_media(
+                        getInternalPtr<libvlc_instance_t>( inst ),
+                        getInternalPtr<libvlc_media_t>( md ) ),
+                    libvlc_media_player_release }
+    {
+    }
+#else
     /**
      * Create a Media Player object from a Media
      *
@@ -107,7 +122,7 @@ public:
                     libvlc_media_player_release }
     {
     }
-
+#endif
     /**
      * Create an empty VLC MediaPlayer instance.
      *