Another new filter, RGB Split

Paul2 · April 7, 2019, 12:35pm

New RGB split filter to try out.

RGBshift.zip (1.9 KB)

BEFORE:
NoShift

AFTER:
WithShift

sauron · April 7, 2019, 5:21pm

This one’s working well. Another well done filter.

https://streamable.com/anso9

jonray · April 7, 2019, 6:02pm

NICE! Well done @Paul2 and @sauron for the demo.

sauron · April 7, 2019, 8:32pm

Might have found a bug in the RGB filter. Don’t think the UI is the problem.

Apply the filter to an image or clip. It works fine.

Put an image or clip on the track below and the image with the RGB filter disappears. The image on the lower track shows.

brian · April 7, 2019, 8:45pm

Inspecting the source code for this filter, it looks like the alpha gets cleared out:

github.com

dyne/frei0r/blob/master/src/filter/rgbsplit0r/rgbsplit0r.c#L227


      
          /* rgbsplit0r.c
           * Copyright (C) 2016 IDENT Software ~ http://identsoft.org
           * Inspired by the witch house and web culture
           * 
           * This file is a Frei0r plugin.
           *
           * This program is free software; you can redistribute it and/or modify
           * it under the terms of the GNU General Public License as published by
           * the Free Software Foundation; either version 2 of the License, or
           * (at your option) any later version.
           *
           * This program is distributed in the hope that it will be useful,
           * but WITHOUT ANY WARRANTY; without even the implied warranty of
           * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
           * GNU General Public License for more details.
           *
           * You should have received a copy of the GNU General Public License
           * along with this program; if not, write to the Free Software
           * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
           */
          
          #include <stdlib.h>
          #include <assert.h>
          
          #include "frei0r.h"
          
          typedef struct rgbsplit0r_instance
          {
              unsigned int width;
              unsigned int height;
              unsigned int shiftX;
              unsigned int shiftY;
          
          } rgbsplit0r_instance_t;
          
          
          inline static void rgbsplit0r_extract_color(uint32_t *pixelIn, uint32_t *pixelOut,
                                                      short int colorIndex)
          {
              uint8_t *pxIn  = (uint8_t *)pixelIn,
                      *pxOut = (uint8_t *)pixelOut;
          
              switch (colorIndex)
              {
                  case 0 :
                      pxOut[0] = pxIn[0];
                      pxOut[1] = 0;
                      pxOut[2] = 0;
                      break;
          
                  case 1 :
                      pxOut[1] = pxIn[1];
                      pxOut[0] = 0;
                      pxOut[2] = 0;
                      break;
          
                  case 2 :
                      pxOut[2] = pxIn[2];
                      pxOut[1] = 0;
                      pxOut[0] = 0;
                      break;
              }
              pxOut[3] = pxIn[3];
          }
          
          int f0r_init()
          {
              return 1;
          }
          
          void f0r_deinit()
          { /* no initialization required */ }
          
          void f0r_get_plugin_info(f0r_plugin_info_t* rgbsplit0rInfo)
          {
              rgbsplit0rInfo->name = "rgbsplit0r";
              rgbsplit0rInfo->author = "IDENT Software";
              rgbsplit0rInfo->plugin_type = F0R_PLUGIN_TYPE_FILTER;
              rgbsplit0rInfo->color_model = F0R_COLOR_MODEL_RGBA8888;
              rgbsplit0rInfo->frei0r_version = FREI0R_MAJOR_VERSION;
              rgbsplit0rInfo->major_version = 1;
              rgbsplit0rInfo->minor_version = 1;
              rgbsplit0rInfo->num_params =  2;
              rgbsplit0rInfo->explanation = "RGB splitting and shifting";
          }
          
          void f0r_get_param_info(f0r_param_info_t* info, int param_index)
          {
              switch(param_index) {
                  case 0:
                  {
                      info->name = "Vertical split distance";
                      info->type = F0R_PARAM_DOUBLE;
                      info->explanation = "How far should layers be moved vertically from each other";
                      break;
                  }
          
                  case 1:
                  {
                      info->name = "Horizontal split distance";
                      info->type = F0R_PARAM_DOUBLE;
                      info->explanation = "How far should layers be moved horizontally from each other";
                      break;
                  }
              }
          }
          
          f0r_instance_t f0r_construct(unsigned int width, unsigned int height)
          {
              rgbsplit0r_instance_t* inst = (rgbsplit0r_instance_t*)calloc(1, sizeof(*inst));
              inst->width = width; inst->height = height;
              inst->shiftY = 0;
              inst->shiftX = 0;
          
              return (f0r_instance_t)inst;
          }
          
          void f0r_destruct(f0r_instance_t instance)
          {
              free(instance);
          }
          
          void f0r_set_param_value(f0r_instance_t instance, 
          			 f0r_param_t param, int param_index)
          {
              assert(instance);
              rgbsplit0r_instance_t *inst = (rgbsplit0r_instance_t*)instance;
          
              switch (param_index)
              {
          
                  case 0 : // vertical shift
                  {
                      // scale to [-1/16..1/16]
                      double shiftY = *((double*)param) - 0.5;
          
                      // Convert to range from 0 to one eighth of height
                      shiftY = ((inst->height / 8) * shiftY);
          
                      inst->shiftY = (unsigned int)shiftY;
                      break;
                  }
          
                  case 1 : // horizontal shift
                  {
                      // scale to [-1/16..1/16]
                      double shiftX = *((double*)param) - 0.5;
                      
                      // Convert to range from 0 to one eighth of width
                      shiftX = ((inst->width / 8) * shiftX);
          
                      inst->shiftX = (unsigned int)shiftX;
                      break;
                  }
              }
          }
          
          void f0r_get_param_value(f0r_instance_t instance,
          			f0r_param_t param, int param_index)
          {
          
              assert(instance);
              rgbsplit0r_instance_t *inst = (rgbsplit0r_instance_t*)instance;
          
              switch (param_index)
              {
                  case 0 : // vertical shift
                  {
                      // convert plugin's param to frei0r range
                      *((double*)param) = (inst->shiftY) / (inst->height / 8) + 0.5;
                      break;
                  }
          
                  case 1 : // horizontal shift
                  {
                      // convert plugin's param to frei0r range
                      *((double*)param) = (inst->shiftX) / (inst->width / 8) + 0.5;
                      break;
                  }
              }
          
          }
          
          
          void f0r_update(f0r_instance_t instance, double time,
          		const uint32_t* src, uint32_t* dst)
          {
              assert(instance);
              rgbsplit0r_instance_t* inst = (rgbsplit0r_instance_t*)instance;
              unsigned int x, y;
          
              for (y = 0; y < inst->height; y++)
                  for (x = 0; x < inst->width; x++)
                  {
                      uint32_t pxR = 0, pxG = 0, pxB = 0;
          
                      // First make a blue layer shifted back
                      if (((x - inst->shiftX) < inst->width) &&
                          ((y - inst->shiftY) < inst->height))
                      {
                          rgbsplit0r_extract_color((uint32_t *)(src +
                              (x - inst->shiftX) +
                              (y - inst->shiftY)*inst->width),
                              &pxB, 2);
                      }
          
                      // The red layer is shifted forward
                      if ((x + inst->shiftX < inst->width) &&
                          (y + inst->shiftY < inst->height))
                      {
                          rgbsplit0r_extract_color((uint32_t *)(src +
                              (x + inst->shiftX) +
                              (y + inst->shiftY)*inst->width),
                              &pxR, 0);
                      }
          
                      // Green layer is on its place
                      rgbsplit0r_extract_color((uint32_t *)(src + x + (y*inst->width)),
                              &pxG, 1);
          
                      *(dst + x + (y*inst->width)) = (pxG | pxB | pxR);
                  }
          }

