/*
 * 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
 */

/**
 * @file
 * Packet sink. Heavily based on libavfilter/buffersink.c
 */

#include "libavutil/avassert.h"
#include "libavutil/opt.h"

#include "libavcodec/bsf.h"
#include "libavcodec/bsf_internal.h"
#include "libavcodec/packet.h"
#include "libavcodec/packet_internal.h"

typedef struct BufferSinkContext {
    const AVClass *class;
    unsigned warning_limit;

    AVPacket *peeked_pkt;
} BufferSinkContext;

static int return_or_keep_packet(BufferSinkContext *buf, AVPacket *out, AVPacket *in, int flags)
{
    if ((flags & AV_BSF_SINK_FLAG_PEEK)) {
        buf->peeked_pkt = in;
        return av_packet_ref(out, in);
    } else {
        buf->peeked_pkt = NULL;
        av_packet_move_ref(out, in);
        av_packet_free(&in);
        return 0;
    }
}

int attribute_align_arg av_bsf_sink_get_packet(AVBitStreamFilterContext *ctx, AVPacket *pkt, int flags)
{
    BufferSinkContext *buf = ctx->priv_data;
    AVBitStreamFilterLink *inlink = ctx->inputs[0];
    BitStreamFilterLinkInternal *li = ff_link_internal(inlink);
    int status, ret;
    AVPacket *cur_pkt;
    int64_t pts;
    int buffersrc_empty = 0;

    if (buf->peeked_pkt)
        return return_or_keep_packet(buf, pkt, buf->peeked_pkt, flags);

    while (1) {
        ret = ff_bsf_inlink_consume_packet(inlink, &cur_pkt);
        if (ret < 0) {
            return ret;
        } else if (ret) {
            return return_or_keep_packet(buf, pkt, cur_pkt, flags);
        } else if (ff_bsf_inlink_acknowledge_status(inlink, &status, &pts)) {
            return status;
        } else if ((flags & AV_BSF_SINK_FLAG_NO_REQUEST)) {
            return AVERROR(EAGAIN);
        } else if (li->packet_wanted_out) {
            ret = ff_bsf_graph_run_once(ctx->graph);
            if (ret == FFERROR_SOURCE_EMPTY) {
                buffersrc_empty = 1;
            } else if (ret == AVERROR(EAGAIN)) {
                if (buffersrc_empty)
                    return ret;
                ff_bsf_inlink_request_packet(inlink);
            } else if (ret < 0) {
                return ret;
            }
        } else {
            ff_bsf_inlink_request_packet(inlink);
        }
    }
}

static int init(AVBitStreamFilterContext *ctx)
{
    BufferSinkContext *s = ctx->priv_data;

    s->warning_limit = 100;

    return 0;
}

static void uninit(AVBitStreamFilterContext *ctx)
{
    BufferSinkContext *buf = ctx->priv_data;

    av_packet_free(&buf->peeked_pkt);
}

static int activate(AVBitStreamFilterContext *ctx)
{
    BufferSinkContext *buf = ctx->priv_data;
    BitStreamFilterLinkInternal * const li = ff_link_internal(ctx->inputs[0]);

    if (buf->warning_limit &&
        av_container_fifo_can_read(li->fifo) >= buf->warning_limit) {
        av_log(ctx, AV_LOG_WARNING,
               "%d buffers queued in %s, something may be wrong.\n",
               buf->warning_limit,
               (char *)av_x_if_null(ctx->name, ctx->filter->name));
        buf->warning_limit *= 10;
    }

    /* The packet is queued, the rest is up to av_bsf_sink_get_packet */
    return 0;
}

AVRational av_bsf_sink_get_time_base(const AVBitStreamFilterContext *ctx)
{
    av_assert0(ff_bsf(ctx->filter)->activate == activate);
    return ctx->inputs[0]->time_base;
}

const AVCodecParameters *av_bsf_sink_get_parameters(const AVBitStreamFilterContext *ctx)
{
    av_assert0(ff_bsf(ctx->filter)->activate == activate);
    return ctx->inputs[0]->par;
}

BSF_DEFINE_CLASS_EXT(sink, "sink", NULL);

const FFBitStreamFilter ff_sink_bsf = {
    .p.name        = "sink",
    .p.priv_class  = &sink_class,
    .priv_data_size = sizeof(BufferSinkContext),
    .init2         = init,
    .uninit        = uninit,
    .activate      = activate,
    BSFILTER_INPUTS(ff_default_bsf_pad),
};