sigrid/ffmpeg

libavdevice/decklink_common.h+1−1

@@ -113,7 +113,7 @@ struct decklink_ctx { · 112 unmodified lines
113	/* Capture buffer queue */	113	/* Capture buffer queue */
114	DecklinkPacketQueue queue;	114	DecklinkPacketQueue queue;
115		115
116	AVCCFifo *cc_fifo; ///< closed captions	116	CCFifo cc_fifo; ///< closed captions
117		117
118	/* Streams present */	118	/* Streams present */
119	int audio;	119	int audio;

libavdevice/decklink_enc.cpp+7−7

     klvanc_context_destroy(ctx->vanc_ctx);
 #endif
-    ff_ccfifo_freep(&ctx->cc_fifo);
+    ff_ccfifo_uninit(&ctx->cc_fifo);
     av_freep(&cctx->ctx);
     return 0;
    that will later be handled by construct_cc... */
 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;
-    if (!ff_ccfifo_ccdetected(ctx->cc_fifo))
+    if (!ff_ccfifo_ccdetected(&ctx->cc_fifo))
         return;
     cc_data = av_packet_new_side_data(pkt, AV_PKT_DATA_A53_CC, cc_size);
     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,
     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
     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;
 }
             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");
-        ret = AVERROR(ENOMEM);
         goto error;
     }

libavfilter/ccfifo.c+15−34

 #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 CC_BYTES_PER_ENTRY 3
     { 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;
-    ccf = av_mallocz(sizeof(*ccf));
+    memset(ccf, 0, sizeof(*ccf));
-    if (!ccf)
-        return NULL;
     ccf->log_ctx = log_ctx;
     ccf->framerate = framerate;
         ccf->passthrough = 1;
     }
-    return ccf;
+    return 0;
 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;
 }
-int ff_ccfifo_ccdetected(AVCCFifo *ccf)
+int ff_ccfifo_ccdetected(CCFifo *ccf)
 {
     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_708_tuples = 0;
     return 0;
 }
-int ff_ccfifo_inject(AVCCFifo *ccf, AVFrame *frame)
+int ff_ccfifo_inject(CCFifo *ccf, AVFrame *frame)
 {
     AVFrameSideData *sd;
     int ret;
     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;
 /* Read the A53 side data, discard padding, and put 608/708 into
    queues so we can ensure they get into the output frames at
    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);
     if (side_data) {

libavfilter/ccfifo.h+25−17

 #include "libavutil/frame.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 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
  * as it will be re-inserted at the appropriate rate later in the
  * filter.
  *
- * @param af          AVCCFifo to write to
+ * @param af          CCFifo to write to
  * @param frame       AVFrame with the video frame to operate on
  * @return            Zero on success, or negative AVERROR
  *                    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
  */
-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
  * 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)
  * Dequeue the appropriate number of CC tuples based on the
  * 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
  * @return            Zero on success, or negative AVERROR
  *                    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
  * 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
  * to ff_ccfifo_extract() or ff_ccfifo_extractbytes()
  */
-int ff_ccfifo_ccdetected(AVCCFifo *ccf);
+int ff_ccfifo_ccdetected(CCFifo *ccf);
 #endif /* AVFILTER_CCFIFO_H */

libavfilter/tinterlace.h+1−1

@@ -78,7 +78,7 @@ typedef struct TInterlaceContext { · 77 unmodified lines
78	const AVPixFmtDescriptor *csp;	78	const AVPixFmtDescriptor *csp;
79	void (lowpass_line)(uint8_t dstp, ptrdiff_t width, const uint8_t *srcp,	79	void (lowpass_line)(uint8_t dstp, ptrdiff_t width, const uint8_t *srcp,
80	ptrdiff_t mref, ptrdiff_t pref, int clip_max);	80	ptrdiff_t mref, ptrdiff_t pref, int clip_max);
81	AVCCFifo *cc_fifo;	81	CCFifo cc_fifo;
82	} TInterlaceContext;	82	} TInterlaceContext;
83		83
84	void ff_tinterlace_init_x86(TInterlaceContext *interlace);	84	void ff_tinterlace_init_x86(TInterlaceContext *interlace);

libavfilter/vf_bwdif.c+5−3

     av_frame_free(&yadif->prev);
     av_frame_free(&yadif->cur );
     av_frame_free(&yadif->next);
-    ff_ccfifo_freep(&yadif->cc_fifo);
+    ff_ccfifo_uninit(&yadif->cc_fifo);
 }
 static const enum AVPixelFormat pix_fmts[] = {
     AVFilterContext *ctx = link->src;
     BWDIFContext *s = link->src->priv;
     YADIFContext *yadif = &s->yadif;
+    int ret;
     link->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2});
     link->w         = link->src->inputs[0]->w;
     else
         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");
-        return AVERROR(ENOMEM);
+        return ret;
     }
     if (link->w < 3 || link->h < 4) {

libavfilter/vf_ccrepack.c+7−6

 typedef struct CCRepackContext
 {
     const AVClass *class;
-    AVCCFifo *cc_fifo;
+    CCFifo cc_fifo;
 } CCRepackContext;
 static const AVOption ccrepack_options[] = {
 {
     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");
-        return AVERROR(ENOMEM);
+        return ret;
     }
     return 0;
     CCRepackContext *ctx = inlink->dst->priv;
     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);
 }
 static av_cold void uninit(AVFilterContext *ctx)
 {
     CCRepackContext *s = ctx->priv;
-    ff_ccfifo_freep(&s->cc_fifo);
+    ff_ccfifo_uninit(&s->cc_fifo);
 }
 static const AVFilterPad avfilter_vf_ccrepack_inputs[] = {

libavfilter/vf_fps.c+7−6

     AVFrame *frames[2];     ///< 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
         frame = shift_frame(ctx, s);
         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, "
            "%d frames duplicated.\n", s->frames_in, s->frames_out, s->drop, s->dup);
                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");
