Ticket #10062: workaround-for-qsv-av1-timestamp-issue.patch

libavcodec/qsvenc.c

@@ -42 +42 @@
 #include "qsv.h"
 #include "qsv_internal.h"
 #include "qsvenc.h"
+#include "get_bits.h"
+#include "av1.h"
 
 struct profile_names {
     mfxU16 profile;
@@ -1503 +1505 @@
     if (!q->async_fifo)
         return AVERROR(ENOMEM);
 
+    if (avctx->codec_id == AV_CODEC_ID_AV1) {
+        q->input_pts = av_fifo_alloc2(8, sizeof(int64_t), AV_FIFO_FLAG_AUTO_GROW);
+        if (!q->input_pts)
+            return AVERROR(ENOMEM);
+        q->output_pkts = av_fifo_alloc2(8, sizeof(AVPacket), AV_FIFO_FLAG_AUTO_GROW);
+        if (!q->output_pkts)
+            return AVERROR(ENOMEM);
+        av_packet_unref(&q->current_pkt);
+    }
+
     if (avctx->hwaccel_context) {
         AVQSVContext *qsv = avctx->hwaccel_context;
 
@@ -1852 +1864 @@
             return ret;
         }
     }
-    qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
+
+    if (q->avctx->codec_id == AV_CODEC_ID_AV1) {
+        av_fifo_write(q->input_pts, &frame->pts, 1);
+    }
+    else
+        qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational) { 1, 90000 });
 
     *new_frame = qf;
 
@@ -2365 +2382 @@
     goto free;
 }
 
+static unsigned get_uleb128(GetBitContext* const c, int* error) {
+    uint64_t val = 0;
+    unsigned i = 0, more;
+    *error = 0;
+
+    do {
+        const int v = get_bits(c, 8);
+        more = v & 0x80;
+        val |= ((uint64_t)(v & 0x7F)) << i;
+        i += 7;
+    } while (more && i < 56);
+
+    if (val > UINT_MAX || more) {
+        *error = 1;
+        return 0;
+    }
+
+    return (unsigned)val;
+}
+
 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
 {
@@ -2391 +2428 @@
             ret = MFXVideoCORE_SyncOperation(q->session, *qpkt.sync, 1000);
         } while (ret == MFX_WRN_IN_EXECUTION);
 
-        qpkt.pkt.dts  = av_rescale_q(qpkt.bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
-        qpkt.pkt.pts  = av_rescale_q(qpkt.bs->TimeStamp,       (AVRational){1, 90000}, avctx->time_base);
         qpkt.pkt.size = qpkt.bs->DataLength;
 
-        if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR) {
-            qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
-            pict_type = AV_PICTURE_TYPE_I;
-        } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_I || qpkt.bs->FrameType & MFX_FRAMETYPE_xI)
-            pict_type = AV_PICTURE_TYPE_I;
-        else if (qpkt.bs->FrameType & MFX_FRAMETYPE_P || qpkt.bs->FrameType & MFX_FRAMETYPE_xP)
-            pict_type = AV_PICTURE_TYPE_P;
-        else if (qpkt.bs->FrameType & MFX_FRAMETYPE_B || qpkt.bs->FrameType & MFX_FRAMETYPE_xB)
-            pict_type = AV_PICTURE_TYPE_B;
-        else if (qpkt.bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
-            pict_type = AV_PICTURE_TYPE_NONE;
-            av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
+        if (avctx->codec_id == AV_CODEC_ID_AV1) {
+            GetBitContext gbc;
+            init_get_bits(&gbc, qpkt.pkt.data, qpkt.pkt.size * 8);
+            while (get_bits_left(&gbc) > 0) {
+                int start_index = gbc.index;
+                get_bits(&gbc, 1);
+                const enum AV1_OBU_Type type = (enum AV1_OBU_Type)get_bits(&gbc, 4);
+                const int has_extension = get_bits(&gbc, 1);
+                const int has_length_field = get_bits(&gbc, 1);
+                get_bits(&gbc, 1);
+                int temporal_id = 0, spatial_id = 0;
+                if (has_extension) {
+                    temporal_id = get_bits(&gbc, 3);
+                    spatial_id = get_bits(&gbc, 2);
+                    get_bits(&gbc, 3);
+                }
+                int error = 0;
+                const unsigned len = has_length_field ?
+                    get_uleb128(&gbc, &error) : qpkt.pkt.size - 1 - has_extension;
+                skip_bits(&gbc, len * 8);
+
+                if (type == AV1_OBU_TEMPORAL_DELIMITER) {
+                    if (q->current_pkt.size > 0) {
+                        AVPacket tmp = { 0 };
+                        av_packet_move_ref(&tmp, &q->current_pkt);
+                        av_fifo_write(q->output_pkts, &tmp, 1);
+                    }
+                    av_fifo_read(q->input_pts, &q->current_pkt.pts, 1);
+                    q->current_pkt.dts = q->current_pkt.pts;
+                    if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR)
+                        q->current_pkt.flags |= AV_PKT_FLAG_KEY;
+                }
+
+                int start_offset = start_index >> 3;
+                int append_bytes = (gbc.index - start_index) >> 3;
+                av_grow_packet(&q->current_pkt, append_bytes);
+                memcpy((uint8_t*)q->current_pkt.data + q->current_pkt.size - append_bytes, gbc.buffer + start_offset, append_bytes);
+            }
         } else {
-            av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", qpkt.bs->FrameType);
-            return AVERROR_INVALIDDATA;
-        }
+            qpkt.pkt.dts = av_rescale_q(qpkt.bs->DecodeTimeStamp, (AVRational) { 1, 90000 }, avctx->time_base);
+            qpkt.pkt.pts = av_rescale_q(qpkt.bs->TimeStamp,       (AVRational) { 1, 90000 }, avctx->time_base);
 
