some filters fix + added more filters codebase

app/src/main/java/ru/vtosters/lite/ui/wallpapers/ConvolutionMatrix.java

@@ -0,0 +1,98 @@
+package ru.vtosters.lite.ui.wallpapers;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+
+public class ConvolutionMatrix{
+    public static final int SIZE = 3;
+
+    public double[][] Matrix;
+    public double Factor = 1;
+    public double Offset = 1;
+
+    public ConvolutionMatrix(int size){
+        Matrix = new double[size][size];
+    }
+
+    public static Bitmap computeConvolution3x3(Bitmap src, ConvolutionMatrix matrix){
+        int width = src.getWidth();
+        int height = src.getHeight();
+        Bitmap result = Bitmap.createBitmap(width, height, src.getConfig());
+
+        int A, R, G, B;
+        int sumR, sumG, sumB;
+        int[][] pixels = new int[SIZE][SIZE];
+
+        for (int y = 0; y < height - 2; ++y) {
+            for (int x = 0; x < width - 2; ++x) {
+
+                // get pixel matrix
+                for (int i = 0; i < SIZE; ++i) {
+                    for (int j = 0; j < SIZE; ++j) {
+                        pixels[i][j] = src.getPixel(x + i, y + j);
+                    }
+                }
+
+                // get alpha of center pixel
+                A = Color.alpha(pixels[1][1]);
+
+                // init color sum
+                sumR = sumG = sumB = 0;
+
+                // get sum of RGB on matrix
+                for (int i = 0; i < SIZE; ++i) {
+                    for (int j = 0; j < SIZE; ++j) {
+                        sumR += (Color.red(pixels[i][j]) * matrix.Matrix[i][j]);
+                        sumG += (Color.green(pixels[i][j]) * matrix.Matrix[i][j]);
+                        sumB += (Color.blue(pixels[i][j]) * matrix.Matrix[i][j]);
+                    }
+                }
+
+                // get final Red
+                R = (int) (sumR / matrix.Factor + matrix.Offset);
+                if (R < 0) {
+                    R = 0;
+                } else if (R > 255) {
+                    R = 255;
+                }
+
+                // get final Green
+                G = (int) (sumG / matrix.Factor + matrix.Offset);
+                if (G < 0) {
+                    G = 0;
+                } else if (G > 255) {
+                    G = 255;
+                }
+
+                // get final Blue
+                B = (int) (sumB / matrix.Factor + matrix.Offset);
+                if (B < 0) {
+                    B = 0;
+                } else if (B > 255) {
+                    B = 255;
+                }
+
+                // apply new pixel
+                result.setPixel(x + 1, y + 1, Color.argb(A, R, G, B));
+            }
+        }
+
+        // final image
+        return result;
+    }
+
+    public void setAll(double value){
+        for (int x = 0; x < SIZE; ++x) {
+            for (int y = 0; y < SIZE; ++y) {
+                Matrix[x][y] = value;
+            }
+        }
+    }
+
+    public void applyConfig(double[][] config){
+        for (int x = 0; x < SIZE; ++x) {
+            for (int y = 0; y < SIZE; ++y) {
+                Matrix[x][y] = config[x][y];
+            }
+        }
+    }
+}

app/src/main/java/ru/vtosters/lite/ui/wallpapers/ImageFilters.java

