mandelbrot: make bailout a variable
[ffmpeg.git] / libavfilter / vsrc_mandelbrot.c
1 /*
2  * Copyright (c) 2011 Michael Niedermayer
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  *
20  * The vsrc_color filter from Stefano Sabatini was used as template to create
21  * this
22  */
23
24 /**
25  * @file
26  * Mandelbrot fraktal renderer
27  */
28
29 #include "avfilter.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/parseutils.h"
32
33 typedef struct {
34     int w, h;
35     AVRational time_base;
36     uint64_t pts;
37     int maxiter;
38     double start_x;
39     double start_y;
40     double start_scale;
41     double bailout;
42 } MBContext;
43
44 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
45 {
46     MBContext *mb = ctx->priv;
47     char frame_size  [128] = "320x240";
48     char frame_rate  [128] = "25";
49     AVRational frame_rate_q;
50     int ret;
51
52     mb->maxiter=1024;
53     mb->start_x=-2.0;
54     mb->start_y=-1.5;
55     mb->start_scale=3.0;
56     mb->bailout=100;
57     if (args)
58         sscanf(args, "%127[^:]:%127[^:]:%d,%lf:%lf:%lf", frame_size, frame_rate, &mb->maxiter, &mb->start_x, &mb->start_y, &mb->start_scale);
59
60     if (av_parse_video_size(&mb->w, &mb->h, frame_size) < 0) {
61         av_log(ctx, AV_LOG_ERROR, "Invalid frame size: %s\n", frame_size);
62         return AVERROR(EINVAL);
63     }
64     mb->start_scale /=mb->h;
65
66     if (av_parse_video_rate(&frame_rate_q, frame_rate) < 0 ||
67         frame_rate_q.den <= 0 || frame_rate_q.num <= 0) {
68         av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: %s\n", frame_rate);
69         return AVERROR(EINVAL);
70     }
71     mb->time_base.num = frame_rate_q.den;
72     mb->time_base.den = frame_rate_q.num;
73
74     return 0;
75 }
76
77 static av_cold void uninit(AVFilterContext *ctx)
78 {
79     MBContext *mb = ctx->priv;
80     int i;
81
82 }
83
84 static int query_formats(AVFilterContext *ctx)
85 {
86     static const enum PixelFormat pix_fmts[] = {
87         PIX_FMT_BGR32,
88         PIX_FMT_NONE
89     };
90
91     avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
92     return 0;
93 }
94
95 static int config_props(AVFilterLink *inlink)
96 {
97     AVFilterContext *ctx = inlink->src;
98     MBContext *mb = ctx->priv;
99
100     if (av_image_check_size(mb->w, mb->h, 0, ctx) < 0)
101         return AVERROR(EINVAL);
102
103     inlink->w = mb->w;
104     inlink->h = mb->h;
105     inlink->time_base = mb->time_base;
106
107     return 0;
108 }
109
110 static void draw_mandelbrot(AVFilterContext *ctx, uint32_t *color, int linesize, int64_t pts)
111 {
112     MBContext *mb = ctx->priv;
113     int x,y,i;
114
115     for(y=0; y<mb->h; y++){
116         for(x=0; x<mb->w; x++){
117             double cr=mb->start_x+mb->start_scale*x;
118             double ci=mb->start_y+mb->start_scale*y;
119             double zr=cr;
120             double zi=ci;
121             uint32_t c=0;
122
123             for(i=0; i<256; i++){
124                 double t;
125                 if(zr*zr + zi*zi > mb->bailout){
126                     zr= i + (log(log(mb->bailout)) - log(log(sqrt(zr*zr + zi*zi))))/log(2); break;
127                     c= lrintf((sin(zr)+1)*127) + lrintf((sin(zr/1.234)+1)*127)*256*256 + lrintf((sin(zr/100)+1)*127)*256;
128                     break;
129                 }
130                 t= zr*zr - zi*zi;
131                 zi= 2*zr*zi + ci;
132                 zr=       t + cr;
133             }
134             color[x + y*linesize]= c;
135         }
136     }
137 }
138
139 static int request_frame(AVFilterLink *link)
140 {
141     MBContext *mb = link->src->priv;
142     AVFilterBufferRef *picref = avfilter_get_video_buffer(link, AV_PERM_WRITE, mb->w, mb->h);
143     picref->video->sample_aspect_ratio = (AVRational) {1, 1};
144     picref->pts = mb->pts++;
145     picref->pos = -1;
146
147     avfilter_start_frame(link, avfilter_ref_buffer(picref, ~0));
148     draw_mandelbrot(link->src, picref->data[0], picref->linesize[0]/4, picref->pts);
149     avfilter_draw_slice(link, 0, mb->h, 1);
150     avfilter_end_frame(link);
151     avfilter_unref_buffer(picref);
152
153     return 0;
154 }
155
156 AVFilter avfilter_vsrc_mandelbrot = {
157     .name        = "mandelbrot",
158     .description = NULL_IF_CONFIG_SMALL("Mandelbrot renderer"),
159
160     .priv_size = sizeof(MBContext),
161     .init      = init,
162     .uninit    = uninit,
163
164     .query_formats = query_formats,
165
166     .inputs    = (const AVFilterPad[]) {{ .name = NULL}},
167
168     .outputs   = (const AVFilterPad[]) {{ .name      = "default",
169                                     .type            = AVMEDIA_TYPE_VIDEO,
170                                     .request_frame   = request_frame,
171                                     .config_props    = config_props },
172                                   { .name = NULL}},
173 };