@woodpecker How is the timing/lag/performance?

My principal issue was huge lag, which I also experienced when just using ffmpeg at the command line. (Since Qt uses ffmpeg under the hood I suspect the actual source of lag is therefore ffmpeg.)

I had come across:

https://forum.qt.io/topic/79208/how-to-kill-delay-in-live-streaming (which never got any reply at all)

https://stackoverflow.com/questions/7759695/terrible-performance-with-qmediaplayer-and-qvideowidget

But your (very) recent outcome will be of interest to myself and others! How's the lag?

(Also, you mentioned 6.10.1 but can you also state which OS or OSes?) EDIT: Android is in the title! But still I'm curious if you build for Linux/Windows also?

                    VLCPlayer {
                        id: vlcplayer
                        videoSink: videoOutput.videoSink
                    }

                    VideoOutput {
                        id: videoOutput
                        anchors.fill: parent
                        fillMode: VideoOutput.PreserveAspectFit
                    }
                    
                    Component.onCompleted: vlcplayer.setSource("https://cdn.some_domen/.../stream.m3u8?uuid=some_uuid&token=some_token")

#ifndef VLCPLAYER_H
#define VLCPLAYER_H

#include <vlc/vlc.h>
#include "vlc/libvlc_media.h"
#include "vlc/libvlc_media_player.h"
#include <QtQml/qqmlregistration.h> //for QML_ELEMENT
#include <QMutex>
#include <vector>
#include <QPointer>
#include <QVideoSink>

// using namespace QNativeInterface;

// extern "C" {
// // We declare the function we found using nm
// void libvlc_media_player_set_android_context(libvlc_media_player_t *p_mi, void *p_jvm_or_surface);
// }

class VLCPlayer : public QObject {
    Q_OBJECT
    QML_ELEMENT // This makes the class available for use/instantiation on the QML side.
    Q_PROPERTY(QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged)
public:
    VLCPlayer();

    Q_INVOKABLE void setSource(const QString &path);

   // 1. LOCK: VLC asks where to write the pixels of the next frame
   static void* lock(void *opaque, void **planes);

   // 2. UNLOCK: The frame has been written to the buffer
   static void unlock(void *opaque, void *picture, void *const *planes);

   // 3. DISPLAY: It's time to tell Qt that the image has been updated
   static void display(void *opaque, void *picture);

   QVideoSink *videoSink() const;
   void setVideoSink(QVideoSink *newVideoSink);

    // Video settings (can be changed)
    const int VIDEO_WIDTH = 1280;
    const int VIDEO_HEIGHT = 720;

    std::vector<uchar> videoBuffer;
    QMutex bufferMutex;
    libvlc_media_player_t *mp = nullptr;
signals:
    void videoSinkChanged();
    void frameReady();

public slots:
    void onframeReady();

private:
    libvlc_instance_t *_vlcInstance;
    libvlc_media_player_t *_vlcPlayer;
    QPointer<QVideoSink> m_videoSink;
};

#include <QGuiApplication>
#include <QQmlApplicationEngine>

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);

    // 1. Load dependencies in the correct order via the Java layer
    // This will automatically call JNI_OnLoad and install s_jvm in VLC
    QJniObject::callStaticMethod<void>(
        "java/lang/System",
        "loadLibrary",
        "(Ljava/lang/String;)V",
        QJniObject::fromString("vlc").object() // core first
        );

    QQmlApplicationEngine engine;
    QObject::connect(
        &engine,
        &QQmlApplicationEngine::objectCreationFailed,
        &app,
        []() { QCoreApplication::exit(-1); },
        Qt::QueuedConnection);
    engine.loadFromModule("myproject", "Main");

    return app.exec();
}

.

#include <vlc/vlc.h>
#include "vlc/libvlc_media.h"
#include "vlc/libvlc_media_player.h"
#include <QQuickItem>

class VLCPlayer : public QQuickItem {
    Q_OBJECT
    QML_ELEMENT // This makes the class available for use/instantiation on the QML side.
    Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged)

public:
    VLCPlayer() {
        qDebug() << "libvlc_new(0, nullptr)...";

        _vlcInstance = libvlc_new(0, nullptr);

        qDebug() << "libvlc_media_player_new...";

        _vlcPlayer = libvlc_media_player_new(_vlcInstance);
    }

    void setSource(const QString &path) {
        libvlc_media_t *m = libvlc_media_new_path(_vlcInstance, path.toUtf8().data());
        libvlc_media_player_set_media(_vlcPlayer, m);
        libvlc_media_release(m);
        libvlc_media_player_play(_vlcPlayer);
        emit sourceChanged();
    }

    QString source() const
    {
        return "";
    }

signals:
    void sourceChanged();

private:
    libvlc_instance_t *_vlcInstance;
    libvlc_media_player_t *_vlcPlayer;
};

and QML:

                    VLCPlayer {
                        id: player
                        anchors.fill: parent
                        source: "https://cdn.some_domen/.../stream.m3u8?uuid=some_uuid&token=some_token"
                    }

,
but in the constructor, on the line
_vlcInstance = libvlc_new(0, nullptr);
the program crashes with the error:
Fatal signal 6 (SIGABRT), code -6 (SI_TKILL) in tid 10680 (qtMainLoopThrea)... .