一、认识滤镜
 
ffmpeg里面的滤镜(也叫过滤器)十分重要，功能也十分强大，除了我们所谓的滤镜，还有贴图、伸缩变形、拆解合并等功能，这里放2个滤镜、变形来证明他的强大。
 
ffmpeg里面用(AVFilterGraph)graph来作为管理一整套滤镜流程的容器，里面还有(AVFilter)filter作为过滤器和它的实例(AVFilterContext)filter_ctx，过滤器里还包含AVFilterPad作为过滤器的输入输出口，还有(AVFilterLink)link在过滤器之间做关联，这样前后串起来就是一个滤镜链了。
 
 
这里需要注意的是，滤镜链的前后需要名字专门叫做“buffer”的过滤器作为输入，也需要名字一定是“buffersink”的过滤器作为输出。
 
滤镜在FFmpeg里还分简单滤镜链和复杂滤镜链，一般的单入单出的为简单滤镜链，我们先讲简单的。
 
二、如何使用滤镜
 
使用滤镜有2种方式，我们就先讲很多demo里面都有的一种，就是使用avfilter_graph_parse_ptr。
 
FFmpeg的example里有个filtering_video.c，对照着滤镜部分看。
 
static int init_filters(const char *filters_descr)
{
    char args[512];
    int ret = 0;
    // "buffer"滤镜：缓冲视频帧，作为滤镜图的输入
    const AVFilter *buffersrc  = avfilter_get_by_name("buffer");
    // "buffersink"滤镜：缓冲视频帧，作为滤镜图的输出
    const AVFilter *buffersink = avfilter_get_by_name("buffersink");
    AVFilterInOut *outputs = avfilter_inout_alloc();
    AVFilterInOut *inputs  = avfilter_inout_alloc();
    AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;
    enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };

    // 分配一个滤镜图filter_graph
    filter_graph = avfilter_graph_alloc();
    if (!outputs || !inputs || !filter_graph) {
        ret = AVERROR(ENOMEM);
        goto end;
    }

    /* buffer video source: the decoded frames from the decoder will be inserted here. */
    // args是buffersrc滤镜的参数
    snprintf(args, sizeof(args),
            "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
            dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
            time_base.num, time_base.den,
            dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
    // 为buffersrc滤镜创建滤镜实例buffersrc_ctx，命名为"in"
    // 将新创建的滤镜实例buffersrc_ctx添加到滤镜图filter_graph中
    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
                                       args, NULL, filter_graph);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
        goto end;
    }

    /* buffer video sink: to terminate the filter chain. */
    // 为buffersink滤镜创建滤镜实例buffersink_ctx，命名为"out"
    // 将新创建的滤镜实例buffersink_ctx添加到滤镜图filter_graph中
    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
                                       NULL, NULL, filter_graph);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
        goto end;
    }

    // 设置输出像素格式为pix_fmts[]中指定的格式(如果要用SDL显示，则这些格式应是SDL支持格式)
    ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
                              AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
        goto end;
    }

    /*
     * Set the endpoints for the filter graph. The filter_graph will
     * be linked to the graph described by filters_descr.
     */
    // 设置滤镜图的端点，包含此端点的滤镜图将会被连接到filters_descr
    // 描述的滤镜图中

    /*
     * The buffer source output must be connected to the input pad of
     * the first filter described by filters_descr; since the first
     * filter input label is not specified, it is set to "in" by
     * default.
     */
    // outputs变量意指buffersrc_ctx滤镜的输出引脚(output pad)
    // src缓冲区(buffersrc_ctx滤镜)的输出必须连到filters_descr中第一个
    // 滤镜的输入；filters_descr中第一个滤镜的输入标号未指定，故默认为
    // "in"，此处将buffersrc_ctx的输出标号也设为"in"，就实现了同标号相连
    outputs->name       = av_strdup("in");
    outputs->filter_ctx = buffersrc_ctx;
    outputs->pad_idx    = 0;
    outputs->next       = NULL;

    /*
     * The buffer sink input must be connected to the output pad of
     * the last filter described by filters_descr; since the last
     * filter output label is not specified, it is set to "out" by
     * default.
     */
    // inputs变量意指buffersink_ctx滤镜的输入引脚(input pad)
    // sink缓冲区(buffersink_ctx滤镜)的输入必须连到filters_descr中最后
    // 一个滤镜的输出；filters_descr中最后一个滤镜的输出标号未指定，故
    // 默认为"out"，此处将buffersink_ctx的输出标号也设为"out"，就实现了
    // 同标号相连
    inputs->name       = av_strdup("out");
    inputs->filter_ctx = buffersink_ctx;
    inputs->pad_idx    = 0;
    inputs->next       = NULL;

    // 将filters_descr描述的滤镜图添加到filter_graph滤镜图中
    // 在filters_descr字符串中，如果第一个滤镜未指定输入标号，则假定为"in"；如果最后一个滤镜
    // 未指定输出标号，则假定为"out"。几个实参说明如下：
    // @filter_graph  将字符串描述的滤镜图连接到此滤镜图中
    // @filters_descr 描述滤镜的字符串，用于解析生成滤镜图 
    // @inputs        指向滤镜图中输入链表，调用返回时，更新为包含开放输入列表
    // @outputs       指向滤镜图的输出链表，调用返回时，更新为包含开放输出列表
    // 我的话：
    // 调用前：filter_graph包含两个滤镜buffersrc_ctx和buffersink_ctx
    // 调用后：filters_descr描述的滤镜图插入到filter_graph中，buffersrc_ctx连接到filters_descr
    //         的输入，filters_descr的输出连接到buffersink_ctx，filters_descr只进行了解析而不
    //         建立内部滤镜间的连接。filters_desc与filter_graph间的连接是利用AVFilterInOut inputs
    //         和AVFilterInOut inputs连接起来的，AVFilterInOut是一个链表，最终可用的连在一起的
    //         滤镜链/滤镜图就是通过这个链表串在一起的。
    if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
                                    &inputs, &outputs, NULL)) < 0)
        goto end;

    // 验证有效性并配置filtergraph中所有连接和格式
    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
        goto end;

