libpipi/pipi/context.c

/*
 *  libpipi       Proper image processing implementation library
 *  Copyright (c) 2004-2008 Sam Hocevar <sam@zoy.org>
 *                All Rights Reserved
 *
 *  $Id$
 *
 *  This library is free software. It comes without any warranty, to
 *  the extent permitted by applicable law. You can redistribute it
 *  and/or modify it under the terms of the Do What The Fuck You Want
 *  To Public License, Version 2, as published by Sam Hocevar. See
 *  http://sam.zoy.org/wtfpl/COPYING for more details.
 */

/*
 * context.c: processing stack handling routines
 */

#include "config.h"
#include "common.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#include "pipi.h"
#include "pipi_internals.h"

pipi_context_t *pipi_create_context()
{
    pipi_context_t *ret;

    ret = malloc(sizeof(pipi_context_t));
    memset(ret, 0, sizeof(pipi_context_t));

    return ret;
}

void pipi_destroy_context(pipi_context_t *ctx)
{
    free(ctx);
}

int pipi_command(pipi_context_t *ctx, char const *cmd, ...)
{
    if(!strcmp(cmd, "load"))
    {
        char const *file;
        va_list ap;

        va_start(ap, cmd);
        file = va_arg(ap, char const *);
        va_end(ap);
        ctx->images[ctx->nimages] = pipi_load(file);
        if(ctx->images[ctx->nimages] == NULL)
            return -1;
        ctx->nimages++;
    }
    else if(!strcmp(cmd, "save"))
    {
        char const *file;
        va_list ap;

        if(ctx->nimages < 1)
            return -1;
        ctx->nimages--;
        va_start(ap, cmd);
        file = va_arg(ap, char const *);
        va_end(ap);
        pipi_save(ctx->images[ctx->nimages], file);
        pipi_free(ctx->images[ctx->nimages]);
    }
    else if(!strcmp(cmd, "dither"))
    {
        pipi_image_t *src, *dst;
        char const *method;
        va_list ap;

        if(ctx->nimages < 1)
            return -1;
        va_start(ap, cmd);
        method = va_arg(ap, char const *);
        va_end(ap);
        src = ctx->images[ctx->nimages - 1];
        dst = NULL;
        if(!strcmp(method, "fs"))
            dst = pipi_dither_floydsteinberg(src, 0);
        else if(!strcmp(method, "sfs"))
            dst = pipi_dither_floydsteinberg(src, 1);
        else if(!strcmp(method, "jajuni"))
            dst = pipi_dither_jajuni(src, 0);
        else if(!strcmp(method, "sjajuni"))
            dst = pipi_dither_jajuni(src, 1);
        else if(!strcmp(method, "ost"))
            dst = pipi_dither_ostromoukhov(src, 0);
        else if(!strcmp(method, "sost"))
            dst = pipi_dither_ostromoukhov(src, 1);
        else if(!strcmp(method, "ordered"))
        {
            if(ctx->nimages < 2)
                return -1;
            dst = pipi_dither_ordered(ctx->images[ctx->nimages - 2], src);
            pipi_free(ctx->images[ctx->nimages - 2]);
            ctx->nimages--;
        }
        else if(!strcmp(method, "random"))
            dst = pipi_dither_random(src);
        else if(!strcmp(method, "dbs"))
            dst = pipi_dither_dbs(src);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "blur"))
    {
        pipi_image_t *src, *dst;
        char const *arg;
        va_list ap;
        double w, h, a = 0.0;

        if(ctx->nimages < 1)
            return -1;
        va_start(ap, cmd);
        arg = va_arg(ap, char const *);
        va_end(ap);
        w = h = atof(arg);
        arg = strchr(arg, 'x');
        if(arg)
        {
            h = atof(arg + 1);
            arg = strchr(arg, 'r');
            if(arg)
                a = atof(arg + 1);
        }
        src = ctx->images[ctx->nimages - 1];
        dst = pipi_gaussian_blur_ext(src, w, h, a, 0.0, 0.0);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "geometry"))
    {
        pipi_image_t *src, *dst;
        char const *arg;
        va_list ap;
        int w, h;

        if(ctx->nimages < 1)
            return -1;
        va_start(ap, cmd);
        arg = va_arg(ap, char const *);
        va_end(ap);
        w = atoi(arg);
        arg = strchr(arg, 'x');
        if(!arg)
            return -1;
        h = atoi(arg + 1);
        if(w <= 0 || h <= 0)
            return -1;
        src = ctx->images[ctx->nimages - 1];
        dst = pipi_resize(src, w, h);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "tile"))
    {
        pipi_image_t *src, *dst;
        char const *arg;
        va_list ap;
        int w, h;

        if(ctx->nimages < 1)
            return -1;
        va_start(ap, cmd);
        arg = va_arg(ap, char const *);
        va_end(ap);
        w = atoi(arg);
        arg = strchr(arg, 'x');
        if(!arg)
            return -1;
        h = atoi(arg + 1);
        if(w <= 0 || h <= 0)
            return -1;
        src = ctx->images[ctx->nimages - 1];
        dst = pipi_tile(src, w, h);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "scale"))
    {
        pipi_image_t *src, *dst;
        char const *arg;
        va_list ap;
        double scale;
        int w, h;

        if(ctx->nimages < 1)
            return -1;
        src = ctx->images[ctx->nimages - 1];
        va_start(ap, cmd);
        arg = va_arg(ap, char const *);
        va_end(ap);
        scale = atof(arg);
        w = (int)(scale * src->w + 0.5);
        h = (int)(scale * src->h + 0.5);
        if(w <= 0 || h <= 0)
            return -1;
        dst = pipi_resize(src, w, h);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "brightness"))
    {
        pipi_image_t *src, *dst;
        char const *arg;
        va_list ap;
        double val;

        if(ctx->nimages < 1)
            return -1;
        va_start(ap, cmd);
        arg = va_arg(ap, char const *);
        va_end(ap);
        val = atof(arg);
        src = ctx->images[ctx->nimages - 1];
        dst = pipi_brightness(src, val);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "contrast"))
    {
        pipi_image_t *src, *dst;
        char const *arg;
        va_list ap;
        double val;

        if(ctx->nimages < 1)
            return -1;
        va_start(ap, cmd);
        arg = va_arg(ap, char const *);
        va_end(ap);
        val = atof(arg);
        src = ctx->images[ctx->nimages - 1];
        dst = pipi_contrast(src, val);
        if(dst == NULL)
            return -1;
        pipi_free(src);
        ctx->images[ctx->nimages - 1] = dst;
    }
    else if(!strcmp(cmd, "mean"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_mean(ctx->images[ctx->nimages - 2],
                        ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "min"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_min(ctx->images[ctx->nimages - 2],
                       ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "max"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_max(ctx->images[ctx->nimages - 2],
                       ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "add"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_add(ctx->images[ctx->nimages - 2],
                       ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "sub"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_sub(ctx->images[ctx->nimages - 2],
                       ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "difference"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_difference(ctx->images[ctx->nimages - 2],
                              ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "multiply"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_multiply(ctx->images[ctx->nimages - 2],
                            ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "divide"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_divide(ctx->images[ctx->nimages - 2],
                          ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "screen"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_screen(ctx->images[ctx->nimages - 2],
                          ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "overlay"))
    {
        pipi_image_t *dst;

        if(ctx->nimages < 2)
            return -1;
        dst = pipi_overlay(ctx->images[ctx->nimages - 2],
                           ctx->images[ctx->nimages - 1]);
        if(dst == NULL)
            return -1;
        pipi_free(ctx->images[ctx->nimages - 2]);
        pipi_free(ctx->images[ctx->nimages - 1]);
        ctx->images[ctx->nimages - 2] = dst;
        ctx->nimages--;
    }
    else if(!strcmp(cmd, "wrap"))
    {
        if(ctx->nimages < 1)
            return -1;
        ctx->images[ctx->nimages - 1]->wrap = 1;
    }
    else if(!strcmp(cmd, "autocontrast"))
    {
        pipi_image_t *tmp;
        if(ctx->nimages < 1)
            return -1;
        tmp = ctx->images[ctx->nimages - 1];
        ctx->images[ctx->nimages - 1] = pipi_autocontrast(tmp);
        pipi_free(tmp);
    }
    else if(!strcmp(cmd, "invert"))
    {
        pipi_image_t *tmp;
        if(ctx->nimages < 1)
            return -1;
        tmp = ctx->images[ctx->nimages - 1];
        ctx->images[ctx->nimages - 1] = pipi_invert(tmp);
        pipi_free(tmp);
    }
    else if(!strcmp(cmd, "gray"))
    {
        if(ctx->nimages < 1)
            return -1;
        pipi_getpixels(ctx->images[ctx->nimages - 1], PIPI_PIXELS_Y_F);
    }
    else if(!strcmp(cmd, "free"))
    {
        if(ctx->nimages < 1)
            return -1;
        ctx->nimages--;
        pipi_free(ctx->images[ctx->nimages]);
    }
    else if(!strcmp(cmd, "dup"))
    {
        if(ctx->nimages < 1)
            return -1;
        ctx->images[ctx->nimages] = pipi_copy(ctx->images[ctx->nimages - 1]);
        ctx->nimages++;
    }
    else if(!strcmp(cmd, "swap"))
    {
        pipi_image_t *tmp;
        if(ctx->nimages < 2)
            return -1;
        tmp = ctx->images[ctx->nimages - 1];
        ctx->images[ctx->nimages - 1] = ctx->images[ctx->nimages - 2];
        ctx->images[ctx->nimages - 2] = tmp;
    }
    else
    {
        return -1;
    }

    return 0;
}