[FFmpeg-devel,20/35] lavc/qsvdec: switch to the new FIFO API

diff --git a/libavcodec/qsvdec.c b/libavcodec/qsvdec.c
index 08370c8a0b..acdf7804f6 100644
--- a/libavcodec/qsvdec.c
+++ b/libavcodec/qsvdec.c
@@ -56,6 +56,11 @@  static const AVRational mfx_tb = { 1, 90000 };
     AV_NOPTS_VALUE : pts_tb.num ? \
     av_rescale_q(mfx_pts, mfx_tb, pts_tb) : mfx_pts)
 
+typedef struct QSVAsyncFrame {
+    mfxSyncPoint *sync;
+    QSVFrame     *frame;
+} QSVAsyncFrame;
+
 typedef struct QSVContext {
     // the session used for decoding
     mfxSession session;
@@ -208,16 +213,6 @@  static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession ses
     return 0;
 }
 
-static inline unsigned int qsv_fifo_item_size(void)
-{
-    return sizeof(mfxSyncPoint*) + sizeof(QSVFrame*);
-}
-
-static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
-{
-    return av_fifo_size(fifo) / qsv_fifo_item_size();
-}
-
 static int qsv_decode_preinit(AVCodecContext *avctx, QSVContext *q, enum AVPixelFormat pix_fmt, mfxVideoParam *param)
 {
     mfxSession session = NULL;
@@ -235,7 +230,7 @@  static int qsv_decode_preinit(AVCodecContext *avctx, QSVContext *q, enum AVPixel
     }
 
     if (!q->async_fifo) {
-        q->async_fifo = av_fifo_alloc(q->async_depth * qsv_fifo_item_size());
+        q->async_fifo = av_fifo_alloc2(q->async_depth, sizeof(QSVAsyncFrame), 0);
         if (!q->async_fifo)
             return AVERROR(ENOMEM);
     }
@@ -502,7 +497,6 @@  static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
                       AVFrame *frame, int *got_frame,
                       const AVPacket *avpkt)
 {
-    QSVFrame *out_frame;
     mfxFrameSurface1 *insurf;
     mfxFrameSurface1 *outsurf;
     mfxSyncPoint *sync;
@@ -561,6 +555,7 @@  static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
     }
 
     if (*sync) {
+        QSVAsyncFrame aframe;
         QSVFrame *out_frame = find_frame(q, outsurf);
 
         if (!out_frame) {
@@ -571,35 +566,36 @@  static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
         }
 
         out_frame->queued = 1;
-        av_fifo_generic_write(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
-        av_fifo_generic_write(q->async_fifo, &sync,      sizeof(sync),      NULL);
+
+        aframe = (QSVAsyncFrame){ sync, out_frame };
+        av_fifo_write(q->async_fifo, &aframe, 1);
     } else {
         av_freep(&sync);
     }
 
-    if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
-        (!avpkt->size && av_fifo_size(q->async_fifo))) {
+    if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
+        (!avpkt->size && av_fifo_can_read(q->async_fifo))) {
+        QSVAsyncFrame aframe;
         AVFrame *src_frame;
 
-        av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
-        av_fifo_generic_read(q->async_fifo, &sync,      sizeof(sync),      NULL);
-        out_frame->queued = 0;
+        av_fifo_read(q->async_fifo, &aframe, 1);
+        aframe.frame->queued = 0;
 
         if (avctx->pix_fmt != AV_PIX_FMT_QSV) {
             do {
-                ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
+                ret = MFXVideoCORE_SyncOperation(q->session, *aframe.sync, 1000);
             } while (ret == MFX_WRN_IN_EXECUTION);
         }
 
-        av_freep(&sync);
+        av_freep(&aframe.sync);
 
-        src_frame = out_frame->frame;
+        src_frame = aframe.frame->frame;
 
         ret = av_frame_ref(frame, src_frame);
         if (ret < 0)
             return ret;
 
-        outsurf = &out_frame->surface;
+        outsurf = &aframe.frame->surface;
 
         frame->pts = MFX_PTS_TO_PTS(outsurf->Data.TimeStamp, avctx->pkt_timebase);
 
@@ -611,10 +607,10 @@  static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
             outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_TFF;
         frame->interlaced_frame =
             !(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
-        frame->pict_type = ff_qsv_map_pictype(out_frame->dec_info.FrameType);
+        frame->pict_type = ff_qsv_map_pictype(aframe.frame->dec_info.FrameType);
         //Key frame is IDR frame is only suitable for H264. For HEVC, IRAPs are key frames.
         if (avctx->codec_id == AV_CODEC_ID_H264)
-            frame->key_frame = !!(out_frame->dec_info.FrameType & MFX_FRAMETYPE_IDR);
+            frame->key_frame = !!(aframe.frame->dec_info.FrameType & MFX_FRAMETYPE_IDR);
 
         /* update the surface properties */
         if (avctx->pix_fmt == AV_PIX_FMT_QSV)
@@ -633,14 +629,11 @@  static void qsv_decode_close_qsvcontext(QSVContext *q)
     if (q->session)
         MFXVideoDECODE_Close(q->session);
 
-    while (q->async_fifo && av_fifo_size(q->async_fifo)) {
-        QSVFrame *out_frame;
-        mfxSyncPoint *sync;
+    while (q->async_fifo && av_fifo_can_read(q->async_fifo)) {
+        QSVAsyncFrame aframe;
 
-        av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
-        av_fifo_generic_read(q->async_fifo, &sync,      sizeof(sync),      NULL);
-
-        av_freep(&sync);
+        av_fifo_read(q->async_fifo, &aframe, 1);
+        av_freep(&aframe.sync);
     }
 
     while (cur) {
@@ -650,8 +643,7 @@  static void qsv_decode_close_qsvcontext(QSVContext *q)
         cur = q->work_frames;
     }
 
-    av_fifo_free(q->async_fifo);
-    q->async_fifo = NULL;
+    av_fifo_freep(&q->async_fifo);
 
     ff_qsv_close_internal_session(&q->internal_qs);
 
@@ -742,8 +734,8 @@  typedef struct QSVDecContext {
 static void qsv_clear_buffers(QSVDecContext *s)
 {
     AVPacket pkt;
-    while (av_fifo_size(s->packet_fifo) >= sizeof(pkt)) {
-        av_fifo_generic_read(s->packet_fifo, &pkt, sizeof(pkt), NULL);
+    while (av_fifo_can_read(s->packet_fifo)) {
+        av_fifo_read(s->packet_fifo, &pkt, 1);
         av_packet_unref(&pkt);
     }
 
@@ -797,7 +789,8 @@  static av_cold int qsv_decode_init(AVCodecContext *avctx)
     }
 
     s->qsv.orig_pix_fmt = AV_PIX_FMT_NV12;
-    s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
+    s->packet_fifo = av_fifo_alloc2(1, sizeof(AVPacket),
+                                    AV_FIFO_FLAG_AUTO_GROW);
     if (!s->packet_fifo) {
         ret = AVERROR(ENOMEM);
         goto fail;
@@ -823,17 +816,10 @@  static int qsv_decode_frame(AVCodecContext *avctx, void *data,
     if (avpkt->size) {
         AVPacket input_ref;
 
-        if (av_fifo_space(s->packet_fifo) < sizeof(input_ref)) {
-            ret = av_fifo_realloc2(s->packet_fifo,
-                                   av_fifo_size(s->packet_fifo) + sizeof(input_ref));
-            if (ret < 0)
-                return ret;
-        }
-
         ret = av_packet_ref(&input_ref, avpkt);
         if (ret < 0)
             return ret;
-        av_fifo_generic_write(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
+        av_fifo_write(s->packet_fifo, &input_ref, 1);
     }
 
     /* process buffered data */
@@ -841,12 +827,12 @@  static int qsv_decode_frame(AVCodecContext *avctx, void *data,
         /* prepare the input data */
         if (s->buffer_pkt.size <= 0) {
             /* no more data */
-            if (av_fifo_size(s->packet_fifo) < sizeof(AVPacket))
+            if (!av_fifo_can_read(s->packet_fifo))
                 return avpkt->size ? avpkt->size : qsv_process_data(avctx, &s->qsv, frame, got_frame, avpkt);
             /* in progress of reinit, no read from fifo and keep the buffer_pkt */
             if (!s->qsv.reinit_flag) {
                 av_packet_unref(&s->buffer_pkt);
-                av_fifo_generic_read(s->packet_fifo, &s->buffer_pkt, sizeof(s->buffer_pkt), NULL);
+                av_fifo_read(s->packet_fifo, &s->buffer_pkt, 1);
             }
         }