end:
    avfilter_inout_free(&inputs);
    avfilter_inout_free(&outputs);

    return ret;
}
 
1、用avfilter_get_by_name创建一个AVFilter对象，如buffersrc
 
2、用avfilter_graph_alloc分配一个AVFilterGraph对象，如filter_graph
 
3、用avfilter_graph_create_filter实例化一个AVFilterContext对象，如buffersrc_ctx，期间对“buffer”的过滤器要设置一些args
 
4、然后对AVFilterInOut进行inputs和outputs的对应创建和设置
 
5、通过avfilter_graph_parse_ptr将filters_descr所描述的滤镜内容插入到前面的inputs、outputs之间，串起来设置到filter_graph中
 
6、通过avfilter_graph_config验证有效性并配置filter_graph中所有连接和格式
 
主要函数和流程就是这些，照着例子搬就行了，你只需要改动filters_descr，也就是你想要的滤镜效果即可
 
7、解码后的帧送入av_buffersrc_add_frame_flags(buffersrc_ctx, frame, 0);
 
8、过滤后的帧从里面取出av_buffersink_get_frame(buffersink_ctx, filt_frame);
 
三、用例子分析流程
 
我这里用命令行来分析一下流程
 
ffmpeg.exe -re -y -rtsp_transport tcp -i "rtsp://xxx" -an -vf "scale=352x288" -vcodec libx264 -f flv 1.flv
 
我们可以使用char *graph_str = avfilter_graph_dump(filter_graph, NULL);将整个滤镜链打印出来，打印出来如下图：
 
