/*

  * This file is part of FFmpeg.

  *

  * FFmpeg is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *

  * FFmpeg is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public

  * License along with FFmpeg; if not, write to the Free Software

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <mfx/mfxvideo.h>
 #include <stdlib.h>
 
 #include "libavutil/dict.h"
 #include "libavutil/mem.h"
 #include "libavutil/opt.h"
 #include "libavcodec/qsv.h"
 

 #include "ffmpeg.h"

 
 typedef struct QSVContext {
     OutputStream *ost;
 
     mfxSession session;
 
     mfxExtOpaqueSurfaceAlloc opaque_alloc;
     AVBufferRef             *opaque_surfaces_buf;
 
     uint8_t           *surface_used;
     mfxFrameSurface1 **surface_ptrs;
     int nb_surfaces;
 
     mfxExtBuffer *ext_buffers[1];
 } QSVContext;
 
 static void buffer_release(void *opaque, uint8_t *data)
 {
     *(uint8_t*)opaque = 0;
 }
 
 static int qsv_get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
 {
     InputStream *ist = s->opaque;
     QSVContext  *qsv = ist->hwaccel_ctx;
     int i;
 
     for (i = 0; i < qsv->nb_surfaces; i++) {
         if (qsv->surface_used[i])
             continue;
 
         frame->buf[0] = av_buffer_create((uint8_t*)qsv->surface_ptrs[i], sizeof(*qsv->surface_ptrs[i]),
                                          buffer_release, &qsv->surface_used[i], 0);
         if (!frame->buf[0])
             return AVERROR(ENOMEM);
         frame->data[3]       = (uint8_t*)qsv->surface_ptrs[i];
         qsv->surface_used[i] = 1;
         return 0;
     }
 
     return AVERROR(ENOMEM);
 }
 
 static int init_opaque_surf(QSVContext *qsv)
 {
     AVQSVContext *hwctx_enc = qsv->ost->enc_ctx->hwaccel_context;
     mfxFrameSurface1 *surfaces;
     int i;
 
     qsv->nb_surfaces = hwctx_enc->nb_opaque_surfaces;
 
     qsv->opaque_surfaces_buf = av_buffer_ref(hwctx_enc->opaque_surfaces);
     qsv->surface_ptrs        = av_mallocz_array(qsv->nb_surfaces, sizeof(*qsv->surface_ptrs));
     qsv->surface_used        = av_mallocz_array(qsv->nb_surfaces, sizeof(*qsv->surface_used));
     if (!qsv->opaque_surfaces_buf || !qsv->surface_ptrs || !qsv->surface_used)
         return AVERROR(ENOMEM);
 
     surfaces = (mfxFrameSurface1*)qsv->opaque_surfaces_buf->data;
     for (i = 0; i < qsv->nb_surfaces; i++)
         qsv->surface_ptrs[i] = surfaces + i;
 
     qsv->opaque_alloc.Out.Surfaces   = qsv->surface_ptrs;
     qsv->opaque_alloc.Out.NumSurface = qsv->nb_surfaces;
     qsv->opaque_alloc.Out.Type       = hwctx_enc->opaque_alloc_type;
 
     qsv->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
     qsv->opaque_alloc.Header.BufferSz = sizeof(qsv->opaque_alloc);
     qsv->ext_buffers[0]               = (mfxExtBuffer*)&qsv->opaque_alloc;
 
     return 0;
 }
 
 static void qsv_uninit(AVCodecContext *s)
 {
     InputStream *ist = s->opaque;
     QSVContext  *qsv = ist->hwaccel_ctx;
 
     av_freep(&qsv->ost->enc_ctx->hwaccel_context);
     av_freep(&s->hwaccel_context);
 
     av_buffer_unref(&qsv->opaque_surfaces_buf);
     av_freep(&qsv->surface_used);
     av_freep(&qsv->surface_ptrs);
 
     av_freep(&qsv);
 }
 
 int qsv_init(AVCodecContext *s)
 {
     InputStream *ist = s->opaque;
     QSVContext  *qsv = ist->hwaccel_ctx;
     AVQSVContext *hwctx_dec;
     int ret;
 
     if (!qsv) {
         av_log(NULL, AV_LOG_ERROR, "QSV transcoding is not initialized. "
                "-hwaccel qsv should only be used for one-to-one QSV transcoding "
                "with no filters.\n");
         return AVERROR_BUG;
     }
 
     ret = init_opaque_surf(qsv);
     if (ret < 0)
         return ret;
 
     hwctx_dec = av_qsv_alloc_context();
     if (!hwctx_dec)
         return AVERROR(ENOMEM);
 
     hwctx_dec->session        = qsv->session;
     hwctx_dec->iopattern      = MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
     hwctx_dec->ext_buffers    = qsv->ext_buffers;
     hwctx_dec->nb_ext_buffers = FF_ARRAY_ELEMS(qsv->ext_buffers);
 
     av_freep(&s->hwaccel_context);
     s->hwaccel_context = hwctx_dec;
 
     ist->hwaccel_get_buffer = qsv_get_buffer;
     ist->hwaccel_uninit     = qsv_uninit;
 
     return 0;
 }
 
 static mfxIMPL choose_implementation(const InputStream *ist)
 {
     static const struct {
         const char *name;
         mfxIMPL     impl;
     } impl_map[] = {
         { "auto",     MFX_IMPL_AUTO         },
         { "sw",       MFX_IMPL_SOFTWARE     },
         { "hw",       MFX_IMPL_HARDWARE     },
         { "auto_any", MFX_IMPL_AUTO_ANY     },
         { "hw_any",   MFX_IMPL_HARDWARE_ANY },
         { "hw2",      MFX_IMPL_HARDWARE2    },
         { "hw3",      MFX_IMPL_HARDWARE3    },
         { "hw4",      MFX_IMPL_HARDWARE4    },
     };
 
     mfxIMPL impl = MFX_IMPL_AUTO_ANY;
     int i;
 
     if (ist->hwaccel_device) {
         for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++)
             if (!strcmp(ist->hwaccel_device, impl_map[i].name)) {
                 impl = impl_map[i].impl;
                 break;
             }
         if (i == FF_ARRAY_ELEMS(impl_map))
             impl = strtol(ist->hwaccel_device, NULL, 0);
     }
 
     return impl;
 }
 
 int qsv_transcode_init(OutputStream *ost)
 {
     InputStream *ist;
     const enum AVPixelFormat *pix_fmt;
 
     AVDictionaryEntry *e;
     const AVOption *opt;
     int flags = 0;
 
     int err, i;
 
     QSVContext *qsv = NULL;
     AVQSVContext *hwctx = NULL;
     mfxIMPL impl;
     mfxVersion ver = { { 3, 1 } };
 
     /* check if the encoder supports QSV */
     if (!ost->enc->pix_fmts)
         return 0;
     for (pix_fmt = ost->enc->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
         if (*pix_fmt == AV_PIX_FMT_QSV)
             break;
     if (*pix_fmt == AV_PIX_FMT_NONE)
         return 0;
 
     if (strcmp(ost->avfilter, "null") || ost->source_index < 0)
         return 0;
 
     /* check if the decoder supports QSV and the output only goes to this stream */
     ist = input_streams[ost->source_index];

     if (ist->hwaccel_id != HWACCEL_QSV || !ist->dec || !ist->dec->pix_fmts)

         return 0;
     for (pix_fmt = ist->dec->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
         if (*pix_fmt == AV_PIX_FMT_QSV)
             break;
     if (*pix_fmt == AV_PIX_FMT_NONE)
         return 0;
 
     for (i = 0; i < nb_output_streams; i++)
         if (output_streams[i] != ost &&
             output_streams[i]->source_index == ost->source_index)
             return 0;
 
     av_log(NULL, AV_LOG_VERBOSE, "Setting up QSV transcoding\n");
 
     qsv   = av_mallocz(sizeof(*qsv));
     hwctx = av_qsv_alloc_context();
     if (!qsv || !hwctx)
         goto fail;
 
     impl = choose_implementation(ist);
 
     err = MFXInit(impl, &ver, &qsv->session);
     if (err != MFX_ERR_NONE) {
         av_log(NULL, AV_LOG_ERROR, "Error initializing an MFX session: %d\n", err);
         goto fail;
     }
 
     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
     opt = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
     if (e && opt)
         av_opt_eval_flags(ost->enc_ctx, opt, e->value, &flags);
 
     qsv->ost = ost;
 
     hwctx->session                = qsv->session;
     hwctx->iopattern              = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
     hwctx->opaque_alloc           = 1;
     hwctx->nb_opaque_surfaces     = 16;
 
     ost->hwaccel_ctx              = qsv;
     ost->enc_ctx->hwaccel_context = hwctx;
     ost->enc_ctx->pix_fmt         = AV_PIX_FMT_QSV;
 
     ist->hwaccel_ctx              = qsv;
     ist->dec_ctx->pix_fmt         = AV_PIX_FMT_QSV;
     ist->resample_pix_fmt         = AV_PIX_FMT_QSV;
 
     return 0;
 
 fail:
     av_freep(&hwctx);
     av_freep(&qsv);
     return AVERROR_UNKNOWN;
 }