-        if (avctx->codec_id == AV_CODEC_ID_H264) {
-            enc_buf = qpkt.bs->ExtParam;
-            enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
-            ff_side_data_set_encoder_stats(&qpkt.pkt,
-                enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
-            av_freep(&enc_info);
-            av_freep(&enc_buf);
+            if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR) {
+                qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
+                pict_type = AV_PICTURE_TYPE_I;
+            }
+            else if (qpkt.bs->FrameType & MFX_FRAMETYPE_I || qpkt.bs->FrameType & MFX_FRAMETYPE_xI)
+                pict_type = AV_PICTURE_TYPE_I;
+            else if (qpkt.bs->FrameType & MFX_FRAMETYPE_P || qpkt.bs->FrameType & MFX_FRAMETYPE_xP)
+                pict_type = AV_PICTURE_TYPE_P;
+            else if (qpkt.bs->FrameType & MFX_FRAMETYPE_B || qpkt.bs->FrameType & MFX_FRAMETYPE_xB)
+                pict_type = AV_PICTURE_TYPE_B;
+            else if (qpkt.bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
+                pict_type = AV_PICTURE_TYPE_NONE;
+                av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
+            }
+            else {
+                av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", qpkt.bs->FrameType);
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (avctx->codec_id == AV_CODEC_ID_H264) {
+                enc_buf = qpkt.bs->ExtParam;
+                enc_info = (mfxExtAVCEncodedFrameInfo*)(*enc_buf);
+                ff_side_data_set_encoder_stats(&qpkt.pkt,
+                    enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
+                av_freep(&enc_info);
+                av_freep(&enc_buf);
+            }
+
+            av_packet_move_ref(pkt, &qpkt.pkt);
+
+            *got_packet = 1;
         }
+
         av_freep(&qpkt.bs);
         av_freep(&qpkt.sync);
+    }
 
-        av_packet_move_ref(pkt, &qpkt.pkt);
-
-        *got_packet = 1;
+    if (q->avctx->codec_id == AV_CODEC_ID_AV1) {
+        if (av_fifo_can_read(q->output_pkts) > 0) {
+            AVPacket tmp = { 0 };
+            av_fifo_read(q->output_pkts, &tmp, 1);
+            av_packet_move_ref(pkt, &tmp);
+            *got_packet = 1;
+        }
+        else if (!frame && !av_fifo_can_read(q->async_fifo) && q->current_pkt.size > 0) {
+            av_packet_move_ref(pkt, &q->current_pkt);
+            *got_packet = 1;
+        }
     }
 
     return 0;
@@ -2469 +2563 @@
         av_fifo_freep2(&q->async_fifo);
     }
 
+    if (avctx->codec_id == AV_CODEC_ID_AV1) {
+        av_fifo_freep2(&q->input_pts);
+        if (q->output_pkts) {
+            AVPacket pkt;
+            while (av_fifo_read(q->output_pkts, &pkt, 1) >= 0) {
+                av_packet_unref(&pkt);
+            }
+            av_fifo_freep2(&q->output_pkts);
+        }
+        av_packet_unref(&q->current_pkt);
+    }
+
 #if QSV_HAVE_OPAQUE
     av_freep(&q->opaque_surfaces);
     av_buffer_unref(&q->opaque_alloc_buf);

libavcodec/qsvenc.h

@@ -186 +186 @@
     mfxExtBuffer **extparam;
 
     AVFifo *async_fifo;
+    AVFifo* input_pts;
+    AVFifo* output_pkts;
+    AVPacket current_pkt;
 
     QSVFramesContext frames_ctx;