我们可以看到，ffmpeg里面给我们的scale过滤器命名为"Parsed_scale_0"。我们知道过滤器一定有个输入有个输出，可以看到输入的buffer过滤器命名为了"graph 0 input from stream 0:0"，里面设置了如video_size的args。然后还看到了format，ffmpeg自动给我们加了色彩空间转换的过滤器。可以看到滤镜链是从  输入过滤器=》scale过滤器=》format过滤器=》输出过滤器
 
[Parsed_scale_0 @ 0x5555559178c0] Setting 'w' to value '352x288'
[Parsed_scale_0 @ 0x5555559178c0] Setting 'flags' to value 'bicubic'
[Parsed_scale_0 @ 0x5555559178c0] w:352 h:288 flags:'bicubic' interl:0
[graph 0 input from stream 0:0 @ 0x55555581b180] Setting 'video_size' to value '1920x1080'
[graph 0 input from stream 0:0 @ 0x55555581b180] Setting 'pix_fmt' to value '12'
[graph 0 input from stream 0:0 @ 0x55555581b180] Setting 'time_base' to value '1/90000'
[graph 0 input from stream 0:0 @ 0x55555581b180] Setting 'pixel_aspect' to value '0/1'
[graph 0 input from stream 0:0 @ 0x55555581b180] Setting 'sws_param' to value 'flags=2'
[graph 0 input from stream 0:0 @ 0x55555581b180] Setting 'frame_rate' to value '25/1'
[graph 0 input from stream 0:0 @ 0x55555581b180] w:1920 h:1080 pixfmt:yuvj420p tb:1/90000 fr:25/1 sar:0/1 sws_param:flags=2
[format @ 0x5555557f7940] Setting 'pix_fmts' to value 'yuv420p|yuvj420p|yuv422p|yuvj422p|yuv444p|yuvj444p|nv12|nv16|nv21|yuv420p10le|yuv422p10le|yuv444p10le|nv20le|gray|gray10le'
avfilter_graph_dump:                                                           
                                                           +----------------+
graph 0 input from stream 0:0:default--[0x0 0:0 ?]--default| Parsed_scale_0 |default--[0x0 0:0 ?]--format:default
                                                           |    (scale)     |
                                                           +----------------+

+-------------------------------+
| graph 0 input from stream 0:0 |default--[0x0 0:0 ?]--Parsed_scale_0:default
|           (buffer)            |
+-------------------------------+

                                    +--------------+
format:default--[0x0 0:0 ?]--default|   out_0_0    |
                                    | (buffersink) |
                                    +--------------+

                                            +----------+
Parsed_scale_0:default--[0x0 0:0 ?]--default|  format  |default--[0x0 0:0 ?]--out_0_0:default
                                            | (format) |
                                            +----------+

 
经过上面代码流程的讲解和实例的展示，看下面的流程图应该也不会难了。
 
 
后续会讲关于第二种过滤器编程的方法和复杂过滤器的编程使用，记得关注哦~
 
参考：
 
https://www.cnblogs.com/vczf/p/13638051.html
 
https://www.cnblogs.com/renhui/p/14663071.html

·
 ·
 
 ·倒角
 ·方向模糊

前言
 
滤镜最早应用在电视影视业，对剧和电影作品后期进行调色效果。如今拍照、修图都离不开滤镜效果。我们在微博、朋友圈、电视、影院里看到的照片视频，无一没有滤镜的效果，滤镜已经深入我们生活的方方面面。
 
这里浅略地揭秘一下当前图像处理中滤镜底层的原理。
 
 
 
RGB颜色
 
RGB色彩模式是工业界的一种颜色标准，是通过对红®、绿(G)、蓝(B)三个颜色通道的变化以及它们相互之间的叠加来得到各式各样的颜色的，RGB即是代表红、绿、蓝三个通道的颜色，这个标准几乎包括了人类视力所能感知的所有颜色，是运用最广的颜色系统之一。
 
 对于一张图片的每一个像素，都可以由唯一的颜色（R，G，B）表示，其中RGB的范围是0~255。0代表最暗，255代表最亮。
 
 
