Traneptora/FFmpeg
1
Fork 0
forked from FFmpeg/FFmpeg
Code Pull requests Activity

avfilter/ccfifo: remove unnecessary context allocations

Browse source 
This is not public API, no it has no need for an alloc() and free()
functions. The struct can reside on stack.

Signed-off-by: James Almer <jamrial@gmail.com>
This commit is contained in:
James Almer 2023-05-11 14:34:57 -03:00
parent 86ee031795
commit 7f890b2fbb
13 changed files with 89 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libavdevice/decklink_common.h
View file

@ -113,7 +113,7 @@ struct decklink_ctx {
/* Capture buffer queue */ /* Capture buffer queue */
DecklinkPacketQueue queue; DecklinkPacketQueue queue;
AVCCFifo *cc_fifo; ///< closed captions CCFifo cc_fifo; ///< closed captions
/* Streams present */ /* Streams present */
int audio; int audio;

14
libavdevice/decklink_enc.cpp
View file

@ -371,7 +371,7 @@ av_cold int ff_decklink_write_trailer(AVFormatContext *avctx)
klvanc_context_destroy(ctx->vanc_ctx); klvanc_context_destroy(ctx->vanc_ctx);
#endif #endif
ff_ccfifo_freep(&ctx->cc_fifo); ff_ccfifo_uninit(&ctx->cc_fifo);
av_freep(&cctx->ctx); av_freep(&cctx->ctx);
return 0; return 0;
@ -527,15 +527,15 @@ out:
that will later be handled by construct_cc... */ that will later be handled by construct_cc... */
static void parse_608subs(AVFormatContext *avctx, struct decklink_ctx *ctx, AVPacket *pkt) static void parse_608subs(AVFormatContext *avctx, struct decklink_ctx *ctx, AVPacket *pkt)
{ {
size_t cc_size = ff_ccfifo_getoutputsize(ctx->cc_fifo); size_t cc_size = ff_ccfifo_getoutputsize(&ctx->cc_fifo);
uint8_t *cc_data; uint8_t *cc_data;
if (!ff_ccfifo_ccdetected(ctx->cc_fifo)) if (!ff_ccfifo_ccdetected(&ctx->cc_fifo))
return; return;
cc_data = av_packet_new_side_data(pkt, AV_PKT_DATA_A53_CC, cc_size); cc_data = av_packet_new_side_data(pkt, AV_PKT_DATA_A53_CC, cc_size);
if (cc_data) if (cc_data)
ff_ccfifo_injectbytes(ctx->cc_fifo, cc_data, cc_size); ff_ccfifo_injectbytes(&ctx->cc_fifo, cc_data, cc_size);
} }
static int decklink_construct_vanc(AVFormatContext *avctx, struct decklink_ctx *ctx, static int decklink_construct_vanc(AVFormatContext *avctx, struct decklink_ctx *ctx,
@ -745,7 +745,7 @@ static int decklink_write_subtitle_packet(AVFormatContext *avctx, AVPacket *pkt)
struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data; struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx; struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
ff_ccfifo_extractbytes(ctx->cc_fifo, pkt->data, pkt->size); ff_ccfifo_extractbytes(&ctx->cc_fifo, pkt->data, pkt->size);
return 0; return 0;
} }
@ -831,9 +831,9 @@ av_cold int ff_decklink_write_header(AVFormatContext *avctx)
avpriv_set_pts_info(st, 64, ctx->bmd_tb_num, ctx->bmd_tb_den); avpriv_set_pts_info(st, 64, ctx->bmd_tb_num, ctx->bmd_tb_den);
} }
if (!(ctx->cc_fifo = ff_ccfifo_alloc(av_make_q(ctx->bmd_tb_den, ctx->bmd_tb_num), avctx))) { ret = ff_ccfifo_init(&ctx->cc_fifo, av_make_q(ctx->bmd_tb_den, ctx->bmd_tb_num), avctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
ret = AVERROR(ENOMEM);
goto error; goto error;
} }

