September 2021 - ffmpeg-cvslog

avfilter/vf_guided: Fix indention
by Limin Wang 29 Sep '21

29 Sep '21

ffmpeg | branch: master | Limin Wang <lance.lmwang(a)gmail.com> | Tue Aug 17 19:36:41 2021 +0800| [31831b611b7d7f092699360e81beede86b09a5f1] | committer: Limin Wang avfilter/vf_guided: Fix indention Signed-off-by: Limin Wang <lance.lmwang(a)gmail.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=31831b611b7d7f092… --- libavfilter/vf_guided.c | 77 ++++++++++++++++++++++++------------------------- 1 file changed, 38 insertions(+), 39 deletions(-) diff --git a/libavfilter/vf_guided.c b/libavfilter/vf_guided.c index bf8be866e6..6720213219 100644 --- a/libavfilter/vf_guided.c +++ b/libavfilter/vf_guided.c @@ -110,19 +110,19 @@ static int box_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) w = (radius << 1) + 1; numPix = w * w; for (int i = slice_start;i < slice_end;i++) { - for (int j = 0;j < width;j++) { - float temp = 0.0; - for (int row = -radius;row <= radius;row++) { - for (int col = -radius;col <= radius;col++) { - int x = i + row; - int y = j + col; - x = (x < 0) ? 0 : (x >= height ? height - 1 : x); - y = (y < 0) ? 0 : (y >= width ? width - 1 : y); - temp += src[x * src_stride + y]; - } + for (int j = 0;j < width;j++) { + float temp = 0.0; + for (int row = -radius;row <= radius;row++) { + for (int col = -radius;col <= radius;col++) { + int x = i + row; + int y = j + col; + x = (x < 0) ? 0 : (x >= height ? height - 1 : x); + y = (y < 0) ? 0 : (y >= width ? width - 1 : y); + temp += src[x * src_stride + y]; + } + } + dst[i * dst_stride + j] = temp / numPix; } - dst[i * dst_stride + j] = temp / numPix; - } } return 0; } @@ -161,8 +161,7 @@ static int config_input(AVFilterLink *inlink) if (s->mode == BASIC) { s->sub = 1; - } - else if (s->mode == FAST) { + } else if (s->mode == FAST) { if (s->radius >= s->sub) s->radius = s->radius / s->sub; else { @@ -235,13 +234,13 @@ static int guided_##name(AVFilterContext *ctx, GuidedContext *s, goto end; \ } \ for (int i = 0;i < h;i++) { \ - for (int j = 0;j < w;j++) { \ - int x = i * w + j; \ - I[x] = src[(i * src_stride + j) * sub] / maxval; \ - II[x] = I[x] * I[x]; \ - P[x] = srcRef[(i * src_ref_stride + j) * sub] / maxval; \ - IP[x] = I[x] * P[x]; \ - } \ + for (int j = 0;j < w;j++) { \ + int x = i * w + j; \ + I[x] = src[(i * src_stride + j) * sub] / maxval; \ + II[x] = I[x] * I[x]; \ + P[x] = srcRef[(i * src_ref_stride + j) * sub] / maxval; \ + IP[x] = I[x] * P[x]; \ + } \ } \ \ t.width = w; \ @@ -262,13 +261,13 @@ static int guided_##name(AVFilterContext *ctx, GuidedContext *s, ff_filter_execute(ctx, s->box_slice, &t, NULL, FFMIN(h, nb_threads)); \ \ for (int i = 0;i < h;i++) { \ - for (int j = 0;j < w;j++) { \ - int x = i * w + j; \ - float varI = meanII[x] - (meanI[x] * meanI[x]); \ - float covIP = meanIP[x] - (meanI[x] * meanP[x]); \ - A[x] = covIP / (varI + eps); \ - B[x] = meanP[x] - A[x] * meanI[x]; \ - } \ + for (int j = 0;j < w;j++) { \ + int x = i * w + j; \ + float varI = meanII[x] - (meanI[x] * meanI[x]); \ + float covIP = meanIP[x] - (meanI[x] * meanP[x]); \ + A[x] = covIP / (varI + eps); \ + B[x] = meanP[x] - A[x] * meanI[x]; \ + } \ } \ \ t.src = A; \ @@ -279,11 +278,11 @@ static int guided_##name(AVFilterContext *ctx, GuidedContext *s, ff_filter_execute(ctx, s->box_slice, &t, NULL, FFMIN(h, nb_threads)); \ \ for (int i = 0;i < height;i++) { \ - for (int j = 0;j < width;j++) { \ - int x = i / sub * w + j / sub; \ - dst[i * dst_stride + j] = meanA[x] * src[i * src_stride + j] + \ - meanB[x] * maxval; \ - } \ + for (int j = 0;j < width;j++) { \ + int x = i / sub * w + j / sub; \ + dst[i * dst_stride + j] = meanA[x] * src[i * src_stride + j] + \ + meanB[x] * maxval; \ + } \ } \ end: \ av_freep(&I); \ @@ -321,13 +320,13 @@ static int filter_frame(AVFilterContext *ctx, AVFrame **out, AVFrame *in, AVFram continue; } if (s->depth <= 8) - guided_byte(ctx, s, in->data[plane], ref->data[plane], (*out)->data[plane], s->radius, s->eps, - s->planewidth[plane], s->planeheight[plane], - in->linesize[plane], ref->linesize[plane], (*out)->linesize[plane], (1 << s->depth) - 1.f); + guided_byte(ctx, s, in->data[plane], ref->data[plane], (*out)->data[plane], s->radius, s->eps, + s->planewidth[plane], s->planeheight[plane], + in->linesize[plane], ref->linesize[plane], (*out)->linesize[plane], (1 << s->depth) - 1.f); else - guided_word(ctx, s, in->data[plane], ref->data[plane], (*out)->data[plane], s->radius, s->eps, - s->planewidth[plane], s->planeheight[plane], - in->linesize[plane] / 2, ref->linesize[plane] / 2, (*out)->linesize[plane] / 2, (1 << s->depth) - 1.f); + guided_word(ctx, s, in->data[plane], ref->data[plane], (*out)->data[plane], s->radius, s->eps, + s->planewidth[plane], s->planeheight[plane], + in->linesize[plane] / 2, ref->linesize[plane] / 2, (*out)->linesize[plane] / 2, (1 << s->depth) - 1.f); } return 0;

1 0

avcodec: remove the unused low_delay
by Limin Wang 29 Sep '21

29 Sep '21

ffmpeg | branch: master | Limin Wang <lance.lmwang(a)gmail.com> | Sat Sep 18 23:10:30 2021 +0800| [e99be1735a59652828655be777de5264ef374b5d] | committer: Limin Wang avcodec: remove the unused low_delay Signed-off-by: Limin Wang <lance.lmwang(a)gmail.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=e99be1735a5965282… --- libavcodec/h264dec.c | 1 - libavcodec/mpegutils.c | 1 - libavcodec/mpegutils.h | 1 - libavcodec/mpegvideo.c | 2 +- 4 files changed, 1 insertion(+), 4 deletions(-) diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c index 5ca41cc91c..6a5bf51f5d 100644 --- a/libavcodec/h264dec.c +++ b/libavcodec/h264dec.c @@ -944,7 +944,6 @@ static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *g out->mb_type, out->qscale_table, out->motion_val, - NULL, out->mb_width, out->mb_height, out->mb_stride, 1); } } diff --git a/libavcodec/mpegutils.c b/libavcodec/mpegutils.c index e5105ecc58..4cbc474543 100644 --- a/libavcodec/mpegutils.c +++ b/libavcodec/mpegutils.c @@ -102,7 +102,6 @@ void ff_draw_horiz_band(AVCodecContext *avctx, void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2], - int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample) { if ((avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS) && mbtype_table && motion_val[0]) { diff --git a/libavcodec/mpegutils.h b/libavcodec/mpegutils.h index 5aeff47bbd..07705854b3 100644 --- a/libavcodec/mpegutils.h +++ b/libavcodec/mpegutils.h @@ -142,7 +142,6 @@ void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, */ void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2], - int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample); #endif /* AVCODEC_MPEGUTILS_H */ diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c index 5383f9dead..ba5b51955e 100644 --- a/libavcodec/mpegvideo.c +++ b/libavcodec/mpegvideo.c @@ -1417,7 +1417,7 @@ void ff_mpv_frame_end(MpegEncContext *s) void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict) { ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type, - p->qscale_table, p->motion_val, &s->low_delay, + p->qscale_table, p->motion_val, s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample); }

