Remove explicit sharing from HWAccel object

HWAccel is not shared or is a part of a shared object. Thus it does not
need to be explicitly shareable.

Change-Id: I18cc9c63b3cf7a17b2aa17b56703a5e9d881ffd4
Reviewed-by: Lars Knoll <lars@knoll.priv.no>
(cherry picked from commit 73c8c2cbcf3fd6d315fba1f8cf96ee87d9fae2d5)

10 files changed, 102 insertions, 105 deletions

diff --git a/src/multimedia/platform/qplatformcamera_p.h b/src/multimedia/platform/qplatformcamera_p.h
index 155590f12..62f2836b8 100644
--- a/src/multimedia/platform/qplatformcamera_p.h
+++ b/src/multimedia/platform/qplatformcamera_p.h
@@ -116,7 +116,7 @@ public:
     static int colorTemperatureForWhiteBalance(QCamera::WhiteBalanceMode mode);
 
     // Can't use FFmpeg specific struct here, use void * for now.
-    virtual const void *ffmpegHWAccel() const { return nullptr; }
+    virtual std::optional<int> ffmpegHWPixelFormat() const { return {}; }
 
 Q_SIGNALS:
     void activeChanged(bool);
diff --git a/src/plugins/multimedia/ffmpeg/qavfcamera.mm b/src/plugins/multimedia/ffmpeg/qavfcamera.mm
index fbe29296e..37dd4b262 100644
--- a/src/plugins/multimedia/ffmpeg/qavfcamera.mm
+++ b/src/plugins/multimedia/ffmpeg/qavfcamera.mm
@@ -60,7 +60,7 @@ static AVAuthorizationStatus m_cameraAuthorizationStatus = AVAuthorizationStatus
          didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
          fromConnection:(AVCaptureConnection *)connection;
 
-- (void) setHWAccel:(QFFmpeg::HWAccel *)accel;
+- (void) setHWAccel:(std::unique_ptr<QFFmpeg::HWAccel> &&)accel;
 
 @end
 
@@ -69,7 +69,7 @@ static AVAuthorizationStatus m_cameraAuthorizationStatus = AVAuthorizationStatus
 @private
     QAVFCamera *m_camera;
     AVBufferRef *hwFramesContext;
-    QFFmpeg::HWAccel m_accel;
+    std::unique_ptr<QFFmpeg::HWAccel> m_accel;
     qint64 startTime;
     qint64 baseTime;
 }
@@ -107,7 +107,10 @@ static AVAuthorizationStatus m_cameraAuthorizationStatus = AVAuthorizationStatus
         return;
     }
 
-    AVFrame *avFrame = allocHWFrame(m_accel.hwFramesContextAsBuffer(), imageBuffer);
+    if (!m_accel)
+        return;
+
+    AVFrame *avFrame = allocHWFrame(m_accel->hwFramesContextAsBuffer(), imageBuffer);
     if (!avFrame)
         return;
 
@@ -141,9 +144,9 @@ static AVAuthorizationStatus m_cameraAuthorizationStatus = AVAuthorizationStatus
     m_camera->syncHandleFrame(frame);
 }
 
-- (void) setHWAccel:(QFFmpeg::HWAccel *)accel
+- (void) setHWAccel:(std::unique_ptr<QFFmpeg::HWAccel> &&)accel
 {
-    m_accel = *accel;
+    m_accel = std::move(accel);
 }
 
 @end
@@ -367,9 +370,15 @@ void QAVFCamera::updateCameraFormat()
         avPixelFormat = setPixelFormat(m_cameraFormat.pixelFormat());
     }
 
-    hwAccel = QFFmpeg::HWAccel(AV_HWDEVICE_TYPE_VIDEOTOOLBOX);
-    hwAccel.createFramesContext(av_map_videotoolbox_format_to_pixfmt(avPixelFormat), m_cameraFormat.resolution());
-    [m_sampleBufferDelegate setHWAccel:&hwAccel];
+    auto hwAccel = QFFmpeg::HWAccel::create(AV_HWDEVICE_TYPE_VIDEOTOOLBOX);
+    if (hwAccel) {
+        hwAccel->createFramesContext(av_map_videotoolbox_format_to_pixfmt(avPixelFormat),
+                                     m_cameraFormat.resolution());
+        hwPixelFormat = hwAccel->hwFormat();
+    } else {
+        hwPixelFormat = AV_PIX_FMT_NONE;
+    }
+    [m_sampleBufferDelegate setHWAccel:std::move(hwAccel)];
 }
 
 uint QAVFCamera::setPixelFormat(const QVideoFrameFormat::PixelFormat pixelFormat)