@@ -0,0 +1,894 @@
+package ru.vtosters.lite.ui.wallpapers;
+import static ru.vtosters.lite.utils.Globals.getPreferences;
+import static ru.vtosters.lite.utils.Globals.getResources;
+
+import android.graphics.Bitmap;
+import android.graphics.BlurMaskFilter;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.LightingColorFilter;
+import android.graphics.LinearGradient;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+
+import com.vk.medianative.MediaNative;
+
+import java.util.Random;
+
+public class ImageFilters{
+    public static final double PI = 3.14159d;
+    public static final double HALF_CIRCLE_DEGREE = 180d;
+    public static final double RANGE = 256d;
+    public static final int COLOR_MIN = 0x00;
+    public static final int COLOR_MAX = 0xFF;
+
+    public static Drawable getBlurredWallpaper(Drawable orig, int radius){
+        try {
+            if (orig == null) return null;
+            if (!(orig instanceof BitmapDrawable)) return orig; // we need only BitmapDrawable
+            Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
+            MediaNative.blurBitmap(instance, radius);
+            return new BitmapDrawable(getResources(), instance);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return orig;
+        }
+    }
+
+    public static Drawable getMosaic(Drawable orig){
+        int scale = 100;
+
+        if (orig == null) return null;
+        if (!(orig instanceof BitmapDrawable)) return orig;
+        Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
+        String radius = getPreferences().getString("msg_mosaic", "disabled");
+
+        switch(radius) {
+            case "high":
+                scale = 25;
+                break;
+            case "med":
+                scale = 50;
+                break;
+            case "low":
+                scale = 75;
+        }
+
+        Bitmap temp = Bitmap.createScaledBitmap(instance, scale, scale, false);
+        Bitmap mosaicBitmap = Bitmap.createScaledBitmap(temp, instance.getWidth(), instance.getHeight(), false);
+
+        return new BitmapDrawable(getResources(), mosaicBitmap);
+    }
+
+    public static Drawable getDimmed(Drawable orig){
+        if (orig == null) return null;
+        if (!(orig instanceof BitmapDrawable)) return orig;
+        Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
+        String radius = getPreferences().getString("msg_dim", "disabled");
+        switch(radius) {
+            case "dim_black":
+                darken(instance);
+            case "dim_white":
+                lighten(instance);
+        }
+        return new BitmapDrawable(getResources(), instance);
+    }
+
+    public static Drawable getMonochrome(Drawable orig){
+        if (orig == null) return null;
+        if (!(orig instanceof BitmapDrawable)) return orig;
+        Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
+
+        Bitmap bwBitmap = Bitmap.createBitmap(instance.getWidth(), instance.getHeight(), Bitmap.Config.RGB_565);
+        float[] hsv = new float[3];
+        for (int col = 0; col < instance.getWidth(); col++) {
+            for (int row = 0; row < instance.getHeight(); row++) {
+                Color.colorToHSV(instance.getPixel(col, row), hsv);
+                if (hsv[2] > 0.5f) {
+                    bwBitmap.setPixel(col, row, 0xffffffff);
+                } else {
+                    bwBitmap.setPixel(col, row, 0xff000000);
+                }
+            }
+        }
+
+        return new BitmapDrawable(getResources(), bwBitmap);
+    }
+
+    private static void darken(Bitmap bm){
+        Canvas canvas = new Canvas(bm);
+        Paint p = new Paint(Color.RED);
+        ColorFilter filter = new LightingColorFilter(0xFF7F7F7F, 0x00000000);    // darken
+        p.setColorFilter(filter);
+        canvas.drawBitmap(bm, new Matrix(), p);
+    }
+
+    private static void lighten(Bitmap bm){
+        Canvas canvas = new Canvas(bm);
+        Paint p = new Paint(Color.RED);
+        ColorFilter filter = new LightingColorFilter(0xFFFFFFFF, 0x00222222); // lighten
+        p.setColorFilter(filter);
+        canvas.drawBitmap(bm, new Matrix(), p);
+    }
+
+    public Bitmap applyHighlightEffect(Bitmap src){
+
+        // create new bitmap, which will be painted and becomes result image
+        Bitmap bmOut = Bitmap.createBitmap(src.getWidth() + 96, src.getHeight() + 96, Bitmap.Config.ARGB_8888);
+        // setup canvas for painting
+        Canvas canvas = new Canvas(bmOut);
+        // setup default color
+        canvas.drawColor(0, PorterDuff.Mode.CLEAR);
+
+        // create a blur paint for capturing alpha
+        Paint ptBlur = new Paint();
+        ptBlur.setMaskFilter(new BlurMaskFilter(15, BlurMaskFilter.Blur.NORMAL));
+        int[] offsetXY = new int[2];
+        // capture alpha into a bitmap
+        Bitmap bmAlpha = src.extractAlpha(ptBlur, offsetXY);
+        // create a color paint
+        Paint ptAlphaColor = new Paint();
+        ptAlphaColor.setColor(0xFFFFFFFF);
+        // paint color for captured alpha region (bitmap)
+        canvas.drawBitmap(bmAlpha, offsetXY[0], offsetXY[1], ptAlphaColor);
+        // free memory
+        bmAlpha.recycle();
+
+        // paint the image source
+        canvas.drawBitmap(src, 0, 0, null);
+
+        // return out final image
+        return bmOut;
+    }
+
+    public Bitmap applyInvertEffect(Bitmap src){
+        // create new bitmap with the same settings as source bitmap
+        Bitmap bmOut = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
+        // color info
+        int A, R, G, B;
+        int pixelColor;
+        // image size
+        int height = src.getHeight();
+        int width = src.getWidth();
+
+        // scan through every pixel
+        for (int y = 0; y < height; y++) {
+            for (int x = 0; x < width; x++) {
+                // get one pixel
+                pixelColor = src.getPixel(x, y);
+                // saving alpha channel
+                A = Color.alpha(pixelColor);
+                // inverting byte for each R/G/B channel
+                R = 255 - Color.red(pixelColor);
+                G = 255 - Color.green(pixelColor);
+                B = 255 - Color.blue(pixelColor);
+                // set newly-inverted pixel to output image
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final bitmap
+        return bmOut;
+    }
+
+    public Bitmap applyGreyscaleEffect(Bitmap src){
+        // constant factors
+        final double GS_RED = 0.299;
+        final double GS_GREEN = 0.587;
+        final double GS_BLUE = 0.114;
+
+        // create output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
+        // pixel information
+        int A, R, G, B;
+        int pixel;
+
+        // get image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+
+        // scan through every single pixel
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get one pixel color
+                pixel = src.getPixel(x, y);
+                // retrieve color of all channels
+                A = Color.alpha(pixel);
+                R = Color.red(pixel);
+                G = Color.green(pixel);
+                B = Color.blue(pixel);
+                // take conversion up to one single value
+                R = G = B = (int) (GS_RED * R + GS_GREEN * G + GS_BLUE * B);
+                // set new pixel color to output bitmap
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    //Gamma Image (R, G, B) = (1.8, 1.8, 1.8)
+    public Bitmap applyGammaEffect(Bitmap src, double red, double green, double blue){
+        // create output image
+        Bitmap bmOut = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
+        // get image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // color information
+        int A, R, G, B;
+        int pixel;
+        // constant value curve
+        final int MAX_SIZE = 256;
+        final double MAX_VALUE_DBL = 255.0;
+        final int MAX_VALUE_INT = 255;
+        final double REVERSE = 1.0;
+
+        // gamma arrays
+        int[] gammaR = new int[MAX_SIZE];
+        int[] gammaG = new int[MAX_SIZE];
+        int[] gammaB = new int[MAX_SIZE];
+
+        // setting values for every gamma channels
+        for (int i = 0; i < MAX_SIZE; ++i) {
+            gammaR[i] = (int) Math.min(MAX_VALUE_INT,
+                    (int) ((MAX_VALUE_DBL * Math.pow(i / MAX_VALUE_DBL, REVERSE / red)) + 0.5));
+            gammaG[i] = (int) Math.min(MAX_VALUE_INT,
+                    (int) ((MAX_VALUE_DBL * Math.pow(i / MAX_VALUE_DBL, REVERSE / green)) + 0.5));
+            gammaB[i] = (int) Math.min(MAX_VALUE_INT,
+                    (int) ((MAX_VALUE_DBL * Math.pow(i / MAX_VALUE_DBL, REVERSE / blue)) + 0.5));
+        }
+
+        // apply gamma table
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get pixel color
+                pixel = src.getPixel(x, y);
+                A = Color.alpha(pixel);
+                // look up gamma
+                R = gammaR[Color.red(pixel)];
+                G = gammaG[Color.green(pixel)];
+                B = gammaB[Color.blue(pixel)];
+                // set new color to output bitmap
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    public Bitmap applyColorFilterEffect(Bitmap src, double red, double green, double blue){
+        // image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // create output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
+        // color information
+        int A, R, G, B;
+        int pixel;
+
+        // scan through all pixels
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get pixel color
+                pixel = src.getPixel(x, y);
+                // apply filtering on each channel R, G, B
+                A = Color.alpha(pixel);
+                R = (int) (Color.red(pixel) * red);
+                G = (int) (Color.green(pixel) * green);
+                B = (int) (Color.blue(pixel) * blue);
+                // set new color pixel to output bitmap
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    public Bitmap applySepiaToningEffect(Bitmap src, int depth, double red, double green, double blue){
+        // image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // create output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
+        // constant grayscale
+        final double GS_RED = 0.3;
+        final double GS_GREEN = 0.59;
+        final double GS_BLUE = 0.11;
+        // color information
+        int A, R, G, B;
+        int pixel;
+
+        // scan through all pixels
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get pixel color
+                pixel = src.getPixel(x, y);
+                // get color on each channel
+                A = Color.alpha(pixel);
+                R = Color.red(pixel);
+                G = Color.green(pixel);
+                B = Color.blue(pixel);
+                // apply grayscale sample
+                B = G = R = (int) (GS_RED * R + GS_GREEN * G + GS_BLUE * B);
+
+                // apply intensity level for sepid-toning on each channel
+                R += (depth * red);
+                if (R > 255) {
+                    R = 255;
+                }
+
+                G += (depth * green);
+                if (G > 255) {
+                    G = 255;
+                }
+
+                B += (depth * blue);
+                if (B > 255) {
+                    B = 255;
+                }
+
+                // set new pixel color to output image
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    public Bitmap applyDecreaseColorDepthEffect(Bitmap src, int bitOffset){
+        // get image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // create output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
+        // color information
+        int A, R, G, B;
+        int pixel;
+
+        // scan through all pixels
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get pixel color
+                pixel = src.getPixel(x, y);
+                A = Color.alpha(pixel);
+                R = Color.red(pixel);
+                G = Color.green(pixel);
+                B = Color.blue(pixel);
+
+                // round-off color offset
+                R = ((R + (bitOffset / 2)) - ((R + (bitOffset / 2)) % bitOffset) - 1);
+                if (R < 0) {
+                    R = 0;
+                }
+                G = ((G + (bitOffset / 2)) - ((G + (bitOffset / 2)) % bitOffset) - 1);
+                if (G < 0) {
+                    G = 0;
+                }
+                B = ((B + (bitOffset / 2)) - ((B + (bitOffset / 2)) % bitOffset) - 1);
+                if (B < 0) {
+                    B = 0;
+                }
+
+                // set pixel color to output bitmap
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    public Bitmap applyContrastEffect(Bitmap src, double value){
+        // image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // create output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
+        // color information
+        int A, R, G, B;
+        int pixel;
+        // get contrast value
+        double contrast = Math.pow((100 + value) / 100, 2);
+
+        // scan through all pixels
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get pixel color
+                pixel = src.getPixel(x, y);
+                A = Color.alpha(pixel);
+                // apply filter contrast for every channel R, G, B
+                R = Color.red(pixel);
+                R = (int) (((((R / 255.0) - 0.5) * contrast) + 0.5) * 255.0);
+                if (R < 0) {
+                    R = 0;
+                } else if (R > 255) {
+                    R = 255;
+                }
+
+                G = Color.red(pixel);
+                G = (int) (((((G / 255.0) - 0.5) * contrast) + 0.5) * 255.0);
+                if (G < 0) {
+                    G = 0;
+                } else if (G > 255) {
+                    G = 255;
+                }
+
+                B = Color.red(pixel);
+                B = (int) (((((B / 255.0) - 0.5) * contrast) + 0.5) * 255.0);
+                if (B < 0) {
+                    B = 0;
+                } else if (B > 255) {
+                    B = 255;
+                }
+
+                // set new pixel color to output bitmap
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    public Bitmap applyBrightnessEffect(Bitmap src, int value){
+        // image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // create output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
+        // color information
+        int A, R, G, B;
+        int pixel;
+
+        // scan through all pixels
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                // get pixel color
+                pixel = src.getPixel(x, y);
+                A = Color.alpha(pixel);
+                R = Color.red(pixel);
+                G = Color.green(pixel);
+                B = Color.blue(pixel);
+
+                // increase/decrease each channel
+                R += value;
+                if (R > 255) {
+                    R = 255;
+                } else if (R < 0) {
+                    R = 0;
+                }
+
+                G += value;
+                if (G > 255) {
+                    G = 255;
+                } else if (G < 0) {
+                    G = 0;
+                }
+
+                B += value;
+                if (B > 255) {
+                    B = 255;
+                } else if (B < 0) {
+                    B = 0;
+                }
+
+                // apply new pixel color to output bitmap
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+
+        // return final image
+        return bmOut;
+    }
+
+    public Bitmap applyGaussianBlurEffect(Bitmap src){
+        double[][] GaussianBlurConfig = new double[][] {
+                {1, 2, 1},
+                {2, 4, 2},
+                {1, 2, 1}
+        };
+        ConvolutionMatrix convMatrix = new ConvolutionMatrix(3);
+        convMatrix.applyConfig(GaussianBlurConfig);
+        convMatrix.Factor = 16;
+        convMatrix.Offset = 0;
+        return ConvolutionMatrix.computeConvolution3x3(src, convMatrix);
+    }
+
+    public Bitmap applySharpenEffect(Bitmap src, double weight){
+        double[][] SharpConfig = new double[][] {
+                {0, -2, 0},
+                {-2, weight, -2},
+                {0, -2, 0}
+        };
+        ConvolutionMatrix convMatrix = new ConvolutionMatrix(3);
+        convMatrix.applyConfig(SharpConfig);
+        convMatrix.Factor = weight - 8;
+        return ConvolutionMatrix.computeConvolution3x3(src, convMatrix);
+    }
+
+    public Bitmap applyMeanRemovalEffect(Bitmap src){
+        double[][] MeanRemovalConfig = new double[][] {
+                {-1, -1, -1},
+                {-1, 9, -1},
+                {-1, -1, -1}
+        };
+        ConvolutionMatrix convMatrix = new ConvolutionMatrix(3);
+        convMatrix.applyConfig(MeanRemovalConfig);
+        convMatrix.Factor = 1;
+        convMatrix.Offset = 0;
+        return ConvolutionMatrix.computeConvolution3x3(src, convMatrix);
+    }
+
+    public Bitmap applySmoothEffect(Bitmap src, double value){
+        ConvolutionMatrix convMatrix = new ConvolutionMatrix(3);
+        convMatrix.setAll(1);
+        convMatrix.Matrix[1][1] = value;
+        convMatrix.Factor = value + 8;
+        convMatrix.Offset = 1;
+        return ConvolutionMatrix.computeConvolution3x3(src, convMatrix);
+    }
+
+    public Bitmap applyEmbossEffect(Bitmap src){
+        double[][] EmbossConfig = new double[][] {
+                {-1, 0, -1},
+                {0, 4, 0},
+                {-1, 0, -1}
+        };
+        ConvolutionMatrix convMatrix = new ConvolutionMatrix(3);
+        convMatrix.applyConfig(EmbossConfig);
+        convMatrix.Factor = 1;
+        convMatrix.Offset = 127;
+        return ConvolutionMatrix.computeConvolution3x3(src, convMatrix);
+    }
+
+    public Bitmap applyEngraveEffect(Bitmap src){
+        ConvolutionMatrix convMatrix = new ConvolutionMatrix(3);
+        convMatrix.setAll(0);
+        convMatrix.Matrix[0][0] = -2;
+        convMatrix.Matrix[1][1] = 2;
+        convMatrix.Factor = 1;
+        convMatrix.Offset = 95;
+        return ConvolutionMatrix.computeConvolution3x3(src, convMatrix);
+    }
+
+    public Bitmap applyBoostEffect(Bitmap src, int type, float percent){
+        int width = src.getWidth();
+        int height = src.getHeight();
+        Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
+
+        int A, R, G, B;
+        int pixel;
+
+        for (int x = 0; x < width; ++x) {
+            for (int y = 0; y < height; ++y) {
+                pixel = src.getPixel(x, y);
+                A = Color.alpha(pixel);
+                R = Color.red(pixel);
+                G = Color.green(pixel);
+                B = Color.blue(pixel);
+                if (type == 1) {
+                    R = (int) (R * (1 + percent));
+                    if (R > 255) R = 255;
+                } else if (type == 2) {
+                    G = (int) (G * (1 + percent));
+                    if (G > 255) G = 255;
+                } else if (type == 3) {
+                    B = (int) (B * (1 + percent));
+                    if (B > 255) B = 255;
+                }
+                bmOut.setPixel(x, y, Color.argb(A, R, G, B));
+            }
+        }
+        return bmOut;
+    }
+
+    public Bitmap applyRoundCornerEffect(Bitmap src, float round){
+        // image size
+        int width = src.getWidth();
+        int height = src.getHeight();
+        // create bitmap output
+        Bitmap result = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        // set canvas for painting
+        Canvas canvas = new Canvas(result);
+        canvas.drawARGB(0, 0, 0, 0);
+
+        // config paint
+        final Paint paint = new Paint();
+        paint.setAntiAlias(true);
+        paint.setColor(Color.BLACK);
+
+        // config rectangle for embedding
+        final Rect rect = new Rect(0, 0, width, height);
+        final RectF rectF = new RectF(rect);
+
+        // draw rect to canvas
+        canvas.drawRoundRect(rectF, round, round, paint);
+
+        // create Xfer mode
+        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
+        // draw source image to canvas
+        canvas.drawBitmap(src, rect, rect, paint);
+
+        // return final image
+        return result;
+    }
+
+    public Bitmap applyTintEffect(Bitmap src, int degree){
+
+        int width = src.getWidth();
+        int height = src.getHeight();
+
+        int[] pix = new int[width * height];
+        src.getPixels(pix, 0, width, 0, 0, width, height);
+
+        int RY, GY, BY, RYY, GYY, BYY, R, G, B, Y;
+        double angle = (PI * (double) degree) / HALF_CIRCLE_DEGREE;
+
+        int S = (int) (RANGE * Math.sin(angle));
+        int C = (int) (RANGE * Math.cos(angle));
+
+        for (int y = 0; y < height; y++)
+            for (int x = 0; x < width; x++) {
+                int index = y * width + x;
+                int r = (pix[index] >> 16) & 0xff;
+                int g = (pix[index] >> 8) & 0xff;
+                int b = pix[index] & 0xff;
+                RY = (70 * r - 59 * g - 11 * b) / 100;
+                GY = (-30 * r + 41 * g - 11 * b) / 100;
+                BY = (-30 * r - 59 * g + 89 * b) / 100;
+                Y = (30 * r + 59 * g + 11 * b) / 100;
+                RYY = (S * BY + C * RY) / 256;
+                BYY = (C * BY - S * RY) / 256;
+                GYY = (-51 * RYY - 19 * BYY) / 100;
+                R = Y + RYY;
+                R = (R < 0) ? 0 : (Math.min(R, 255));
+                G = Y + GYY;
+                G = (G < 0) ? 0 : (Math.min(G, 255));
+                B = Y + BYY;
+                B = (B < 0) ? 0 : (Math.min(B, 255));
+                pix[index] = 0xff000000 | (R << 16) | (G << 8) | B;
+            }
+
+        Bitmap outBitmap = Bitmap.createBitmap(width, height, src.getConfig());
+        outBitmap.setPixels(pix, 0, width, 0, 0, width, height);
+
+        pix = null;
+
+        return outBitmap;
+    }
+
+    public Bitmap applyFleaEffect(Bitmap source){
+        // get image size
+        int width = source.getWidth();
+        int height = source.getHeight();
+        int[] pixels = new int[width * height];
+        // get pixel array from source
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+        // a random object
+        Random random = new Random();
+
+        int index = 0;
+        // iteration through pixels
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+                // get current index in 2D-matrix
+                index = y * width + x;
+                // get random color
+                int randColor = Color.rgb(random.nextInt(COLOR_MAX),
+                        random.nextInt(COLOR_MAX), random.nextInt(COLOR_MAX));
+                // OR
+                pixels[index] |= randColor;
+            }
+        }
+        // output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, source.getConfig());
+        bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bmOut;
+    }
+
+    public Bitmap applyBlackFilter(Bitmap source){
+        // get image size
+        int width = source.getWidth();
+        int height = source.getHeight();
+        int[] pixels = new int[width * height];
+        // get pixel array from source
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+        // random object
+        Random random = new Random();
+
+        int R, G, B, index = 0, thresHold = 0;
+        // iteration through pixels
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+                // get current index in 2D-matrix
+                index = y * width + x;
+                // get color
+                R = Color.red(pixels[index]);
+                G = Color.green(pixels[index]);
+                B = Color.blue(pixels[index]);
+                // generate threshold
+                thresHold = random.nextInt(COLOR_MAX);
+                if (R < thresHold && G < thresHold && B < thresHold) {
+                    pixels[index] = Color.rgb(COLOR_MIN, COLOR_MIN, COLOR_MIN);
+                }
+            }
+        }
+        // output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bmOut;
+    }
+
+    public Bitmap applySnowEffect(Bitmap source){
+        // get image size
+        int width = source.getWidth();
+        int height = source.getHeight();
+        int[] pixels = new int[width * height];
+        // get pixel array from source
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+        // random object
+        Random random = new Random();
+
+        int R, G, B, index = 0, thresHold = 50;
+        // iteration through pixels
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+                // get current index in 2D-matrix
+                index = y * width + x;
+                // get color
+                R = Color.red(pixels[index]);
+                G = Color.green(pixels[index]);
+                B = Color.blue(pixels[index]);
+                // generate threshold
+                thresHold = random.nextInt(COLOR_MAX);
+                if (R > thresHold && G > thresHold && B > thresHold) {
+                    pixels[index] = Color.rgb(COLOR_MAX, COLOR_MAX, COLOR_MAX);
+                }
+            }
+        }
+        // output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
+        bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bmOut;
+    }
+
+    public Bitmap applyShadingFilter(Bitmap source, int shadingColor){
+        // get image size
+        int width = source.getWidth();
+        int height = source.getHeight();
+        int[] pixels = new int[width * height];
+        // get pixel array from source
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+
+        int index = 0;
+        // iteration through pixels
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+                // get current index in 2D-matrix
+                index = y * width + x;
+                // AND
+                pixels[index] &= shadingColor;
+            }
+        }
+        // output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bmOut;
+    }
+
+    public Bitmap applySaturationFilter(Bitmap source, int level){
+        // get image size
+        int width = source.getWidth();
+        int height = source.getHeight();
+        int[] pixels = new int[width * height];
+        float[] HSV = new float[3];
+        // get pixel array from source
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+
+        int index = 0;
+        // iteration through pixels
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+                // get current index in 2D-matrix
+                index = y * width + x;
+                // convert to HSV
+                Color.colorToHSV(pixels[index], HSV);
+                // increase Saturation level
+                HSV[1] *= level;
+                HSV[1] = (float) Math.max(0.0, Math.min(HSV[1], 1.0));
+                // take color back
+                pixels[index] |= Color.HSVToColor(HSV);
+            }
+        }
+        // output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bmOut;
+    }
+
+    public Bitmap applyHueFilter(Bitmap source, int level){
+        // get image size
+        int width = source.getWidth();
+        int height = source.getHeight();
+        int[] pixels = new int[width * height];
+        float[] HSV = new float[3];
+        // get pixel array from source
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+
+        int index = 0;
+        // iteration through pixels
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+                // get current index in 2D-matrix
+                index = y * width + x;
+                // convert to HSV
+                Color.colorToHSV(pixels[index], HSV);
+                // increase Saturation level
+                HSV[0] *= level;
+                HSV[0] = (float) Math.max(0.0, Math.min(HSV[0], 360.0));
+                // take color back
+                pixels[index] |= Color.HSVToColor(HSV);
+            }
+        }
+        // output bitmap
+        Bitmap bmOut = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        bmOut.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bmOut;
+    }
+
+    public Bitmap applyReflection(Bitmap originalImage){
+        // gap space between original and reflected
+        final int reflectionGap = 4;
+        // get image size
+        int width = originalImage.getWidth();
+        int height = originalImage.getHeight();
+
+        // this will not scale but will flip on the Y axis
+        Matrix matrix = new Matrix();
+        matrix.preScale(1, -1);
+
+        // create a Bitmap with the flip matrix applied to it.
+        // we only want the bottom half of the image
+        Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0, height / 2, width, height / 2, matrix, false);
+
+        // create a new bitmap with same width but taller to fit reflection
+        Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height / 2), Bitmap.Config.ARGB_8888);
+
+        // create a new Canvas with the bitmap that's big enough for
+        // the image plus gap plus reflection
+        Canvas canvas = new Canvas(bitmapWithReflection);
+        // draw in the original image
+        canvas.drawBitmap(originalImage, 0, 0, null);
+        // draw in the gap
+        Paint defaultPaint = new Paint();
+        canvas.drawRect(0, height, width, height + reflectionGap, defaultPaint);
+        // draw in the reflection
+        canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
+
+        // create a shader that is a linear gradient that covers the reflection
+        Paint paint = new Paint();
+        LinearGradient shader = new LinearGradient(0, originalImage.getHeight(), 0,
+                bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff,
+                Shader.TileMode.CLAMP);
+        // set the paint to use this shader (linear gradient)
+        paint.setShader(shader);
+        // set the Transfer mode to be porter duff and destination in
+        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
+        // draw a rectangle using the paint with our linear gradient
+        canvas.drawRect(0, height, width, bitmapWithReflection.getHeight() + reflectionGap, paint);
+
+        return bitmapWithReflection;
+    }
+}

