Merge pull request #23 from quietvoid/fix_deband

Modernize placebo code and fix conflicting function names

Author: quietvoid

README.md

@@ -84,6 +84,13 @@ using the supplied filter options, which are identical to ``Resample``’s.
 
  
 
+### Debugging `libplacebo` processing
+
+All the filters can take a `log_level` argument corresponding to a `pl_log_level`.  
+Defaults to 2, meaning only errors are logged.
+
+ 
+
 ### Installing
 
 If you’re on Arch, just do

src/deband.c

@@ -16,86 +16,39 @@ typedef struct {
     int dither;
     struct pl_dither_params *ditherParams;
     struct pl_deband_params *debandParams;
-    int renderer; // for debugging purposes
     uint8_t frame_index;
+
     pthread_mutex_t lock;
-} MData;
+} DebandData;
 
-bool do_plane(struct priv *p, void* data, int chroma)
+bool vspl_deband_do_plane(struct priv *p, void* data)
 {
-    MData* d = (MData*) data;
-
-    if (!d->renderer) {
-
-        struct pl_shader *sh = pl_dispatch_begin(p->dp);
-        pl_shader_reset(sh, &(struct pl_shader_params) {
-            .gpu = p->gpu,
-            .index = d->frame_index++,
-        });
-
-        int new_depth = p->tex_out[0]->params.format->component_depth[0];
-        pl_shader_deband(sh, &(struct pl_sample_src) {.tex = p->tex_in[0]},
-                         d->debandParams);
-        if (d->dither)
-            pl_shader_dither(sh, new_depth, &p->dither_state, d->ditherParams);
-        return pl_dispatch_finish(p->dp, &(struct pl_dispatch_params) {
-            .shader = &sh,
-            .target = p->tex_out[0],
-        });
-
-    } else {
-        struct pl_color_repr crpr = {
-            .bits = {
-                .sample_depth = d->vi->format->bytesPerSample * 8,
-                .color_depth = d->vi->format->bytesPerSample * 8,
-                .bit_shift = 0
-            },
-            .levels = PL_COLOR_LEVELS_UNKNOWN,
-            .alpha = PL_ALPHA_UNKNOWN,
-            .sys = PL_COLOR_SYSTEM_UNKNOWN
-        };
-
-        int src_w = d->vi->width >> (chroma ? d->vi->format->subSamplingW : 0);
-        int src_h = d->vi->height >> (chroma ? d->vi->format->subSamplingH : 0);
-
-        struct pl_color_space color = (struct pl_color_space) {0};
-
-        struct pl_frame img = {
-            .num_planes = 1,
-            .planes = {{
-                .texture = p->tex_in[0],
-                .components = p->tex_in[0]->params.format->num_components,
-                .component_mapping = {0, 1, 2, 3},
-            }},
-            .repr = crpr,
-            .color = color,
-            .crop = {0, 0, src_w, src_h},
-        };
-
-        struct pl_frame out = {
-            .num_planes = 1,
-            .planes = {{
-                .texture = p->tex_out[0],
-                .components = p->tex_out[0]->params.format->num_components,
-                .component_mapping = {0, 1, 2, 3},
-            }},
-            .repr = crpr,
-            .color = color,
-            .crop = {0, 0, src_w, src_h},
-        };
-
-        pl_rect2df_aspect_copy(&out.crop, &img.crop, 0.0);
-
-        struct pl_render_params par = pl_render_default_params;
-        par.deband_params = d->debandParams;
-        par.dither_params = d->dither ? d->ditherParams : NULL;
-
-        return pl_render_image(p->rr, &img, &out, &par);
+    DebandData* d = (DebandData*) data;
 
-    }
+    pl_shader sh = pl_dispatch_begin(p->dp);
+    pl_shader_reset(sh, pl_shader_params(
+        .gpu = p->gpu,
+        .index = d->frame_index++,
+    ));
+
+    struct pl_sample_src *src = pl_sample_src(
+        .tex = p->tex_in[0]
+    );
+
+    int new_depth = p->tex_out[0]->params.format->component_depth[0];
+
+    pl_shader_deband(sh, src, d->debandParams);
+
+    if (d->dither)
+        pl_shader_dither(sh, new_depth, &p->dither_state, d->ditherParams);
+
+    return pl_dispatch_finish(p->dp, pl_dispatch_params(
+        .target = p->tex_out[0],
+        .shader = &sh,
+    ));
 }
 
