/*

 * V4L2 mem2mem decoders

 *

 * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>

 * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>

 *

 * 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 <linux/videodev2.h>

#include <sys/ioctl.h>

#include "libavutil/pixfmt.h"

#include "libavutil/pixdesc.h"

#include "libavutil/opt.h"

#include "libavcodec/avcodec.h"

#include "codec_internal.h"

#include "libavcodec/decode.h"

#include "v4l2_context.h"

#include "v4l2_m2m.h"

#include "v4l2_fmt.h"

static int v4l2_try_start(AVCodecContext *avctx)

{

    V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;

    V4L2Context *const capture = &s->capture;

    V4L2Context *const output = &s->output;

    struct v4l2_selection selection = { 0 };

    int ret;

    /* 1. start the output process */

    if (!output->streamon) {

        ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);

        if (ret < 0) {

            av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n");

            return ret;

        }

    }

    if (capture->streamon)

        return 0;

    /* 2. get the capture format */

    capture->format.type = capture->type;

    ret = ioctl(s->fd, VIDIOC_G_FMT, &capture->format);

    if (ret) {

        av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_FMT ioctl\n");

        return ret;

    }

    /* 2.1 update the AVCodecContext */

    avctx->pix_fmt = ff_v4l2_format_v4l2_to_avfmt(capture->format.fmt.pix_mp.pixelformat, AV_CODEC_ID_RAWVIDEO);

    capture->av_pix_fmt = avctx->pix_fmt;

    /* 3. set the crop parameters */

    selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    selection.r.height = avctx->coded_height;

    selection.r.width = avctx->coded_width;

    ret = ioctl(s->fd, VIDIOC_S_SELECTION, &selection);

    if (!ret) {

        ret = ioctl(s->fd, VIDIOC_G_SELECTION, &selection);

        if (ret) {

            av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_SELECTION ioctl\n");

        } else {

            av_log(avctx, AV_LOG_DEBUG, "crop output %dx%d\n", selection.r.width, selection.r.height);

            /* update the size of the resulting frame */

            capture->height = selection.r.height;

            capture->width  = selection.r.width;

        }

    }

    /* 4. init the capture context now that we have the capture format */

    if (!capture->buffers) {

        ret = ff_v4l2_context_init(capture);

        if (ret) {

            av_log(avctx, AV_LOG_ERROR, "can't request capture buffers\n");

            return AVERROR(ENOMEM);

        }

    }

    /* 5. start the capture process */

    ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);

    if (ret) {

        av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON, on capture context\n");

        return ret;

    }

    return 0;

}

static int v4l2_prepare_decoder(V4L2m2mContext *s)

{

    struct v4l2_event_subscription sub;

    V4L2Context *output = &s->output;

    int ret;

    /**

     * requirements

     */

    memset(&sub, 0, sizeof(sub));

    sub.type = V4L2_EVENT_SOURCE_CHANGE;

    ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);

    if ( ret < 0) {

        if (output->height == 0 || output->width == 0) {

            av_log(s->avctx, AV_LOG_ERROR,

                "the v4l2 driver does not support VIDIOC_SUBSCRIBE_EVENT\n"

                "you must provide codec_height and codec_width on input\n");

            return ret;

        }

    }

    memset(&sub, 0, sizeof(sub));

    sub.type = V4L2_EVENT_EOS;

    ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);

    if (ret < 0)

        av_log(s->avctx, AV_LOG_WARNING,

               "the v4l2 driver does not support end of stream VIDIOC_SUBSCRIBE_EVENT\n");

    return 0;

}

static int v4l2_receive_frame(AVCodecContext *avctx, AVFrame *frame)