diff --git a/src/plugins/multimedia/ffmpeg/qavfcamera_p.h b/src/plugins/multimedia/ffmpeg/qavfcamera_p.h
index 281ebf672..40a53dc7c 100644
--- a/src/plugins/multimedia/ffmpeg/qavfcamera_p.h
+++ b/src/plugins/multimedia/ffmpeg/qavfcamera_p.h
@@ -58,7 +58,7 @@ public:
 
     void deviceOrientationChanged(int angle = -1);
 
-    const void *ffmpegHWAccel() const override { return &hwAccel; }
+    std::optional<int> ffmpegHWPixelFormat() const override { return hwPixelFormat; }
 
 private:
     void requestCameraPermissionIfNeeded();
@@ -77,7 +77,7 @@ private:
     QAVFSampleBufferDelegate *m_sampleBufferDelegate = nullptr;
     dispatch_queue_t m_delegateQueue;
     QVideoOutputOrientationHandler m_orientationHandler;
-    QFFmpeg::HWAccel hwAccel;
+    AVPixelFormat hwPixelFormat = AV_PIX_FMT_NONE;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegdecoder.cpp b/src/plugins/multimedia/ffmpeg/qffmpegdecoder.cpp
index 57aa6f20b..42cd0ada3 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegdecoder.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpegdecoder.cpp
@@ -33,10 +33,10 @@ Q_LOGGING_CATEGORY(qLcDecoder, "qt.multimedia.ffmpeg.decoder")
 Q_LOGGING_CATEGORY(qLcVideoRenderer, "qt.multimedia.ffmpeg.videoRenderer")
 Q_LOGGING_CATEGORY(qLcAudioRenderer, "qt.multimedia.ffmpeg.audioRenderer")
 
-Codec::Data::Data(UniqueAVCodecContext &&context, AVStream *stream, const HWAccel &hwAccel)
+Codec::Data::Data(UniqueAVCodecContext &&context, AVStream *stream, std::unique_ptr<QFFmpeg::HWAccel> &&hwAccel)
     : context(std::move(context))
     , stream(stream)
-    , hwAccel(hwAccel)
+    , hwAccel(std::move(hwAccel))
 {
 }
 
@@ -55,10 +55,6 @@ QMaybe<Codec> Codec::create(AVStream *stream)
     if (!decoder)
         return { "Failed to find a valid FFmpeg decoder" };
 
-    QFFmpeg::HWAccel hwAccel;
-    if (decoder->type == AVMEDIA_TYPE_VIDEO)
-        hwAccel = QFFmpeg::HWAccel(decoder);
-
     //avcodec_free_context
     UniqueAVCodecContext context(avcodec_alloc_context3(decoder));
     if (!context)
@@ -74,9 +70,12 @@ QMaybe<Codec> Codec::create(AVStream *stream)
     if (ret < 0)
         return { "Failed to set FFmpeg codec parameters" };
 
-    auto *buf = hwAccel.hwDeviceContextAsBuffer();
-    if (buf)
-        context->hw_device_ctx = av_buffer_ref(buf);
+    std::unique_ptr<QFFmpeg::HWAccel> hwAccel;
+    if (decoder->type == AVMEDIA_TYPE_VIDEO) {
+        hwAccel = QFFmpeg::HWAccel::create(decoder);
+        if (hwAccel)
+            context->hw_device_ctx = av_buffer_ref(hwAccel->hwDeviceContextAsBuffer());
+    }
     // ### This still gives errors about wrong HW formats (as we accept all of them)
     // But it would be good to get so we can filter out pixel format we don't support natively
     context->get_format = QFFmpeg::getFormat;
@@ -89,7 +88,7 @@ QMaybe<Codec> Codec::create(AVStream *stream)
     if (ret < 0)
         return "Failed to open FFmpeg codec context " + err2str(ret);
 
-    return Codec(new Data(std::move(context), stream, hwAccel));
+    return Codec(new Data(std::move(context), stream, std::move(hwAccel)));
 }
 
 
@@ -662,14 +661,14 @@ void VideoRenderer::loop()
 //        qDebug() << "RHI:" << accel.isNull() << accel.rhi() << sink->rhi();
 
         // in practice this only happens with mediacodec
