FFmpeg
vsrc_life.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) Stefano Sabatini 2010
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 
21 /**
22  * @file
23  * life video source, based on John Conways' Life Game
24  */
25 
26 /* #define DEBUG */
27 
28 #include "libavutil/file.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/lfg.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/random_seed.h"
35 #include "libavutil/avstring.h"
36 #include "avfilter.h"
37 #include "internal.h"
38 #include "formats.h"
39 #include "video.h"
40 
41 typedef struct LifeContext {
42  const AVClass *class;
43  int w, h;
44  char *filename;
45  char *rule_str;
47  size_t file_bufsize;
48 
49  /**
50  * The two grid state buffers.
51  *
52  * A 0xFF (ALIVE_CELL) value means the cell is alive (or new born), while
53  * the decreasing values from 0xFE to 0 means the cell is dead; the range
54  * of values is used for the slow death effect, or mold (0xFE means dead,
55  * 0xFD means very dead, 0xFC means very very dead... and 0x00 means
56  * definitely dead/mold).
57  */
58  uint8_t *buf[2];
59 
61  uint16_t stay_rule; ///< encode the behavior for filled cells
62  uint16_t born_rule; ///< encode the behavior for empty cells
63  uint64_t pts;
66  uint32_t random_seed;
67  int stitch;
68  int mold;
74 } LifeContext;
75 
76 #define ALIVE_CELL 0xFF
77 #define OFFSET(x) offsetof(LifeContext, x)
78 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
79 
80 static const AVOption life_options[] = {
81  { "filename", "set source file", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
82  { "f", "set source file", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
83  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, FLAGS },
84  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, FLAGS },
85  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
86  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
87  { "rule", "set rule", OFFSET(rule_str), AV_OPT_TYPE_STRING, {.str = "B3/S23"}, CHAR_MIN, CHAR_MAX, FLAGS },
88  { "random_fill_ratio", "set fill ratio for filling initial grid randomly", OFFSET(random_fill_ratio), AV_OPT_TYPE_DOUBLE, {.dbl=1/M_PHI}, 0, 1, FLAGS },
89  { "ratio", "set fill ratio for filling initial grid randomly", OFFSET(random_fill_ratio), AV_OPT_TYPE_DOUBLE, {.dbl=1/M_PHI}, 0, 1, FLAGS },
90  { "random_seed", "set the seed for filling the initial grid randomly", OFFSET(random_seed), AV_OPT_TYPE_INT, {.i64=-1}, -1, UINT32_MAX, FLAGS },
91  { "seed", "set the seed for filling the initial grid randomly", OFFSET(random_seed), AV_OPT_TYPE_INT, {.i64=-1}, -1, UINT32_MAX, FLAGS },
92  { "stitch", "stitch boundaries", OFFSET(stitch), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
93  { "mold", "set mold speed for dead cells", OFFSET(mold), AV_OPT_TYPE_INT, {.i64=0}, 0, 0xFF, FLAGS },
94  { "life_color", "set life color", OFFSET( life_color), AV_OPT_TYPE_COLOR, {.str="white"}, CHAR_MIN, CHAR_MAX, FLAGS },
95  { "death_color", "set death color", OFFSET(death_color), AV_OPT_TYPE_COLOR, {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS },
96  { "mold_color", "set mold color", OFFSET( mold_color), AV_OPT_TYPE_COLOR, {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS },
97  { NULL }
98 };
99 
101 
102 static int parse_rule(uint16_t *born_rule, uint16_t *stay_rule,
103  const char *rule_str, void *log_ctx)
104 {
105  char *tail;
106  const char *p = rule_str;
107  *born_rule = 0;
108  *stay_rule = 0;
109 
110  if (strchr("bBsS", *p)) {
111  /* parse rule as a Born / Stay Alive code, see
112  * http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life */
113  do {
114  uint16_t *rule = (*p == 'b' || *p == 'B') ? born_rule : stay_rule;
115  p++;
116  while (*p >= '0' && *p <= '8') {
117  *rule += 1<<(*p - '0');
118  p++;
119  }
120  if (*p != '/')
121  break;
122  p++;
123  } while (strchr("bBsS", *p));
124 
125  if (*p)
126  goto error;
127  } else {
128  /* parse rule as a number, expressed in the form STAY|(BORN<<9),
129  * where STAY and BORN encode the corresponding 9-bits rule */
130  long int rule = strtol(rule_str, &tail, 10);
131  if (*tail)
132  goto error;
133  *born_rule = ((1<<9)-1) & rule;
134  *stay_rule = rule >> 9;
135  }
136 
137  return 0;
138 
139 error:
140  av_log(log_ctx, AV_LOG_ERROR, "Invalid rule code '%s' provided\n", rule_str);
141  return AVERROR(EINVAL);
142 }
143 
144 #ifdef DEBUG
145 static void show_life_grid(AVFilterContext *ctx)
146 {
147  LifeContext *life = ctx->priv;
148  int i, j;
149 
150  char *line = av_malloc(life->w + 1);
151  if (!line)
152  return;
153  for (i = 0; i < life->h; i++) {
154  for (j = 0; j < life->w; j++)
155  line[j] = life->buf[life->buf_idx][i*life->w + j] == ALIVE_CELL ? '@' : ' ';
156  line[j] = 0;
157  av_log(ctx, AV_LOG_DEBUG, "%3d: %s\n", i, line);
158  }
159  av_free(line);
160 }
161 #endif
162 
164 {
165  LifeContext *life = ctx->priv;
166  char *p;
167  int ret, i, i0, j, h = 0, w, max_w = 0;
168 
169  if ((ret = av_file_map(life->filename, &life->file_buf, &life->file_bufsize,
170  0, ctx)) < 0)
171  return ret;
172  av_freep(&life->filename);
173 
174  /* prescan file to get the number of lines and the maximum width */
175  w = 0;
176  for (i = 0; i < life->file_bufsize; i++) {
177  if (life->file_buf[i] == '\n') {
178  h++; max_w = FFMAX(w, max_w); w = 0;
179  } else {
180  w++;
181  }
182  }
183  av_log(ctx, AV_LOG_DEBUG, "h:%d max_w:%d\n", h, max_w);
184 
185  if (life->w) {
186  if (max_w > life->w || h > life->h) {
187  av_log(ctx, AV_LOG_ERROR,
188  "The specified size is %dx%d which cannot contain the provided file size of %dx%d\n",
189  life->w, life->h, max_w, h);
190  return AVERROR(EINVAL);
191  }
192  } else {
193  /* size was not specified, set it to size of the grid */
194  life->w = max_w;
195  life->h = h;
196  }
197 
198  if (!(life->buf[0] = av_calloc(life->h * life->w, sizeof(*life->buf[0]))) ||
199  !(life->buf[1] = av_calloc(life->h * life->w, sizeof(*life->buf[1])))) {
200  av_freep(&life->buf[0]);
201  av_freep(&life->buf[1]);
202  return AVERROR(ENOMEM);
203  }
204 
205  /* fill buf[0] */
206  p = life->file_buf;
207  for (i0 = 0, i = (life->h - h)/2; i0 < h; i0++, i++) {
208  for (j = (life->w - max_w)/2;; j++) {
209  av_log(ctx, AV_LOG_DEBUG, "%d:%d %c\n", i, j, *p == '\n' ? 'N' : *p);
210  if (*p == '\n') {
211  p++; break;
212  } else
213  life->buf[0][i*life->w + j] = av_isgraph(*(p++)) ? ALIVE_CELL : 0;
214  }
215  }
216  life->buf_idx = 0;
217 
218  return 0;
219 }
220 
221 static av_cold int init(AVFilterContext *ctx)
222 {
223  LifeContext *life = ctx->priv;
224  int ret;
225 
226  if (!life->w && !life->filename)
227  av_opt_set(life, "size", "320x240", 0);
228 
229  if ((ret = parse_rule(&life->born_rule, &life->stay_rule, life->rule_str, ctx)) < 0)
230  return ret;
231 
232  if (!life->mold && memcmp(life->mold_color, "\x00\x00\x00", 3))
233  av_log(ctx, AV_LOG_WARNING,
234  "Mold color is set while mold isn't, ignoring the color.\n");
235 
236  if (!life->filename) {
237  /* fill the grid randomly */
238  int i;
239 
240  if (!(life->buf[0] = av_calloc(life->h * life->w, sizeof(*life->buf[0]))) ||
241  !(life->buf[1] = av_calloc(life->h * life->w, sizeof(*life->buf[1])))) {
242  av_freep(&life->buf[0]);
243  av_freep(&life->buf[1]);
244  return AVERROR(ENOMEM);
245  }
246  if (life->random_seed == -1)
248 
249  av_lfg_init(&life->lfg, life->random_seed);
250 
251  for (i = 0; i < life->w * life->h; i++) {
252  double r = (double)av_lfg_get(&life->lfg) / UINT32_MAX;
253  if (r <= life->random_fill_ratio)
254  life->buf[0][i] = ALIVE_CELL;
255  }
256  life->buf_idx = 0;
257  } else {
258  if ((ret = init_pattern_from_file(ctx)) < 0)
259  return ret;
260  }
261 
262  av_log(ctx, AV_LOG_VERBOSE,
263  "s:%dx%d r:%d/%d rule:%s stay_rule:%d born_rule:%d stitch:%d seed:%"PRIu32"\n",
264  life->w, life->h, life->frame_rate.num, life->frame_rate.den,
265  life->rule_str, life->stay_rule, life->born_rule, life->stitch,
266  life->random_seed);
267  return 0;
268 }
269 
270 static av_cold void uninit(AVFilterContext *ctx)
271 {
272  LifeContext *life = ctx->priv;
273 
274  av_file_unmap(life->file_buf, life->file_bufsize);
275  av_freep(&life->rule_str);
276  av_freep(&life->buf[0]);
277  av_freep(&life->buf[1]);
278 }
279 
280 static int config_props(AVFilterLink *outlink)
281 {
282  LifeContext *life = outlink->src->priv;
283 
284  outlink->w = life->w;
285  outlink->h = life->h;
286  outlink->time_base = av_inv_q(life->frame_rate);
287 
288  return 0;
289 }
290 
291 static void evolve(AVFilterContext *ctx)
292 {
293  LifeContext *life = ctx->priv;
294  int i, j;
295  uint8_t *oldbuf = life->buf[ life->buf_idx];
296  uint8_t *newbuf = life->buf[!life->buf_idx];
297 
298  enum { NW, N, NE, W, E, SW, S, SE };
299 
300  /* evolve the grid */
301  for (i = 0; i < life->h; i++) {
302  for (j = 0; j < life->w; j++) {
303  int pos[8][2], n, alive, cell;
304  if (life->stitch) {
305  pos[NW][0] = (i-1) < 0 ? life->h-1 : i-1; pos[NW][1] = (j-1) < 0 ? life->w-1 : j-1;
306  pos[N ][0] = (i-1) < 0 ? life->h-1 : i-1; pos[N ][1] = j ;
307  pos[NE][0] = (i-1) < 0 ? life->h-1 : i-1; pos[NE][1] = (j+1) == life->w ? 0 : j+1;
308  pos[W ][0] = i ; pos[W ][1] = (j-1) < 0 ? life->w-1 : j-1;
309  pos[E ][0] = i ; pos[E ][1] = (j+1) == life->w ? 0 : j+1;
310  pos[SW][0] = (i+1) == life->h ? 0 : i+1; pos[SW][1] = (j-1) < 0 ? life->w-1 : j-1;
311  pos[S ][0] = (i+1) == life->h ? 0 : i+1; pos[S ][1] = j ;
312  pos[SE][0] = (i+1) == life->h ? 0 : i+1; pos[SE][1] = (j+1) == life->w ? 0 : j+1;
313  } else {
314  pos[NW][0] = (i-1) < 0 ? -1 : i-1; pos[NW][1] = (j-1) < 0 ? -1 : j-1;
315  pos[N ][0] = (i-1) < 0 ? -1 : i-1; pos[N ][1] = j ;
316  pos[NE][0] = (i-1) < 0 ? -1 : i-1; pos[NE][1] = (j+1) == life->w ? -1 : j+1;
317  pos[W ][0] = i ; pos[W ][1] = (j-1) < 0 ? -1 : j-1;
318  pos[E ][0] = i ; pos[E ][1] = (j+1) == life->w ? -1 : j+1;
319  pos[SW][0] = (i+1) == life->h ? -1 : i+1; pos[SW][1] = (j-1) < 0 ? -1 : j-1;
320  pos[S ][0] = (i+1) == life->h ? -1 : i+1; pos[S ][1] = j ;
321  pos[SE][0] = (i+1) == life->h ? -1 : i+1; pos[SE][1] = (j+1) == life->w ? -1 : j+1;
322  }
323 
324  /* compute the number of live neighbor cells */
325  n = (pos[NW][0] == -1 || pos[NW][1] == -1 ? 0 : oldbuf[pos[NW][0]*life->w + pos[NW][1]] == ALIVE_CELL) +
326  (pos[N ][0] == -1 || pos[N ][1] == -1 ? 0 : oldbuf[pos[N ][0]*life->w + pos[N ][1]] == ALIVE_CELL) +
327  (pos[NE][0] == -1 || pos[NE][1] == -1 ? 0 : oldbuf[pos[NE][0]*life->w + pos[NE][1]] == ALIVE_CELL) +
328  (pos[W ][0] == -1 || pos[W ][1] == -1 ? 0 : oldbuf[pos[W ][0]*life->w + pos[W ][1]] == ALIVE_CELL) +
329  (pos[E ][0] == -1 || pos[E ][1] == -1 ? 0 : oldbuf[pos[E ][0]*life->w + pos[E ][1]] == ALIVE_CELL) +
330  (pos[SW][0] == -1 || pos[SW][1] == -1 ? 0 : oldbuf[pos[SW][0]*life->w + pos[SW][1]] == ALIVE_CELL) +
331  (pos[S ][0] == -1 || pos[S ][1] == -1 ? 0 : oldbuf[pos[S ][0]*life->w + pos[S ][1]] == ALIVE_CELL) +
332  (pos[SE][0] == -1 || pos[SE][1] == -1 ? 0 : oldbuf[pos[SE][0]*life->w + pos[SE][1]] == ALIVE_CELL);
333  cell = oldbuf[i*life->w + j];
334  alive = 1<<n & (cell == ALIVE_CELL ? life->stay_rule : life->born_rule);
335  if (alive) *newbuf = ALIVE_CELL; // new cell is alive
336  else if (cell) *newbuf = cell - 1; // new cell is dead and in the process of mold
337  else *newbuf = 0; // new cell is definitely dead
338  ff_dlog(ctx, "i:%d j:%d live_neighbors:%d cell:%d -> cell:%d\n", i, j, n, cell, *newbuf);
339  newbuf++;
340  }
341  }
342 
343  life->buf_idx = !life->buf_idx;
344 }
345 
347 {
348  LifeContext *life = ctx->priv;
349  uint8_t *buf = life->buf[life->buf_idx];
350  int i, j, k;
351 
352  /* fill the output picture with the old grid buffer */
353  for (i = 0; i < life->h; i++) {
354  uint8_t byte = 0;
355  uint8_t *p = picref->data[0] + i * picref->linesize[0];
356  for (k = 0, j = 0; j < life->w; j++) {
357  byte |= (buf[i*life->w+j] == ALIVE_CELL)<<(7-k++);
358  if (k==8 || j == life->w-1) {
359  k = 0;
360  *p++ = byte;
361  byte = 0;
362  }
363  }
364  }
365 }
366 
367 // divide by 255 and round to nearest
368 // apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
369 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
370 
371 static void fill_picture_rgb(AVFilterContext *ctx, AVFrame *picref)
372 {
373  LifeContext *life = ctx->priv;
374  uint8_t *buf = life->buf[life->buf_idx];
375  int i, j;
376 
377  /* fill the output picture with the old grid buffer */
378  for (i = 0; i < life->h; i++) {
379  uint8_t *p = picref->data[0] + i * picref->linesize[0];
380  for (j = 0; j < life->w; j++) {
381  uint8_t v = buf[i*life->w + j];
382  if (life->mold && v != ALIVE_CELL) {
383  const uint8_t *c1 = life-> mold_color;
384  const uint8_t *c2 = life->death_color;
385  int death_age = FFMIN((0xff - v) * life->mold, 0xff);
386  *p++ = FAST_DIV255((c2[0] << 8) + ((int)c1[0] - (int)c2[0]) * death_age);
387  *p++ = FAST_DIV255((c2[1] << 8) + ((int)c1[1] - (int)c2[1]) * death_age);
388  *p++ = FAST_DIV255((c2[2] << 8) + ((int)c1[2] - (int)c2[2]) * death_age);
389  } else {
390  const uint8_t *c = v == ALIVE_CELL ? life->life_color : life->death_color;
391  AV_WB24(p, c[0]<<16 | c[1]<<8 | c[2]);
392  p += 3;
393  }
394  }
395  }
396 }
397 
398 static int request_frame(AVFilterLink *outlink)
399 {
400  LifeContext *life = outlink->src->priv;
401  AVFrame *picref = ff_get_video_buffer(outlink, life->w, life->h);
402  if (!picref)
403  return AVERROR(ENOMEM);
404  picref->sample_aspect_ratio = (AVRational) {1, 1};
405  picref->pts = life->pts++;
406 
407  life->draw(outlink->src, picref);
408  evolve(outlink->src);
409 #ifdef DEBUG
410  show_life_grid(outlink->src);
411 #endif
412  return ff_filter_frame(outlink, picref);
413 }
414 
416 {
417  LifeContext *life = ctx->priv;
419  AVFilterFormats *fmts_list;
420 
421  if (life->mold || memcmp(life-> life_color, "\xff\xff\xff", 3)
422  || memcmp(life->death_color, "\x00\x00\x00", 3)) {
423  pix_fmts[0] = AV_PIX_FMT_RGB24;
424  life->draw = fill_picture_rgb;
425  } else {
426  pix_fmts[0] = AV_PIX_FMT_MONOBLACK;
428  }
429 
430  fmts_list = ff_make_format_list(pix_fmts);
431  return ff_set_common_formats(ctx, fmts_list);
432 }
433 
434 static const AVFilterPad life_outputs[] = {
435  {
436  .name = "default",
437  .type = AVMEDIA_TYPE_VIDEO,
438  .request_frame = request_frame,
439  .config_props = config_props,
440  },
441  { NULL}
442 };
443 
445  .name = "life",
446  .description = NULL_IF_CONFIG_SMALL("Create life."),
447  .priv_size = sizeof(LifeContext),
448  .priv_class = &life_class,
449  .init = init,
450  .uninit = uninit,
452  .inputs = NULL,
453  .outputs = life_outputs,
454 };
Definition: lfg.h:27
#define NULL
Definition: coverity.c:32
uint32_t random_seed
Definition: vsrc_life.c:66
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
uint16_t stay_rule
encode the behavior for filled cells
Definition: vsrc_life.c:61
AVOption.
Definition: opt.h:246
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Main libavfilter public API header.
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
static const AVFilterPad life_outputs[]
Definition: vsrc_life.c:434
int num
Numerator.
Definition: rational.h:59
static void fill_picture_monoblack(AVFilterContext *ctx, AVFrame *picref)
Definition: vsrc_life.c:346
static av_cold int init(AVFilterContext *ctx)
Definition: vsrc_life.c:221
static int request_frame(AVFilterLink *outlink)
Definition: vsrc_life.c:398
static void fill_picture_rgb(AVFilterContext *ctx, AVFrame *picref)
Definition: vsrc_life.c:371
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
#define N
Definition: af_mcompand.c:54
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
AVLFG lfg
Definition: vsrc_life.c:72
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
static int query_formats(AVFilterContext *ctx)
Definition: vsrc_life.c:415
uint8_t death_color[4]
Definition: vsrc_life.c:70
Misc file utilities.
static const uint64_t c1
Definition: murmur3.c:49
char * rule_str
Definition: vsrc_life.c:45
#define ff_dlog(a,...)
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void av_file_unmap(uint8_t *bufptr, size_t size)
Unmap or free the buffer bufptr created by av_file_map().
Definition: file.c:139
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx)
Read the file with name filename, and put its content in a newly allocated buffer or map it with mmap...
Definition: file.c:53
static int config_props(AVFilterLink *outlink)
Definition: vsrc_life.c:280
#define S(s, c, i)
static av_cold void uninit(AVFilterContext *ctx)
Definition: vsrc_life.c:270
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVFilter ff_vsrc_life
Definition: vsrc_life.c:444
const char * r
Definition: vf_curves.c:114
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
Definition: graph2dot.c:48
#define FAST_DIV255(x)
Definition: vsrc_life.c:369
static void evolve(AVFilterContext *ctx)
Definition: vsrc_life.c:291
int stitch
Definition: vsrc_life.c:67
#define FFMAX(a, b)
Definition: common.h:94
uint8_t buf_idx
Definition: vsrc_life.c:60
common internal API header
#define OFFSET(x)
Definition: vsrc_life.c:77
#define E
Definition: avdct.c:32
#define FFMIN(a, b)
Definition: common.h:96
uint8_t * file_buf
Definition: vsrc_life.c:46
In the ELBG jargon, a cell is the set of points that are closest to a codebook entry.
Definition: elbg.c:39
AVFILTER_DEFINE_CLASS(life)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
uint8_t life_color[4]
Definition: vsrc_life.c:69
AVFormatContext * ctx
Definition: movenc.c:48
#define FLAGS
Definition: vsrc_life.c:78
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
int n
Definition: avisynth_c.h:760
static int init_pattern_from_file(AVFilterContext *ctx)
Definition: vsrc_life.c:163
static void error(const char *err)
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define ALIVE_CELL
Definition: vsrc_life.c:76
double random_fill_ratio
Definition: vsrc_life.c:65
Definition: vf_addroi.c:26
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
void(* draw)(AVFilterContext *, AVFrame *)
Definition: vsrc_life.c:73
uint16_t born_rule
encode the behavior for empty cells
Definition: vsrc_life.c:62
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:383
#define SE
Definition: dvdsubenc.c:468
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:47
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define M_PHI
Definition: mathematics.h:49
offset must point to AVRational
Definition: opt.h:236
const char * name
Filter name.
Definition: avfilter.h:148
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
offset must point to two consecutive integers
Definition: opt.h:233
misc parsing utilities
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define SW(val, pdst)
uint64_t pts
Definition: vsrc_life.c:63
static int parse_rule(uint16_t *born_rule, uint16_t *stay_rule, const char *rule_str, void *log_ctx)
Definition: vsrc_life.c:102
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
static av_const int av_isgraph(int c)
Locale-independent conversion of ASCII isgraph.
Definition: avstring.h:214
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:76
static const uint64_t c2
Definition: murmur3.c:50
int den
Denominator.
Definition: rational.h:60
AVRational frame_rate
Definition: vsrc_life.c:64
static const AVOption life_options[]
Definition: vsrc_life.c:80
#define av_free(p)
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
#define av_freep(p)
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
size_t file_bufsize
Definition: vsrc_life.c:47
internal API functions
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
uint8_t mold_color[4]
Definition: vsrc_life.c:71
uint8_t * buf[2]
The two grid state buffers.
Definition: vsrc_life.c:58
char * filename
Definition: vsrc_life.c:44