LCOV - code coverage report
Current view: top level - libavfilter - vsrc_cellauto.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 125 0.0 %
Date: 2017-12-16 13:57:32 Functions: 0 9 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) Stefano Sabatini 2011
       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             :  * cellular automaton video source, based on Stephen Wolfram "experimentus crucis"
      24             :  */
      25             : 
      26             : /* #define DEBUG */
      27             : 
      28             : #include "libavutil/file.h"
      29             : #include "libavutil/internal.h"
      30             : #include "libavutil/lfg.h"
      31             : #include "libavutil/opt.h"
      32             : #include "libavutil/parseutils.h"
      33             : #include "libavutil/random_seed.h"
      34             : #include "libavutil/avstring.h"
      35             : #include "avfilter.h"
      36             : #include "internal.h"
      37             : #include "formats.h"
      38             : #include "video.h"
      39             : 
      40             : typedef struct CellAutoContext {
      41             :     const AVClass *class;
      42             :     int w, h;
      43             :     char *filename;
      44             :     char *rule_str;
      45             :     uint8_t *file_buf;
      46             :     size_t file_bufsize;
      47             :     uint8_t *buf;
      48             :     int buf_prev_row_idx, buf_row_idx;
      49             :     uint8_t rule;
      50             :     uint64_t pts;
      51             :     AVRational frame_rate;
      52             :     double   random_fill_ratio;
      53             :     uint32_t random_seed;
      54             :     int stitch, scroll, start_full;
      55             :     int64_t generation;         ///< the generation number, starting from 0
      56             :     AVLFG lfg;
      57             :     char *pattern;
      58             : } CellAutoContext;
      59             : 
      60             : #define OFFSET(x) offsetof(CellAutoContext, x)
      61             : #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
      62             : 
      63             : static const AVOption cellauto_options[] = {
      64             :     { "filename", "read initial pattern from file", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
      65             :     { "f",        "read initial pattern from file", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
      66             :     { "pattern",  "set initial pattern", OFFSET(pattern), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
      67             :     { "p",        "set initial pattern", OFFSET(pattern), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
      68             :     { "rate",     "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
      69             :     { "r",        "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
      70             :     { "size",     "set video size", OFFSET(w),    AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, FLAGS },
      71             :     { "s",        "set video size", OFFSET(w),    AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, FLAGS },
      72             :     { "rule",     "set rule",       OFFSET(rule), AV_OPT_TYPE_INT,    {.i64 = 110},  0, 255, FLAGS },
      73             :     { "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 },
      74             :     { "ratio",             "set fill ratio for filling initial grid randomly", OFFSET(random_fill_ratio), AV_OPT_TYPE_DOUBLE, {.dbl = 1/M_PHI}, 0, 1, FLAGS },
      75             :     { "random_seed", "set the seed for filling the initial grid randomly", OFFSET(random_seed), AV_OPT_TYPE_INT, {.i64 = -1}, -1, UINT32_MAX, FLAGS },
      76             :     { "seed",        "set the seed for filling the initial grid randomly", OFFSET(random_seed), AV_OPT_TYPE_INT, {.i64 = -1}, -1, UINT32_MAX, FLAGS },
      77             :     { "scroll",      "scroll pattern downward", OFFSET(scroll), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS },
      78             :     { "start_full",  "start filling the whole video", OFFSET(start_full), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
      79             :     { "full",        "start filling the whole video", OFFSET(start_full), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS },
      80             :     { "stitch",      "stitch boundaries", OFFSET(stitch), AV_OPT_TYPE_BOOL,    {.i64 = 1},   0, 1, FLAGS },
      81             :     { NULL }
      82             : };
      83             : 
      84             : AVFILTER_DEFINE_CLASS(cellauto);
      85             : 
      86             : #ifdef DEBUG
      87             : static void show_cellauto_row(AVFilterContext *ctx)
      88             : {
      89             :     CellAutoContext *s = ctx->priv;
      90             :     int i;
      91             :     uint8_t *row = s->buf + s->w * s->buf_row_idx;
      92             :     char *line = av_malloc(s->w + 1);
      93             :     if (!line)
      94             :         return;
      95             : 
      96             :     for (i = 0; i < s->w; i++)
      97             :         line[i] = row[i] ? '@' : ' ';
      98             :     line[i] = 0;
      99             :     av_log(ctx, AV_LOG_DEBUG, "generation:%"PRId64" row:%s|\n", s->generation, line);
     100             :     av_free(line);
     101             : }
     102             : #endif
     103             : 
     104           0 : static int init_pattern_from_string(AVFilterContext *ctx)
     105             : {
     106           0 :     CellAutoContext *s = ctx->priv;
     107             :     char *p;
     108           0 :     int i, w = 0;
     109             : 
     110           0 :     w = strlen(s->pattern);
     111           0 :     av_log(ctx, AV_LOG_DEBUG, "w:%d\n", w);
     112             : 
     113           0 :     if (s->w) {
     114           0 :         if (w > s->w) {
     115           0 :             av_log(ctx, AV_LOG_ERROR,
     116             :                    "The specified width is %d which cannot contain the provided string width of %d\n",
     117             :                    s->w, w);
     118           0 :             return AVERROR(EINVAL);
     119             :         }
     120             :     } else {
     121             :         /* width was not specified, set it to width of the provided row */
     122           0 :         s->w = w;
     123           0 :         s->h = (double)s->w * M_PHI;
     124             :     }
     125             : 
     126           0 :     s->buf = av_mallocz_array(sizeof(uint8_t) * s->w, s->h);
     127           0 :     if (!s->buf)
     128           0 :         return AVERROR(ENOMEM);
     129             : 
     130             :     /* fill buf */
     131           0 :     p = s->pattern;
     132           0 :     for (i = (s->w - w)/2;; i++) {
     133           0 :         av_log(ctx, AV_LOG_DEBUG, "%d %c\n", i, *p == '\n' ? 'N' : *p);
     134           0 :         if (*p == '\n' || !*p)
     135             :             break;
     136             :         else
     137           0 :             s->buf[i] = !!av_isgraph(*(p++));
     138             :     }
     139             : 
     140           0 :     return 0;
     141             : }
     142             : 
     143           0 : static int init_pattern_from_file(AVFilterContext *ctx)
     144             : {
     145           0 :     CellAutoContext *s = ctx->priv;
     146             :     int ret;
     147             : 
     148           0 :     ret = av_file_map(s->filename,
     149             :                       &s->file_buf, &s->file_bufsize, 0, ctx);
     150           0 :     if (ret < 0)
     151           0 :         return ret;
     152             : 
     153             :     /* create a string based on the read file */
     154           0 :     s->pattern = av_malloc(s->file_bufsize + 1);
     155           0 :     if (!s->pattern)
     156           0 :         return AVERROR(ENOMEM);
     157           0 :     memcpy(s->pattern, s->file_buf, s->file_bufsize);
     158           0 :     s->pattern[s->file_bufsize] = 0;
     159             : 
     160           0 :     return init_pattern_from_string(ctx);
     161             : }
     162             : 
     163           0 : static av_cold int init(AVFilterContext *ctx)
     164             : {
     165           0 :     CellAutoContext *s = ctx->priv;
     166             :     int ret;
     167             : 
     168           0 :     if (!s->w && !s->filename && !s->pattern)
     169           0 :         av_opt_set(s, "size", "320x518", 0);
     170             : 
     171           0 :     if (s->filename && s->pattern) {
     172           0 :         av_log(ctx, AV_LOG_ERROR, "Only one of the filename or pattern options can be used\n");
     173           0 :         return AVERROR(EINVAL);
     174             :     }
     175             : 
     176           0 :     if (s->filename) {
     177           0 :         if ((ret = init_pattern_from_file(ctx)) < 0)
     178           0 :             return ret;
     179           0 :     } else if (s->pattern) {
     180           0 :         if ((ret = init_pattern_from_string(ctx)) < 0)
     181           0 :             return ret;
     182             :     } else {
     183             :         /* fill the first row randomly */
     184             :         int i;
     185             : 
     186           0 :         s->buf = av_mallocz_array(sizeof(uint8_t) * s->w, s->h);
     187           0 :         if (!s->buf)
     188           0 :             return AVERROR(ENOMEM);
     189           0 :         if (s->random_seed == -1)
     190           0 :             s->random_seed = av_get_random_seed();
     191             : 
     192           0 :         av_lfg_init(&s->lfg, s->random_seed);
     193             : 
     194           0 :         for (i = 0; i < s->w; i++) {
     195           0 :             double r = (double)av_lfg_get(&s->lfg) / UINT32_MAX;
     196           0 :             if (r <= s->random_fill_ratio)
     197           0 :                 s->buf[i] = 1;
     198             :         }
     199             :     }
     200             : 
     201           0 :     av_log(ctx, AV_LOG_VERBOSE,
     202             :            "s:%dx%d r:%d/%d rule:%d stitch:%d scroll:%d full:%d seed:%"PRIu32"\n",
     203             :            s->w, s->h, s->frame_rate.num, s->frame_rate.den,
     204           0 :            s->rule, s->stitch, s->scroll, s->start_full,
     205             :            s->random_seed);
     206           0 :     return 0;
     207             : }
     208             : 
     209           0 : static av_cold void uninit(AVFilterContext *ctx)
     210             : {
     211           0 :     CellAutoContext *s = ctx->priv;
     212             : 
     213           0 :     av_file_unmap(s->file_buf, s->file_bufsize);
     214           0 :     av_freep(&s->buf);
     215           0 :     av_freep(&s->pattern);
     216           0 : }
     217             : 
     218           0 : static int config_props(AVFilterLink *outlink)
     219             : {
     220           0 :     CellAutoContext *s = outlink->src->priv;
     221             : 
     222           0 :     outlink->w = s->w;
     223           0 :     outlink->h = s->h;
     224           0 :     outlink->time_base = av_inv_q(s->frame_rate);
     225             : 
     226           0 :     return 0;
     227             : }
     228             : 
     229           0 : static void evolve(AVFilterContext *ctx)
     230             : {
     231           0 :     CellAutoContext *s = ctx->priv;
     232             :     int i, v, pos[3];
     233           0 :     uint8_t *row, *prev_row = s->buf + s->buf_row_idx * s->w;
     234             :     enum { NW, N, NE };
     235             : 
     236           0 :     s->buf_prev_row_idx = s->buf_row_idx;
     237           0 :     s->buf_row_idx      = s->buf_row_idx == s->h-1 ? 0 : s->buf_row_idx+1;
     238           0 :     row = s->buf + s->w * s->buf_row_idx;
     239             : 
     240           0 :     for (i = 0; i < s->w; i++) {
     241           0 :         if (s->stitch) {
     242           0 :             pos[NW] = i-1 < 0 ? s->w-1 : i-1;
     243           0 :             pos[N]  = i;
     244           0 :             pos[NE] = i+1 == s->w ? 0  : i+1;
     245           0 :             v = prev_row[pos[NW]]<<2 | prev_row[pos[N]]<<1 | prev_row[pos[NE]];
     246             :         } else {
     247           0 :             v = 0;
     248           0 :             v|= i-1 >= 0          ? prev_row[i-1]<<2 : 0;
     249           0 :             v|=                     prev_row[i  ]<<1    ;
     250           0 :             v|= i+1 < s->w ? prev_row[i+1]    : 0;
     251             :         }
     252           0 :         row[i] = !!(s->rule & (1<<v));
     253             :         ff_dlog(ctx, "i:%d context:%c%c%c -> cell:%d\n", i,
     254             :                 v&4?'@':' ', v&2?'@':' ', v&1?'@':' ', row[i]);
     255             :     }
     256             : 
     257           0 :     s->generation++;
     258           0 : }
     259             : 
     260           0 : static void fill_picture(AVFilterContext *ctx, AVFrame *picref)
     261             : {
     262           0 :     CellAutoContext *s = ctx->priv;
     263           0 :     int i, j, k, row_idx = 0;
     264           0 :     uint8_t *p0 = picref->data[0];
     265             : 
     266           0 :     if (s->scroll && s->generation >= s->h)
     267             :         /* show on top the oldest row */
     268           0 :         row_idx = (s->buf_row_idx + 1) % s->h;
     269             : 
     270             :     /* fill the output picture with the whole buffer */
     271           0 :     for (i = 0; i < s->h; i++) {
     272           0 :         uint8_t byte = 0;
     273           0 :         uint8_t *row = s->buf + row_idx*s->w;
     274           0 :         uint8_t *p = p0;
     275           0 :         for (k = 0, j = 0; j < s->w; j++) {
     276           0 :             byte |= row[j]<<(7-k++);
     277           0 :             if (k==8 || j == s->w-1) {
     278           0 :                 k = 0;
     279           0 :                 *p++ = byte;
     280           0 :                 byte = 0;
     281             :             }
     282             :         }
     283           0 :         row_idx = (row_idx + 1) % s->h;
     284           0 :         p0 += picref->linesize[0];
     285             :     }
     286           0 : }
     287             : 
     288           0 : static int request_frame(AVFilterLink *outlink)
     289             : {
     290           0 :     CellAutoContext *s = outlink->src->priv;
     291           0 :     AVFrame *picref = ff_get_video_buffer(outlink, s->w, s->h);
     292           0 :     if (!picref)
     293           0 :         return AVERROR(ENOMEM);
     294           0 :     picref->sample_aspect_ratio = (AVRational) {1, 1};
     295           0 :     if (s->generation == 0 && s->start_full) {
     296             :         int i;
     297           0 :         for (i = 0; i < s->h-1; i++)
     298           0 :             evolve(outlink->src);
     299             :     }
     300           0 :     fill_picture(outlink->src, picref);
     301           0 :     evolve(outlink->src);
     302             : 
     303           0 :     picref->pts = s->pts++;
     304             : 
     305             : #ifdef DEBUG
     306             :     show_cellauto_row(outlink->src);
     307             : #endif
     308           0 :     return ff_filter_frame(outlink, picref);
     309             : }
     310             : 
     311           0 : static int query_formats(AVFilterContext *ctx)
     312             : {
     313             :     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE };
     314           0 :     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
     315           0 :     if (!fmts_list)
     316           0 :         return AVERROR(ENOMEM);
     317           0 :     return ff_set_common_formats(ctx, fmts_list);
     318             : }
     319             : 
     320             : static const AVFilterPad cellauto_outputs[] = {
     321             :     {
     322             :         .name          = "default",
     323             :         .type          = AVMEDIA_TYPE_VIDEO,
     324             :         .request_frame = request_frame,
     325             :         .config_props  = config_props,
     326             :     },
     327             :     { NULL }
     328             : };
     329             : 
     330             : AVFilter ff_vsrc_cellauto = {
     331             :     .name          = "cellauto",
     332             :     .description   = NULL_IF_CONFIG_SMALL("Create pattern generated by an elementary cellular automaton."),
     333             :     .priv_size     = sizeof(CellAutoContext),
     334             :     .priv_class    = &cellauto_class,
     335             :     .init          = init,
     336             :     .uninit        = uninit,
     337             :     .query_formats = query_formats,
     338             :     .inputs        = NULL,
     339             :     .outputs       = cellauto_outputs,
     340             : };

Generated by: LCOV version 1.13