-bool reconfig(void *priv, struct pl_plane_data *data, const VSAPI *vsapi)
+bool vspl_deband_reconfig(void *priv, const struct pl_plane_data *data, const VSAPI *vsapi, VSFrameRef *dst, int planeIdx)
 {
     struct priv *p = priv;
 
@@ -106,21 +59,21 @@ bool reconfig(void *priv, struct pl_plane_data *data, const VSAPI *vsapi)
     }
 
     bool ok = true;
-    ok &= pl_tex_recreate(p->gpu, &p->tex_in[0], &(struct pl_tex_params) {
-            .w = data->width,
-            .h = data->height,
-            .format = fmt,
-            .sampleable = true,
-            .host_writable = true,
-    });
-
-    ok &= pl_tex_recreate(p->gpu, &p->tex_out[0], &(struct pl_tex_params) {
-            .w = data->width,
-            .h = data->height,
-            .format = fmt,
-            .renderable = true,
-            .host_readable = true,
-    });
+    ok &= pl_tex_recreate(p->gpu, &p->tex_in[0], pl_tex_params(
+        .w = data->width,
+        .h = data->height,
+        .format = fmt,
+        .sampleable = true,
+        .host_writable = true,
+    ));
+
+    ok &= pl_tex_recreate(p->gpu, &p->tex_out[0], pl_tex_params(
+        .w = vsapi->getFrameWidth(dst, planeIdx),
+        .h = vsapi->getFrameHeight(dst, planeIdx),
+        .format = fmt,
+        .renderable = true,
+        .host_readable = true,
+    ));
 
     if (!ok) {
         vsapi->logMessage(mtCritical, "Failed creating GPU textures!\n");
@@ -130,35 +83,40 @@ bool reconfig(void *priv, struct pl_plane_data *data, const VSAPI *vsapi)
     return true;
 }
 