{

    V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;

    V4L2Context *const capture = &s->capture;

    V4L2Context *const output = &s->output;

    int ret;

    if (!s->buf_pkt.size) {

        ret = ff_decode_get_packet(avctx, &s->buf_pkt);

        if (ret < 0) {

            if (ret == AVERROR(EAGAIN))

                return ff_v4l2_context_dequeue_frame(capture, frame, 0);

            else if (ret != AVERROR_EOF)

                return ret;

        }

    }

    if (s->draining)

        goto dequeue;

    ret = ff_v4l2_context_enqueue_packet(output, &s->buf_pkt);

    if (ret < 0 && ret != AVERROR(EAGAIN))

        goto fail;

    /* if EAGAIN don't unref packet and try to enqueue in the next iteration */

    if (ret != AVERROR(EAGAIN))

        av_packet_unref(&s->buf_pkt);

    if (!s->draining) {

        ret = v4l2_try_start(avctx);

        if (ret) {

            /* cant recover */

            if (ret != AVERROR(ENOMEM))

                ret = 0;

            goto fail;

        }

    }

dequeue:

    return ff_v4l2_context_dequeue_frame(capture, frame, -1);

fail:

    av_packet_unref(&s->buf_pkt);

    return ret;

}

static av_cold int v4l2_decode_init(AVCodecContext *avctx)

{

    V4L2Context *capture, *output;

    V4L2m2mContext *s;

    V4L2m2mPriv *priv = avctx->priv_data;

    int ret;

    ret = ff_v4l2_m2m_create_context(priv, &s);

    if (ret < 0)

        return ret;

    capture = &s->capture;

    output = &s->output;

    /* if these dimensions are invalid (ie, 0 or too small) an event will be raised

     * by the v4l2 driver; this event will trigger a full pipeline reconfig and

     * the proper values will be retrieved from the kernel driver.

     */

    output->height = capture->height = avctx->coded_height;

    output->width = capture->width = avctx->coded_width;

    output->av_codec_id = avctx->codec_id;

    output->av_pix_fmt  = AV_PIX_FMT_NONE;

    capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;

    capture->av_pix_fmt = avctx->pix_fmt;

    s->avctx = avctx;

    ret = ff_v4l2_m2m_codec_init(priv);

    if (ret) {

        av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");

        return ret;

    }

    return v4l2_prepare_decoder(s);

}

static av_cold int v4l2_decode_close(AVCodecContext *avctx)

{

    return ff_v4l2_m2m_codec_end(avctx->priv_data);

}

#define OFFSET(x) offsetof(V4L2m2mPriv, x)

#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

static const AVOption options[] = {

    V4L_M2M_DEFAULT_OPTS,

    { "num_capture_buffers", "Number of buffers in the capture context",

        OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 2, INT_MAX, FLAGS },

    { NULL},

};

#define M2MDEC_CLASS(NAME) \

    static const AVClass v4l2_m2m_ ## NAME ## _dec_class = { \

        .class_name = #NAME "_v4l2m2m_decoder", \

        .item_name  = av_default_item_name, \

        .option     = options, \

        .version    = LIBAVUTIL_VERSION_INT, \

    };

#define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \

    M2MDEC_CLASS(NAME) \

    const FFCodec ff_ ## NAME ## _v4l2m2m_decoder = { \

        .p.name         = #NAME "_v4l2m2m" , \

        CODEC_LONG_NAME("V4L2 mem2mem " LONGNAME " decoder wrapper"), \

        .p.type         = AVMEDIA_TYPE_VIDEO, \

        .p.id           = CODEC , \

        .priv_data_size = sizeof(V4L2m2mPriv), \

        .p.priv_class   = &v4l2_m2m_ ## NAME ## _dec_class, \

        .init           = v4l2_decode_init, \

        FF_CODEC_RECEIVE_FRAME_CB(v4l2_receive_frame), \

        .close          = v4l2_decode_close, \

        .bsfs           = bsf_name, \

        .p.capabilities = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \

        .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \

                          FF_CODEC_CAP_INIT_CLEANUP, \

        .p.wrapper_name = "v4l2m2m", \

    }

M2MDEC(h264,  "H.264", AV_CODEC_ID_H264,       "h264_mp4toannexb");

M2MDEC(hevc,  "HEVC",  AV_CODEC_ID_HEVC,       "hevc_mp4toannexb");

M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);

M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);

M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4,      NULL);

M2MDEC(h263,  "H.263", AV_CODEC_ID_H263,       NULL);

M2MDEC(vc1 ,  "VC1",   AV_CODEC_ID_VC1,        NULL);

M2MDEC(vp8,   "VP8",   AV_CODEC_ID_VP8,        NULL);

M2MDEC(vp9,   "VP9",   AV_CODEC_ID_VP9,        NULL);