video.h

#ifndef OE_EXT_VIDEO_H
#define OE_EXT_VIDEO_H
 
#include <mutex>
#include <vector>
#include <vlc/vlc.h>
 
namespace oe::ext::video
{
    struct VideoPlayer
    {
        VideoPlayer(const int32_t argc = 0, const char *const* argv = nullptr)
        {
            vlc = libvlc_new(argc, argv);
        }
 
        ~VideoPlayer()
        {
            stop();
 
            if (vlc)
            {
                libvlc_release(vlc);
            }
        }
 
        bool loadMediaFromFile(const char* path)
        {
            media = libvlc_media_new_path(vlc, path);
 
            if (media == NULL)
            {
                fprintf(stderr, "unable to create media %s", path);
                return false;
            }
 
            return loadMedia(media);
        }
 
        bool loadMediaFromUrl(const char* url)
        {
            media = libvlc_media_new_location(vlc, url);
 
            if (media == NULL)
            {
                fprintf(stderr, "unable to create media %s", url);
                return false;
            }
 
            return loadMedia(media);
        }
 
        bool loadMedia(libvlc_media_t* media)
        {
            media_player = libvlc_media_player_new_from_media(media);
 
            if (media_player == NULL)
            {
                fprintf(stderr, "unable to create media player");
                libvlc_media_release(media);
                return false;
            }
 
            buffer.resize(width*height*3);
            libvlc_video_set_callbacks(media_player, lock_callback, unlock_callback, nullptr, this);
            libvlc_video_set_format(media_player, "RV24", width, height, width*3);
 
            libvlc_media_player_pause(media_player);
 
            return true;
        }
 
        void play()
        {
            libvlc_media_player_play(media_player);
        }
 
        void pause()
        {
            libvlc_media_player_pause(media_player);
        }
 
        bool isPlaying()
        {
            return libvlc_media_player_is_playing(media_player);
        }
 
        void seekPercentagePosition(const float position)
        {
            libvlc_media_player_set_position(media_player, position);
        }
 
        float getPercentagePosition()
        {
            return libvlc_media_player_get_position(media_player);
        }
 
        void stop()
        {
            if (media_player)
            {
                libvlc_media_player_stop(media_player);
                libvlc_media_player_release(media_player);
                media_player = nullptr;
            }
 
            if (media)
            {
                libvlc_media_release(media);
                media = nullptr;
            }
        }
 
        static void* lock_callback(void *object, void **planes)
        {
            VideoPlayer* video_player = static_cast<VideoPlayer*>(object);
 
            video_player->mutex.lock();
            planes[0] = static_cast<void*>(video_player->buffer.data());
 
            return nullptr;
        }
 
        static void unlock_callback(void *object, void* /*picture*/, void * const * /*planes*/)
        {
            VideoPlayer* video_player = static_cast<VideoPlayer*>(object);
            video_player->need_frame_update = true;
 
            video_player->mutex.unlock();
        }
 
        bool need_frame_update = false;
        std::mutex mutex;
 
        uint32_t width = 800, height = 600;
 
        std::vector<std::byte> buffer;
 
        libvlc_instance_t* vlc = nullptr;
 
        libvlc_media_player_t* media_player = nullptr;
 
        libvlc_media_t* media = nullptr;
    };
}
#endif