-bool filter(void *priv, void *dst, struct pl_plane_data *src, void* d, const VSAPI *vsapi, int chroma)
+bool vspl_deband_filter(void *priv, VSFrameRef *dst, const struct pl_plane_data *data, void* d, const VSAPI *vsapi, int planeIdx)
 {
     struct priv *p = priv;
+    pl_fmt in_fmt = p->tex_in[0]->params.format;
+    pl_fmt out_fmt = p->tex_out[0]->params.format;
 
     // Upload planes
     bool ok = true;
-    ok &= pl_tex_upload(p->gpu, &(struct pl_tex_transfer_params) {
+    ok &= pl_tex_upload(p->gpu, pl_tex_transfer_params(
         .tex = p->tex_in[0],
-        .stride_w = src->row_stride / src->pixel_stride,
-        .ptr = (void *) src->pixels,
-    });
+        .row_pitch = (data->row_stride / data->pixel_stride) * in_fmt->texel_size,
+        .ptr = (void *) data->pixels,
+    ));
 
     if (!ok) {
         vsapi->logMessage(mtCritical, "Failed uploading data to the GPU!\n");
         return false;
     }
 
     // Process plane
-    if (!do_plane(p, d, chroma)) {
+    if (!vspl_deband_do_plane(p, d)) {
         vsapi->logMessage(mtCritical, "Failed processing planes!\n");
         return false;
     }
 
+    uint8_t *dst_ptr = vsapi->getWritePtr(dst, planeIdx);
+    int dst_row_pitch = (vsapi->getStride(dst, planeIdx) / data->pixel_stride) * out_fmt->texel_size;
+
     // Download planes
-    ok = pl_tex_download(p->gpu, &(struct pl_tex_transfer_params) {
+    ok = pl_tex_download(p->gpu, pl_tex_transfer_params(
         .tex = p->tex_out[0],
-        .stride_w = src->row_stride / src->pixel_stride,
-        .ptr = dst,
-    });
+        .row_pitch = dst_row_pitch,
+        .ptr = (void *) dst_ptr,
+    ));
 
     if (!ok) {
         vsapi->logMessage(mtCritical, "Failed downloading data from the GPU!\n");
@@ -168,14 +126,14 @@ bool filter(void *priv, void *dst, struct pl_plane_data *src, void* d, const VSA
     return true;
 }
 
-static void VS_CC DebandInit(VSMap *in, VSMap *out, void **instanceData, VSNode *node, VSCore *core, const VSAPI *vsapi) {
-    MData *d = (MData *) * instanceData;
+static void VS_CC VSPlaceboDebandInit(VSMap *in, VSMap *out, void **instanceData, VSNode *node, VSCore *core, const VSAPI *vsapi) {
+    DebandData *d = (DebandData *) * instanceData;
     VSVideoInfo new_vi = (VSVideoInfo) * (d->vi);
     vsapi->setVideoInfo(&new_vi, 1, node);
 }
 
-static const VSFrameRef *VS_CC DebandGetFrame(int n, int activationReason, void **instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
-    MData *d = (MData *) * instanceData;
+static const VSFrameRef *VS_CC VSPlaceboDebandGetFrame(int n, int activationReason, void **instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
+    DebandData *d = (DebandData *) * instanceData;
 
     if (activationReason == arInitial) {
         vsapi->requestFrameFilter(n, d->node, frameCtx);
@@ -185,32 +143,37 @@ static const VSFrameRef *VS_CC DebandGetFrame(int n, int activationReason, void
         int ih = vsapi->getFrameHeight(frame, 0);
         int iw = vsapi->getFrameWidth(frame, 0);
 
-        int copy[3];
+        int copy[3] = {0};
         for (unsigned int j = 0; j < 3; ++j)
             copy[j] = ((1u << j) & d->planes) == 0;
 
-        VSFrameRef *dst = vsapi->newVideoFrame(d->vi->format, iw, ih, frame, core);
+        const VSFormat *srcFmt = d->vi->format;
+        VSFrameRef *dst = vsapi->newVideoFrame(srcFmt, iw, ih, frame, core);
 
-        for (int i=0; i<d->vi->format->numPlanes; i++) {
+        for (unsigned int i = 0; i < srcFmt->numPlanes; i++) {
             if (copy[i]) {
                 vs_bitblt(vsapi->getWritePtr(dst, i), vsapi->getStride(dst, i), vsapi->getWritePtr((VSFrameRef *) frame, i),
                           vsapi->getStride(frame, i), vsapi->getFrameWidth(dst, i) * d->vi->format->bytesPerSample,
                           vsapi->getFrameHeight(dst, i));
             } else {
-                struct pl_plane_data plane = {
-                        .type = d->vi->format->sampleType == stInteger ? PL_FMT_UNORM : PL_FMT_FLOAT,
-                        .width = vsapi->getFrameWidth(frame, i),
-                        .height = vsapi->getFrameHeight(frame, i),
-                        .pixel_stride = 1 /* components */ * d->vi->format->bytesPerSample /* bytes per sample*/,
-                        .row_stride =  vsapi->getStride(frame, i),
-                        .pixels =  vsapi->getWritePtr((VSFrameRef *) frame, i),
-                        .component_size[0] = d->vi->format->bitsPerSample,
-                        .component_pad[0] = 0,
-                        .component_map[0] = 0,
+                const struct pl_plane_data plane = {
+                    .type = srcFmt->sampleType == stInteger ? PL_FMT_UNORM : PL_FMT_FLOAT,
+                    .width = vsapi->getFrameWidth(frame, i),
+                    .height = vsapi->getFrameHeight(frame, i),
+                    .pixel_stride = srcFmt->bytesPerSample,
+                    .row_stride = vsapi->getStride(frame, i),
+                    .pixels = vsapi->getReadPtr((VSFrameRef *) frame, i),
+                    .component_size[0] = srcFmt->bitsPerSample,
+                    .component_pad[0] = 0,
+                    .component_map[0] = 0,
                 };
+
                 pthread_mutex_lock(&d->lock); // libplacebo isn’t thread-safe
-                if (reconfig(d->vf, &plane, vsapi))
-                    filter(d->vf, vsapi->getWritePtr(dst, i), &plane, d, vsapi, i != 0);
+
+                if (vspl_deband_reconfig(d->vf, &plane, vsapi, dst, i)) {
+                    vspl_deband_filter(d->vf, dst, &plane, d, vsapi, i);
+                }
+
                 pthread_mutex_unlock(&d->lock);
             }
         }
@@ -222,27 +185,32 @@ static const VSFrameRef *VS_CC DebandGetFrame(int n, int activationReason, void
     return 0;
 }
 
-static void VS_CC DebandFree(void *instanceData, VSCore *core, const VSAPI *vsapi) {
-    MData *d = (MData *)instanceData;
+static void VS_CC VSPlaceboDebandFree(void *instanceData, VSCore *core, const VSAPI *vsapi) {
+    DebandData *d = (DebandData *) instanceData;
     vsapi->freeNode(d->node);
-    uninit(d->vf);
+    VSPlaceboUninit(d->vf);
     free(d->ditherParams);
     free(d->debandParams);
     pthread_mutex_destroy(&d->lock);
     free(d);
 }
 
-void VS_CC DebandCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi) {
-    MData d;
-    MData *data;
+void VS_CC VSPlaceboDebandCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi) {
+    DebandData d;
+    DebandData *data;
     int err;
+    enum pl_log_level log_level;
 
     if (pthread_mutex_init(&d.lock, NULL) != 0)
     {
         vsapi->setError(out, "placebo.Deband: mutex init failed\n");
         return;
     }
 
+    log_level = vsapi->propGetInt(in, "log_level", 0, &err);
+    if (err)
+        log_level = PL_LOG_ERR;
+
     d.node = vsapi->propGetNode(in, "clip", 0, 0);
     d.vi = vsapi->getVideoInfo(d.node);
 
@@ -251,9 +219,8 @@ void VS_CC DebandCreate(const VSMap *in, VSMap *out, void *userData, VSCore *cor
         vsapi->freeNode(d.node);
     }
 
-    d.vf = init();
+    d.vf = VSPlaceboInit(log_level);
 
-    d.renderer = vsapi->propGetInt(in, "renderer_api", 0, &err);
     d.dither = vsapi->propGetInt(in, "dither", 0, &err) && d.vi->format->bitsPerSample == 8;
     if (err)
         d.dither = d.vi->format->bitsPerSample == 8;
@@ -263,24 +230,28 @@ void VS_CC DebandCreate(const VSMap *in, VSMap *out, void *userData, VSCore *cor
         d.planes = 1u;
 
     struct pl_deband_params *debandParams = malloc(sizeof(struct pl_deband_params));
+    *debandParams = pl_deband_default_params;
+
 #define DB_PARAM(par, type) debandParams->par = vsapi->propGet##type(in, #par, 0, &err); \
         if (err) debandParams->par = pl_deband_default_params.par;
 
     DB_PARAM(iterations, Int)
     DB_PARAM(threshold, Float)
-    DB_PARAM(grain, Float)
     DB_PARAM(radius, Float)
+    DB_PARAM(grain, Float)
 
     struct pl_dither_params *plDitherParams = malloc(sizeof(struct pl_dither_params));
     *plDitherParams = pl_dither_default_params;
+
     plDitherParams->method = vsapi->propGetInt(in, "dither_algo", 0, &err);
     if (err)
         plDitherParams->method = pl_dither_default_params.method;
 
     d.ditherParams = plDitherParams;
     d.debandParams = debandParams;
+    d.frame_index = 0;
     data = malloc(sizeof(d));
     *data = d;
 
-    vsapi->createFilter(in, out, "Deband", DebandInit, DebandGetFrame, DebandFree, fmParallel, 0, data, core);
+    vsapi->createFilter(in, out, "Deband", VSPlaceboDebandInit, VSPlaceboDebandGetFrame, VSPlaceboDebandFree, fmParallel, 0, data, core);
 }

src/deband.h

@@ -3,6 +3,6 @@
 
 #include "VapourSynth.h"
 
-void VS_CC DebandCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi);
+void VS_CC VSPlaceboDebandCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi);
 
 #endif //VS_PLACEBO_DEBAND_H