颜色查找表
 
滤镜的本质就是颜色的变换。我们可以把一个像素的颜色（R，G，B）看成是一个三维空间上的一个坐标点。颜色变换相当于是三维空间的 [一个坐标点] 到 [另一个坐标点] 的映射关系。也就是：
 
    （old R，old G，old B）  --->   （new R，new G，new B）
 
例如：
 
    （23，77，134）  --->      （122，34，255）

    （189，65，138）  --->      （5，65，21）

    （0，0，2）  --->      （33，0，1）

            ………………
 
 
即每一个（R，G，B）都有一个一一对应的目标颜色，那么一个完整的RGB颜色查找表总共有 256×256×256 = 2^24 条。
 
显然 2^24 这个数字有点太大了，存储它需要至少16Mb的空间，加载到内存也至少需要吃掉16Mb的内存
 （问题1：这里可以先思考一下为什么是16Mb？后面会给出解释）
 
因此我们在实际查找表应用中一般使用 64×64×64 的查找表，RGB每个通道都将 [连续的4个坐标] 映射成 [1个目标坐标]
 
例如：
 
    （0，X，X）    --->   （34，X，X）

    （1，X，X）    --->   （34，X，X）

    （2，X，X）    --->   （34，X，X）

    （3，X，X）    --->   （34，X，X）



    （4，X，X）    --->   （128，X，X）

    （5，X，X）    --->   （128，X，X）

    （6，X，X）    --->   （128，X，X）

    （7，X，X）    --->   （128，X，X）
 
但显然这样会导致原始图片颜色精度的丢失（例如上面的0~3的亮度映射后都变成了无差别的34），那么就需要想办法降低这种精度丢失的问题
 （问题2：这里可以先思考一下有哪些补偿精度的方法？后面会给出解答）
 
LUT图
 
有了颜色映射表，接下来需要考虑如何去表达这些映射关系了。有一个笨办法是用文本去存储这 64×64×64 这么多条 （old R，old G，old B） —> （new R，new G，new B）这样的映射关系。聪明的你肯定意识到了这个文本的大小会是一个天文数字。那么有没有更好的表达方法呢？优秀的前辈们发现可以用一个图片去表示这个映射关系，这就是LUT图：
 
 这个LUT图的尺寸是 512×512 ，正好等于 64×64×64（查找表的数量），也就是刚好每一个像素可以表示一条 （old R，old G，old B） —> （new R，new G，new B）这样的映射关系！
 
我们可以用 [图片的像素坐标] 表示（old R，old G，old B），用这个坐标所在的 [像素的颜色] 表示（new R，new G，new B），这样就实现了映射表的一一对应关系。
 
我们可以先从比较简单的开始看，为什么用这个坐标所在的 [像素的颜色] 表示（new R，new G，new B）？因为图片本身每个像素就是由（R，G，B）组成，并且都是0~255，刚好可以完美表示一个（new R，new G，new B）。
 
再来看看比较复杂一丁点的，如何用 [图片的像素坐标] 表示（old R，old G，old B）？因为一个图片的坐标是二维坐标（x，y），要如何表示一个三维的（old R，old G，old B）呢？
 
可以看到这个图片每一行有8个小正方形，每一列也有8个小正方形，总共有64个小正方形。每个小正方形都是一张 64×64的图片。
 
我们先从一个小正方形开始看。其实每一个小正方形都代表了完整的（old R，old G） —> （new R，new G）的映射。其中像素Target坐标（x，y）代表（old R，old G），像素Target的颜色的RG值就代表（new R，new G）。
 
例如下面这张图片：
 
1.假设（old R，old G） = （100，150），那么Target的坐标就是（100 / 4，150 / 4）= （25，37）
 
2.如果这个图片里坐标是（25，37）的Target的像素值是（213， 88），那么（new R，new G）=（213， 88）
 