49
libavfilter/ccfifo.c
View file

@ -23,18 +23,6 @@
#include "ccfifo.h" #include "ccfifo.h"
struct AVCCFifo {
AVFifo *cc_608_fifo;
AVFifo *cc_708_fifo;
AVRational framerate;
int expected_cc_count;
int expected_608;
int cc_detected;
int passthrough;
int passthrough_warning;
void *log_ctx;
};
#define MAX_CC_ELEMENTS 128 #define MAX_CC_ELEMENTS 128
#define CC_BYTES_PER_ENTRY 3 #define CC_BYTES_PER_ENTRY 3
@ -55,25 +43,18 @@ const static struct cc_lookup cc_lookup_vals[] = {
{ 60000, 1001, 10, 1}, { 60000, 1001, 10, 1},
}; };
void ff_ccfifo_freep(AVCCFifo **ccf) void ff_ccfifo_uninit(CCFifo *ccf)
{ {
AVCCFifo *tmp = *ccf; av_fifo_freep2(&ccf->cc_608_fifo);
if (tmp) { av_fifo_freep2(&ccf->cc_708_fifo);
av_fifo_freep2(&tmp->cc_608_fifo); memset(ccf, 0, sizeof(*ccf));
av_fifo_freep2(&tmp->cc_708_fifo);
}
av_freep(ccf);
} }
AVCCFifo *ff_ccfifo_alloc(AVRational framerate, void *log_ctx) int ff_ccfifo_init(CCFifo *ccf, AVRational framerate, void *log_ctx)
{ {
AVCCFifo *ccf;
int i; int i;
ccf = av_mallocz(sizeof(*ccf)); memset(ccf, 0, sizeof(*ccf));
if (!ccf)
return NULL;
ccf->log_ctx = log_ctx; ccf->log_ctx = log_ctx;
ccf->framerate = framerate; ccf->framerate = framerate;
@ -101,24 +82,24 @@ AVCCFifo *ff_ccfifo_alloc(AVRational framerate, void *log_ctx)
ccf->passthrough = 1; ccf->passthrough = 1;
} }
return ccf; return 0;
error: error:
ff_ccfifo_freep(&ccf); ff_ccfifo_uninit(ccf);
return NULL; return AVERROR(ENOMEM);
} }
int ff_ccfifo_getoutputsize(AVCCFifo *ccf) int ff_ccfifo_getoutputsize(CCFifo *ccf)
{ {
return ccf->expected_cc_count * CC_BYTES_PER_ENTRY; return ccf->expected_cc_count * CC_BYTES_PER_ENTRY;
} }
int ff_ccfifo_ccdetected(AVCCFifo *ccf) int ff_ccfifo_ccdetected(CCFifo *ccf)
{ {
return ccf->cc_detected; return ccf->cc_detected;
} }
int ff_ccfifo_injectbytes(AVCCFifo *ccf, uint8_t *cc_data, size_t len) int ff_ccfifo_injectbytes(CCFifo *ccf, uint8_t *cc_data, size_t len)
{ {
int cc_608_tuples = 0; int cc_608_tuples = 0;
int cc_708_tuples = 0; int cc_708_tuples = 0;
@ -159,7 +140,7 @@ int ff_ccfifo_injectbytes(AVCCFifo *ccf, uint8_t *cc_data, size_t len)
return 0; return 0;
} }
int ff_ccfifo_inject(AVCCFifo *ccf, AVFrame *frame) int ff_ccfifo_inject(CCFifo *ccf, AVFrame *frame)
{ {
AVFrameSideData *sd; AVFrameSideData *sd;
int ret; int ret;
@ -180,7 +161,7 @@ int ff_ccfifo_inject(AVCCFifo *ccf, AVFrame *frame)
return 0; return 0;
} }
int ff_ccfifo_extractbytes(AVCCFifo *ccf, uint8_t *cc_bytes, size_t len) int ff_ccfifo_extractbytes(CCFifo *ccf, uint8_t *cc_bytes, size_t len)
{ {
int cc_count = len / CC_BYTES_PER_ENTRY; int cc_count = len / CC_BYTES_PER_ENTRY;
@ -209,7 +190,7 @@ int ff_ccfifo_extractbytes(AVCCFifo *ccf, uint8_t *cc_bytes, size_t len)
/* Read the A53 side data, discard padding, and put 608/708 into /* Read the A53 side data, discard padding, and put 608/708 into
queues so we can ensure they get into the output frames at queues so we can ensure they get into the output frames at
the correct rate... */ the correct rate... */
int ff_ccfifo_extract(AVCCFifo *ccf, AVFrame *frame) int ff_ccfifo_extract(CCFifo *ccf, AVFrame *frame)
{ {
AVFrameSideData *side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC); AVFrameSideData *side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC);
if (side_data) { if (side_data) {

42
libavfilter/ccfifo.h
View file

@ -33,25 +33,33 @@
#include "libavutil/frame.h" #include "libavutil/frame.h"
#include "libavutil/fifo.h" #include "libavutil/fifo.h"
typedef struct AVCCFifo AVCCFifo; typedef struct CCFifo {
AVFifo *cc_608_fifo;
AVFifo *cc_708_fifo;
AVRational framerate;
int expected_cc_count;
int expected_608;
int cc_detected;
int passthrough;
int passthrough_warning;
void *log_ctx;
} CCFifo;
/** /**
* Allocate an AVCCFifo. * Initialize a CCFifo.
* *
* @param framerate output framerate * @param framerate output framerate
* @param log_ctx used for any av_log() calls * @param log_ctx used for any av_log() calls
* @return newly allocated AVCCFifo, or NULL on error * @return Zero on success, or negative AVERROR code on failure.
*/ */
AVCCFifo *ff_ccfifo_alloc(AVRational framerate, void *log_ctx); int ff_ccfifo_init(CCFifo *ccf, AVRational framerate, void *log_ctx);
/** /**
* Free an AVCCFifo * Free all memory allocated in a CCFifo and clear the context.
* *
* @param ccf Pointer to the pointer to the AVCCFifo which should be freed * @param ccf Pointer to the CCFifo which should be uninitialized
* @note `*ptr = NULL` is safe and leads to no action.
*/ */
void ff_ccfifo_freep(AVCCFifo **ccf); void ff_ccfifo_uninit(CCFifo *ccf);
/** /**
* Extract CC data from an AVFrame * Extract CC data from an AVFrame
@ -61,17 +69,17 @@ void ff_ccfifo_freep(AVCCFifo **ccf);
* as it will be re-inserted at the appropriate rate later in the * as it will be re-inserted at the appropriate rate later in the
* filter. * filter.
* *
* @param af AVCCFifo to write to * @param af CCFifo to write to
* @param frame AVFrame with the video frame to operate on * @param frame AVFrame with the video frame to operate on
* @return Zero on success, or negative AVERROR * @return Zero on success, or negative AVERROR
* code on failure. * code on failure.
*/ */
int ff_ccfifo_extract(AVCCFifo *ccf, AVFrame *frame); int ff_ccfifo_extract(CCFifo *ccf, AVFrame *frame);
/** /**
*Just like ff_ccfifo_extract(), but takes the raw bytes instead of an AVFrame *Just like ff_ccfifo_extract(), but takes the raw bytes instead of an AVFrame
*/ */
int ff_ccfifo_extractbytes(AVCCFifo *ccf, uint8_t *data, size_t len); int ff_ccfifo_extractbytes(CCFifo *ccf, uint8_t *data, size_t len);
/** /**
* Provide the size in bytes of an output buffer to allocate * Provide the size in bytes of an output buffer to allocate
@ -80,7 +88,7 @@ int ff_ccfifo_extractbytes(AVCCFifo *ccf, uint8_t *data, size_t len);
* an appropriately sized buffer and pass it to ff_ccfifo_injectbytes() * an appropriately sized buffer and pass it to ff_ccfifo_injectbytes()
* *
*/ */
int ff_ccfifo_getoutputsize(AVCCFifo *ccf); int ff_ccfifo_getoutputsize(CCFifo *ccf);
/** /**
* Insert CC data from the FIFO into an AVFrame (as side data) * Insert CC data from the FIFO into an AVFrame (as side data)
@ -88,23 +96,23 @@ int ff_ccfifo_getoutputsize(AVCCFifo *ccf);
* Dequeue the appropriate number of CC tuples based on the * Dequeue the appropriate number of CC tuples based on the
* frame rate, and insert them into the AVFrame * frame rate, and insert them into the AVFrame
* *
* @param af AVCCFifo to read from * @param af CCFifo to read from
* @param frame AVFrame with the video frame to operate on * @param frame AVFrame with the video frame to operate on
* @return Zero on success, or negative AVERROR * @return Zero on success, or negative AVERROR
* code on failure. * code on failure.
*/ */
int ff_ccfifo_inject(AVCCFifo *ccf, AVFrame *frame); int ff_ccfifo_inject(CCFifo *ccf, AVFrame *frame);
/** /**
* Just like ff_ccfifo_inject(), but takes the raw bytes to insert the CC data * Just like ff_ccfifo_inject(), but takes the raw bytes to insert the CC data
* int rather than an AVFrame * int rather than an AVFrame
*/ */
int ff_ccfifo_injectbytes(AVCCFifo *ccf, uint8_t *data, size_t len); int ff_ccfifo_injectbytes(CCFifo *ccf, uint8_t *data, size_t len);
/** /**
* Returns 1 if captions have been found as a prior call * Returns 1 if captions have been found as a prior call
* to ff_ccfifo_extract() or ff_ccfifo_extractbytes() * to ff_ccfifo_extract() or ff_ccfifo_extractbytes()
*/ */
int ff_ccfifo_ccdetected(AVCCFifo *ccf); int ff_ccfifo_ccdetected(CCFifo *ccf);
#endif /* AVFILTER_CCFIFO_H */ #endif /* AVFILTER_CCFIFO_H */

2
libavfilter/tinterlace.h
View file

@ -78,7 +78,7 @@ typedef struct TInterlaceContext {
const AVPixFmtDescriptor *csp; const AVPixFmtDescriptor *csp;
void (*lowpass_line)(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp, void (*lowpass_line)(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
ptrdiff_t mref, ptrdiff_t pref, int clip_max); ptrdiff_t mref, ptrdiff_t pref, int clip_max);
AVCCFifo *cc_fifo; CCFifo cc_fifo;
} TInterlaceContext; } TInterlaceContext;
void ff_tinterlace_init_x86(TInterlaceContext *interlace); void ff_tinterlace_init_x86(TInterlaceContext *interlace);

8
libavfilter/vf_bwdif.c
View file

@ -297,7 +297,7 @@ static av_cold void uninit(AVFilterContext *ctx)
av_frame_free(&yadif->prev); av_frame_free(&yadif->prev);
av_frame_free(&yadif->cur ); av_frame_free(&yadif->cur );
av_frame_free(&yadif->next); av_frame_free(&yadif->next);
ff_ccfifo_freep(&yadif->cc_fifo); ff_ccfifo_uninit(&yadif->cc_fifo);
} }
static const enum AVPixelFormat pix_fmts[] = { static const enum AVPixelFormat pix_fmts[] = {
@ -326,6 +326,7 @@ static int config_props(AVFilterLink *link)
AVFilterContext *ctx = link->src; AVFilterContext *ctx = link->src;
BWDIFContext *s = link->src->priv; BWDIFContext *s = link->src->priv;
YADIFContext *yadif = &s->yadif; YADIFContext *yadif = &s->yadif;
int ret;
link->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2}); link->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2});
link->w = link->src->inputs[0]->w; link->w = link->src->inputs[0]->w;
@ -336,9 +337,10 @@ static int config_props(AVFilterLink *link)
else else
link->frame_rate = ctx->inputs[0]->frame_rate; link->frame_rate = ctx->inputs[0]->frame_rate;
if (!(yadif->cc_fifo = ff_ccfifo_alloc(link->frame_rate, ctx))) { ret = ff_ccfifo_init(&yadif->cc_fifo, link->frame_rate, ctx);
if (ret < 0 ) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
return AVERROR(ENOMEM); return ret;
} }
if (link->w < 3 || link->h < 4) { if (link->w < 3 || link->h < 4) {

13
libavfilter/vf_ccrepack.c
View file

@ -37,7 +37,7 @@
typedef struct CCRepackContext typedef struct CCRepackContext
{ {
const AVClass *class; const AVClass *class;
AVCCFifo *cc_fifo; CCFifo cc_fifo;
} CCRepackContext; } CCRepackContext;
static const AVOption ccrepack_options[] = { static const AVOption ccrepack_options[] = {
@ -50,9 +50,10 @@ static int config_input(AVFilterLink *link)
{ {
CCRepackContext *ctx = link->dst->priv; CCRepackContext *ctx = link->dst->priv;
if (!(ctx->cc_fifo = ff_ccfifo_alloc(link->frame_rate, ctx))) { int ret = ff_ccfifo_init(&ctx->cc_fifo, link->frame_rate, ctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
return AVERROR(ENOMEM); return ret;
} }
return 0; return 0;
@ -63,8 +64,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
CCRepackContext *ctx = inlink->dst->priv; CCRepackContext *ctx = inlink->dst->priv;
AVFilterLink *outlink = inlink->dst->outputs[0]; AVFilterLink *outlink = inlink->dst->outputs[0];
ff_ccfifo_extract(ctx->cc_fifo, frame); ff_ccfifo_extract(&ctx->cc_fifo, frame);
ff_ccfifo_inject(ctx->cc_fifo, frame); ff_ccfifo_inject(&ctx->cc_fifo, frame);
return ff_filter_frame(outlink, frame); return ff_filter_frame(outlink, frame);
} }
@ -72,7 +73,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
static av_cold void uninit(AVFilterContext *ctx) static av_cold void uninit(AVFilterContext *ctx)
{ {
CCRepackContext *s = ctx->priv; CCRepackContext *s = ctx->priv;
ff_ccfifo_freep(&s->cc_fifo); ff_ccfifo_uninit(&s->cc_fifo);
} }
static const AVFilterPad avfilter_vf_ccrepack_inputs[] = { static const AVFilterPad avfilter_vf_ccrepack_inputs[] = {

13
libavfilter/vf_fps.c
View file

@ -86,7 +86,7 @@ typedef struct FPSContext {
AVFrame *frames[2]; ///< buffered frames AVFrame *frames[2]; ///< buffered frames
int frames_count; ///< number of buffered frames int frames_count; ///< number of buffered frames
AVCCFifo *cc_fifo; ///< closed captions CCFifo cc_fifo; ///< closed captions
int64_t next_pts; ///< pts of the next frame to output int64_t next_pts; ///< pts of the next frame to output
@ -167,7 +167,7 @@ static av_cold void uninit(AVFilterContext *ctx)
frame = shift_frame(ctx, s); frame = shift_frame(ctx, s);
av_frame_free(&frame); av_frame_free(&frame);
} }
ff_ccfifo_freep(&s->cc_fifo); ff_ccfifo_uninit(&s->cc_fifo);
av_log(ctx, AV_LOG_VERBOSE, "%d frames in, %d frames out; %d frames dropped, " av_log(ctx, AV_LOG_VERBOSE, "%d frames in, %d frames out; %d frames dropped, "
"%d frames duplicated.\n", s->frames_in, s->frames_out, s->drop, s->dup); "%d frames duplicated.\n", s->frames_in, s->frames_out, s->drop, s->dup);
@ -213,9 +213,10 @@ static int config_props(AVFilterLink* outlink)
s->in_pts_off, s->out_pts_off, s->start_time); s->in_pts_off, s->out_pts_off, s->start_time);
} }
if (!(s->cc_fifo = ff_ccfifo_alloc(outlink->frame_rate, ctx))) { ret = ff_ccfifo_init(&s->cc_fifo, outlink->frame_rate, ctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
return AVERROR(ENOMEM); return ret;
} }
av_log(ctx, AV_LOG_VERBOSE, "fps=%d/%d\n", outlink->frame_rate.num, outlink->frame_rate.den); av_log(ctx, AV_LOG_VERBOSE, "fps=%d/%d\n", outlink->frame_rate.num, outlink->frame_rate.den);
@ -250,7 +251,7 @@ static int read_frame(AVFilterContext *ctx, FPSContext *s, AVFilterLink *inlink,
av_log(ctx, AV_LOG_DEBUG, "Read frame with in pts %"PRId64", out pts %"PRId64"\n", av_log(ctx, AV_LOG_DEBUG, "Read frame with in pts %"PRId64", out pts %"PRId64"\n",
in_pts, frame->pts); in_pts, frame->pts);
ff_ccfifo_extract(s->cc_fifo, frame); ff_ccfifo_extract(&s->cc_fifo, frame);
s->frames[s->frames_count++] = frame; s->frames[s->frames_count++] = frame;
s->frames_in++; s->frames_in++;
@ -298,7 +299,7 @@ static int write_frame(AVFilterContext *ctx, FPSContext *s, AVFilterLink *outlin
if (!frame) if (!frame)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
// Make sure Closed Captions will not be duplicated // Make sure Closed Captions will not be duplicated
ff_ccfifo_inject(s->cc_fifo, frame); ff_ccfifo_inject(&s->cc_fifo, frame);
frame->pts = s->next_pts++; frame->pts = s->next_pts++;
frame->duration = 1; frame->duration = 1;

18
libavfilter/vf_tinterlace.c
View file

@ -203,7 +203,7 @@ static av_cold void uninit(AVFilterContext *ctx)
av_frame_free(&tinterlace->next); av_frame_free(&tinterlace->next);
av_freep(&tinterlace->black_data[0][0]); av_freep(&tinterlace->black_data[0][0]);
av_freep(&tinterlace->black_data[1][0]); av_freep(&tinterlace->black_data[1][0]);
ff_ccfifo_freep(&tinterlace->cc_fifo); ff_ccfifo_uninit(&tinterlace->cc_fifo);
} }
static int config_out_props(AVFilterLink *outlink) static int config_out_props(AVFilterLink *outlink)
@ -212,7 +212,7 @@ static int config_out_props(AVFilterLink *outlink)
AVFilterLink *inlink = outlink->src->inputs[0]; AVFilterLink *inlink = outlink->src->inputs[0];
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format); const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
TInterlaceContext *tinterlace = ctx->priv; TInterlaceContext *tinterlace = ctx->priv;
int i; int ret, i;
tinterlace->vsub = desc->log2_chroma_h; tinterlace->vsub = desc->log2_chroma_h;
outlink->w = inlink->w; outlink->w = inlink->w;
@ -224,7 +224,6 @@ static int config_out_props(AVFilterLink *outlink)
if (tinterlace->mode == MODE_PAD) { if (tinterlace->mode == MODE_PAD) {
uint8_t black[4] = { 0, 0, 0, 16 }; uint8_t black[4] = { 0, 0, 0, 16 };
int ret;
ff_draw_init(&tinterlace->draw, outlink->format, 0); ff_draw_init(&tinterlace->draw, outlink->format, 0);
ff_draw_color(&tinterlace->draw, &tinterlace->color, black); ff_draw_color(&tinterlace->draw, &tinterlace->color, black);
/* limited range */ /* limited range */
@ -292,9 +291,10 @@ static int config_out_props(AVFilterLink *outlink)
#endif #endif
} }
if (!(tinterlace->cc_fifo = ff_ccfifo_alloc(outlink->frame_rate, ctx))) { ret = ff_ccfifo_init(&tinterlace->cc_fifo, outlink->frame_rate, ctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
return AVERROR(ENOMEM); return ret;
} }
av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n", tinterlace->mode, av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n", tinterlace->mode,
@ -381,7 +381,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
tinterlace->cur = tinterlace->next; tinterlace->cur = tinterlace->next;
tinterlace->next = picref; tinterlace->next = picref;
ff_ccfifo_extract(tinterlace->cc_fifo, picref); ff_ccfifo_extract(&tinterlace->cc_fifo, picref);
cur = tinterlace->cur; cur = tinterlace->cur;
next = tinterlace->next; next = tinterlace->next;
@ -464,7 +464,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
if (!out) if (!out)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
out->pts /= 2; // adjust pts to new framerate out->pts /= 2; // adjust pts to new framerate
ff_ccfifo_inject(tinterlace->cc_fifo, out); ff_ccfifo_inject(&tinterlace->cc_fifo, out);
ret = ff_filter_frame(outlink, out); ret = ff_filter_frame(outlink, out);
return ret; return ret;
} }
@ -514,7 +514,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
out->pts = cur->pts*2; out->pts = cur->pts*2;
out->pts = av_rescale_q(out->pts, tinterlace->preout_time_base, outlink->time_base); out->pts = av_rescale_q(out->pts, tinterlace->preout_time_base, outlink->time_base);
ff_ccfifo_inject(tinterlace->cc_fifo, out); ff_ccfifo_inject(&tinterlace->cc_fifo, out);
if ((ret = ff_filter_frame(outlink, out)) < 0) if ((ret = ff_filter_frame(outlink, out)) < 0)
return ret; return ret;
@ -559,7 +559,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
out->pts = av_rescale_q(out->pts, tinterlace->preout_time_base, outlink->time_base); out->pts = av_rescale_q(out->pts, tinterlace->preout_time_base, outlink->time_base);
out->duration = av_rescale_q(1, av_inv_q(outlink->frame_rate), outlink->time_base); out->duration = av_rescale_q(1, av_inv_q(outlink->frame_rate), outlink->time_base);
ff_ccfifo_inject(tinterlace->cc_fifo, out); ff_ccfifo_inject(&tinterlace->cc_fifo, out);
ret = ff_filter_frame(outlink, out); ret = ff_filter_frame(outlink, out);
return ret; return ret;