app/src/main/java/ru/vtosters/lite/ui/wallpapers/WallpaperMenuFragment.java

@@ -8,8 +8,6 @@ import static ru.vtosters.lite.ui.wallpapers.WallpapersHooks.requestUpdateWallpa
 import static ru.vtosters.lite.utils.CacheUtils.deleteCache;
 import static ru.vtosters.lite.utils.Globals.edit;
 import static ru.vtosters.lite.utils.Globals.getIdentifier;
-import static ru.vtosters.lite.utils.Globals.getPreferences;
-import static ru.vtosters.lite.utils.Preferences.DoNotUseOldIcons;
 
 import android.content.Context;
 import android.content.Intent;
@@ -29,7 +27,6 @@ import java.io.InputStream;
 import java.io.OutputStream;
 
 import ru.vtosters.lite.ui.PreferencesUtil;
-import ru.vtosters.lite.utils.Globals;
 
 public class WallpaperMenuFragment extends MaterialPreferenceToolbarFragment{
 

app/src/main/java/ru/vtosters/lite/ui/wallpapers/WallpapersHooks.java

@@ -1,23 +1,16 @@
 package ru.vtosters.lite.ui.wallpapers;
 import static com.vk.im.engine.h.im_bg_chat;
+import static ru.vtosters.lite.ui.wallpapers.ImageFilters.getBlurredWallpaper;
+import static ru.vtosters.lite.ui.wallpapers.ImageFilters.getDimmed;
+import static ru.vtosters.lite.ui.wallpapers.ImageFilters.getMonochrome;
+import static ru.vtosters.lite.ui.wallpapers.ImageFilters.getMosaic;
 import static ru.vtosters.lite.utils.Globals.getContext;
 import static ru.vtosters.lite.utils.Globals.getPreferences;
-import static ru.vtosters.lite.utils.Globals.getResources;
 
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.graphics.Color;
-import android.graphics.ColorFilter;
-import android.graphics.LightingColorFilter;
-import android.graphics.Matrix;
-import android.graphics.Paint;
-import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.view.View;
 import android.widget.ImageView;
 
-import com.vk.medianative.MediaNative;
-
 import java.io.File;
 
 public class WallpapersHooks{
@@ -127,96 +120,6 @@ public class WallpapersHooks{
         }
     }
 
-    public static Drawable getBlurredWallpaper(Drawable orig, int radius){
-        try {
-            if (orig == null) return null;
-            if (!(orig instanceof BitmapDrawable)) return orig; // we need only BitmapDrawable
-            Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
-            MediaNative.blurBitmap(instance, radius);
-            return new BitmapDrawable(getResources(), instance);
-        } catch (Exception e) {
-            e.printStackTrace();
-            return orig;
-        }
-    }
-
-    public static Drawable getMosaic(Drawable orig){
-        int scale = 100;
-
-        if (orig == null) return null;
-        if (!(orig instanceof BitmapDrawable)) return orig;
-        Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
-        String radius = getPreferences().getString("msg_mosaic", "disabled");
-
-        switch(radius) {
-            case "high":
-                scale = 25;
-                break;
-            case "med":
-                scale = 50;
-                break;
-            case "low":
-                scale = 75;
-        }
-
-        Bitmap temp = Bitmap.createScaledBitmap(instance, scale, scale, false);
-        Bitmap mosaicBitmap = Bitmap.createScaledBitmap(temp, instance.getWidth(), instance.getHeight(), false);
-
-        return new BitmapDrawable(getResources(), mosaicBitmap);
-    }
-
-    public static Drawable getDimmed(Drawable orig){
-        if (orig == null) return null;
-        if (!(orig instanceof BitmapDrawable)) return orig;
-        Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
-        String radius = getPreferences().getString("msg_dim", "disabled");
-        switch(radius) {
-            case "dim_black":
-                instance = darken(instance);
-            case "dim_white":
-                instance = lighten(instance);
-        }
-        return new BitmapDrawable(getResources(), instance);
-    }
-
-    public static Drawable getMonochrome(Drawable orig){
-        if (orig == null) return null;
-        if (!(orig instanceof BitmapDrawable)) return orig;
-        Bitmap instance = ((BitmapDrawable) orig).getBitmap().copy(Bitmap.Config.ARGB_8888, true);
-
-        Bitmap bwBitmap = Bitmap.createBitmap( instance.getWidth(), instance.getHeight(), Bitmap.Config.RGB_565 );
-        float[] hsv = new float[ 3 ];
-        for( int col = 0; col < instance.getWidth(); col++ ) {
-            for( int row = 0; row < instance.getHeight(); row++ ) {
-                Color.colorToHSV( instance.getPixel( col, row ), hsv );
-                if( hsv[ 2 ] > 0.5f ) {
-                    bwBitmap.setPixel( col, row, 0xffffffff );
-                } else {
-                    bwBitmap.setPixel( col, row, 0xff000000 );
-                }
-            }
-        }
-
-        return new BitmapDrawable(getResources(), bwBitmap);
-    }
-
-    private static Bitmap darken(Bitmap bm){
-        Canvas canvas = new Canvas(bm);
-        Paint p = new Paint(Color.RED);
-        ColorFilter filter = new LightingColorFilter(0xFF7F7F7F, 0x00000000);    // darken
-        p.setColorFilter(filter);
-        canvas.drawBitmap(bm, new Matrix(), p);
-        return bm;
-    }
-
-    private static Bitmap lighten(Bitmap bm){
-        Canvas canvas = new Canvas(bm);
-        Paint p = new Paint(Color.RED);
-        ColorFilter filter = new LightingColorFilter(0xFFFFFFFF, 0x00222222); // lighten
-        p.setColorFilter(filter);
-        canvas.drawBitmap(bm, new Matrix(), p);
-        return bm;
-    }
 
     public static void removeWallpaper(){
         getWallpaperFile().delete();