2.即完成了（old R，old G） = （100，150） —> （new R，new G）=（213， 88） 的映射关系！
 
 至此已经完成了R通道和G通道的映射，那么如何确定B通道的映射关系呢？前面说到一个完整LUT图有8×8=64个小正方形，这64个小正方形就是用来确定B通道的映射关系的。
 
我们把这64个小正方形按从左到右从上到下排列，编号0~63，我们就可以把（old B）映射到其中的某个小正方形格子。
 
拿下面这个示例图比较能说明过程：
 
假如（old B） = （50），那么最终的颜色落在第（50 / 4）=（12）个格子上。
 
但注意，这里的（12）并不是（new B），（12）仍然只是图片的 [坐标]，因此它代表的其实还是（old B），仅仅 / 4 了而已。
 
我们回到上面一步的步骤，确定了在是哪个小正方形，就可以在这个小正方形里根据（old R，old G）确定最终的Target。那么（new B）就等于 像素Target颜色的B值！
 
 
聪明的你也许已经意识到了，在这64个小正方形里，每个小正方形相同（x，y）坐标所对应Target像素颜色的（R，G）都是一样的，仅仅只有B不一样。这也就是为什么B颜色最终是根据计算 [在哪个小正方形里] 来确定的。
 
我们再来完整走一遍LUT图颜色映射的全过程。
 
1.假如一个像素点原始的颜色是 （old R，old G，old B）=（38，201，88）
 
2.根据（old B）确定在哪个小正方形：88 / 4 = 22
 
3.在第22个小正方形里，根据（old R，old G）确定最终Target的坐标：（38 / 4，201 / 4）=（9，50）
 
4.假如第22个小正方形中，（9，50）所对应的Target像素的颜色是（50，3，126）
 
5.那么最终的颜色（new R，new G，new B）=（50，3，126），至此完成一个像素点颜色的映射。
 
6.遍历原始图片的每一个像素，都走一遍1~5的过程，完成对整张图片的滤镜效果。
 
这里先解答一下上面 [问题1] 和 [问题2] 的解答：
 
问题1：为什么是16Mb？
 
因为映射关系都用LUT图表示，每个像素代表一条映射，那么64×64×64 = 2^18，一张 2^18 个像素的无损图片（一般是.png）大小至少是256Kb，而 256×256×256 = 2^24 个像素的无损图片大小至少是16Mb。
 
问题2：有哪些补偿精度的方法？
 
注意到上面精度的丢失是因为像素颜色从 256 --> 64，我们上面在做除法的时候丢失了小数点，例如（38 / 4，201 / 4）=（9，50），但其实应该是（38 / 4，201 / 4）=（9.5，50.25），在实际运用的时候我们并不会抛弃小数点。
 
在计算的时候，如果计算得到的坐标不是位于一个像素的正中心，那么在取色时，会对相邻的几个像素进行加权平均，更靠近的像素权重越大。直观地说就是，理谁越靠近，那么谁就对最终的颜色有更重要的影响。
 
例如下面这个图，在最终确定颜色时，会考虑相邻的4个像素点的颜色。这就是双线性插值法，除此之外也有单线性插值法，有兴趣的朋友欢迎交流。
 
 双线性插值法示意图：
 
 
如何制作一个LUT图？
 
1.打开Photoshop，打开一个你想调色的图片
 
 
2.通过各种调节，达到你所期待的颜色
 
 
3.载入一张原始LUT图
 

 什么是原始LUT图：就是经过这个LUT颜色变化之后，还是原来的颜色，也就是 [什么颜色都不变]
 
它的映射关系：
 
    （0，0，0） ---> （0，0，0）

    （0，0，1） ---> （0，0，1）

            ………………

    （254，255，255） ---> （254，255，255）

    （255，255，255） ---> （255，255，255）
 