-        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_DEBUG, "Read frame with in pts %"PRId64", out pts %"PRId64"\n",
            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_in++;
         if (!frame)
             return AVERROR(ENOMEM);
         // 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->duration = 1;

libavfilter/vf_tinterlace.c+9−9

     av_frame_free(&tinterlace->next);
     av_freep(&tinterlace->black_data[0][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)
     AVFilterLink *inlink = outlink->src->inputs[0];
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
     TInterlaceContext *tinterlace = ctx->priv;
-    int i;
+    int ret, i;
     tinterlace->vsub = desc->log2_chroma_h;
     outlink->w = inlink->w;
     if (tinterlace->mode == MODE_PAD) {
         uint8_t black[4] = { 0, 0, 0, 16 };
-        int ret;
         ff_draw_init(&tinterlace->draw, outlink->format, 0);
         ff_draw_color(&tinterlace->draw, &tinterlace->color, black);
         /* limited range */
 #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");
-        return AVERROR(ENOMEM);
+        return ret;
     }
     av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n", tinterlace->mode,
     tinterlace->cur  = tinterlace->next;
     tinterlace->next = picref;
-    ff_ccfifo_extract(tinterlace->cc_fifo, picref);
+    ff_ccfifo_extract(&tinterlace->cc_fifo, picref);
     cur = tinterlace->cur;
     next = tinterlace->next;
             if (!out)
                 return AVERROR(ENOMEM);
             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);
             return ret;
         }
             out->pts = cur->pts*2;
         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)
             return ret;
     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);
-    ff_ccfifo_inject(tinterlace->cc_fifo, out);
+    ff_ccfifo_inject(&tinterlace->cc_fifo, out);
     ret = ff_filter_frame(outlink, out);
     return ret;

libavfilter/vf_yadif.c+5−3

     av_frame_free(&yadif->prev);
     av_frame_free(&yadif->cur );
     av_frame_free(&yadif->next);
-    ff_ccfifo_freep(&yadif->cc_fifo);
+    ff_ccfifo_uninit(&yadif->cc_fifo);
 }
 static const enum AVPixelFormat pix_fmts[] = {
 {
     AVFilterContext *ctx = outlink->src;
     YADIFContext *s = ctx->priv;
+    int ret;
     outlink->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2});
     outlink->w             = ctx->inputs[0]->w;
     else
         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");
-        return AVERROR(ENOMEM);
+        return ret;
     }
     if (outlink->w < 3 || outlink->h < 3) {

libavfilter/vf_yadif_cuda.c+3−3

     av_frame_free(&y->prev);
     av_frame_free(&y->cur);
     av_frame_free(&y->next);
-    ff_ccfifo_freep(&y->cc_fifo);
+    ff_ccfifo_uninit(&y->cc_fifo);
     av_buffer_unref(&s->device_ref);
     s->hwctx = NULL;
     else
         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");
-        ret = AVERROR(ENOMEM);
         goto exit;
     }

libavfilter/yadif.h+1−1

@@ -77,7 +77,7 @@ typedef struct YADIFContext { · 76 unmodified lines
77	int eof;	77	int eof;
78	uint8_t *temp_line;	78	uint8_t *temp_line;
79	int temp_line_size;	79	int temp_line_size;
80	AVCCFifo *cc_fifo;	80	CCFifo cc_fifo;
81		81
82	/*	82	/*
83	* An algorithm that treats first and/or last fields in a sequence	83	* An algorithm that treats first and/or last fields in a sequence

libavfilter/yadif_common.c+3−3

@@ -66,7 +66,7 @@ FF_ENABLE_DEPRECATION_WARNINGS · 65 unmodified lines
66	}	66	}
67	}	67	}
68		68
69	ff_ccfifo_inject(yadif->cc_fifo, yadif->out);	69	ff_ccfifo_inject(&yadif->cc_fifo, yadif->out);
70	ret = ff_filter_frame(ctx->outputs[0], yadif->out);	70	ret = ff_filter_frame(ctx->outputs[0], yadif->out);
71		71
72	yadif->frame_pending = (yadif->mode&1) && !is_second;	72	yadif->frame_pending = (yadif->mode&1) && !is_second;
@@ -103,7 +103,7 @@ int ff_yadif_filter_frame(AVFilterLink link, AVFrame frame) · 30 unmodified lines
103		103
104	av_assert0(frame);	104	av_assert0(frame);
105		105
106	ff_ccfifo_extract(yadif->cc_fifo, frame);	106	ff_ccfifo_extract(&yadif->cc_fifo, frame);
107		107
108	if (yadif->frame_pending)	108	if (yadif->frame_pending)
109	return_frame(ctx, 1);	109	return_frame(ctx, 1);
@@ -146,7 +146,7 @@ int ff_yadif_filter_frame(AVFilterLink link, AVFrame frame) · 36 unmodified lines
146	if (!yadif->out)	146	if (!yadif->out)
147	return AVERROR(ENOMEM);	147	return AVERROR(ENOMEM);
148		148
149	ff_ccfifo_inject(yadif->cc_fifo, yadif->out);	149	ff_ccfifo_inject(&yadif->cc_fifo, yadif->out);
150	av_frame_free(&yadif->prev);	150	av_frame_free(&yadif->prev);
151	if (yadif->out->pts != AV_NOPTS_VALUE)	151	if (yadif->out->pts != AV_NOPTS_VALUE)
152	yadif->out->pts *= 2;	152	yadif->out->pts *= 2;

avfilter/ccfifo: remove unnecessary context allocations

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code