#include "internal.h"
#include "video.h"
+enum MatrixMode {
+ MATRIX_SQUARE,
+ MATRIX_ROW,
+ MATRIX_COLUMN,
+ MATRIX_NBMODES,
+};
+
typedef struct ConvolutionContext {
const AVClass *class;
char *matrix_str[4];
float rdiv[4];
float bias[4];
+ int mode[4];
float scale;
float delta;
int planes;
int matrix_length[4];
int copy[4];
- void (*setup[4])(const uint8_t *c[], const uint8_t *src, int stride,
+ void (*setup[4])(int radius, const uint8_t *c[], const uint8_t *src, int stride,
int x, int width, int y, int height, int bpc);
- void (*filter[4])(uint8_t *dst, const uint8_t *src, int width,
+ void (*filter[4])(uint8_t *dst, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak);
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride);
} ConvolutionContext;
#define OFFSET(x) offsetof(ConvolutionContext, x)
{ "1bias", "set bias for 2nd plane", OFFSET(bias[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
{ "2bias", "set bias for 3rd plane", OFFSET(bias[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
{ "3bias", "set bias for 4th plane", OFFSET(bias[3]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
+ { "0mode", "set matrix mode for 1st plane", OFFSET(mode[0]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, "mode" },
+ { "1mode", "set matrix mode for 2nd plane", OFFSET(mode[1]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, "mode" },
+ { "2mode", "set matrix mode for 3rd plane", OFFSET(mode[2]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, "mode" },
+ { "3mode", "set matrix mode for 4th plane", OFFSET(mode[3]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, "mode" },
+ { "square", "square matrix", 0, AV_OPT_TYPE_CONST, {.i64=MATRIX_SQUARE}, 0, 0, FLAGS, "mode" },
+ { "row", "single row matrix", 0, AV_OPT_TYPE_CONST, {.i64=MATRIX_ROW} , 0, 0, FLAGS, "mode" },
+ { "column", "single column matrix", 0, AV_OPT_TYPE_CONST, {.i64=MATRIX_COLUMN}, 0, 0, FLAGS, "mode" },
{ NULL }
};
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
- AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
+ AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE
};
AVFrame *in, *out;
} ThreadData;
-static void filter16_prewitt(uint8_t *dstp, const uint8_t *src, int width,
+static void filter16_prewitt(uint8_t *dstp, int width,
float scale, float delta, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
uint16_t *dst = (uint16_t *)dstp;
int x;
int sumb = AV_RN16A(&c[0][2 * x]) * -1 + AV_RN16A(&c[2][2 * x]) * 1 + AV_RN16A(&c[3][2 * x]) * -1 +
AV_RN16A(&c[5][2 * x]) * 1 + AV_RN16A(&c[6][2 * x]) * -1 + AV_RN16A(&c[8][2 * x]) * 1;
- dst[x] = av_clip(sqrt(suma*suma + sumb*sumb) * scale + delta, 0, peak);
+ dst[x] = av_clip(sqrtf(suma*suma + sumb*sumb) * scale + delta, 0, peak);
}
}
-static void filter16_roberts(uint8_t *dstp, const uint8_t *src, int width,
+static void filter16_roberts(uint8_t *dstp, int width,
float scale, float delta, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
uint16_t *dst = (uint16_t *)dstp;
int x;
for (x = 0; x < width; x++) {
- int suma = AV_RN16A(&c[0][2 * x]) * 1 + AV_RN16A(&c[4][2 * x]) * -1;
- int sumb = AV_RN16A(&c[1][2 * x]) * 1 + AV_RN16A(&c[3][2 * x]) * -1;
+ int suma = AV_RN16A(&c[0][2 * x]) * 1 + AV_RN16A(&c[1][2 * x]) * -1;
+ int sumb = AV_RN16A(&c[4][2 * x]) * 1 + AV_RN16A(&c[3][2 * x]) * -1;
- dst[x] = av_clip(sqrt(suma*suma + sumb*sumb) * scale + delta, 0, peak);
+ dst[x] = av_clip(sqrtf(suma*suma + sumb*sumb) * scale + delta, 0, peak);
}
}
-static void filter16_sobel(uint8_t *dstp, const uint8_t *src, int width,
+static void filter16_sobel(uint8_t *dstp, int width,
float scale, float delta, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
uint16_t *dst = (uint16_t *)dstp;
int x;
int sumb = AV_RN16A(&c[0][2 * x]) * -1 + AV_RN16A(&c[2][2 * x]) * 1 + AV_RN16A(&c[3][2 * x]) * -2 +
AV_RN16A(&c[5][2 * x]) * 2 + AV_RN16A(&c[6][2 * x]) * -1 + AV_RN16A(&c[8][2 * x]) * 1;
- dst[x] = av_clip(sqrt(suma*suma + sumb*sumb) * scale + delta, 0, peak);
+ dst[x] = av_clip(sqrtf(suma*suma + sumb*sumb) * scale + delta, 0, peak);
}
}
-static void filter_prewitt(uint8_t *dst, const uint8_t *src, int width,
+static void filter_prewitt(uint8_t *dst, int width,
float scale, float delta, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
const uint8_t *c3 = c[3], *c5 = c[5];
int sumb = c0[x] * -1 + c2[x] * 1 + c3[x] * -1 +
c5[x] * 1 + c6[x] * -1 + c8[x] * 1;
- dst[x] = av_clip_uint8(sqrt(suma*suma + sumb*sumb) * scale + delta);
+ dst[x] = av_clip_uint8(sqrtf(suma*suma + sumb*sumb) * scale + delta);
}
}
-static void filter_roberts(uint8_t *dst, const uint8_t *src, int width,
+static void filter_roberts(uint8_t *dst, int width,
float scale, float delta, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
int x;
for (x = 0; x < width; x++) {
- int suma = c[0][x - 1] * 1 + c[4][x ] * -1;
- int sumb = c[1][x ] * 1 + c[3][x - 1] * -1;
+ int suma = c[0][x] * 1 + c[1][x] * -1;
+ int sumb = c[4][x] * 1 + c[3][x] * -1;
- dst[x] = av_clip_uint8(sqrt(suma*suma + sumb*sumb) * scale + delta);
+ dst[x] = av_clip_uint8(sqrtf(suma*suma + sumb*sumb) * scale + delta);
}
}
-static void filter_sobel(uint8_t *dst, const uint8_t *src, int width,
+static void filter_sobel(uint8_t *dst, int width,
float scale, float delta, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
const uint8_t *c3 = c[3], *c5 = c[5];
int sumb = c0[x] * -1 + c2[x] * 1 + c3[x] * -2 +
c5[x] * 2 + c6[x] * -1 + c8[x] * 1;
- dst[x] = av_clip_uint8(sqrt(suma*suma + sumb*sumb) * scale + delta);
+ dst[x] = av_clip_uint8(sqrtf(suma*suma + sumb*sumb) * scale + delta);
}
}
-static void filter16_3x3(uint8_t *dstp, const uint8_t *src, int width,
+static void filter16_3x3(uint8_t *dstp, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
uint16_t *dst = (uint16_t *)dstp;
int x;
}
}
-static void filter16_5x5(uint8_t *dstp, const uint8_t *src, int width,
+static void filter16_5x5(uint8_t *dstp, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
uint16_t *dst = (uint16_t *)dstp;
int x;
}
}
-static void filter16_7x7(uint8_t *dstp, const uint8_t *src, int width,
+static void filter16_7x7(uint8_t *dstp, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
uint16_t *dst = (uint16_t *)dstp;
int x;
}
}
-static void filter_7x7(uint8_t *dst, const uint8_t *src, int width,
+static void filter16_row(uint8_t *dstp, int width,
+ float rdiv, float bias, const int *const matrix,
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
+{
+ uint16_t *dst = (uint16_t *)dstp;
+ int x;
+
+ for (x = 0; x < width; x++) {
+ int i, sum = 0;
+
+ for (i = 0; i < 2 * radius + 1; i++)
+ sum += AV_RN16A(&c[i][2 * x]) * matrix[i];
+
+ sum = (int)(sum * rdiv + bias + 0.5f);
+ dst[x] = av_clip(sum, 0, peak);
+ }
+}
+
+static void filter16_column(uint8_t *dstp, int height,
+ float rdiv, float bias, const int *const matrix,
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
+{
+ uint16_t *dst = (uint16_t *)dstp;
+ int y;
+
+ for (y = 0; y < height; y++) {
+ int i, sum = 0;
+
+ for (i = 0; i < 2 * radius + 1; i++)
+ sum += AV_RN16A(&c[i][0 + y * stride]) * matrix[i];
+
+ sum = (int)(sum * rdiv + bias + 0.5f);
+ dst[0] = av_clip(sum, 0, peak);
+ dst += dstride / 2;
+ }
+}
+
+static void filter_7x7(uint8_t *dst, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
int x;
}
}
-static void filter_5x5(uint8_t *dst, const uint8_t *src, int width,
+static void filter_5x5(uint8_t *dst, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
int x;
}
}
-static void filter_3x3(uint8_t *dst, const uint8_t *src, int width,
+static void filter_3x3(uint8_t *dst, int width,
float rdiv, float bias, const int *const matrix,
- const uint8_t *c[], int peak)
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
{
const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
const uint8_t *c3 = c[3], *c4 = c[4], *c5 = c[5];
}
}
-static void setup_3x3(const uint8_t *c[], const uint8_t *src, int stride,
+static void filter_row(uint8_t *dst, int width,
+ float rdiv, float bias, const int *const matrix,
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
+{
+ int x;
+
+ for (x = 0; x < width; x++) {
+ int i, sum = 0;
+
+ for (i = 0; i < 2 * radius + 1; i++)
+ sum += c[i][x] * matrix[i];
+
+ sum = (int)(sum * rdiv + bias + 0.5f);
+ dst[x] = av_clip_uint8(sum);
+ }
+}
+
+static void filter_column(uint8_t *dst, int height,
+ float rdiv, float bias, const int *const matrix,
+ const uint8_t *c[], int peak, int radius,
+ int dstride, int stride)
+{
+ int y;
+
+ for (y = 0; y < height; y++) {
+ int i, sum = 0;
+
+ for (i = 0; i < 2 * radius + 1; i++)
+ sum += c[i][0 + y * stride] * matrix[i];
+
+ sum = (int)(sum * rdiv + bias + 0.5f);
+ dst[0] = av_clip_uint8(sum);
+ dst += dstride;
+ }
+}
+
+static void setup_3x3(int radius, const uint8_t *c[], const uint8_t *src, int stride,
int x, int w, int y, int h, int bpc)
{
int i;
}
}
-static void setup_5x5(const uint8_t *c[], const uint8_t *src, int stride,
+static void setup_5x5(int radius, const uint8_t *c[], const uint8_t *src, int stride,
int x, int w, int y, int h, int bpc)
{
int i;
}
}
-static void setup_7x7(const uint8_t *c[], const uint8_t *src, int stride,
+static void setup_7x7(int radius, const uint8_t *c[], const uint8_t *src, int stride,
int x, int w, int y, int h, int bpc)
{
int i;
}
}
+static void setup_row(int radius, const uint8_t *c[], const uint8_t *src, int stride,
+ int x, int w, int y, int h, int bpc)
+{
+ int i;
+
+ for (i = 0; i < radius * 2 + 1; i++) {
+ int xoff = FFABS(x + i - radius);
+
+ xoff = xoff >= w ? 2 * w - 1 - xoff : xoff;
+
+ c[i] = src + xoff * bpc + y * stride;
+ }
+}
+
+static void setup_column(int radius, const uint8_t *c[], const uint8_t *src, int stride,
+ int x, int w, int y, int h, int bpc)
+{
+ int i;
+
+ for (i = 0; i < radius * 2 + 1; i++) {
+ int xoff = FFABS(x + i - radius);
+
+ xoff = xoff >= h ? 2 * h - 1 - xoff : xoff;
+
+ c[i] = src + y * bpc + xoff * stride;
+ }
+}
+
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
{
ConvolutionContext *s = ctx->priv;
int plane;
for (plane = 0; plane < s->nb_planes; plane++) {
+ const int mode = s->mode[plane];
+ const int bpc = s->bpc;
const int radius = s->size[plane] / 2;
const int height = s->planeheight[plane];
const int width = s->planewidth[plane];
const int stride = in->linesize[plane];
const int dstride = out->linesize[plane];
- const int slice_start = (height * jobnr) / nb_jobs;
- const int slice_end = (height * (jobnr+1)) / nb_jobs;
+ const int sizeh = mode == MATRIX_COLUMN ? width : height;
+ const int sizew = mode == MATRIX_COLUMN ? height : width;
+ const int slice_start = (sizeh * jobnr) / nb_jobs;
+ const int slice_end = (sizeh * (jobnr+1)) / nb_jobs;
const float rdiv = s->rdiv[plane];
const float bias = s->bias[plane];
const uint8_t *src = in->data[plane];
- uint8_t *dst = out->data[plane] + slice_start * out->linesize[plane];
+ const int dst_pos = slice_start * (mode == MATRIX_COLUMN ? bpc : dstride);
+ uint8_t *dst = out->data[plane] + dst_pos;
const int *matrix = s->matrix[plane];
- const int bpc = s->bpc;
const uint8_t *c[49];
int y, x;
if (s->copy[plane]) {
- av_image_copy_plane(dst, dstride, src + slice_start * stride, stride,
- width * bpc, slice_end - slice_start);
+ if (mode == MATRIX_COLUMN)
+ av_image_copy_plane(dst, dstride, src + slice_start * bpc, stride,
+ (slice_end - slice_start) * bpc, height);
+ else
+ av_image_copy_plane(dst, dstride, src + slice_start * stride, stride,
+ width * bpc, slice_end - slice_start);
continue;
}
for (y = slice_start; y < slice_end; y++) {
+ const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : radius * bpc;
+ const int yoff = mode == MATRIX_COLUMN ? radius * stride : 0;
+
for (x = 0; x < radius; x++) {
- s->setup[plane](c, src, stride, x, width, y, height, bpc);
- s->filter[plane](dst + x * bpc, src, 1, rdiv, bias, matrix, c, s->max);
+ const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : x * bpc;
+ const int yoff = mode == MATRIX_COLUMN ? x * stride : 0;
+
+ s->setup[plane](radius, c, src, stride, x, width, y, height, bpc);
+ s->filter[plane](dst + yoff + xoff, 1, rdiv,
+ bias, matrix, c, s->max, radius,
+ dstride, stride);
}
- s->setup[plane](c, src, stride, radius, width, y, height, bpc);
- s->filter[plane](dst + radius * bpc, src, width - 2 * radius,
- rdiv, bias, matrix, c, s->max);
- for (x = width - radius; x < width; x++) {
- s->setup[plane](c, src, stride, x, width, y, height, bpc);
- s->filter[plane](dst + x * bpc, src, 1, rdiv, bias, matrix, c, s->max);
+ s->setup[plane](radius, c, src, stride, radius, width, y, height, bpc);
+ s->filter[plane](dst + yoff + xoff, sizew - 2 * radius,
+ rdiv, bias, matrix, c, s->max, radius,
+ dstride, stride);
+ for (x = sizew - radius; x < sizew; x++) {
+ const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : x * bpc;
+ const int yoff = mode == MATRIX_COLUMN ? x * stride : 0;
+
+ s->setup[plane](radius, c, src, stride, x, width, y, height, bpc);
+ s->filter[plane](dst + yoff + xoff, 1, rdiv,
+ bias, matrix, c, s->max, radius,
+ dstride, stride);
}
- dst += dstride;
+ if (mode != MATRIX_COLUMN)
+ dst += dstride;
}
}
if (!strcmp(ctx->filter->name, "convolution")) {
if (s->depth > 8) {
for (p = 0; p < s->nb_planes; p++) {
- if (s->size[p] == 3)
+ if (s->mode[p] == MATRIX_ROW)
+ s->filter[p] = filter16_row;
+ else if (s->mode[p] == MATRIX_COLUMN)
+ s->filter[p] = filter16_column;
+ else if (s->size[p] == 3)
s->filter[p] = filter16_3x3;
else if (s->size[p] == 5)
s->filter[p] = filter16_5x5;
td.in = in;
td.out = out;
- ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(s->planeheight[1], s->nb_threads));
+ ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN3(s->planeheight[1], s->planewidth[1], s->nb_threads));
av_frame_free(&in);
return ff_filter_frame(outlink, out);
s->matrix_length[i]++;
}
- if (s->matrix_length[i] == 9) {
+ if (!(s->matrix_length[i] & 1)) {
+ av_log(ctx, AV_LOG_ERROR, "number of matrix elements must be odd\n");
+ return AVERROR(EINVAL);
+ }
+ if (s->mode[i] == MATRIX_ROW) {
+ s->filter[i] = filter_row;
+ s->setup[i] = setup_row;
+ s->size[i] = s->matrix_length[i];
+ } else if (s->mode[i] == MATRIX_COLUMN) {
+ s->filter[i] = filter_column;
+ s->setup[i] = setup_column;
+ s->size[i] = s->matrix_length[i];
+ } else if (s->matrix_length[i] == 9) {
s->size[i] = 3;
if (!memcmp(matrix, same3x3, sizeof(same3x3)))
s->copy[i] = 1;
projects / ffmpeg / blobdiff