4.对这张LUT图也应用上对刚才图片的调色效果
 

 至此一张LUT滤镜图就做好了：
 
 
怎么理解这个过程？
 
我的理解是，我们对图片进行 [调色的一系列操作]，再 [作用在原始LUT图上]，就相当于让这张原始LUT图记录下了 [这一系列操作]，记下来之后就可以拿去对任意的图片进行滤镜效果了。
 
参考：
 
滤镜原理介绍：
 
http://www.360doc.com/content/19/0531/19/54268891_839485594.shtml
 
双线性差值：
 
https://zh.wikipedia.org/wiki/%E5%8F%8C%E7%BA%BF%E6%80%A7%E6%8F%92%E5%80%BC

 
最近在看关于自定义控件的东西，顺便看到了关于滤镜的东西，就写出来分享一下
 

 
这个有三个已知子类，写一个滤镜效果，只需要第一个已知子类就够用了，这个类构造方法public ColorMatrixColorFilter (ColorMatrix matrix)，ColorMatrix的初始化则需要一个4*5的fload行的矩阵 大家看下面就知道了
 

 
这是我的写法
 

 
这个就是颜色矩阵，修改这里面的值就可以做到滤镜的效果，先改一下试试，看运行结果
 
对了 首先要给画笔设置上一个颜色
 
mpaint.setColor(Color.argb(255,255,128,103)); ，然后看效果
 

 
这个解释绘制出来的效果，然后改一改，再看效果
 