1 0

avfilter/vf_morpho: Rename functions to unbreak MSVC
by Andreas Rheinhardt 29 Sep '21

29 Sep '21

ffmpeg | branch: master | Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> | Wed Sep 29 09:17:46 2021 +0200| [b2538ce578ef729c5437465fd845e877d5151a39] | committer: Andreas Rheinhardt avfilter/vf_morpho: Rename functions to unbreak MSVC MSVC's headers include function-like macros min and max which collide with function pointers in vf_morpho.c, leading to compilation failures. Fix this by renaming said function pointers. Reviewed-by: Paul B Mahol <onemda(a)gmail.com> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=b2538ce578ef729c5… --- libavfilter/vf_morpho.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/libavfilter/vf_morpho.c b/libavfilter/vf_morpho.c index fd181ddaa5..e45f7522f8 100644 --- a/libavfilter/vf_morpho.c +++ b/libavfilter/vf_morpho.c @@ -49,8 +49,8 @@ typedef struct IPlane { int depth; int type_size; - void (*max)(uint8_t *c, const uint8_t *a, const uint8_t *b, int x); - void (*min)(uint8_t *c, const uint8_t *a, const uint8_t *b, int x); + void (*max_out_place)(uint8_t *c, const uint8_t *a, const uint8_t *b, int x); + void (*min_out_place)(uint8_t *c, const uint8_t *a, const uint8_t *b, int x); void (*max_in_place)(uint8_t *a, const uint8_t *b, int x); void (*min_in_place)(uint8_t *a, const uint8_t *b, int x); } IPlane; @@ -304,7 +304,7 @@ static void compute_min_row(IPlane *f, LUT *Ty, chord_set *SE, int r, int y) for (int i = 1; i < SE->Lnum; i++) { int d = SE->R[i] - SE->R[i - 1]; - f->min(Ty->arr[r][i] - Ty->pre_pad_x * f->type_size, + f->min_out_place(Ty->arr[r][i] - Ty->pre_pad_x * f->type_size, Ty->arr[r][i - 1] - Ty->pre_pad_x * f->type_size, Ty->arr[r][i - 1] + (d - Ty->pre_pad_x) * f->type_size, Ty->X + Ty->pre_pad_x - d); @@ -358,7 +358,7 @@ static void compute_max_row(IPlane *f, LUT *Ty, chord_set *SE, int r, int y) for (int i = 1; i < SE->Lnum; i++) { int d = SE->R[i] - SE->R[i - 1]; - f->max(Ty->arr[r][i] - Ty->pre_pad_x * f->type_size, + f->max_out_place(Ty->arr[r][i] - Ty->pre_pad_x * f->type_size, Ty->arr[r][i - 1] - Ty->pre_pad_x * f->type_size, Ty->arr[r][i - 1] + (d - Ty->pre_pad_x) * f->type_size, Ty->X + Ty->pre_pad_x - d); @@ -685,8 +685,8 @@ static int read_iplane(IPlane *imp, const uint8_t *dst, int dst_linesize, imp->range = R; imp->depth = depth; imp->type_size = type_size; - imp->max = type_size == 1 ? max_fun : max16_fun; - imp->min = type_size == 1 ? min_fun : min16_fun; + imp->max_out_place = type_size == 1 ? max_fun : max16_fun; + imp->min_out_place = type_size == 1 ? min_fun : min16_fun; imp->max_in_place = type_size == 1 ? maxinplace_fun : maxinplace16_fun; imp->min_in_place = type_size == 1 ? mininplace_fun : mininplace16_fun;

1 0

checkasm/hevc_pel: Fix stack buffer overreads
by Andreas Rheinhardt 29 Sep '21

29 Sep '21

