trunk/libfjme/video.h

Go to the documentation of this file.

/*
A GTK video editor Designed for Artists to do, special effects, compositing and animation.
Copyright (C) 2011  Fabio J. Gonzalez

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gtk/gtk.h>
#include "basic.h"

#ifndef FJME_VIDEO_H
#define FJME_VIDEO_H 1

#define GetPixeIntf(pixbuf, x,  y) \
        GetPixelf( pixbuf, gdk_pixbuf_get_width(pixbuf) / 2 + x, gdk_pixbuf_get_height(pixbuf) / 2 + y )

#define SetPixeIntf(pixbuf, x,  y, p) \
        SetPixelf( pixbuf, gdk_pixbuf_get_width(pixbuf) / 2 + x, gdk_pixbuf_get_height(pixbuf) / 2 + y, p )


#define GetPixelFloatf( pixbuf, x, y ) \
        GetPixeIntf( pixbuf, x*(gdk_pixbuf_get_width(pixbuf) / 2) ,  y*(gdk_pixbuf_get_height(pixbuf)/2) )

#define SetPixelFloatf( pixbuf, x, y, p ) \
        SetPixeIntf( pixbuf, x*(gdk_pixbuf_get_width(pixbuf) / 2) ,  y*(gdk_pixbuf_get_height(pixbuf)/2), p )

#define fjme_image_from_file(file) \
        gtk_image_new_from_pixbuf( gdk_pixbuf_new_from_file(file, NULL) )

struct Layer;
typedef struct Layer Layer;

struct Pixel;
typedef struct Pixel Pixel;

struct Pixelf;
typedef struct Pixelf Pixelf;

struct Pixeld;
typedef struct Pixeld Pixeld;

struct VideoFrame {
    GdkPixbuf* pixels;
    gdouble* audio;
};

typedef struct VideoFrame VideoFrame;

struct Layer {
    gchar* name;

    union {

        struct {
            GdkPixbuf* pixels;
            gdouble* audio;
        };

        VideoFrame video;
    };

    //Animated values

    gdouble *volume;

    gdouble *opacity;

    gdouble* x;

    gdouble* y;

    gdouble* width;

    gdouble* height;

    gboolean selected;

    gboolean central;

    gdouble *rotation;

    gdouble* pos;

    guint32 frame;

    gdouble* end;

    gdouble* fps;

    GList* plugins;
};

struct Pixelf {
    //range from 0 to 1

    union {
        gfloat c[4];

        struct {
            gfloat r;
            gfloat g;
            gfloat b;
            gfloat a;
        };

        struct {
            gfloat red;
            gfloat green;
            gfloat blue;
            gfloat alpha;
        };

    };
};

struct Pixeld {
    //range from 0 to 1

    union {
        gdouble c[4];

        struct {
            gdouble r;
            gdouble g;
            gdouble b;
            gdouble a;
        };

        struct {
            gdouble red;
            gdouble green;
            gdouble blue;
            gdouble alpha;
        };

    };
};

struct Pixel {
    //range from 0 to 255

    union {
        guchar c[4];

        struct {
            guchar r;
            guchar g;
            guchar b;
            guchar a;
        };

        struct {
            guchar red;
            guchar green;
            guchar blue;
            guchar alpha;
        };
    };
};

void SetPixel(GdkPixbuf *pixbuf, guint32 x, guint32 y, Pixel* p);

Pixel* GetPixel(GdkPixbuf *pixbuf, guint32 x, guint32 y);

Pixelf GetPixelf(GdkPixbuf *pixbuf, guint32 x, guint32 y);
void SetPixelf(GdkPixbuf *pixbuf, guint32 x, guint32 y, Pixelf pf);

Layer* addEmptyVideoLayer(guint32 width, guint32 height);

gboolean LayerSet(Layer* layer);

Layer* findLayerByName(gchar* name);

gboolean pixbuf_draw(GdkPixbuf* dst, GdkPixbuf* src,
        guint32 x, guint32 y, guint32 width, guint32 height);

gboolean pixbuf_draw_simple(GdkPixbuf* dst, GdkPixbuf* src,
        guint32 x, guint32 y);

#define pixbuf_draw_fullcreen( dst, src ) pixbuf_draw( dst, src, 0, 0, \
gdk_pixbuf_get_width(dst), gdk_pixbuf_get_height(dst))

void layer_window_show( GtkWidget* widget, gpointer data );

#endif