ColorMatrix colorMatrix = newColorMatrix(new float[]{
 
0.9F,1,0,0,0,//A0,0.5F,0.6f,0,0,//R0,0,0.5F,0,0.7f,//G0,0,0,1,0,//B}); 随便改了改
 

 
这就是效果
 
换一张图片可能效果更加明显
 
 原图 
 
运行代码后的图
 

 
还有这样
 

 
是不是很酷炫？
 
然而刚才的矩阵怎么计算的，下面是他的公式
 

 
矩阵ColorMatrix的一行乘以矩阵MyColor的一列作为矩阵Result的一行，这里MyColor的RGBA值我们需要转换为[0, 1]。那么我们依据此公式来计算下我们得到的RGBA值是否跟我们计算得出来的圆的RGBA值一样：
 
 就是这样。 
 
下面是这个控件的源码,只需要在里面填上一个方法，就可以做一个滤镜了。 全部项目的源码在我的 GitHub 上。。。
 
package com.liran.custom_view.MyView;
 
import android.content.Context;
 
import android.graphics.Bitmap;
 
import android.graphics.BitmapFactory;
 
import android.graphics.Canvas;
 
import android.graphics.Color;
 
import android.graphics.ColorMatrix;
 
import android.graphics.ColorMatrixColorFilter;
 
import android.graphics.Paint;
 
import android.util.AttributeSet;
 
import android.util.Log;
 
import android.view.View;
 
import com.liran.custom_view.R;
 
import com.liran.custom_view.Utils.DisplayUtil;
 
import com.liran.custom_view.Utils.MeasureUtil;
 
/**
 
* Created by lr 李冉 on 2015-08-31.
 
*/
 
public class CustomView extends View {
 
private String TAG = "CustomView";
 
private Paint mpaint;
 
private int radious = 50;
 
private int x, y;// 位图绘制时左上角的起点坐标
 
private Bitmap bitmap;
 
public CustomView(Context context) {
 
super(context);
 
initPaint(context);
 
}
 
public CustomView(Context context, AttributeSet attrs) {
 
super(context, attrs);
 
initPaint(context);
 
}
 
public CustomView(Context context, AttributeSet attrs, int defStyleAttr) {
 
super(context, attrs, defStyleAttr);
 
initPaint(context);
 
}
 
private void initPaint(Context context) {
 
mpaint = new Paint();
 
mpaint.setAntiAlias(true);
 
/*
 
* 设置画笔样式为描边，圆环嘛……当然不能填充不然就么意思了
 
*
 
* 画笔样式分三种：
 
* 1.Paint.Style.STROKE：描边
 
* 2.Paint.Style.FILL_AND_STROKE：描边并填充
 
* 3.Paint.Style.FILL：填充
 
*/
 
// mpaint.setStyle(Paint.Style.STROKE);
 
mpaint.setStyle(Paint.Style.FILL);
 
// 设置画笔颜色为自定义颜色
 
mpaint.setColor(Color.argb(255, 255, 128, 103));
 
//设置颜色矩阵 注意 是 4x5的float[]类型的矩阵 修改这里的数值就相当于做一个滤镜了
 
ColorMatrix colorMatrix = new ColorMatrix(new float[]{
 
0.9F, 0, 0.5f, 0, 0, //A
 
0, 0.5F, 0, 0.6f, 0, //R
 
0, 0, 0.5F, 0.3f, 0, //G
 
0, 0, 0, 1, 0, //B
 
});
 
// 设置颜色过滤
 
mpaint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
 
// 设置颜色过滤
 
// mpaint.setColorFilter(new LightingColorFilter(0xFFFF00FF, 0x00000000));
 
// 设置颜色过滤
 
// mpaint.setColorFilter(new PorterDuffColorFilter(Color.RED, PorterDuff.Mode.DARKEN));
 
/*
 
* 设置描边的粗细，单位：像素px
 
* 注意：当setStrokeWidth(0)的时候描边宽度并不为0而是只占一个像素
 
*/
 
mpaint.setStrokeWidth(10);
 
initRes(context);
 
}
 
private void initRes(Context context) {
 
bitmap = BitmapFactory.decodeResource(context.getResources(), R.mipmap.bg2);
 
/* x = Math.abs(getMeasuredWidth() / 2 - bitmap.getWidth() / 2);
 
y = Math.abs(getMeasuredHeight() / 2 - bitmap.getHeight() / 2);*/
 
x = MeasureUtil.getScreenWidth(context)[0] / 2 - bitmap.getWidth() / 2 - 18;
 
y = (MeasureUtil.getScreenWidth(context)[1] - MeasureUtil.getStatusBarHeight(context) - DisplayUtil.dip2px(context, 50)) / 2 - bitmap.getHeight() / 2;
 
Log.d(TAG, "initRes x=" + x + "y=" + y + " MeasureUtil.getScreenWidth(context)[1]= " + MeasureUtil.getScreenWidth(context)[1]);
 
Log.d(TAG, "initRes bitmap.getHeight()=" + bitmap.getHeight());
 
}
 
@Override
 
protected void onDraw(Canvas canvas) {
 
super.onDraw(canvas);
 
// Log.d(TAG, "onDraw with="+getMeasuredWidth()+" heigh="+getMeasuredHeight());
 
// canvas.drawCircle(getMeasuredWidth() / 2, getMeasuredHeight() / 2, radious, mpaint);
 
Log.d(TAG, "onDraw x=" + x + " y= " + y);
 
canvas.drawBitmap(bitmap, x, y, mpaint);
 
}
 
public synchronized void setRadius(int radius) {
 
this.radious = radius;
 
invalidate();
 
}
 
/**
 
* 开启一个线程去执行动画
 
*/
 
public void startAnmi() {
 
new Thread(new Runnable() {
 
@Override
 
public void run() {
 
while (true) {
 
/*
 
* 确保线程不断执行不断刷新界面
 
*/
 
while (true) {
 
try {
 
/*
 
* 如果半径小于200则自加否则大于200后重置半径值以实现往复
 
*/
 
if (radious <= 200) {
 
radious += 10;
 
//非主线程刷新view
 
postInvalidate();
 
} else {
 
radious = 0;
 
}
 
// 每执行一次暂停40毫秒
 
Thread.sleep(40);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
}
 
}
 
}
 
}
 
}).start();
 
}
 
}