diff --git a/libavfilter/vf_neighbor.c b/libavfilter/vf_neighbor.c
index 12fe4b7ab77c80f9f87df4a51dfcb2a931aa8b54..4af71685991bdfae797b33d5ba224bcaa93c4e5c 100644
--- a/libavfilter/vf_neighbor.c
+++ b/libavfilter/vf_neighbor.c
@@ -20,6 +20,7 @@
  */
 
 #include "libavutil/imgutils.h"
+#include "libavutil/intreadwrite.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/opt.h"
 #include "avfilter.h"
@@ -39,6 +40,9 @@ typedef struct NContext {
     int threshold[4];
     int coordinates;
 
+    int depth;
+    int bpc;
+
     void (*filter)(uint8_t *dst, const uint8_t *p1, int width,
                    int threshold, const uint8_t *coordinates[], int coord);
 } NContext;
@@ -46,10 +50,24 @@ typedef struct NContext {
 static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pix_fmts[] = {
-        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
-        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
-        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
+        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_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        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_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
+        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
+        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_NONE
     };
 
     return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
@@ -75,6 +93,27 @@ static void erosion(uint8_t *dst, const uint8_t *p1, int width,
     }
 }
 
+static void erosion16(uint8_t *dstp, const uint8_t *p1, int width,
+                      int threshold, const uint8_t *coordinates[], int coord)
+{
+    uint16_t *dst = (uint16_t *)dstp;
+    int x, i;
+
+    for (x = 0; x < width; x++) {
+        int min = AV_RN16A(&p1[2 * x]);
+        int limit = FFMAX(min - threshold, 0);
+
+        for (i = 0; i < 8; i++) {
+            if (coord & (1 << i)) {
+                min = FFMIN(min, AV_RN16A(coordinates[i] + x * 2));
+            }
+            min = FFMAX(min, limit);
+        }
+
+        dst[x] = min;
+    }
+}
+
 static void dilation(uint8_t *dst, const uint8_t *p1, int width,
                      int threshold, const uint8_t *coordinates[], int coord)
 {
@@ -95,6 +134,27 @@ static void dilation(uint8_t *dst, const uint8_t *p1, int width,
     }
 }
 
+static void dilation16(uint8_t *dstp, const uint8_t *p1, int width,
+                       int threshold, const uint8_t *coordinates[], int coord)
+{
+    uint16_t *dst = (uint16_t *)dstp;
+    int x, i;
+
+    for (x = 0; x < width; x++) {
+        int max = AV_RN16A(&p1[x * 2]);
+        int limit = FFMIN(max + threshold, 255);
+
+        for (i = 0; i < 8; i++) {
+            if (coord & (1 << i)) {
+                max = FFMAX(max, AV_RN16A(coordinates[i] + x * 2));
+            }
+            max = FFMIN(max, limit);
+        }
+
+        dst[x] = max;
+    }
+}
+
 static void deflate(uint8_t *dst, const uint8_t *p1, int width,
                     int threshold, const uint8_t *coordinates[], int coord)
 {
@@ -110,6 +170,22 @@ static void deflate(uint8_t *dst, const uint8_t *p1, int width,
     }
 }
 
+static void deflate16(uint8_t *dstp, const uint8_t *p1, int width,
+                      int threshold, const uint8_t *coordinates[], int coord)
+{
+    uint16_t *dst = (uint16_t *)dstp;
+    int x, i;
+
+    for (x = 0; x < width; x++) {
+        int sum = 0;
+        int limit = FFMAX(AV_RN16A(&p1[2 * x]) - threshold, 0);
+
+        for (i = 0; i < 8; sum += AV_RN16A(coordinates[i++] + x * 2));
+
+        dst[x] = FFMAX(FFMIN(sum / 8, p1[x]), limit);
+    }
+}
+
 static void inflate(uint8_t *dst, const uint8_t *p1, int width,
                     int threshold, const uint8_t *coordinates[], int coord)
 {
@@ -125,29 +201,46 @@ static void inflate(uint8_t *dst, const uint8_t *p1, int width,
     }
 }
 
+static void inflate16(uint8_t *dstp, const uint8_t *p1, int width,
+                      int threshold, const uint8_t *coordinates[], int coord)
+{
+    uint16_t *dst = (uint16_t *)dstp;
+    int x, i;
+
+    for (x = 0; x < width; x++) {
+        int sum = 0;
+        int limit = FFMIN(AV_RN16A(&p1[2 * x]) + threshold, 255);
+
+        for (i = 0; i < 8; sum += AV_RN16A(coordinates[i++] + x * 2));
+
+        dst[x] = FFMIN(FFMAX(sum / 8, p1[x]), limit);
+    }
+}
+
 static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
     NContext *s = ctx->priv;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
