FFmpeg/libavcodec/bsf/source.c

/*
 * 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 source. Heavily based on libavfilter/buffersrc.c
 */

#include <float.h>

#include "libavutil/container_fifo.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 SourceContext {
    const AVClass    *class;
    AVCodecParameters *par;
    AVRational        time_base;     ///< time_base to set in the output link

    unsigned          nb_failed_requests;
    unsigned          warning_limit;

    int eof;
    int64_t last_pts;
} SourceContext;

int av_bsf_source_parameters_set(AVBitStreamFilterContext *ctx, const AVCodecParameters *par)
{
    SourceContext *s = ctx->priv_data;

    return avcodec_parameters_copy(s->par, par);
}

static int push_packet(AVBitStreamFilterGraph *graph)
{
    int ret;

    while (1) {
        ret = ff_bsf_graph_run_once(graph);
        if (ret == AVERROR(EAGAIN))
            break;
        if (ret < 0 && ret != FFERROR_SOURCE_EMPTY)
            return ret;
    }
    return 0;
}

int attribute_align_arg av_bsf_source_add_packet(AVBitStreamFilterContext *ctx, AVPacket *pkt, int flags)
{
    SourceContext *s = ctx->priv_data;
    AVPacket *copy;
    int ret;

    s->nb_failed_requests = 0;

    if (!pkt || AVPACKET_IS_EMPTY(pkt))
        return av_bsf_source_close(ctx, s->last_pts, flags);
    if (s->eof)
        return AVERROR_EOF;

    s->last_pts = pkt->pts + pkt->duration;

    copy = av_packet_alloc();
    if (!copy)
        return AVERROR(ENOMEM);

    if ((flags & AV_BSF_SOURCE_FLAG_KEEP_REF)) {
        ret = av_packet_ref(copy, pkt);
        if (ret < 0) {
            av_packet_free(&copy);
            return ret;
        }
    } else
        av_packet_move_ref(copy, pkt);

    ret = ff_bsf_filter_packet(ctx->outputs[0], copy);
    if (ret < 0)
        return ret;

    if ((flags & AV_BSF_SOURCE_FLAG_PUSH)) {
        ret = push_packet(ctx->graph);
        if (ret < 0)
            return ret;
    }

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

    return 0;
}

int av_bsf_source_close(AVBitStreamFilterContext *ctx, int64_t pts, unsigned flags)
{
    SourceContext *s = ctx->priv_data;

    s->eof = 1;
    ff_bsf_link_set_in_status(ctx->outputs[0], AVERROR_EOF, pts);
    return 0;
}

int av_bsf_source_get_status(AVBitStreamFilterContext *ctx)
{
    SourceContext *s = ctx->priv_data;

    if (!s->eof && ff_bsf_outlink_get_status(ctx->outputs[0]))
        s->eof = 1;

    return s->eof ? AVERROR(EOF) : 0;
}

static av_cold int preinit(AVBitStreamFilterContext *ctx)
{
    SourceContext *c = ctx->priv_data;

    c->par = avcodec_parameters_alloc();
    if (!c->par)
        return AVERROR(ENOMEM);

    return 0;
}

static av_cold int init(AVBitStreamFilterContext *ctx)
{
    SourceContext *c = ctx->priv_data;

    if (av_q2d(c->time_base) <= 0) {
        av_log(ctx, AV_LOG_ERROR, "Invalid time base %d/%d\n", c->time_base.num, c->time_base.den);
        return AVERROR(EINVAL);
    }

    c->warning_limit = 100;
    return 0;
}

unsigned ff_bsf_source_get_nb_failed_requests(const AVBitStreamFilterContext *buffer_src)
{
    return ((SourceContext *)buffer_src->priv_data)->nb_failed_requests;
}

#define OFFSET(x) offsetof(SourceContext, x)
#define FLAGS (AV_OPT_FLAG_BSF_PARAM|AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
static const AVOption buffer_options[] = {
    { "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, FLAGS },
    { NULL },
};

BSF_DEFINE_CLASS(buffer);

static av_cold void uninit(AVBitStreamFilterContext *ctx)
{
    SourceContext *s = ctx->priv_data;
    avcodec_parameters_free(&s->par);
}

static int config_props(AVBitStreamFilterLink *link)
{
    SourceContext *c = link->src->priv_data;

    link->time_base = c->time_base;
    return avcodec_parameters_copy(link->par, c->par);
}

static int activate(AVBitStreamFilterContext *ctx)
{
    AVBitStreamFilterLink *outlink = ctx->outputs[0];
    SourceContext *c = ctx->priv_data;

    if (!c->eof && ff_bsf_outlink_get_status(outlink)) {
        c->eof = 1;
        return 0;
    }

    if (c->eof) {
        ff_bsf_link_set_in_status(outlink, AVERROR_EOF, c->last_pts);
        return 0;
    }
    c->nb_failed_requests++;
    return FFERROR_SOURCE_EMPTY;
}

static const AVBitStreamFilterPad source_outputs[] = {
    {
        .name          = "default",
        .config_props  = config_props,
    },
};

const FFBitStreamFilter ff_source_bsf = {
    .p.name        = "source",
    .p.priv_class  = &buffer_class,
    .priv_data_size = sizeof(SourceContext),
    .activate  = activate,
    .preinit   = preinit,
    .init2     = init,
    .uninit    = uninit,

    BSFILTER_OUTPUTS(source_outputs),
};