diff --git a/AVQt/AVQt b/AVQt/AVQt
index 3acd66f277e2bb6201c41f916dc7d9ea09cce65c..ec0a50036238753aaa622340081da626b5811b8f 100644
--- a/AVQt/AVQt
+++ b/AVQt/AVQt
@@ -9,6 +9,7 @@
 #include "filter/DecoderMMAL.h"
 #include "filter/AudioDecoder.h"
 #include "filter/EncoderVAAPI.h"
+#include "filter/EncoderQSV.h"
 #include "output/IPacketSink.h"
 #include "output/IFrameSink.h"
 #include "output/IAudioSink.h"
diff --git a/AVQt/CMakeLists.txt b/AVQt/CMakeLists.txt
index 1f4c491de4e00118a034c538b15fb4ba169a5cf8..88e334f39cc8db4b2eb182e0bd6b293c0c4d9ebe 100644
--- a/AVQt/CMakeLists.txt
+++ b/AVQt/CMakeLists.txt
@@ -66,6 +66,10 @@ set(SOURCES
         filter/private/EncoderVAAPI_p.h
         filter/EncoderVAAPI.cpp
 
+        filter/EncoderQSV.h
+        filter/private/EncoderQSV_p.h
+        filter/EncoderQSV.cpp
+
         output/RenderClock.h
         output/private/RenderClock_p.h
         output/RenderClock.cpp
diff --git a/AVQt/filter/EncoderQSV.cpp b/AVQt/filter/EncoderQSV.cpp
index 7950b75f8871a94628b1db329cab7b29281f39a4..a2c760d92c1e1709978f2e580cd28bcc6815804d 100644
--- a/AVQt/filter/EncoderQSV.cpp
+++ b/AVQt/filter/EncoderQSV.cpp
@@ -44,11 +44,15 @@ namespace AVQt {
                 codec_name = "hevc_qsv";
                 break;
             case CODEC::VP9:
-                codec_name = "vp9_qsv";
+                if (qEnvironmentVariable("LIBVA_DRIVER_NAME") == "iHD") {
+                    qFatal("[AVQt::EncoderQSV] Unsupported codec: VP9");
+                } else {
+                    codec_name = "vp9_qsv";
+                }
                 break;
             case CODEC::VP8:
-//                codec_name = "vp8_qsv";
-                qFatal("[AVQt::EncoderQSV] Unsupported codec: VP8");
+                codec_name = "vp8_qsv";
+                break;
             case CODEC::MPEG2:
                 codec_name = "mpeg2_qsv";
                 break;
@@ -93,6 +97,8 @@ namespace AVQt {
             av_buffer_unref(&d->m_pFramesCtx);
         }
 
+        d->m_pLockedSource = nullptr;
+
         return 0;
     }
 
@@ -156,34 +162,55 @@ namespace AVQt {
     }
 
     int EncoderQSV::init(IFrameSource *source, AVRational framerate, int64_t duration) {
-        Q_UNUSED(source)
         Q_UNUSED(duration)
+        Q_UNUSED(framerate)
         Q_D(AVQt::EncoderQSV);
-        d->m_framerate = framerate;
+
+        if (d->m_pLockedSource) {
+            qFatal("[AVQt::EncoderQSV] Already initialized and bound to frame source");
+        }
+
+        d->m_pLockedSource = source;
         init();
         return 0;
     }
 
     int EncoderQSV::deinit(IFrameSource *source) {
-        Q_UNUSED(source)
+        Q_D(AVQt::EncoderQSV);
+        if (d->m_pLockedSource != source) {
+            qFatal("[AVQt::EncoderQSV] Cleaning up encoder from other source than initialized is forbidden");
+        }
+
         deinit();
         return 0;
     }
 
     int EncoderQSV::start(IFrameSource *source) {
-        Q_UNUSED(source)
+        Q_D(AVQt::EncoderQSV);
+        if (d->m_pLockedSource != source) {
+            qFatal("[AVQt::EncoderQSV] Starting encoder from other source than initialized is forbidden");
+        }
+
         start();
         return 0;
     }
 
     int EncoderQSV::stop(IFrameSource *source) {
-        Q_UNUSED(source)
+        Q_D(AVQt::EncoderQSV);
+        if (d->m_pLockedSource != source) {
+            qFatal("[AVQt::EncoderQSV] Stopping encoder from other source than initialized is forbidden");
+        }
+
         stop();
         return 0;
     }
 
     void EncoderQSV::pause(IFrameSource *source, bool paused) {
-        Q_UNUSED(source)
+        Q_D(AVQt::EncoderQSV);
+        if (d->m_pLockedSource != source) {
+            qFatal("[AVQt::EncoderQSV] Pausing encoder from other source than initialized is forbidden");
+        }
+
         pause(paused);
     }
 
@@ -216,134 +243,80 @@ namespace AVQt {
     }
 
     void EncoderQSV::onFrame(IFrameSource *source, AVFrame *frame, int64_t frameDuration, AVBufferRef *pDeviceCtx) {
-        Q_UNUSED(source)
         Q_D(AVQt::EncoderQSV);
 
-        QMutexLocker locker{&d->m_onFrameMutex};
-        int ret = 0;
+        if (d->m_pLockedSource != source) {
+            qFatal("[AVQt::EncoderQSV] Sending frames from other source than initialized is forbidden");
+        }
+
+        int ret;
         constexpr auto strBufSize = 64;
         char strBuf[strBufSize];
 
-        bool shouldBe = true;
-        // Encoder init is only possible with frame parameters
-        if (d->m_firstFrame.compare_exchange_strong(shouldBe, false)) {
-            d->m_pCodecCtx = avcodec_alloc_context3(d->m_pCodec);
-            if (!d->m_pCodecCtx) {
-                qFatal("Could not create QSV encoder context");
-            }
-            d->m_pCodecCtx->width = frame->width;
-            d->m_pCodecCtx->height = frame->height;
-            qDebug("Creating new HW context...");
-
-            if (pDeviceCtx) {
-                ret = av_hwdevice_ctx_create_derived(&d->m_pDeviceCtx, AV_HWDEVICE_TYPE_QSV, pDeviceCtx, 0);
-            }
-            ret = av_hwdevice_ctx_create(&d->m_pDeviceCtx, AV_HWDEVICE_TYPE_QSV, "", nullptr, 0);
-            if (ret < 0) {
-                qFatal("%i: Unable to create AVHWDeviceContext: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
-            } else if (!d->m_pDeviceCtx) {
-                qFatal("Unable to create AVHWDeviceContext");
-            }
-
-            if (frame->hw_frames_ctx) {
-                d->m_pCodecCtx->sw_pix_fmt = static_cast<AVPixelFormat>(reinterpret_cast<AVHWFramesContext *>(frame->hw_frames_ctx->data)->sw_format);
-            } else {
-                d->m_pCodecCtx->sw_pix_fmt = static_cast<AVPixelFormat>(frame->format);
-            }
-
-            d->m_pFramesCtx = av_hwframe_ctx_alloc(d->m_pDeviceCtx);
-            auto *framesContext = reinterpret_cast<AVHWFramesContext *>(d->m_pFramesCtx->data);
-            framesContext->width = d->m_pCodecCtx->width;
-            framesContext->height = d->m_pCodecCtx->height;
-            framesContext->sw_format = d->m_pCodecCtx->sw_pix_fmt;
-            framesContext->format = AV_PIX_FMT_QSV;
-            framesContext->initial_pool_size = 20;
-
-            ret = av_hwframe_ctx_init(d->m_pFramesCtx);
-            if (ret != 0) {
-                qFatal("%i: Could not init HW frames context: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
-            }
-
-            d->m_pCodecCtx->pix_fmt = framesContext->format;
-
-            d->m_pCodecCtx->hw_device_ctx = av_buffer_ref(d->m_pDeviceCtx);
-//            d->m_pCodecCtx->hw_frames_ctx = av_buffer_ref(d->m_pFramesCtx);
-            d->m_pCodecCtx->bit_rate = d->m_bitrate;
-            d->m_pCodecCtx->rc_min_rate = static_cast<int>(std::round(d->m_bitrate * 0.8));
-            d->m_pCodecCtx->rc_max_rate = static_cast<int>(std::round(d->m_bitrate * 1.1));
-            d->m_pCodecCtx->rc_buffer_size = d->m_bitrate * 2;
-            d->m_pCodecCtx->gop_size = 20;
-            d->m_pCodecCtx->max_b_frames = 0;
-            d->m_pCodecCtx->color_primaries = AVCOL_PRI_BT2020;
-            d->m_pCodecCtx->color_trc = AVCOL_TRC_SMPTE2084;
-            d->m_pCodecCtx->colorspace = AVCOL_SPC_BT2020_NCL;
-            d->m_pCodecCtx->framerate = d->m_framerate;
-
-            // Timestamps from frame sources are always microseconds, trying to use this timebase for the encoder too
-            d->m_pCodecCtx->time_base = av_make_q(1, 1000000);
-            ret = avcodec_open2(d->m_pCodecCtx, d->m_pCodec, nullptr);
-            if (ret < 0) {
-                qFatal("%i: Unable to open QSV encoder: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
-            }
-            qDebug("[AVQt::EncoderQSV] Encoder timebase: %d/%d", d->m_pCodecCtx->time_base.num, d->m_pCodecCtx->time_base.den);
-
-//            // Preallocating frame on gpu
-            d->m_pHWFrame = av_frame_alloc();
-//            ret = av_hwframe_get_buffer(d->m_pFramesCtx, d->m_pHWFrame, 0);
-
-            QMutexLocker lock(&d->m_cbListMutex);
-            for (const auto &cb: d->m_cbList) {
-                AVCodecParameters *parameters = avcodec_parameters_alloc();
-                avcodec_parameters_from_context(parameters, d->m_pCodecCtx);
-                cb->init(this, d->m_framerate, d->m_pCodecCtx->time_base, 0, parameters, nullptr, nullptr);
-                cb->start(this);
-            }
-            d->m_initialized.store(true);
-        }
-
-        if (frame->hw_frames_ctx) {
-            ret = av_hwframe_map(d->m_pHWFrame, frame, AV_HWFRAME_MAP_READ);
-            if (ret != 0) {
-                qDebug("[AVQt::EncoderQSV] %i: Could not map frame to GPU memory, trying copy: %s", ret,
-                       av_make_error_string(strBuf, strBufSize, ret));
-                ret = av_hwframe_transfer_data(d->m_pHWFrame, frame, 0);
+        QPair<AVFrame *, int64_t> queueFrame{av_frame_alloc(), frameDuration};
+        switch (frame->format) {
+            case AV_PIX_FMT_QSV:
+            case AV_PIX_FMT_DRM_PRIME:
+            case AV_PIX_FMT_VAAPI:
+                if (!d->m_pDeviceCtx) {
+//                    d->m_pDeviceCtx = av_buffer_ref(pDeviceCtx);
+//                    d->m_pFramesCtx = av_buffer_ref(frame->hw_frames_ctx);
+                    ret = av_hwdevice_ctx_create_derived(&d->m_pDeviceCtx, AV_HWDEVICE_TYPE_QSV, pDeviceCtx, 0);
+                    if (ret != 0) {
+                        qFatal("[AVQt::EncoderQSV] %d: Could not create derived AVHWDeviceContext: %s", ret,
+                               av_make_error_string(strBuf, strBufSize, ret));
+                    }
+                    AVHWFramesContext *framesCtx, *framesCtxOld;
+                    framesCtxOld = reinterpret_cast<AVHWFramesContext *>(frame->hw_frames_ctx->data);
+                    ret = av_hwframe_ctx_create_derived(&d->m_pFramesCtx, framesCtxOld->sw_format, d->m_pDeviceCtx, frame->hw_frames_ctx, AV_HWFRAME_MAP_READ);
+                    if (ret != 0) {
+                        qFatal("[AVQt::EncoderQSV] %d: Could not create derived AVHWFramesContext: %s", ret,
+                               av_make_error_string(strBuf, strBufSize, ret));
+                    }
+                    framesCtx = reinterpret_cast<AVHWFramesContext *>(d->m_pFramesCtx->data);
+
+                    framesCtx->sw_format = framesCtxOld->sw_format;
+                    framesCtx->format = AV_PIX_FMT_QSV;
+                    framesCtx->width = framesCtxOld->width;
+                    framesCtx->height = framesCtxOld->height;
+                    framesCtx->initial_pool_size = framesCtxOld->initial_pool_size;
+
+                    ret = av_hwframe_ctx_init(d->m_pFramesCtx);
+                    if (ret != 0) {
+                        qFatal("[AVQt::EncoderQSV] %d: Could not init HW frames context: %s", ret,
+                               av_make_error_string(strBuf, strBufSize, ret));
+                    }
+                }
+                queueFrame.first->hw_frames_ctx = av_buffer_ref(d->m_pFramesCtx);
+                queueFrame.first->format = AV_PIX_FMT_QSV;
+                ret = av_hwframe_map(queueFrame.first, frame, AV_HWFRAME_MAP_READ);
                 if (ret != 0) {
-                    qFatal("[AVQt::EncoderQSV] %i: Could not copy frame to GPU memory: %s", ret,
+                    qFatal("[AVQt::EncoderQSV] %d: Could not map frame from source device to QSV: %s", ret,
                            av_make_error_string(strBuf, strBufSize, ret));
                 }
-            }
-        } else {
-            d->m_pHWFrame = av_frame_clone(frame);
+                break;
+            case AV_PIX_FMT_DXVA2_VLD:
+                qDebug("Transferring frame from GPU to CPU");
+                av_hwframe_transfer_data(queueFrame.first, frame, 0);
+                queueFrame.first->pts = frame->pts;
+                break;
+            default:
+                qDebug("Referencing frame");
+                av_frame_ref(queueFrame.first, frame);
+                break;
         }
 
-        d->m_pHWFrame->pts = av_rescale_q(frame->pts, av_make_q(1, 1000000), d->m_pCodecCtx->time_base);
-
-        while (d->m_codecBufferFull) {
-            msleep(1);
+        while (d->m_inputQueue.size() > 4) {
+            QThread::msleep(1);
         }
-
         {
-            QMutexLocker lock1{&d->m_codecMutex};
-            ret = avcodec_send_frame(d->m_pCodecCtx, d->m_pHWFrame);
-        }
-        if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
-            d->m_codecBufferFull.store(true);
+            QMutexLocker lock{&d->m_inputQueueMutex};
+            d->m_inputQueue.enqueue(queueFrame);
+//            std::sort(d->m_inputQueue.begin(), d->m_inputQueue.end(),
+//                      [&](const QPair<AVFrame *, int64_t> &f1, const QPair<AVFrame *, int64_t> &f2) {
+//                          return f1.first->pts < f2.first->pts;
+//                      });
         }
-        av_frame_unref(d->m_pHWFrame);
-//        d->m_pHWFrame->hw_frames_ctx = av_buffer_ref(d->m_pFramesCtx);
-        av_hwframe_get_buffer(d->m_pFramesCtx, d->m_pHWFrame, 0);
-
-//        while (d->m_inputQueue.size() > 3) {
-//            QThread::msleep(1);
-//        }
-//        {
-//            QMutexLocker lock{&d->m_inputQueueMutex};
-//            d->m_inputQueue.enqueue(queueFrame);
-////            std::sort(d->m_inputQueue.begin(), d->m_inputQueue.end(),
-////                      [&](const QPair<AVFrame *, int64_t> &f1, const QPair<AVFrame *, int64_t> &f2) {
-////                          return f1.first->pts < f2.first->pts;
-////                      });
-//        }
     }
 
     void EncoderQSV::run() {
@@ -354,44 +327,119 @@ namespace AVQt {
         char strBuf[strBufSize];
 
         while (d->m_running.load()) {
-            if (!d->m_paused.load() && d->m_initialized.load()) {
-//                if (!d->m_inputQueue.isEmpty()) {
-//                    QPair<AVFrame *, int64_t> frame;
-//                    {
-//                        QMutexLocker lock(&d->m_inputQueueMutex);
-//                        frame = d->m_inputQueue.dequeue();
-//                    }
-//
-//                    ret = avcodec_send_frame(d->m_pCodecCtx, frame.first);
-//                    qDebug("[AVQt::EncoderQSV] Sent frame with PTS %lld to encoder", static_cast<long long>(frame.first->pts));
-//                    /*if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
-//                        break;
-//                    } else */if (ret != 0) {
-//                        qFatal("%i: Could not send frame to QSV encoder: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
-//                    }
-//
-////                    avcodec_send_frame(d->m_pCodecCtx, nullptr);
-////
-////                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
-////                        break;
-////                    } else if (ret != 0) {
-////                        qFatal("%i: Could not flush QSV encoder: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
-////                    }
-//                }
-                AVPacket *packet = av_packet_alloc();
-                while (true) {
+            if (!d->m_paused.load() && d->m_inputQueue.size() > 1) {
+                bool shouldBe = true;
+                // Encoder init is only possible with frame parameters
+                if (d->m_firstFrame.compare_exchange_strong(shouldBe, false)) {
+                    auto frame = d->m_inputQueue.first().first;
+
+                    d->m_pCodecCtx = avcodec_alloc_context3(d->m_pCodec);
+                    if (!d->m_pCodecCtx) {
+                        qFatal("[AVQt::EncoderQSV] Could not create QSV encoder context");
+                    }
+                    d->m_pCodecCtx->width = frame->width;
+                    d->m_pCodecCtx->height = frame->height;
+                    if (!d->m_pDeviceCtx) {
+                        qDebug("[AVQt::EncoderQSV] Creating new HW context...");
+                        ret = av_hwdevice_ctx_create(&d->m_pDeviceCtx, AV_HWDEVICE_TYPE_QSV, nullptr, nullptr, 0);
+                        if (ret < 0) {
+                            qFatal("[AVQt::EncoderQSV] %i: Unable to create AVHWDeviceContext: %s", ret,
+                                   av_make_error_string(strBuf, strBufSize, ret));
+                        } else if (!d->m_pDeviceCtx) {
+                            qFatal("[AVQt::EncoderQSV] Unable to create AVHWDeviceContext");
+                        }
+
+                        d->m_pCodecCtx->sw_pix_fmt = static_cast<AVPixelFormat>(frame->format);
+
+                        d->m_pFramesCtx = av_hwframe_ctx_alloc(d->m_pDeviceCtx);
+                        auto *framesContext = reinterpret_cast<AVHWFramesContext *>(d->m_pFramesCtx->data);
+                        framesContext->width = d->m_pCodecCtx->width;
+                        framesContext->height = d->m_pCodecCtx->height;
+                        framesContext->sw_format = d->m_pCodecCtx->sw_pix_fmt;
+                        framesContext->format = AV_PIX_FMT_QSV;
+                        framesContext->initial_pool_size = 20;
+
+                        ret = av_hwframe_ctx_init(d->m_pFramesCtx);
+                        if (ret != 0) {
+                            qFatal("[AVQt::EncoderQSV] %i: Could not init HW frames context: %s", ret,
+                                   av_make_error_string(strBuf, strBufSize, ret));
+                        }
+                        d->m_pCodecCtx->pix_fmt = framesContext->format;
+
+                        // Preallocating frame on gpu
+                        d->m_pHWFrame = av_frame_alloc();
+                        ret = av_hwframe_get_buffer(d->m_pFramesCtx, d->m_pHWFrame, 0);
+                        if (ret != 0) {
+                            qFatal("[AVQt::EncoderQSV] %i: Could not allocate HW frame in encoder context: %s", ret,
+                                   av_make_error_string(strBuf, strBufSize, ret));
+                        }
+                    }
+                    d->m_pCodecCtx->hw_device_ctx = av_buffer_ref(d->m_pDeviceCtx);
+                    d->m_pCodecCtx->hw_frames_ctx = av_buffer_ref(d->m_pFramesCtx);
+                    d->m_pCodecCtx->pix_fmt = AV_PIX_FMT_QSV;
+                    d->m_pCodecCtx->bit_rate = d->m_bitrate;
+                    d->m_pCodecCtx->rc_min_rate = static_cast<int>(std::round(d->m_bitrate * 0.8));
+                    d->m_pCodecCtx->rc_max_rate = static_cast<int>(std::round(d->m_bitrate * 1.1));
+                    d->m_pCodecCtx->rc_buffer_size = d->m_bitrate * 2;
+                    d->m_pCodecCtx->gop_size = 20;
+                    d->m_pCodecCtx->max_b_frames = 0;
+                    d->m_pCodecCtx->color_primaries = AVCOL_PRI_BT2020;
+                    d->m_pCodecCtx->color_trc = AVCOL_TRC_SMPTE2084;
+                    d->m_pCodecCtx->colorspace = AVCOL_SPC_BT2020_NCL;
+                    d->m_pCodecCtx->framerate = av_make_q(60, 1);
+
+                    // Timestamps from frame sources are always microseconds, trying to use this timebase for the encoder too
+                    d->m_pCodecCtx->time_base = av_make_q(1, 1000000);
+                    ret = avcodec_open2(d->m_pCodecCtx, d->m_pCodec, nullptr);
+                    if (ret < 0) {
+                        qFatal("[AVQt::EncoderQSV] %i: Unable to open QSV encoder: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
+                    }
+                    qDebug("[AVQt::EncoderQSV] Encoder timebase: %d/%d", d->m_pCodecCtx->time_base.num, d->m_pCodecCtx->time_base.den);
+
+                    QMutexLocker lock(&d->m_cbListMutex);
+                    for (const auto &cb: d->m_cbList) {
+                        AVCodecParameters *parameters = avcodec_parameters_alloc();
+                        avcodec_parameters_from_context(parameters, d->m_pCodecCtx);
+                        cb->init(this, av_make_q(0, 1), d->m_pCodecCtx->time_base, 0, parameters, nullptr, nullptr);
+                        cb->start(this);
+                    }
+                }
+                if (!d->m_inputQueue.isEmpty()) {
+                    QPair<AVFrame *, int64_t> frame;
                     {
-                        QMutexLocker lock{&d->m_codecMutex};
-                        ret = avcodec_receive_packet(d->m_pCodecCtx, packet);
+                        QMutexLocker lock(&d->m_inputQueueMutex);
+                        frame = d->m_inputQueue.dequeue();
+                    }
+                    if (frame.first->hw_frames_ctx) {
+                        frame.first->pts = av_rescale_q(frame.first->pts, av_make_q(1, 1000000),
+                                                        d->m_pCodecCtx->time_base); // Incoming timestamps are always microseconds
+                        ret = avcodec_send_frame(d->m_pCodecCtx, frame.first);
+                        qDebug("[AVQt::EncoderQSV] Sent frame with PTS %lld to encoder", static_cast<long long>(frame.first->pts));
+                        av_frame_free(&frame.first);
+                    } else {
+                        av_hwframe_transfer_data(d->m_pHWFrame, frame.first, 0);
+                        d->m_pHWFrame->pts = av_rescale_q(frame.first->pts, av_make_q(1, 1000000),
+                                                          d->m_pCodecCtx->time_base); // Incoming timestamps are always microseconds
+                        av_frame_free(&frame.first);
+                        ret = avcodec_send_frame(d->m_pCodecCtx, d->m_pHWFrame);
+                        qDebug("[AVQt::EncoderQSV] Sent frame with PTS %lld to encoder", static_cast<long long>(d->m_pHWFrame->pts));
                     }
+                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+                        break;
+                    } else if (ret != 0) {
+                        qFatal("[AVQt::EncoderQSV] %i: Could not send frame to QSV encoder: %s", ret,
+                               av_make_error_string(strBuf, strBufSize, ret));
+                    }
+                }
+                AVPacket *packet = av_packet_alloc();
+                while (true) {
+                    ret = avcodec_receive_packet(d->m_pCodecCtx, packet);
                     if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
                         break;
                     } else if (ret != 0) {
-                        qFatal("%i: Could not receive packet from encoder: %s", ret, av_make_error_string(strBuf, strBufSize, ret));
+                        qFatal("[AVQt::EncoderQSV] %i: Could not receive packet from encoder: %s", ret,
+                               av_make_error_string(strBuf, strBufSize, ret));
                     }
-//                    packet->pts = d->m_pHWFrame->pts;
-//                    packet->pts = d->m_pCodecCtx->coded_frame->pts;
-//                    packet->pts = packet->dts;
                     packet->pos = -1;
                     av_packet_rescale_ts(packet, d->m_pCodecCtx->time_base, av_make_q(1, 1000000));
                     qDebug("[AVQt::EncoderQSV] Got packet from encoder with PTS: %lld, DTS: %lld, duration: %lld, timebase: %d/%d",
@@ -409,7 +457,6 @@ namespace AVQt {
                     }
                     av_packet_unref(packet);
                 }
-                d->m_codecBufferFull.store(false);
             } else {
                 msleep(1);
             }
diff --git a/AVQt/filter/EncoderVAAPI.cpp b/AVQt/filter/EncoderVAAPI.cpp
index f1f10f0fe99a8755e057c6d689c3b7f9a1543ac8..e001d48eaff91df8b2e1a28db4335d69d1943dfa 100644
--- a/AVQt/filter/EncoderVAAPI.cpp
+++ b/AVQt/filter/EncoderVAAPI.cpp
@@ -259,7 +259,7 @@ namespace AVQt {
         char strBuf[strBufSize];
 
         while (d->m_running.load()) {
-            if (!d->m_paused.load() && d->m_inputQueue.size() > 5) {
+            if (!d->m_paused.load() && d->m_inputQueue.size() > 1) {
                 bool shouldBe = true;
                 // Encoder init is only possible with frame parameters
                 if (d->m_firstFrame.compare_exchange_strong(shouldBe, false)) {
diff --git a/AVQt/filter/private/EncoderQSV_p.h b/AVQt/filter/private/EncoderQSV_p.h
index 856b11e84720dd15691ac04d13152be2cf69846a..8c3a545e42e25be8d647c77b0e0ad93f1fb51a4e 100644
--- a/AVQt/filter/private/EncoderQSV_p.h
+++ b/AVQt/filter/private/EncoderQSV_p.h
@@ -35,6 +35,7 @@ namespace AVQt {
         QMutex m_inputQueueMutex{};
         QQueue<QPair<AVFrame *, int64_t>> m_inputQueue{};
 
+        IFrameSource *m_pLockedSource = nullptr;
         QMutex m_cbListMutex{};
         QList<IPacketSink *> m_cbList{};
 
diff --git a/Player/main.cpp b/Player/main.cpp
index c966b4645ed93fdcea092eec9b7c67d97f9a26a9..e9c2d8e8fc8c44ebc4879930fb0fae2f87d57b33 100644
--- a/Player/main.cpp
+++ b/Player/main.cpp
@@ -74,7 +74,7 @@ int main(int argc, char *argv[]) {
     AVQt::IEncoder *videoEncoder;
 #ifdef Q_OS_LINUX
     videoDecoder = new AVQt::DecoderQSV;
-    videoEncoder = new AVQt::EncoderVAAPI(AVQt::IEncoder::CODEC::HEVC, 10 * 1000 * 1000);
+    videoEncoder = new AVQt::EncoderQSV(AVQt::IEncoder::CODEC::HEVC, 10 * 1000 * 1000);
 #elif defined(Q_OS_WINDOWS)
     videoDecoder = new AVQt::DecoderDXVA2();
 #else