ffmpeg | branch: master | Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> | Tue Sep 28 16:13:03 2021 +0200| [09408539f4ad5d79f437d9b4789c5e64ad9b424f] | committer: Andreas Rheinhardt checkasm/hevc_pel: Fix stack buffer overreads This patch increases several stack buffers in order to fix stack-buffer-overflows (e.g. in put_hevc_qpel_uni_hv_9 in line 814 of hevcdsp_template.c) detected with ASAN in the hevc_pel checkasm test. The buffers are increased by the minimal amount necessary in order not to mask potential future bugs. Reviewed-by: Martin Storsjö <martin(a)martin.st> Reviewed-by: "zhilizhao(赵志立)" <quinkblack(a)foxmail.com> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=09408539f4ad5d79f… --- tests/checkasm/hevc_pel.c | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/tests/checkasm/hevc_pel.c b/tests/checkasm/hevc_pel.c index ec24309081..43aa5cd084 100644 --- a/tests/checkasm/hevc_pel.c +++ b/tests/checkasm/hevc_pel.c @@ -40,10 +40,12 @@ static const int offsets[] = {0, 255, -1 }; do { \ uint32_t mask = pixel_mask[bit_depth - 8]; \ int k; \ - for (k = 0; k < BUF_SIZE; k += 4) { \ + for (k = 0; k < BUF_SIZE + SRC_EXTRA; k += 4) { \ uint32_t r = rnd() & mask; \ AV_WN32A(buf0 + k, r); \ AV_WN32A(buf1 + k, r); \ + if (k >= BUF_SIZE) \ + continue; \ r = rnd(); \ AV_WN32A(dst0 + k, r); \ AV_WN32A(dst1 + k, r); \ @@ -65,10 +67,13 @@ static const int offsets[] = {0, 255, -1 }; #define src0 (buf0 + 2 * 4 * MAX_PB_SIZE) /* hevc qpel functions read data from negative src pointer offsets */ #define src1 (buf1 + 2 * 4 * MAX_PB_SIZE) +/* FIXME: Does the need for SRC_EXTRA for these tests indicate a bug? */ +#define SRC_EXTRA 8 + static void checkasm_check_hevc_qpel(void) { - LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]); - LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]); + LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]); + LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]); LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]); LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]); @@ -111,8 +116,8 @@ static void checkasm_check_hevc_qpel(void) static void checkasm_check_hevc_qpel_uni(void) { - LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]); - LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]); + LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]); + LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]); LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]); LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]); @@ -152,8 +157,8 @@ static void checkasm_check_hevc_qpel_uni(void) static void checkasm_check_hevc_qpel_uni_w(void) { - LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]); - LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]); + LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]); + LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]); LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]); LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]); @@ -200,8 +205,8 @@ static void checkasm_check_hevc_qpel_uni_w(void) static void checkasm_check_hevc_qpel_bi(void) { - LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]); - LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]); + LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]); + LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]); LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]); LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]); LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]); @@ -244,8 +249,8 @@ static void checkasm_check_hevc_qpel_bi(void) static void checkasm_check_hevc_qpel_bi_w(void) { - LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]); - LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]); + LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]); + LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]); LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]); LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]); LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]); @@ -294,6 +299,9 @@ static void checkasm_check_hevc_qpel_bi_w(void) report("qpel_bi_w"); } +#undef SRC_EXTRA +#define SRC_EXTRA 0 + static void checkasm_check_hevc_epel(void) { LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);

1 0

avutil/utils: Remove racy check from avutil_version()
by Andreas Rheinhardt 29 Sep '21

29 Sep '21

ffmpeg | branch: master | Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> | Sun Sep 26 10:56:49 2021 +0200| [ff800903747325f15056444c11053279e391d60b] | committer: Andreas Rheinhardt avutil/utils: Remove racy check from avutil_version() avutil_version() currently performs several checks before just returning the version. There is a static int that aims to ensure that these tests are run only once. The reason is that there used to be a slightly expensive check, but it has been removed in 92e3a6fdac73f7e1d69d69717219a7538877d7a0. Today running only once is unnecessary and can be counterproductive: GCC 10 optimizes all the actual checks away, but the checks_done variable and the code setting it has been kept. Given that this check is inherently racy (it uses non-atomic variables), it is best to just remove it. Reviewed-by: Paul B Mahol <onemda(a)gmail.com> Reviewed-by: James Almer <jamrial(a)gmail.com> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=ff800903747325f15… --- libavutil/utils.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/libavutil/utils.c b/libavutil/utils.c index c1cd452eee..ea9b5097b8 100644 --- a/libavutil/utils.c +++ b/libavutil/utils.c @@ -37,10 +37,6 @@ const char *av_version_info(void) unsigned avutil_version(void) { - static int checks_done; - if (checks_done) - return LIBAVUTIL_VERSION_INT; - av_assert0(AV_SAMPLE_FMT_DBLP == 9); av_assert0(AVMEDIA_TYPE_ATTACHMENT == 4); av_assert0(AV_PICTURE_TYPE_BI == 7); @@ -58,7 +54,6 @@ unsigned avutil_version(void) av_log(NULL, AV_LOG_ERROR, "Libavutil has been linked to a broken llrint()\n"); } - checks_done = 1; return LIBAVUTIL_VERSION_INT; }

1 0

avfilter: add morpho filter
by Paul B Mahol 28 Sep '21

28 Sep '21

ffmpeg | branch: master | Paul B Mahol <onemda(a)gmail.com> | Mon Sep 20 13:47:45 2021 +0200| [b2ec4edef798af1112ed7c3aadc3a2c91f7d3665] | committer: Paul B Mahol avfilter: add morpho filter > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=b2ec4edef798af111… --- Changelog | 1 + doc/filters.texi | 39 ++ libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/version.h | 2 +- libavfilter/vf_morpho.c | 939 +++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 982 insertions(+), 1 deletion(-) diff --git a/Changelog b/Changelog index d0b1a9724e..78662416a4 100644 --- a/Changelog +++ b/Changelog @@ -20,6 +20,7 @@ version <next>: - MSN Siren decoder - scharr video filter - apsyclip audio filter +- morpho video filter version 4.4: diff --git a/doc/filters.texi b/doc/filters.texi index 0b7e21f7f8..568c2995bc 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -10257,6 +10257,7 @@ A number representing position of the first frame with respect to the telecine pattern. This is to be used if the stream is cut. The default value is @code{0}. @end table +@anchor{dilation} @section dilation Apply dilation effect to the video. @@ -11577,6 +11578,7 @@ value. @end table +@anchor{erosion} @section erosion Apply erosion effect to the video. @@ -15352,6 +15354,43 @@ Default value is 0. This filter supports the all above options as @ref{commands}. +@section morpho + +This filter allows to apply main morphological grayscale transforms, +erode and dilate with arbitrary structures set in second input stream. + +Unlike naive implementation and much slower performance in @ref{erosion} +and @ref{dilation} filters, when speed is critical @code{morpho} filter +should be used instead. + +A description of accepted options follows, + +@table @option +@item mode +Set morphological transform to apply, can be: + +@table @samp +@item erode +@item dilate +@item open +@item close +@end table +Default is @code{erode}. + +@item planes +Set planes to filter, by default all planes except alpha are filtered. + +@item structure +Set which structure video frames will be processed from second input stream, +can be @var{first} or @var{all}. Default is @var{all}. +@end table + +The @code{morpho} filter also supports the @ref{framesync} options. + +@subsection Commands + +This filter supports same @ref{commands} as options. + @section mpdecimate Drop frames that do not differ greatly from the previous frame in diff --git a/libavfilter/Makefile b/libavfilter/Makefile index f059f3fef8..fa2d18e45f 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -344,6 +344,7 @@ OBJS-$(CONFIG_MIDEQUALIZER_FILTER) += vf_midequalizer.o framesync.o OBJS-$(CONFIG_MINTERPOLATE_FILTER) += vf_minterpolate.o motion_estimation.o OBJS-$(CONFIG_MIX_FILTER) += vf_mix.o framesync.o OBJS-$(CONFIG_MONOCHROME_FILTER) += vf_monochrome.o +OBJS-$(CONFIG_MORPHO_FILTER) += vf_morpho.o OBJS-$(CONFIG_MPDECIMATE_FILTER) += vf_mpdecimate.o OBJS-$(CONFIG_NEGATE_FILTER) += vf_lut.o OBJS-$(CONFIG_NLMEANS_FILTER) += vf_nlmeans.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index ddd6404228..338561a446 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -329,6 +329,7 @@ extern const AVFilter ff_vf_midequalizer; extern const AVFilter ff_vf_minterpolate; extern const AVFilter ff_vf_mix; extern const AVFilter ff_vf_monochrome; +extern const AVFilter ff_vf_morpho; extern const AVFilter ff_vf_mpdecimate; extern const AVFilter ff_vf_msad; extern const AVFilter ff_vf_negate; diff --git a/libavfilter/version.h b/libavfilter/version.h index 24b59acde6..ab5eb14634 100644 --- a/libavfilter/version.h +++ b/libavfilter/version.h @@ -30,7 +30,7 @@ #include "libavutil/version.h" #define LIBAVFILTER_VERSION_MAJOR 8 -#define LIBAVFILTER_VERSION_MINOR 9 +#define LIBAVFILTER_VERSION_MINOR 10 #define LIBAVFILTER_VERSION_MICRO 100 diff --git a/libavfilter/vf_morpho.c b/libavfilter/vf_morpho.c new file mode 100644 index 0000000000..fd181ddaa5 --- /dev/null +++ b/libavfilter/vf_morpho.c @@ -0,0 +1,939 @@ +/* + * Copyright (c) 2016 ReneBrals + * Copyright (c) 2021 Paul B Mahol + * + * This file is part of FFmpeg. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "libavutil/avassert.h" +#include "libavutil/imgutils.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/opt.h" +#include "libavutil/pixdesc.h" +#include "avfilter.h" +#include "formats.h" +#include "framesync.h" +#include "internal.h" +#include "video.h" + +enum MorphModes { + ERODE, + DILATE, + OPEN, + CLOSE, + NB_MODES +}; + +typedef struct IPlane { + uint8_t **img; + int w, h; + int range; + int depth; + int type_size; + + void (*max)(uint8_t *c, const uint8_t *a, const uint8_t *b, int x); + void (*min)(uint8_t *c, const uint8_t *a, const uint8_t *b, int x); + void (*max_in_place)(uint8_t *a, const uint8_t *b, int x); + void (*min_in_place)(uint8_t *a, const uint8_t *b, int x); +} IPlane; + +typedef struct LUT { + uint8_t ***arr; + int min_r; + int max_r; + int I; + int X; + int pre_pad_x; + int type_size; +} LUT; + +typedef struct chord { + int x; + int y; + int l; + int i; +} chord; + +typedef struct chord_set { + chord *C; + int size; + int cap; + + int *R; + int Lnum; + + int minX; + int maxX; + int minY; + int maxY; + unsigned nb_elements; +} chord_set; + +typedef struct MorphoContext { + const AVClass *class; + FFFrameSync fs; + + chord_set SE[4]; + IPlane SEimg[4]; + IPlane g[4], f[4], h[4]; + LUT Ty[2][4]; + + int mode; + int planes; + int structures; + + int planewidth[4]; + int planeheight[4]; + int splanewidth[4]; + int splaneheight[4]; + int depth; + int type_size; + int nb_planes; + + int got_structure[4]; + + AVFrame *temp; + + int64_t *plane_f, *plane_g; +} MorphoContext; + +#define OFFSET(x) offsetof(MorphoContext, x) +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_RUNTIME_PARAM + +static const AVOption morpho_options[] = { + { "mode", "set morphological transform", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_MODES-1, FLAGS, "mode" }, + { "erode", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ERODE}, 0, 0, FLAGS, "mode" }, + { "dilate", NULL, 0, AV_OPT_TYPE_CONST, {.i64=DILATE}, 0, 0, FLAGS, "mode" }, + { "open", NULL, 0, AV_OPT_TYPE_CONST, {.i64=OPEN}, 0, 0, FLAGS, "mode" }, + { "close", NULL, 0, AV_OPT_TYPE_CONST, {.i64=CLOSE}, 0, 0, FLAGS, "mode" }, + { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=7}, 0, 15, FLAGS }, + { "structure", "when to process structures", OFFSET(structures), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "str" }, + { "first", "process only first structure, ignore rest", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "str" }, + { "all", "process all structure", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "str" }, + { NULL } +}; + +FRAMESYNC_DEFINE_CLASS(morpho, MorphoContext, fs); + +static int query_formats(AVFilterContext *ctx) +{ + static const enum AVPixelFormat pix_fmts[] = { + AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, + AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, + AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, + AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, + AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, + AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, + AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_GBRP9, + AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, + AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, + AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12, + AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, + AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, + AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, + AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12, + AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16, + AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, + AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16, + AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16, + AV_PIX_FMT_NONE + }; + + return ff_set_common_formats_from_list(ctx, pix_fmts); +} + +static void min_fun(uint8_t *c, const uint8_t *a, const uint8_t *b, int x) +{ + for (int i = 0; i < x; i++) + c[i] = FFMIN(b[i], a[i]); +} + +static void mininplace_fun(uint8_t *a, const uint8_t *b, int x) +{ + for (int i = 0; i < x; i++) + a[i] = FFMIN(a[i], b[i]); +} + +static void max_fun(uint8_t *c, const uint8_t *a, const uint8_t *b, int x) +{ + for (int i = 0; i < x; i++) + c[i] = FFMAX(a[i], b[i]); +} + +static void maxinplace_fun(uint8_t *a, const uint8_t *b, int x) +{ + for (int i = 0; i < x; i++) + a[i] = FFMAX(a[i], b[i]); +} + +static void min16_fun(uint8_t *cc, const uint8_t *aa, const uint8_t *bb, int x) +{ + const uint16_t *a = (const uint16_t *)aa; + const uint16_t *b = (const uint16_t *)bb; + uint16_t *c = (uint16_t *)cc; + + for (int i = 0; i < x; i++) + c[i] = FFMIN(b[i], a[i]); +} + +static void mininplace16_fun(uint8_t *aa, const uint8_t *bb, int x) +{ + uint16_t *a = (uint16_t *)aa; + const uint16_t *b = (const uint16_t *)bb; + + for (int i = 0; i < x; i++) + a[i] = FFMIN(a[i], b[i]); +} + +static void max16_fun(uint8_t *cc, const uint8_t *aa, const uint8_t *bb, int x) +{ + const uint16_t *a = (const uint16_t *)aa; + const uint16_t *b = (const uint16_t *)bb; + uint16_t *c = (uint16_t *)cc; + + for (int i = 0; i < x; i++) + c[i] = FFMAX(a[i], b[i]); +} + +static void maxinplace16_fun(uint8_t *aa, const uint8_t *bb, int x) +{ + uint16_t *a = (uint16_t *)aa; + const uint16_t *b = (const uint16_t *)bb; + + for (int i = 0; i < x; i++) + a[i] = FFMAX(a[i], b[i]); +} + +static int alloc_lut(LUT *Ty, chord_set *SE, int type_size, int mode) +{ + const int size = Ty->max_r + 1 - Ty->min_r; + int pre_pad_x = 0; + + if (SE->minX < 0) + pre_pad_x = 0 - SE->minX; + Ty->pre_pad_x = pre_pad_x; + Ty->type_size = type_size; + + Ty->arr = av_calloc(size, sizeof(*Ty->arr)); + if (!Ty->arr) + return AVERROR(ENOMEM); + for (int r = 0; r < Ty->max_r - Ty->min_r + 1; r++) { + Ty->arr[r] = av_calloc(Ty->I, sizeof(uint8_t *)); + if (!Ty->arr[r]) + return AVERROR(ENOMEM); + for (int i = 0; i < Ty->I; i++) { + Ty->arr[r][i] = av_calloc(Ty->X + pre_pad_x, type_size); + if (!Ty->arr[r][i]) + return AVERROR(ENOMEM); + if (mode == ERODE) + memset(Ty->arr[r][i], UINT8_MAX, pre_pad_x * type_size); + /* Shifting the X index such that negative indices correspond to + * the pre-padding. + */ + Ty->arr[r][i] = &(Ty->arr[r][i][pre_pad_x * type_size]); + } + } + + Ty->arr = &(Ty->arr[0 - Ty->min_r]); + + return 0; +} + +static void free_lut(LUT *table) +{ + uint8_t ***rp; + + if (!table->arr) + return; + + // The R index was shifted, create a pointer to the original array + rp = &(table->arr[table->min_r]); + + for (int r = table->min_r; r <= table->max_r; r++) { + for (int i = 0; i < table->I; i++) { + // The X index was also shifted, for padding purposes. + av_free(table->arr[r][i] - table->pre_pad_x * table->type_size); + } + av_freep(&table->arr[r]); + } + av_freep(&rp); +} + +static void circular_swap(LUT *Ty) +{ + /* + * Swap the pointers to r-indices in a circle. This is useful because + * Ty(r,i,x) = Ty-1(r+1,i,x) for r < ymax. + */ + if (Ty->max_r - Ty->min_r > 0) { + uint8_t **Ty0 = Ty->arr[Ty->min_r]; + + for (int r = Ty->min_r; r < Ty->max_r; r++) + Ty->arr[r] = Ty->arr[r + 1]; + + Ty->arr[Ty->max_r] = Ty0; + } +} + +static void compute_min_row(IPlane *f, LUT *Ty, chord_set *SE, int r, int y) +{ + if (y + r >= 0 && y + r < f->h) { + memcpy(Ty->arr[r][0], f->img[y + r], Ty->X * Ty->type_size); + } else { + memset(Ty->arr[r][0], UINT8_MAX, Ty->X * Ty->type_size); + } + + for (int i = 1; i < SE->Lnum; i++) { + int d = SE->R[i] - SE->R[i - 1]; + + f->min(Ty->arr[r][i] - Ty->pre_pad_x * f->type_size, + Ty->arr[r][i - 1] - Ty->pre_pad_x * f->type_size, + Ty->arr[r][i - 1] + (d - Ty->pre_pad_x) * f->type_size, + Ty->X + Ty->pre_pad_x - d); + memcpy(Ty->arr[r][i] + (Ty->X - d) * f->type_size, + Ty->arr[r][i - 1] + (Ty->X - d) * f->type_size, + d * f->type_size); + } +} + +static void update_min_lut(IPlane *f, LUT *Ty, chord_set *SE, int y, int tid, int num) +{ + for (int i = 0; i < num; i++) + circular_swap(Ty); + + compute_min_row(f, Ty, SE, Ty->max_r - tid, y); +} + +static int compute_min_lut(LUT *Ty, IPlane *f, chord_set *SE, int y, int num) +{ + if (Ty->I != SE->Lnum || + Ty->X != f->w || + Ty->min_r != SE->minY || + Ty->max_r != SE->maxY + num - 1) { + int ret; + + free_lut(Ty); + + Ty->I = SE->Lnum; + Ty->X = f->w; + Ty->min_r = SE->minY; + Ty->max_r = SE->maxY + num - 1; + ret = alloc_lut(Ty, SE, f->type_size, ERODE); + if (ret < 0) + return ret; + } + + for (int r = Ty->min_r; r <= Ty->max_r; r++) + compute_min_row(f, Ty, SE, r, y); + + return 0; +} + +static void compute_max_row(IPlane *f, LUT *Ty, chord_set *SE, int r, int y) +{ + if (y + r >= 0 && y + r < f->h) { + memcpy(Ty->arr[r][0], f->img[y + r], Ty->X * Ty->type_size); + } else { + memset(Ty->arr[r][0], 0, Ty->X * Ty->type_size); + } + + for (int i = 1; i < SE->Lnum; i++) { + int d = SE->R[i] - SE->R[i - 1]; + + f->max(Ty->arr[r][i] - Ty->pre_pad_x * f->type_size, + Ty->arr[r][i - 1] - Ty->pre_pad_x * f->type_size, + Ty->arr[r][i - 1] + (d - Ty->pre_pad_x) * f->type_size, + Ty->X + Ty->pre_pad_x - d); + memcpy(Ty->arr[r][i] + (Ty->X - d) * f->type_size, + Ty->arr[r][i - 1] + (Ty->X - d) * f->type_size, + d * f->type_size); + } +} + +static void update_max_lut(IPlane *f, LUT *Ty, chord_set *SE, int y, int tid, int num) +{ + for (int i = 0; i < num; i++) + circular_swap(Ty); + + compute_max_row(f, Ty, SE, Ty->max_r - tid, y); +} + +static int compute_max_lut(LUT *Ty, IPlane *f, chord_set *SE, int y, int num) +{ + if (Ty->I != SE->Lnum || + Ty->X != f->w || + Ty->min_r != SE->minY || + Ty->max_r != SE->maxY + num - 1) { + int ret; + + free_lut(Ty); + + Ty->I = SE->Lnum; + Ty->X = f->w; + Ty->min_r = SE->minY; + Ty->max_r = SE->maxY + num - 1; + ret = alloc_lut(Ty, SE, f->type_size, DILATE); + if (ret < 0) + return ret; + } + + for (int r = Ty->min_r; r <= Ty->max_r; r++) + compute_max_row(f, Ty, SE, r, y); + + return 0; +} + +static void line_dilate(IPlane *g, LUT *Ty, chord_set *SE, int y, int tid) +{ + memset(g->img[y], 0, g->w * g->type_size); + + for (int c = 0; c < SE->size; c++) { + g->max_in_place(g->img[y], + Ty->arr[SE->C[c].y + tid][SE->C[c].i] + SE->C[c].x * Ty->type_size, + av_clip(g->w - SE->C[c].x, 0, g->w)); + } +} + +static void line_erode(IPlane *g, LUT *Ty, chord_set *SE, int y, int tid) +{ + memset(g->img[y], UINT8_MAX, g->w * g->type_size); + + for (int c = 0; c < SE->size; c++) { + g->min_in_place(g->img[y], + Ty->arr[SE->C[c].y + tid][SE->C[c].i] + SE->C[c].x * Ty->type_size, + av_clip(g->w - SE->C[c].x, 0, g->w)); + } +} + +static int dilate(IPlane *g, IPlane *f, chord_set *SE, LUT *Ty) +{ + int ret = compute_max_lut(Ty, f, SE, 0, 1); + if (ret < 0) + return ret; + + line_dilate(g, Ty, SE, 0, 0); + for (int y = 1; y < f->h; y++) { + update_max_lut(f, Ty, SE, y, 0, 1); + line_dilate(g, Ty, SE, y, 0); + } + + return 0; +} + +static int erode(IPlane *g, IPlane *f, chord_set *SE, LUT *Ty) +{ + int ret = compute_min_lut(Ty, f, SE, 0, 1); + if (ret < 0) + return ret; + + line_erode(g, Ty, SE, 0, 0); + for (int y = 1; y < f->h; y++) { + update_min_lut(f, Ty, SE, y, 0, 1); + line_erode(g, Ty, SE, y, 0); + } + + return 0; +} + +static int insert_chord_set(chord_set *chords, chord c) +{ + // Checking if chord fits in dynamic array, resize if not. + if (chords->size == chords->cap) { + chords->C = av_realloc_f(chords->C, chords->cap * 2, sizeof(chord)); + if (!chords->C) + return AVERROR(ENOMEM); + chords->cap *= 2; + } + + // Add the chord to the dynamic array. + chords->C[chords->size].x = c.x; + chords->C[chords->size].y = c.y; + chords->C[chords->size++].l = c.l; + + // Update minimum/maximum x/y offsets of the chord set. + chords->minX = FFMIN(chords->minX, c.x); + chords->maxX = FFMAX(chords->maxX, c.x); + + chords->minY = FFMIN(chords->minY, c.y); + chords->maxY = FFMAX(chords->maxY, c.y); + + return 0; +} + +static void free_chord_set(chord_set *SE) +{ + av_freep(&SE->C); + SE->size = 0; + SE->cap = 0; + + av_freep(&SE->R); + SE->Lnum = 0; +} + +static int init_chordset(chord_set *chords) +{ + chords->nb_elements = 0; + chords->size = 0; + chords->C = av_calloc(1, sizeof(chord)); + if (!chords->C) + return AVERROR(ENOMEM); + + chords->cap = 1; + chords->minX = INT16_MAX; + chords->maxX = INT16_MIN; + chords->minY = INT16_MAX; + chords->maxY = INT16_MIN; + + return 0; +} + +static int comp_chord_length(const void *p, const void *q) +{ + chord a, b; + a = *((chord *)p); + b = *((chord *)q); + + return (a.l > b.l) - (a.l < b.l); +} + +static int comp_chord(const void *p, const void *q) +{ + chord a, b; + a = *((chord *)p); + b = *((chord *)q); + + return (a.y > b.y) - (a.y < b.y); +} + +static int build_chord_set(IPlane *SE, chord_set *chords) +{ + const int mid = 1 << (SE->depth - 1); + int chord_length_index; + int chord_start, val, ret; + int centerX, centerY; + int r_cap = 1; + chord c; + + ret = init_chordset(chords); + if (ret < 0) + return ret; + /* + * In erosion/dilation, the center of the IPlane has S.E. offset (0,0). + * Otherwise, the resulting IPlane would be shifted to the top-left. + */ + centerX = (SE->w - 1) / 2; + centerY = (SE->h - 1) / 2; + + /* + * Computing the set of chords C. + */ + for (int y = 0; y < SE->h; y++) { + int x; + + chord_start = -1; + for (x = 0; x < SE->w; x++) { + if (SE->type_size == 1) { + chords->nb_elements += (SE->img[y][x] >= mid); + //A chord is a run of non-zero pixels. + if (SE->img[y][x] >= mid && chord_start == -1) { + // Chord starts. + chord_start = x; + } else if (SE->img[y][x] < mid && chord_start != -1) { + // Chord ends before end of line. + c.x = chord_start - centerX; + c.y = y - centerY; + c.l = x - chord_start; + ret = insert_chord_set(chords, c); + if (ret < 0) + return AVERROR(ENOMEM); + chord_start = -1; + } + } else { + chords->nb_elements += (AV_RN16(&SE->img[y][x * 2]) >= mid); + //A chord is a run of non-zero pixels. + if (AV_RN16(&SE->img[y][x * 2]) >= mid && chord_start == -1) { + // Chord starts. + chord_start = x; + } else if (AV_RN16(&SE->img[y][x * 2]) < mid && chord_start != -1) { + // Chord ends before end of line. + c.x = chord_start - centerX; + c.y = y - centerY; + c.l = x - chord_start; + ret = insert_chord_set(chords, c); + if (ret < 0) + return AVERROR(ENOMEM); + chord_start = -1; + } + } + } + if (chord_start != -1) { + // Chord ends at end of line. + c.x = chord_start - centerX; + c.y = y - centerY; + c.l = x - chord_start; + ret = insert_chord_set(chords, c); + if (ret < 0) + return AVERROR(ENOMEM); + } + } + + /* + * Computing the array of chord lengths R(i). + * This is needed because the lookup table will contain a row for each + * length index i. + */ + qsort(chords->C, chords->size, sizeof(chord), comp_chord_length); + chords->R = av_calloc(1, sizeof(*chords->R)); + if (!chords->R) + return AVERROR(ENOMEM); + chords->Lnum = 0; + val = 0; + r_cap = 1; + + if (chords->size > 0) { + val = 1; + if (chords->Lnum >= r_cap) { + chords->R = av_realloc_f(chords->R, r_cap * 2, sizeof(*chords->R)); + if (!chords->R) + return AVERROR(ENOMEM); + r_cap *= 2; + } + chords->R[chords->Lnum++] = 1; + val = 1; + } + + for (int i = 0; i < chords->size; i++) { + if (val != chords->C[i].l) { + while (2 * val < chords->C[i].l && val != 0) { + if (chords->Lnum >= r_cap) { + chords->R = av_realloc_f(chords->R, r_cap * 2, sizeof(*chords->R)); + if (!chords->R) + return AVERROR(ENOMEM); + r_cap *= 2; + } + + chords->R[chords->Lnum++] = 2 * val; + val *= 2; + } + val = chords->C[i].l; + + if (chords->Lnum >= r_cap) { + chords->R = av_realloc_f(chords->R, r_cap * 2, sizeof(*chords->R)); + if (!chords->R) + return AVERROR(ENOMEM); + r_cap *= 2; + } + chords->R[chords->Lnum++] = val; + } + } + + /* + * Setting the length indices of chords. + * These are needed so that the algorithm can, for each chord, + * access the lookup table at the correct length in constant time. + */ + chord_length_index = 0; + for (int i = 0; i < chords->size; i++) { + while (chords->R[chord_length_index] < chords->C[i].l) + chord_length_index++; + chords->C[i].i = chord_length_index; + } + + /* + * Chords are sorted on Y. This way, when a row of the lookup table or IPlane + * is cached, the next chord offset has a better chance of being on the + * same cache line. + */ + qsort(chords->C, chords->size, sizeof(chord), comp_chord); + + return 0; +} + +static void free_iplane(IPlane *imp) +{ + av_freep(&imp->img); +} + +static int read_iplane(IPlane *imp, const uint8_t *dst, int dst_linesize, + int w, int h, int R, int type_size, int depth) +{ + if (!imp->img) + imp->img = av_calloc(h, sizeof(*imp->img)); + if (!imp->img) + return AVERROR(ENOMEM); + + imp->w = w; + imp->h = h; + imp->range = R; + imp->depth = depth; + imp->type_size = type_size; + imp->max = type_size == 1 ? max_fun : max16_fun; + imp->min = type_size == 1 ? min_fun : min16_fun; + imp->max_in_place = type_size == 1 ? maxinplace_fun : maxinplace16_fun; + imp->min_in_place = type_size == 1 ? mininplace_fun : mininplace16_fun; + + for (int y = 0; y < h; y++) + imp->img[y] = (uint8_t *)dst + y * dst_linesize; + + return 0; +} + +static int config_input(AVFilterLink *inlink) +{ + const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); + MorphoContext *s = inlink->dst->priv; + + s->depth = desc->comp[0].depth; + s->type_size = (s->depth + 7) / 8; + s->nb_planes = desc->nb_components; + s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w); + s->planewidth[0] = s->planewidth[3] = inlink->w; + s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h); + s->planeheight[0] = s->planeheight[3] = inlink->h; + + return 0; +} + +static int config_input_structure(AVFilterLink *inlink) +{ + const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); + AVFilterContext *ctx = inlink->dst; + MorphoContext *s = inlink->dst->priv; + + av_assert0(ctx->inputs[0]->format == ctx->inputs[1]->format); + + s->splanewidth[1] = s->splanewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w); + s->splanewidth[0] = s->splanewidth[3] = inlink->w; + s->splaneheight[1] = s->splaneheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h); + s->splaneheight[0] = s->splaneheight[3] = inlink->h; + + return 0; +} + +static int activate(AVFilterContext *ctx) +{ + MorphoContext *s = ctx->priv; + return ff_framesync_activate(&s->fs); +} + +static int do_morpho(FFFrameSync *fs) +{ + AVFilterContext *ctx = fs->parent; + AVFilterLink *outlink = ctx->outputs[0]; + MorphoContext *s = ctx->priv; + AVFrame *in = NULL, *structurepic = NULL; + AVFrame *out; + int ret; + + ret = ff_framesync_dualinput_get(fs, &in, &structurepic); + if (ret < 0) + return ret; + if (!structurepic) + return ff_filter_frame(outlink, in); + + out = ff_get_video_buffer(outlink, outlink->w, outlink->h); + if (!out) { + av_frame_free(&in); + return AVERROR(ENOMEM); + } + av_frame_copy_props(out, in); + + for (int p = 0; p < s->nb_planes; p++) { + const uint8_t *src = in->data[p]; + int src_linesize = in->linesize[p]; + const uint8_t *ssrc = structurepic->data[p]; + const int ssrc_linesize = structurepic->linesize[p]; + uint8_t *dst = out->data[p]; + int dst_linesize = out->linesize[p]; + const int swidth = s->splanewidth[p]; + const int sheight = s->splaneheight[p]; + const int width = s->planewidth[p]; + const int height = s->planeheight[p]; + const int depth = s->depth; + int type_size = s->type_size; + + if (!(s->planes & (1 << p))) { +copy: + av_image_copy_plane(out->data[p] + 0 * out->linesize[p], + out->linesize[p], + in->data[p] + 0 * in->linesize[p], + in->linesize[p], + width * ((s->depth + 7) / 8), + height); + continue; + } + + if (!s->got_structure[p] || s->structures) { + free_chord_set(&s->SE[p]); + + ret = read_iplane(&s->SEimg[p], ssrc, ssrc_linesize, swidth, sheight, 1, type_size, depth); + if (ret < 0) + goto fail; + ret = build_chord_set(&s->SEimg[p], &s->SE[p]); + if (ret < 0) + goto fail; + s->got_structure[p] = 1; + } + + if (s->SE[p].minX == INT16_MAX || + s->SE[p].minY == INT16_MAX || + s->SE[p].maxX == INT16_MIN || + s->SE[p].maxY == INT16_MIN) + goto copy; + + ret = read_iplane(&s->f[p], src, src_linesize, width, height, 1, type_size, depth); + if (ret < 0) + goto fail; + + ret = read_iplane(&s->g[p], dst, dst_linesize, s->f[p].w, s->f[p].h, s->f[p].range, type_size, depth); + if (ret < 0) + goto fail; + + switch (s->mode) { + case ERODE: + ret = erode(&s->g[p], &s->f[p], &s->SE[p], &s->Ty[0][p]); + break; + case DILATE: + ret = dilate(&s->g[p], &s->f[p], &s->SE[p], &s->Ty[0][p]); + break; + case OPEN: + ret = read_iplane(&s->h[p], s->temp->data[p], s->temp->linesize[p], width, height, 1, type_size, depth); + if (ret < 0) + break; + ret = erode(&s->h[p], &s->f[p], &s->SE[p], &s->Ty[0][p]); + if (ret < 0) + break; + ret = dilate(&s->g[p], &s->h[p], &s->SE[p], &s->Ty[1][p]); + break; + case CLOSE: + ret = read_iplane(&s->h[p], s->temp->data[p], s->temp->linesize[p], width, height, 1, type_size, depth); + if (ret < 0) + break; + ret = dilate(&s->h[p], &s->f[p], &s->SE[p], &s->Ty[0][p]); + if (ret < 0) + break; + ret = erode(&s->g[p], &s->h[p], &s->SE[p], &s->Ty[1][p]); + break; + default: + av_assert0(0); + } + + if (ret < 0) + goto fail; + } + + av_frame_free(&in); + out->pts = av_rescale_q(s->fs.pts, s->fs.time_base, outlink->time_base); + return ff_filter_frame(outlink, out); +fail: + av_frame_free(&in); + return ret; +} + +static int config_output(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + MorphoContext *s = ctx->priv; + AVFilterLink *mainlink = ctx->inputs[0]; + int ret; + + s->fs.on_event = do_morpho; + ret = ff_framesync_init_dualinput(&s->fs, ctx); + if (ret < 0) + return ret; + outlink->w = mainlink->w; + outlink->h = mainlink->h; + outlink->time_base = mainlink->time_base; + outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio; + outlink->frame_rate = mainlink->frame_rate; + + if ((ret = ff_framesync_configure(&s->fs)) < 0) + return ret; + outlink->time_base = s->fs.time_base; + + s->temp = ff_get_video_buffer(outlink, outlink->w, outlink->h); + if (!s->temp) + return AVERROR(ENOMEM); + + s->plane_f = av_calloc(outlink->w * outlink->h, sizeof(*s->plane_f)); + s->plane_g = av_calloc(outlink->w * outlink->h, sizeof(*s->plane_g)); + if (!s->plane_f || !s->plane_g) + return AVERROR(ENOMEM); + + return 0; +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + MorphoContext *s = ctx->priv; + + for (int p = 0; p < 4; p++) { + free_iplane(&s->SEimg[p]); + free_iplane(&s->f[p]); + free_iplane(&s->g[p]); + free_iplane(&s->h[p]); + free_chord_set(&s->SE[p]); + free_lut(&s->Ty[0][p]); + free_lut(&s->Ty[1][p]); + } + + ff_framesync_uninit(&s->fs); + + av_frame_free(&s->temp); + av_freep(&s->plane_f); + av_freep(&s->plane_g); +} + +static const AVFilterPad morpho_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = config_input, + }, + { + .name = "structure", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = config_input_structure, + }, +}; + +static const AVFilterPad morpho_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = config_output, + }, +}; + +const AVFilter ff_vf_morpho = { + .name = "morpho", + .description = NULL_IF_CONFIG_SMALL("Apply Morphological filter."), + .preinit = morpho_framesync_preinit, + .priv_size = sizeof(MorphoContext), + .priv_class = &morpho_class, + .activate = activate, + .uninit = uninit, + .query_formats = query_formats, + FILTER_INPUTS(morpho_inputs), + FILTER_OUTPUTS(morpho_outputs), + .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, + .process_command = ff_filter_process_command, +};

1 0

avformat/aacdec: enable probesize-sized resyncs mid-stream
by Jan Ekström 28 Sep '21

28 Sep '21

ffmpeg | branch: master | Jan Ekström <jeebjp(a)gmail.com> | Tue Sep 28 00:12:42 2021 +0300| [c20577806f0a161c6867e72f884d020a253de10a] | committer: Jan Ekström avformat/aacdec: enable probesize-sized resyncs mid-stream Before adts_aac_resync would always bail out after probesize amount of bytes had been progressed from the start of the input. Now just query the current position when entering resync, and at most advance probesize amount of data from that start position. Fixes #9433 > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=c20577806f0a161c6… --- libavformat/aacdec.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/libavformat/aacdec.c b/libavformat/aacdec.c index ab97be60b5..a476640904 100644 --- a/libavformat/aacdec.c +++ b/libavformat/aacdec.c @@ -83,10 +83,12 @@ static int adts_aac_probe(const AVProbeData *p) static int adts_aac_resync(AVFormatContext *s) { uint16_t state; + int64_t start_pos = avio_tell(s->pb); // skip data until an ADTS frame is found state = avio_r8(s->pb); - while (!avio_feof(s->pb) && avio_tell(s->pb) < s->probesize) { + while (!avio_feof(s->pb) && + (avio_tell(s->pb) - start_pos) < s->probesize) { state = (state << 8) | avio_r8(s->pb); if ((state >> 4) != 0xFFF) continue;

1 0

avcodec/siren: add checksum calculation
by Peter Ross 28 Sep '21

28 Sep '21

ffmpeg | branch: master | Peter Ross <pross(a)xvid.org> | Sat Sep 4 21:14:37 2021 +1000| [855014ff83dae786e914b4c7df88d263ec4122a7] | committer: Peter Ross avcodec/siren: add checksum calculation Reviewed-by: Lynne <dev(a)lynne.ee> Signed-off-by: Peter Ross <pross(a)xvid.org> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=855014ff83dae786e… --- libavcodec/siren.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/libavcodec/siren.c b/libavcodec/siren.c index 0ecf0fcafc..6909ebbf2e 100644 --- a/libavcodec/siren.c +++ b/libavcodec/siren.c @@ -760,7 +760,37 @@ static int siren_decode(AVCodecContext *avctx, void *data, frame_error = 1; } - skip_bits(gb, s->checksum_bits); + if ((avctx->err_recognition & AV_EF_CRCCHECK) && s->checksum_bits) { + static const uint16_t ChecksumTable[4] = {0x7F80, 0x7878, 0x6666, 0x5555}; + int wpf, checksum, sum, calculated_checksum, temp1; + + checksum = get_bits(gb, s->checksum_bits); + + wpf = bits_per_frame / 16; + sum = 0; + for (int i = 0; i < wpf - 1; i++) + sum ^= AV_RB16(avpkt->data + i * 2) << (i % 15); + sum ^= (AV_RB16(avpkt->data + (wpf - 1) * 2) & ~checksum) << ((wpf - 1) % 15); + sum = (sum >> 15) ^ (sum & 0x7FFF); + + calculated_checksum = 0; + for (int i = 0; i < 4; i++) { + temp1 = ChecksumTable[i] & sum; + + for (int j = 8; j > 0; j >>= 1) + temp1 ^= temp1 >> j; + + calculated_checksum <<= 1; + calculated_checksum |= temp1 & 1; + } + + if (checksum != calculated_checksum) { + av_log(avctx, AV_LOG_WARNING, "Invalid checksum\n"); + if (avctx->err_recognition & AV_EF_EXPLODE) + return AVERROR_INVALIDDATA; + frame_error = 1; + } + } if (frame_error) { memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));

1 0

avcodec/siren: don't reduce getbitcontext size by checksum_bits at initialisation
by Peter Ross 28 Sep '21

28 Sep '21

ffmpeg | branch: master | Peter Ross <pross(a)xvid.org> | Sat Sep 18 19:55:22 2021 +1000| [e40593c0505a3ee143b8ac949af1bb70becafb21] | committer: Peter Ross avcodec/siren: don't reduce getbitcontext size by checksum_bits at initialisation this allows the checksum calculation routine to also use getbitcontext Signed-off-by: Peter Ross <pross(a)xvid.org> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=e40593c0505a3ee14… --- libavcodec/siren.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/libavcodec/siren.c b/libavcodec/siren.c index 27ee356c44..0ecf0fcafc 100644 --- a/libavcodec/siren.c +++ b/libavcodec/siren.c @@ -594,7 +594,7 @@ static int decode_vector(SirenContext *s, int number_of_regions, for (i = 0; i < number_of_vectors[category]; i++) { index = 0; do { - if (get_bits_left(gb) <= 0) { + if (get_bits_left(gb) - s->checksum_bits <= 0) { error = 1; break; } @@ -614,7 +614,7 @@ static int decode_vector(SirenContext *s, int number_of_regions, index >>= index_table[category]; if (decoded_value) { - if (get_bits_left(gb) <= 0) { + if (get_bits_left(gb) - s->checksum_bits <= 0) { error = 1; break; } @@ -697,7 +697,7 @@ static int decode_vector(SirenContext *s, int number_of_regions, } } - return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb); + return error == 1 ? AVERROR_INVALIDDATA : (get_bits_left(gb) - s->checksum_bits); } static int siren_decode(AVCodecContext *avctx, void *data, @@ -716,7 +716,7 @@ static int siren_decode(AVCodecContext *avctx, void *data, if (avpkt->size < bits_per_frame / 8) return AVERROR_INVALIDDATA; - if ((ret = init_get_bits(gb, avpkt->data, bits_per_frame - s->checksum_bits)) < 0) + if ((ret = init_get_bits(gb, avpkt->data, bits_per_frame)) < 0) return ret; } else if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0) @@ -730,7 +730,7 @@ static int siren_decode(AVCodecContext *avctx, void *data, rate_control = get_bits(gb, 4); - ret = categorize_regions(s->number_of_regions, get_bits_left(gb), + ret = categorize_regions(s->number_of_regions, get_bits_left(gb) - s->checksum_bits, s->absolute_region_power_index, s->power_categories, s->category_balance); if (ret < 0) @@ -745,11 +745,11 @@ static int siren_decode(AVCodecContext *avctx, void *data, if (ret < 0 && !s->microsoft) return ret; - if (get_bits_left(gb) > 0) { + if (get_bits_left(gb) - s->checksum_bits > 0) { do { frame_error |= !get_bits1(gb); - } while (get_bits_left(gb) > 0); - } else if (get_bits_left(gb) < 0 && + } while (get_bits_left(gb) - s->checksum_bits > 0); + } else if (get_bits_left(gb) - s->checksum_bits < 0 && rate_control + 1 < s->rate_control_possibilities) { frame_error = 1; }

1 0

avcodec/siren: prevent getbitcontext overread
by Peter Ross 28 Sep '21

28 Sep '21

ffmpeg | branch: master | Peter Ross <pross(a)xvid.org> | Sat Sep 18 19:55:03 2021 +1000| [b007e8968f2072b9e8076d0ab474ad944fc07ade] | committer: Peter Ross avcodec/siren: prevent getbitcontext overread Reviewed-by: Michael Niedermayer <michael(a)niedermayer.cc> Signed-off-by: Peter Ross <pross(a)xvid.org> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=b007e8968f2072b9e… --- libavcodec/siren.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/libavcodec/siren.c b/libavcodec/siren.c index 7f2b467860..27ee356c44 100644 --- a/libavcodec/siren.c +++ b/libavcodec/siren.c @@ -608,12 +608,16 @@ static int decode_vector(SirenContext *s, int number_of_regions, index >>= 1; - if (error == 0 && get_bits_left(gb) >= 0) { + if (error == 0) { for (j = 0; j < vector_dimension[category]; j++) { decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)]; index >>= index_table[category]; if (decoded_value) { + if (get_bits_left(gb) <= 0) { + error = 1; + break; + } if (!get_bits1(gb)) decoded_value *= -decoder_standard_deviation[region]; else

1 0