This file has been truncated. show original

That might be causing this behavior.

Thinking about this critically, what would a person expect the alpha channel to do in this situation? remain unchanged? Be set to 100% opaque?

sauron · April 7, 2019, 8:56pm

Guess it’s just the way the filter was coded. Still a useful effect. Just can’t use it in a transition.

Paul2 · April 7, 2019, 9:00pm

Unfortunately not all filters can be used in all situations.
Changes could be made but that would mean going back to the source, applying those changes and then compiling for all the OS’s, not a fun exercise.

As you say @sauron , it can still be rather handy especially once it has keyframes.

@brian
What are the chances of including a small area under the sliders of the filters (or at least some) that gives the user a short description of the filter and any shortcomings?

For example for the RGB Spilt:

RGB splitter - splits the red, green and blue channels and shifts them by the amount set by the sliders.
NOTE - Does not preserve the alpha channel.

Something like this:

FilterInfoArea

brian · April 7, 2019, 9:35pm

My preference would be:

Labor over the filter name and the names of the parameters to make them as clear as possible
Add tooltips to the parameters to help give further detail
Fix the underlying alpha issue (I can help with that)

I think that adding informational text is only a very last resort if we can’t find a way to make the interface itself intuitive. In my experience, the best user interfaces don’t require any instructions because the user can tell what to do just by looking at it. But sometimes it isn’t possible to achieve that.