-        if (!frame.codec()->hwAccel().isNull() && !frame.avFrame()->hw_frames_ctx) {
-            HWAccel hwaccel = frame.codec()->hwAccel();
+        if (frame.codec()->hwAccel() && !frame.avFrame()->hw_frames_ctx) {
+            HWAccel *hwaccel = frame.codec()->hwAccel();
             AVFrame *avframe = frame.avFrame();
-            if (!hwaccel.hwFramesContext())
-                hwaccel.createFramesContext(AVPixelFormat(avframe->format),
+            if (!hwaccel->hwFramesContext())
+                hwaccel->createFramesContext(AVPixelFormat(avframe->format),
                                             { avframe->width, avframe->height });
 
-            avframe->hw_frames_ctx = av_buffer_ref(hwaccel.hwFramesContextAsBuffer());
+            avframe->hw_frames_ctx = av_buffer_ref(hwaccel->hwFramesContextAsBuffer());
         }
 
         QFFmpegVideoBuffer *buffer = new QFFmpegVideoBuffer(frame.takeAVFrame());
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegdecoder_p.h b/src/plugins/multimedia/ffmpeg/qffmpegdecoder_p.h
index 27bcf8c28..235080418 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegdecoder_p.h
+++ b/src/plugins/multimedia/ffmpeg/qffmpegdecoder_p.h
@@ -71,12 +71,12 @@ struct Codec
     struct AVCodecFreeContext { void operator()(AVCodecContext *ctx) { avcodec_free_context(&ctx); } };
     using UniqueAVCodecContext = std::unique_ptr<AVCodecContext, AVCodecFreeContext>;
     struct Data {
-        Data(UniqueAVCodecContext &&context, AVStream *stream, const QFFmpeg::HWAccel &hwAccel);
+        Data(UniqueAVCodecContext &&context, AVStream *stream, std::unique_ptr<QFFmpeg::HWAccel> &&hwAccel);
         ~Data();
         QAtomicInt ref;
         UniqueAVCodecContext context;
         AVStream *stream = nullptr;
-        QFFmpeg::HWAccel hwAccel;
+        std::unique_ptr<QFFmpeg::HWAccel> hwAccel;
     };
 
     static QMaybe<Codec> create(AVStream *);
@@ -84,7 +84,7 @@ struct Codec
     AVCodecContext *context() const { return d->context.get(); }
     AVStream *stream() const { return d->stream; }
     uint streamIndex() const { return d->stream->index; }
-    HWAccel hwAccel() const { return d->hwAccel; }
+    HWAccel *hwAccel() const { return d->hwAccel.get(); }
     qint64 toMs(qint64 ts) const { return timeStamp(ts, d->stream->time_base); }
     qint64 toUs(qint64 ts) const { return timeStampUs(ts, d->stream->time_base); }
 
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegencoder.cpp b/src/plugins/multimedia/ffmpeg/qffmpegencoder.cpp
index 186e254fd..86e33c83c 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegencoder.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpegencoder.cpp
@@ -403,10 +403,14 @@ VideoEncoder::VideoEncoder(Encoder *encoder, QPlatformCamera *camera, const QMed
     qCDebug(qLcFFmpegEncoder) << "VideoEncoder" << settings.videoCodec();
 
     auto format = m_camera->cameraFormat();
-    auto *hwAccel = static_cast<const QFFmpeg::HWAccel *>(camera->ffmpegHWAccel());
+    std::optional<AVPixelFormat> hwFormat = camera->ffmpegHWPixelFormat()
+            ? AVPixelFormat(*camera->ffmpegHWPixelFormat())
+            : std::optional<AVPixelFormat>{};
+
     AVPixelFormat swFormat = QFFmpegVideoBuffer::toAVPixelFormat(format.pixelFormat());
-    AVPixelFormat pixelFormat = hwAccel ? hwAccel->hwFormat() : swFormat;
+    AVPixelFormat pixelFormat = hwFormat ? *hwFormat : swFormat;
     frameEncoder = new VideoFrameEncoder(settings, format.resolution(), format.maxFrameRate(), pixelFormat, swFormat);
+
     frameEncoder->initWithFormatContext(encoder->formatContext);
 }
 
diff --git a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel.cpp b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel.cpp
index 1fb469551..84d84ff12 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel.cpp
@@ -139,39 +139,31 @@ TextureConverter::Data::~Data()
     delete backend;
 }
 
-
-
-HWAccel::Data::~Data()
+HWAccel::~HWAccel()
 {
-    if (hwDeviceContext)
-        av_buffer_unref(&hwDeviceContext);
-    if (hwFramesContext)
-        av_buffer_unref(&hwFramesContext);
+    if (m_hwDeviceContext)
+        av_buffer_unref(&m_hwDeviceContext);
+    if (m_hwFramesContext)
+        av_buffer_unref(&m_hwFramesContext);
 }
 
-
-HWAccel::HWAccel(const AVCodec *codec)
+std::unique_ptr<HWAccel> HWAccel::create(const AVCodec *codec)
 {
-    if (codec->type != AVMEDIA_TYPE_VIDEO)
-        return;
-    auto *ctx = hardwareContextForCodec(codec);
-    if (!ctx)
-        return;
-    d = new Data;
-    d->hwDeviceContext = ctx;
+    if (codec->type == AVMEDIA_TYPE_VIDEO) {
+        if (auto *ctx = hardwareContextForCodec(codec))
+            return std::unique_ptr<HWAccel>(new HWAccel(ctx));
+    }
+    return {};
 }
 
-HWAccel::HWAccel(AVHWDeviceType deviceType)
+std::unique_ptr<HWAccel> HWAccel::create(AVHWDeviceType deviceType)
 {
-    auto *ctx = loadHWContext(deviceType);
-    if (!ctx)
-        return;
-    d = new Data;
-    d->hwDeviceContext = ctx;
+    if (auto *ctx = loadHWContext(deviceType))
+        return std::unique_ptr<HWAccel>(new HWAccel(ctx));
+    else
+        return {};
 }
 
-HWAccel::~HWAccel() = default;
-
 AVPixelFormat HWAccel::format(AVFrame *frame)
 {
     if (!frame->hw_frames_ctx)
@@ -189,9 +181,7 @@ const AVHWDeviceType *HWAccel::preferredDeviceTypes()
 
 AVHWDeviceContext *HWAccel::hwDeviceContext() const
 {
-    if (!d || !d->hwDeviceContext)
-        return nullptr;
-    return (AVHWDeviceContext *)d->hwDeviceContext->data;
+    return m_hwDeviceContext ? (AVHWDeviceContext *)m_hwDeviceContext->data : nullptr;
 }
 
 AVPixelFormat HWAccel::hwFormat() const
@@ -297,12 +287,12 @@ const AVCodec *HWAccel::hardwareEncoderForCodecId(AVCodecID id) const
     return c;
 }
 
-HWAccel HWAccel::findHardwareAccelForCodecID(AVCodecID id)
+std::unique_ptr<HWAccel> HWAccel::findHardwareAccelForCodecID(AVCodecID id)
 {
     auto *accels = preferredHardwareAccelerators;
     while (*accels != AV_HWDEVICE_TYPE_NONE) {
-        auto accel = HWAccel(*accels);
-        if (accel.hardwareEncoderForCodecId(id) != nullptr)
+        auto accel = HWAccel::create(*accels);
+        if (accel && accel->hardwareEncoderForCodecId(id))
             return accel;
         ++accels;
     }
@@ -311,23 +301,21 @@ HWAccel HWAccel::findHardwareAccelForCodecID(AVCodecID id)
 
 AVHWDeviceType HWAccel::deviceType() const
 {
-    if (!d || !d->hwDeviceContext)
-        return AV_HWDEVICE_TYPE_NONE;
-    return hwDeviceContext()->type;
+    return m_hwDeviceContext ? hwDeviceContext()->type : AV_HWDEVICE_TYPE_NONE;
 }
 
 void HWAccel::createFramesContext(AVPixelFormat swFormat, const QSize &size)
 {
-    if (!d || !d->hwDeviceContext)
+    if (m_hwDeviceContext)
         return;
-    d->hwFramesContext = av_hwframe_ctx_alloc(d->hwDeviceContext);
-    auto *c = (AVHWFramesContext *)d->hwFramesContext->data;
+    m_hwFramesContext = av_hwframe_ctx_alloc(m_hwDeviceContext);
+    auto *c = (AVHWFramesContext *)m_hwFramesContext->data;
     c->format = hwFormat();
     c->sw_format = swFormat;
     c->width = size.width();
     c->height = size.height();
     qDebug() << "init frames context";
-    int err = av_hwframe_ctx_init(d->hwFramesContext);
+    int err = av_hwframe_ctx_init(m_hwFramesContext);
     if (err < 0)
         qWarning() << "failed to init HW frame context" << err << err2str(err);
     else
@@ -336,9 +324,7 @@ void HWAccel::createFramesContext(AVPixelFormat swFormat, const QSize &size)
 
 AVHWFramesContext *HWAccel::hwFramesContext() const
 {
-    if (!d || !d->hwFramesContext)
-        return nullptr;
-    return (AVHWFramesContext *)d->hwFramesContext->data;
+    return m_hwFramesContext ? (AVHWFramesContext *)m_hwFramesContext->data : nullptr;
 }
 
 
diff --git a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_p.h b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_p.h
index 025157bff..7186d56ab 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_p.h
+++ b/src/plugins/multimedia/ffmpeg/qffmpeghwaccel_p.h
@@ -82,40 +82,35 @@ private:
 
 class HWAccel
 {
-    struct Data {
-        ~Data();
-        QAtomicInt ref = 0;
-        AVBufferRef *hwDeviceContext = nullptr;
-        AVBufferRef *hwFramesContext = nullptr;
-    };
+    AVBufferRef *m_hwDeviceContext = nullptr;
+    AVBufferRef *m_hwFramesContext = nullptr;
 
 public:
-    HWAccel() = default;
-    explicit HWAccel(AVHWDeviceType deviceType);
-    explicit HWAccel(const AVCodec *codec);
     ~HWAccel();
 
-    bool isNull() const { return !d || !d->hwDeviceContext; }
+    static std::unique_ptr<HWAccel> create(const AVCodec *decoder);
+    static std::unique_ptr<HWAccel> create(AVHWDeviceType deviceType);
+    static std::unique_ptr<HWAccel> findHardwareAccelForCodecID(AVCodecID id);
+
+    static const AVCodec *hardwareDecoderForCodecId(AVCodecID id);
+    const AVCodec *hardwareEncoderForCodecId(AVCodecID id) const;
 
     AVHWDeviceType deviceType() const;
 
-    AVBufferRef *hwDeviceContextAsBuffer() const { return d ? d->hwDeviceContext : nullptr; }
+    AVBufferRef *hwDeviceContextAsBuffer() const { return m_hwDeviceContext; }
     AVHWDeviceContext *hwDeviceContext() const;
     AVPixelFormat hwFormat() const;
 
-    const AVCodec *hardwareEncoderForCodecId(AVCodecID id) const;
-    static HWAccel findHardwareAccelForCodecID(AVCodecID id);
-
-    static const AVCodec *hardwareDecoderForCodecId(AVCodecID id);
-
     void createFramesContext(AVPixelFormat swFormat, const QSize &size);
-    AVBufferRef *hwFramesContextAsBuffer() const { return d ? d->hwFramesContext : nullptr; }
+    AVBufferRef *hwFramesContextAsBuffer() const { return m_hwFramesContext; }
     AVHWFramesContext *hwFramesContext() const;
 
     static AVPixelFormat format(AVFrame *frame);
     static const AVHWDeviceType *preferredDeviceTypes();
 private:
-    QExplicitlySharedDataPointer<Data> d;
+    HWAccel(AVBufferRef *hwDeviceContext, AVBufferRef *hwFrameContext = nullptr)
+        : m_hwDeviceContext(hwDeviceContext), m_hwFramesContext(hwFrameContext)
+    {}
 };
 
 }
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder.cpp b/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder.cpp
index 374152bfa..ea2ed46d3 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder.cpp
@@ -48,11 +48,13 @@ VideoFrameEncoder::VideoFrameEncoder(const QMediaEncoderSettings &encoderSetting
 #ifndef QT_DISABLE_HW_ENCODING
     const auto *accels = HWAccel::preferredDeviceTypes();
     while (*accels != AV_HWDEVICE_TYPE_NONE) {
-        auto accel = HWAccel(*accels);
+        auto accel = HWAccel::create(*accels);
         ++accels;
+        if (!accel)
+            continue;
 
         auto matchesSizeConstraints = [&]() -> bool {
-            auto *constraints = av_hwdevice_get_hwframe_constraints(accel.hwDeviceContextAsBuffer(), nullptr);
+            auto *constraints = av_hwdevice_get_hwframe_constraints(accel->hwDeviceContextAsBuffer(), nullptr);
             if (!constraints)
                 return true;
                 // Check size constraints
@@ -65,15 +67,15 @@ VideoFrameEncoder::VideoFrameEncoder(const QMediaEncoderSettings &encoderSetting
         if (!matchesSizeConstraints())
             continue;
 
-        d->codec = accel.hardwareEncoderForCodecId(codecID);
+        d->codec = accel->hardwareEncoderForCodecId(codecID);
         if (!d->codec)
             continue;
-        d->accel = accel;
+        d->accel = std::move(accel);
         break;
     }
 #endif
 
-    if (d->accel.isNull()) {
+    if (!d->accel) {
         d->codec = avcodec_find_encoder(codecID);
         if (!d->codec) {
             qWarning() << "Could not find encoder for codecId" << codecID;
@@ -122,7 +124,7 @@ VideoFrameEncoder::VideoFrameEncoder(const QMediaEncoderSettings &encoderSetting
     }
 
     if (d->targetFormatIsHWFormat) {
-        Q_ASSERT(!d->accel.isNull());
+        Q_ASSERT(d->accel);
         // if source and target formats don't agree, but the target is a HW format, we need to upload
         if (d->sourceFormat != d->targetFormat || needToScale) {
             d->uploadToHW = true;
@@ -135,7 +137,7 @@ VideoFrameEncoder::VideoFrameEncoder(const QMediaEncoderSettings &encoderSetting
 
             d->targetSWFormat = AV_PIX_FMT_NONE;
 
-            auto *constraints = av_hwdevice_get_hwframe_constraints(d->accel.hwDeviceContextAsBuffer(), nullptr);
+            auto *constraints = av_hwdevice_get_hwframe_constraints(d->accel->hwDeviceContextAsBuffer(), nullptr);
             auto *f = constraints->valid_sw_formats;
             int score = INT_MIN;
             while (*f != AV_PIX_FMT_NONE) {
@@ -183,7 +185,7 @@ VideoFrameEncoder::VideoFrameEncoder(const QMediaEncoderSettings &encoderSetting
 
             av_hwframe_constraints_free(&constraints);
             // need to create a frames context to convert the input data
-            d->accel.createFramesContext(d->targetSWFormat, sourceSize);
+            d->accel->createFramesContext(d->targetSWFormat, sourceSize);
         }
     } else {
         d->targetSWFormat = d->targetFormat;
@@ -256,12 +258,14 @@ void QFFmpeg::VideoFrameEncoder::initWithFormatContext(AVFormatContext *formatCo
     qCDebug(qLcVideoFrameEncoder) << "requesting time base" << d->codecContext->time_base.num << d->codecContext->time_base.den;
     auto [num, den] = qRealToFraction(requestedRate);
     d->codecContext->framerate = { num, den };
-    auto deviceContext = d->accel.hwDeviceContextAsBuffer();
-    if (deviceContext)
-        d->codecContext->hw_device_ctx = av_buffer_ref(deviceContext);
-    auto framesContext = d->accel.hwFramesContextAsBuffer();
-    if (framesContext)
-        d->codecContext->hw_frames_ctx = av_buffer_ref(framesContext);
+    if (d->accel) {
+        auto deviceContext = d->accel->hwDeviceContextAsBuffer();
+        if (deviceContext)
+            d->codecContext->hw_device_ctx = av_buffer_ref(deviceContext);
+        auto framesContext = d->accel->hwFramesContextAsBuffer();
+        if (framesContext)
+            d->codecContext->hw_frames_ctx = av_buffer_ref(framesContext);
+    }
 }
 
 bool VideoFrameEncoder::open()
@@ -316,7 +320,7 @@ int VideoFrameEncoder::sendFrame(AVFrame *frame)
     }
 
     if (d->uploadToHW) {
-        auto *hwFramesContext = d->accel.hwFramesContextAsBuffer();
+        auto *hwFramesContext = d->accel->hwFramesContextAsBuffer();
         Q_ASSERT(hwFramesContext);
         auto *f = av_frame_alloc();
         if (!f)
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder_p.h b/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder_p.h
index 4dd9f05d7..f71460799 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder_p.h
+++ b/src/plugins/multimedia/ffmpeg/qffmpegvideoframeencoder_p.h
@@ -33,7 +33,7 @@ class VideoFrameEncoder
         float frameRate = 0.;
         QSize sourceSize;
 
-        HWAccel accel;
+        std::unique_ptr<HWAccel> accel;
         const AVCodec *codec = nullptr;
         AVStream *stream = nullptr;
         AVCodecContext *codecContext = nullptr;