-    int ret;
 
-    if ((ret = av_image_fill_linesizes(s->planewidth, inlink->format, inlink->w)) < 0)
-        return ret;
+    s->depth = desc->comp[0].depth;
+    s->bpc = (s->depth + 7) / 8;
 
+    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;
 
     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
 
     if (!strcmp(ctx->filter->name, "erosion"))
-        s->filter = erosion;
+        s->filter = s->depth > 8 ? erosion16 : erosion;
     else if (!strcmp(ctx->filter->name, "dilation"))
-        s->filter = dilation;
+        s->filter = s->depth > 8 ? dilation16 : dilation;
     else if (!strcmp(ctx->filter->name, "deflate"))
-        s->filter = deflate;
+        s->filter = s->depth > 8 ? deflate16 : deflate;
     else if (!strcmp(ctx->filter->name, "inflate"))
-        s->filter = inflate;
+        s->filter = s->depth > 8 ? inflate16 : inflate;
 
     return 0;
 }
@@ -161,6 +254,7 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
     int plane, y;
 
     for (plane = 0; plane < s->nb_planes; plane++) {
+        const int bpc = s->bpc;
         const int threshold = s->threshold[plane];
         const int stride = in->linesize[plane];
         const int dstride = out->linesize[plane];
@@ -172,28 +266,28 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
         uint8_t *dst = out->data[plane] + slice_start * dstride;
 
         if (!threshold) {
-            av_image_copy_plane(dst, dstride, src, stride, width, slice_end - slice_start);
+            av_image_copy_plane(dst, dstride, src, stride, width * bpc, slice_end - slice_start);
             continue;
         }
 
         for (y = slice_start; y < slice_end; y++) {
             const int nh = y > 0;
             const int ph = y < height - 1;
-            const uint8_t *coordinates[] = { src - nh * stride, src + 1 - nh * stride, src + 2 - nh * stride,
-                                             src,                                      src + 2,
-                                             src + ph * stride, src + 1 + ph * stride, src + 2 + ph * stride};
+            const uint8_t *coordinates[] = { src - nh * stride, src + 1 * bpc - nh * stride, src + 2 * bpc - nh * stride,
+                                             src,                                            src + 2 * bpc,
+                                             src + ph * stride, src + 1 * bpc + ph * stride, src + 2 * bpc + ph * stride};
 
-            const uint8_t *coordinateslb[] = { src - nh * stride, src - nh * stride, src + 1 - nh * stride,
-                                               src,                                  src + 1,
-                                               src + ph * stride, src + ph * stride, src + 1 + ph * stride};
+            const uint8_t *coordinateslb[] = { src + 1 * bpc - nh * stride, src - nh * stride, src + 1 * bpc - nh * stride,
+                                               src + 1 * bpc,                                  src + 1 * bpc,
+                                               src + 1 * bpc + ph * stride, src + ph * stride, src + 1 * bpc + ph * stride};
 
-            const uint8_t *coordinatesrb[] = { src + width - 2 - nh * stride, src + width - 1 - nh * stride, src + width - 1 - nh * stride,
-                                               src + width - 2,                                              src + width - 1,
-                                               src + width - 2 + ph * stride, src + width - 1 + ph * stride, src + width - 1 + ph * stride};
+            const uint8_t *coordinatesrb[] = { src + (width - 2) * bpc - nh * stride, src + (width - 1) * bpc - nh * stride, src + (width - 2) * bpc - nh * stride,
+                                               src + (width - 2) * bpc,                                                      src + (width - 2) * bpc,
+                                               src + (width - 2) * bpc + ph * stride, src + (width - 1) * bpc + ph * stride, src + (width - 2) * bpc + ph * stride};
 
-            s->filter(dst,             src,             1,         threshold, coordinateslb, s->coordinates);
-            s->filter(dst         + 1, src         + 1, width - 2, threshold, coordinates,   s->coordinates);
-            s->filter(dst + width - 1, src + width - 1, 1,         threshold, coordinatesrb, s->coordinates);
+            s->filter(dst,                     src,                     1,         threshold, coordinateslb, s->coordinates);
+            s->filter(dst          + 1  * bpc, src          + 1  * bpc, width - 2, threshold, coordinates,   s->coordinates);
+            s->filter(dst + (width - 1) * bpc, src + (width - 1) * bpc, 1,         threshold, coordinatesrb, s->coordinates);
 
             src += stride;
             dst += dstride;