8
libavfilter/vf_yadif.c
View file

@ -261,7 +261,7 @@ static av_cold void uninit(AVFilterContext *ctx)
av_frame_free(&yadif->prev); av_frame_free(&yadif->prev);
av_frame_free(&yadif->cur ); av_frame_free(&yadif->cur );
av_frame_free(&yadif->next); av_frame_free(&yadif->next);
ff_ccfifo_freep(&yadif->cc_fifo); ff_ccfifo_uninit(&yadif->cc_fifo);
} }
static const enum AVPixelFormat pix_fmts[] = { static const enum AVPixelFormat pix_fmts[] = {
@ -286,6 +286,7 @@ static int config_output(AVFilterLink *outlink)
{ {
AVFilterContext *ctx = outlink->src; AVFilterContext *ctx = outlink->src;
YADIFContext *s = ctx->priv; YADIFContext *s = ctx->priv;
int ret;
outlink->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2}); outlink->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2});
outlink->w = ctx->inputs[0]->w; outlink->w = ctx->inputs[0]->w;
@ -297,9 +298,10 @@ static int config_output(AVFilterLink *outlink)
else else
outlink->frame_rate = ctx->inputs[0]->frame_rate; outlink->frame_rate = ctx->inputs[0]->frame_rate;
if (!(s->cc_fifo = ff_ccfifo_alloc(outlink->frame_rate, ctx))) { ret = ff_ccfifo_init(&s->cc_fifo, outlink->frame_rate, ctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
return AVERROR(ENOMEM); return ret;
} }
if (outlink->w < 3 || outlink->h < 3) { if (outlink->w < 3 || outlink->h < 3) {

6
libavfilter/vf_yadif_cuda.c
View file

@ -205,7 +205,7 @@ static av_cold void deint_cuda_uninit(AVFilterContext *ctx)
av_frame_free(&y->prev); av_frame_free(&y->prev);
av_frame_free(&y->cur); av_frame_free(&y->cur);
av_frame_free(&y->next); av_frame_free(&y->next);
ff_ccfifo_freep(&y->cc_fifo); ff_ccfifo_uninit(&y->cc_fifo);
av_buffer_unref(&s->device_ref); av_buffer_unref(&s->device_ref);
s->hwctx = NULL; s->hwctx = NULL;
@ -295,9 +295,9 @@ static int config_output(AVFilterLink *link)
else else
link->frame_rate = ctx->inputs[0]->frame_rate; link->frame_rate = ctx->inputs[0]->frame_rate;
if (!(y->cc_fifo = ff_ccfifo_alloc(link->frame_rate, ctx))) { ret = ff_ccfifo_init(&y->cc_fifo, link->frame_rate, ctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n"); av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
ret = AVERROR(ENOMEM);
goto exit; goto exit;
} }

2
libavfilter/yadif.h
View file

@ -77,7 +77,7 @@ typedef struct YADIFContext {
int eof; int eof;
uint8_t *temp_line; uint8_t *temp_line;
int temp_line_size; int temp_line_size;
AVCCFifo *cc_fifo; CCFifo cc_fifo;
/* /*
* An algorithm that treats first and/or last fields in a sequence * An algorithm that treats first and/or last fields in a sequence

6
libavfilter/yadif_common.c
View file

@ -66,7 +66,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
} }
} }
ff_ccfifo_inject(yadif->cc_fifo, yadif->out); ff_ccfifo_inject(&yadif->cc_fifo, yadif->out);
ret = ff_filter_frame(ctx->outputs[0], yadif->out); ret = ff_filter_frame(ctx->outputs[0], yadif->out);
yadif->frame_pending = (yadif->mode&1) && !is_second; yadif->frame_pending = (yadif->mode&1) && !is_second;
@ -103,7 +103,7 @@ int ff_yadif_filter_frame(AVFilterLink *link, AVFrame *frame)
av_assert0(frame); av_assert0(frame);
ff_ccfifo_extract(yadif->cc_fifo, frame); ff_ccfifo_extract(&yadif->cc_fifo, frame);
if (yadif->frame_pending) if (yadif->frame_pending)
return_frame(ctx, 1); return_frame(ctx, 1);
@ -146,7 +146,7 @@ int ff_yadif_filter_frame(AVFilterLink *link, AVFrame *frame)
if (!yadif->out) if (!yadif->out)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ff_ccfifo_inject(yadif->cc_fifo, yadif->out); ff_ccfifo_inject(&yadif->cc_fifo, yadif->out);
av_frame_free(&yadif->prev); av_frame_free(&yadif->prev);
if (yadif->out->pts != AV_NOPTS_VALUE) if (yadif->out->pts != AV_NOPTS_VALUE)
yadif->out->pts *= 2; yadif->out->pts *= 2;