Paul2 · April 8, 2019, 10:31am

Thanks @brian

I do agree with you, choice of name is very important.
Busy studying examples and the notes for QT qml and seeing which would be the best way to apply tooltips without them becoming annoying.

As regards fixing the alpha problem, I’m wondering if it’s worth it for just this filter.
It can still be used just not when alpha is required.
Your time and effort could probably be better spent on other areas of Shotcut, like adding VST support, hint, hint

DRM · April 8, 2019, 11:12am

I would argue that it’s an oversight that should be corrected. Who knows if a future filter would also be affected. Plus, even if an explanation were provided to the user in the UI about this, only being able to use the filter on a clip if there is no image or video underneath it is a perplexing limitation and one that would always carry a workaround that really shouldn’t exist.

Paul2 · April 8, 2019, 12:25pm

@DRM

You really like this filter…only kidding, you do raise some valid points.
However, I’m thinking as to why the alpha was stripped off and suspecting that it created problems.
Judging by the comment in the code, it certainly looks that way.

“// No need to save alpha because it will distort the resulting image”

So taking that into account, will it be worth spending time and effort on trying to add it?
I don’t know.
I certainly don’t have the time and enough C++ experience, coded a bit with C ages ago, but that is a different kettle of fish.

If @brian and @shotcut think it’s worth it and they have the time then great, it would be nice to have alpha too, but it’s not a show stopper for me.

shotcut · April 8, 2019, 7:42pm

It is a bug in that frei0r plugin in my opinion. It should not touch the alpha if the effect does not use or affect it. Easy change but needs contributors review.

MusicalBox · April 11, 2019, 9:47pm

The Flirts !
I didn’t try the filter (sorry). I’m just glad someone else remembers The Flirts Particularly that “version” of the trio.

shotcut · April 14, 2019, 8:51pm

dailylolrecap · April 16, 2019, 7:21am

It needs to be keyframe capable
Very nice work!

shotcut · April 19, 2019, 3:06am

I fixed this bug.

shotcut · April 19, 2019, 6:45am

I added this filter for the next release. In the course of that, not only did I make some changes and fix some bugs but also added support for keyframes (simple and advanced). Prior to adding keyframes, I created a small UI framework to support keyframable filters and used that for this filter addition. The framework is intended to take away a lot of the boilerplate JavaScript code to support keyframes that gets copied from one filter to the next. Thank you for the contribution.

Here is how it looks now:

github.com

mltframework/shotcut/blob/master/src/qml/filters/rgbsplit0r/ui.qml

/*
 * Copyright (c) 2019 Meltytech, LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import QtQuick 2.0
import QtQuick.Controls 1.1
import QtQuick.Layouts 1.1

This file has been truncated. show original

Paul2 · April 19, 2019, 4:47pm

Many thanks @shotcut

Looks great and as you say, the “copy/paste” process will be much easier and less error prone.

yqmi · April 20, 2019, 11:43am

amazing filter… well done
p.s. before this filter i just make 3 layer copys on the video with different color channels… but now everything is much more easy

edit: from where i can find and download other shotcut filters ?

jonray · April 20, 2019, 1:42pm

Hi @yqmi, recently a small group of users have been developing some new filters. @sauron kindly collected them together into a folder. I hope @sauron won’t mind me re-posting the link here?
https://drive.google.com/drive/folders/1FSefzlfD_txqufHSu8tAN08YHqmhq4WF

The link was originally posted in this thread:

https://forum.shotcut.org/t/3-new-filters-for-users-to-try/10591/4