mirror of
https://github.com/game-stop/veejay.git
synced 2025-12-20 06:40:01 +01:00
merged with libvevo from veejay-current
git-svn-id: svn://code.dyne.org/veejay/trunk@636 eb8d1916-c9e9-0310-b8de-cf0c9472ead5
This commit is contained in:
Niels Elburg
@@ -1,6 +1,6 @@
|
|||||||
# Process with automake to produce Makefile.in
|
# Process with automake to produce Makefile.in
|
||||||
|
|
||||||
SUBDIRS = src include test examples
|
SUBDIRS = src include test
|
||||||
|
|
||||||
bin_SCRIPTS = vevo-config
|
bin_SCRIPTS = vevo-config
|
||||||
|
|
||||||
|
|||||||
7081
vevo-current/aclocal.m4
vendored
7081
vevo-current/aclocal.m4
vendored
File diff suppressed because it is too large
Load Diff
30
vevo-current/config.guess
vendored
30
vevo-current/config.guess
vendored
@@ -1,9 +1,9 @@
|
|||||||
#! /bin/sh
|
#! /bin/sh
|
||||||
# Attempt to guess a canonical system name.
|
# Attempt to guess a canonical system name.
|
||||||
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
||||||
# 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
# 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
|
||||||
|
|
||||||
timestamp='2004-09-07'
|
timestamp='2005-04-22'
|
||||||
|
|
||||||
# This file is free software; you can redistribute it and/or modify it
|
# This file is free software; you can redistribute it and/or modify it
|
||||||
# under the terms of the GNU General Public License as published by
|
# under the terms of the GNU General Public License as published by
|
||||||
@@ -53,7 +53,7 @@ version="\
|
|||||||
GNU config.guess ($timestamp)
|
GNU config.guess ($timestamp)
|
||||||
|
|
||||||
Originally written by Per Bothner.
|
Originally written by Per Bothner.
|
||||||
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
|
||||||
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
||||||
|
|
||||||
This is free software; see the source for copying conditions. There is NO
|
This is free software; see the source for copying conditions. There is NO
|
||||||
@@ -319,6 +319,9 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
|||||||
*:OS/390:*:*)
|
*:OS/390:*:*)
|
||||||
echo i370-ibm-openedition
|
echo i370-ibm-openedition
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
|
*:z/VM:*:*)
|
||||||
|
echo s390-ibm-zvmoe
|
||||||
|
exit 0 ;;
|
||||||
*:OS400:*:*)
|
*:OS400:*:*)
|
||||||
echo powerpc-ibm-os400
|
echo powerpc-ibm-os400
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
@@ -342,7 +345,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
|||||||
DRS?6000:unix:4.0:6*)
|
DRS?6000:unix:4.0:6*)
|
||||||
echo sparc-icl-nx6
|
echo sparc-icl-nx6
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
DRS?6000:UNIX_SV:4.2*:7*)
|
DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
|
||||||
case `/usr/bin/uname -p` in
|
case `/usr/bin/uname -p` in
|
||||||
sparc) echo sparc-icl-nx7 && exit 0 ;;
|
sparc) echo sparc-icl-nx7 && exit 0 ;;
|
||||||
esac ;;
|
esac ;;
|
||||||
@@ -801,6 +804,9 @@ EOF
|
|||||||
i*:UWIN*:*)
|
i*:UWIN*:*)
|
||||||
echo ${UNAME_MACHINE}-pc-uwin
|
echo ${UNAME_MACHINE}-pc-uwin
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
|
amd64:CYGWIN*:*:*)
|
||||||
|
echo x86_64-unknown-cygwin
|
||||||
|
exit 0 ;;
|
||||||
p*:CYGWIN*:*)
|
p*:CYGWIN*:*)
|
||||||
echo powerpcle-unknown-cygwin
|
echo powerpcle-unknown-cygwin
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
@@ -1134,6 +1140,10 @@ EOF
|
|||||||
# From seanf@swdc.stratus.com.
|
# From seanf@swdc.stratus.com.
|
||||||
echo i860-stratus-sysv4
|
echo i860-stratus-sysv4
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
|
i*86:VOS:*:*)
|
||||||
|
# From Paul.Green@stratus.com.
|
||||||
|
echo ${UNAME_MACHINE}-stratus-vos
|
||||||
|
exit 0 ;;
|
||||||
*:VOS:*:*)
|
*:VOS:*:*)
|
||||||
# From Paul.Green@stratus.com.
|
# From Paul.Green@stratus.com.
|
||||||
echo hppa1.1-stratus-vos
|
echo hppa1.1-stratus-vos
|
||||||
@@ -1194,6 +1204,9 @@ EOF
|
|||||||
*:QNX:*:4*)
|
*:QNX:*:4*)
|
||||||
echo i386-pc-qnx
|
echo i386-pc-qnx
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
|
NSE-?:NONSTOP_KERNEL:*:*)
|
||||||
|
echo nse-tandem-nsk${UNAME_RELEASE}
|
||||||
|
exit 0 ;;
|
||||||
NSR-?:NONSTOP_KERNEL:*:*)
|
NSR-?:NONSTOP_KERNEL:*:*)
|
||||||
echo nsr-tandem-nsk${UNAME_RELEASE}
|
echo nsr-tandem-nsk${UNAME_RELEASE}
|
||||||
exit 0 ;;
|
exit 0 ;;
|
||||||
@@ -1247,7 +1260,10 @@ EOF
|
|||||||
A*) echo alpha-dec-vms && exit 0 ;;
|
A*) echo alpha-dec-vms && exit 0 ;;
|
||||||
I*) echo ia64-dec-vms && exit 0 ;;
|
I*) echo ia64-dec-vms && exit 0 ;;
|
||||||
V*) echo vax-dec-vms && exit 0 ;;
|
V*) echo vax-dec-vms && exit 0 ;;
|
||||||
esac
|
esac ;;
|
||||||
|
*:XENIX:*:SysV)
|
||||||
|
echo i386-pc-xenix
|
||||||
|
exit 0 ;;
|
||||||
esac
|
esac
|
||||||
|
|
||||||
#echo '(No uname command or uname output not recognized.)' 1>&2
|
#echo '(No uname command or uname output not recognized.)' 1>&2
|
||||||
@@ -1407,7 +1423,9 @@ This script, last modified $timestamp, has failed to recognize
|
|||||||
the operating system you are using. It is advised that you
|
the operating system you are using. It is advised that you
|
||||||
download the most up to date version of the config scripts from
|
download the most up to date version of the config scripts from
|
||||||
|
|
||||||
ftp://ftp.gnu.org/pub/gnu/config/
|
http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess
|
||||||
|
and
|
||||||
|
http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub
|
||||||
|
|
||||||
If the version you run ($0) is already up to date, please
|
If the version you run ($0) is already up to date, please
|
||||||
send the following data and any information you think might be
|
send the following data and any information you think might be
|
||||||
|
|||||||
36
vevo-current/config.sub
vendored
36
vevo-current/config.sub
vendored
@@ -1,9 +1,9 @@
|
|||||||
#! /bin/sh
|
#! /bin/sh
|
||||||
# Configuration validation subroutine script.
|
# Configuration validation subroutine script.
|
||||||
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
||||||
# 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
# 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
|
||||||
|
|
||||||
timestamp='2004-08-29'
|
timestamp='2005-04-22'
|
||||||
|
|
||||||
# This file is (in principle) common to ALL GNU software.
|
# This file is (in principle) common to ALL GNU software.
|
||||||
# The presence of a machine in this file suggests that SOME GNU software
|
# The presence of a machine in this file suggests that SOME GNU software
|
||||||
@@ -70,7 +70,7 @@ Report bugs and patches to <config-patches@gnu.org>."
|
|||||||
version="\
|
version="\
|
||||||
GNU config.sub ($timestamp)
|
GNU config.sub ($timestamp)
|
||||||
|
|
||||||
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
|
||||||
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
||||||
|
|
||||||
This is free software; see the source for copying conditions. There is NO
|
This is free software; see the source for copying conditions. There is NO
|
||||||
@@ -231,13 +231,14 @@ case $basic_machine in
|
|||||||
| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
|
| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
|
||||||
| am33_2.0 \
|
| am33_2.0 \
|
||||||
| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
|
| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
|
||||||
|
| bfin \
|
||||||
| c4x | clipper \
|
| c4x | clipper \
|
||||||
| d10v | d30v | dlx | dsp16xx \
|
| d10v | d30v | dlx | dsp16xx \
|
||||||
| fr30 | frv \
|
| fr30 | frv \
|
||||||
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
|
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
|
||||||
| i370 | i860 | i960 | ia64 \
|
| i370 | i860 | i960 | ia64 \
|
||||||
| ip2k | iq2000 \
|
| ip2k | iq2000 \
|
||||||
| m32r | m32rle | m68000 | m68k | m88k | mcore \
|
| m32r | m32rle | m68000 | m68k | m88k | maxq | mcore \
|
||||||
| mips | mipsbe | mipseb | mipsel | mipsle \
|
| mips | mipsbe | mipseb | mipsel | mipsle \
|
||||||
| mips16 \
|
| mips16 \
|
||||||
| mips64 | mips64el \
|
| mips64 | mips64el \
|
||||||
@@ -262,12 +263,13 @@ case $basic_machine in
|
|||||||
| pyramid \
|
| pyramid \
|
||||||
| sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \
|
| sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \
|
||||||
| sh64 | sh64le \
|
| sh64 | sh64le \
|
||||||
| sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv8 | sparcv9 | sparcv9b \
|
| sparc | sparc64 | sparc64b | sparc86x | sparclet | sparclite \
|
||||||
|
| sparcv8 | sparcv9 | sparcv9b \
|
||||||
| strongarm \
|
| strongarm \
|
||||||
| tahoe | thumb | tic4x | tic80 | tron \
|
| tahoe | thumb | tic4x | tic80 | tron \
|
||||||
| v850 | v850e \
|
| v850 | v850e \
|
||||||
| we32k \
|
| we32k \
|
||||||
| x86 | xscale | xstormy16 | xtensa \
|
| x86 | xscale | xscalee[bl] | xstormy16 | xtensa \
|
||||||
| z8k)
|
| z8k)
|
||||||
basic_machine=$basic_machine-unknown
|
basic_machine=$basic_machine-unknown
|
||||||
;;
|
;;
|
||||||
@@ -298,7 +300,7 @@ case $basic_machine in
|
|||||||
| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
|
| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
|
||||||
| arm-* | armbe-* | armle-* | armeb-* | armv*-* \
|
| arm-* | armbe-* | armle-* | armeb-* | armv*-* \
|
||||||
| avr-* \
|
| avr-* \
|
||||||
| bs2000-* \
|
| bfin-* | bs2000-* \
|
||||||
| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
|
| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
|
||||||
| clipper-* | craynv-* | cydra-* \
|
| clipper-* | craynv-* | cydra-* \
|
||||||
| d10v-* | d30v-* | dlx-* \
|
| d10v-* | d30v-* | dlx-* \
|
||||||
@@ -310,7 +312,7 @@ case $basic_machine in
|
|||||||
| ip2k-* | iq2000-* \
|
| ip2k-* | iq2000-* \
|
||||||
| m32r-* | m32rle-* \
|
| m32r-* | m32rle-* \
|
||||||
| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
|
| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
|
||||||
| m88110-* | m88k-* | mcore-* \
|
| m88110-* | m88k-* | maxq-* | mcore-* \
|
||||||
| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
|
| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
|
||||||
| mips16-* \
|
| mips16-* \
|
||||||
| mips64-* | mips64el-* \
|
| mips64-* | mips64el-* \
|
||||||
@@ -336,15 +338,16 @@ case $basic_machine in
|
|||||||
| romp-* | rs6000-* \
|
| romp-* | rs6000-* \
|
||||||
| sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \
|
| sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \
|
||||||
| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
|
| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
|
||||||
| sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \
|
| sparc-* | sparc64-* | sparc64b-* | sparc86x-* | sparclet-* \
|
||||||
|
| sparclite-* \
|
||||||
| sparcv8-* | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \
|
| sparcv8-* | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \
|
||||||
| tahoe-* | thumb-* \
|
| tahoe-* | thumb-* \
|
||||||
| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
|
| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
|
||||||
| tron-* \
|
| tron-* \
|
||||||
| v850-* | v850e-* | vax-* \
|
| v850-* | v850e-* | vax-* \
|
||||||
| we32k-* \
|
| we32k-* \
|
||||||
| x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \
|
| x86-* | x86_64-* | xps100-* | xscale-* | xscalee[bl]-* \
|
||||||
| xtensa-* \
|
| xstormy16-* | xtensa-* \
|
||||||
| ymp-* \
|
| ymp-* \
|
||||||
| z8k-*)
|
| z8k-*)
|
||||||
;;
|
;;
|
||||||
@@ -489,6 +492,10 @@ case $basic_machine in
|
|||||||
basic_machine=m88k-motorola
|
basic_machine=m88k-motorola
|
||||||
os=-sysv3
|
os=-sysv3
|
||||||
;;
|
;;
|
||||||
|
djgpp)
|
||||||
|
basic_machine=i586-pc
|
||||||
|
os=-msdosdjgpp
|
||||||
|
;;
|
||||||
dpx20 | dpx20-*)
|
dpx20 | dpx20-*)
|
||||||
basic_machine=rs6000-bull
|
basic_machine=rs6000-bull
|
||||||
os=-bosx
|
os=-bosx
|
||||||
@@ -1029,6 +1036,10 @@ case $basic_machine in
|
|||||||
basic_machine=hppa1.1-winbond
|
basic_machine=hppa1.1-winbond
|
||||||
os=-proelf
|
os=-proelf
|
||||||
;;
|
;;
|
||||||
|
xbox)
|
||||||
|
basic_machine=i686-pc
|
||||||
|
os=-mingw32
|
||||||
|
;;
|
||||||
xps | xps100)
|
xps | xps100)
|
||||||
basic_machine=xps100-honeywell
|
basic_machine=xps100-honeywell
|
||||||
;;
|
;;
|
||||||
@@ -1297,6 +1308,9 @@ case $os in
|
|||||||
-kaos*)
|
-kaos*)
|
||||||
os=-kaos
|
os=-kaos
|
||||||
;;
|
;;
|
||||||
|
-zvmoe)
|
||||||
|
os=-zvmoe
|
||||||
|
;;
|
||||||
-none)
|
-none)
|
||||||
;;
|
;;
|
||||||
*)
|
*)
|
||||||
|
|||||||
@@ -37,6 +37,8 @@ AC_SUBST(LT_AGE)
|
|||||||
|
|
||||||
dnl **********************************************************************
|
dnl **********************************************************************
|
||||||
dnl Options
|
dnl Options
|
||||||
|
AC_ARG_ENABLE(assertions,
|
||||||
|
[ --enable-mpool, Use memory pool])
|
||||||
AC_ARG_ENABLE(assertions,
|
AC_ARG_ENABLE(assertions,
|
||||||
[ --enable-assertions, Turn on runtime assertion checking.])
|
[ --enable-assertions, Turn on runtime assertion checking.])
|
||||||
AC_ARG_ENABLE(compile-warnings,
|
AC_ARG_ENABLE(compile-warnings,
|
||||||
@@ -129,6 +131,10 @@ if test "x$enable_assertions" != "xno"; then
|
|||||||
fi
|
fi
|
||||||
fi
|
fi
|
||||||
|
|
||||||
|
if test "x$enable_mpool" != "xno"; then
|
||||||
|
AC_DEFINE(HAVE_MEMPOOL,,[memory pool])
|
||||||
|
fi
|
||||||
|
|
||||||
AC_MSG_RESULT($warnCFLAGS)
|
AC_MSG_RESULT($warnCFLAGS)
|
||||||
if test "x$cflags_set" != "xyes" ; then
|
if test "x$cflags_set" != "xyes" ; then
|
||||||
CFLAGS="$CFLAGS $warnCFLAGS"
|
CFLAGS="$CFLAGS $warnCFLAGS"
|
||||||
@@ -139,7 +145,6 @@ AC_CONFIG_FILES([
|
|||||||
Makefile
|
Makefile
|
||||||
src/Makefile
|
src/Makefile
|
||||||
include/Makefile
|
include/Makefile
|
||||||
examples/Makefile
|
|
||||||
test/Makefile
|
test/Makefile
|
||||||
vevo-config
|
vevo-config
|
||||||
])
|
])
|
||||||
|
|||||||
@@ -1,15 +0,0 @@
|
|||||||
INCLUDES = -I$(top_srcdir)/include \
|
|
||||||
-I$(top_srcdir) -I$(includedir) \
|
|
||||||
-DG_LOG_DOMAIN=\"libvido\" -DLIBVIDO_VERSION=\"$(VERSION)\"
|
|
||||||
|
|
||||||
LIBVEVO = $(top_builddir)/src/libvevo.la
|
|
||||||
|
|
||||||
# *********************************************************************
|
|
||||||
# The tools themselves
|
|
||||||
EXAMPLES_BIN = hosttest
|
|
||||||
|
|
||||||
bin_PROGRAMS = $(EXAMPLES_BIN)
|
|
||||||
|
|
||||||
hosttest_SOURCES = testhost.c
|
|
||||||
hosttest_LDADD = -lvevo -ldl
|
|
||||||
hosttest_LDFLAGS = -export-dynamic
|
|
||||||
@@ -1,432 +0,0 @@
|
|||||||
|
|
||||||
#include <dlfcn.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
#include "../include/vevo.h"
|
|
||||||
#include "../include/livido.h"
|
|
||||||
#include "../src/livido-utils.c"
|
|
||||||
|
|
||||||
int verbose = 1;
|
|
||||||
|
|
||||||
int errorcount = 0;
|
|
||||||
int warningcount = 0;
|
|
||||||
|
|
||||||
typedef int (deepcheck_f)(livido_port_t *, char *);
|
|
||||||
typedef struct {
|
|
||||||
int ver; // -1 - end sentinel, 1 for specification 100
|
|
||||||
int sets; // 1 - host, 2 - plugin, 3 - both
|
|
||||||
int mand; // 0 - optional, 1 - mandatory
|
|
||||||
char *name; // name of the property
|
|
||||||
int atomtype; // atom type of the property, -1 - don't check - should be checked by func()
|
|
||||||
int minc; // minimum number of elements, -1 - no limit
|
|
||||||
int maxc; // maximum number of elements, -1 - no limit
|
|
||||||
deepcheck_f *func; // deep check function to be called
|
|
||||||
} property_desc_t;
|
|
||||||
|
|
||||||
deepcheck_f deep_plugininfo_filters;
|
|
||||||
deepcheck_f deep_channel_templates;
|
|
||||||
deepcheck_f deep_parameter_templates;
|
|
||||||
deepcheck_f deep_filter_api_version;
|
|
||||||
int test_port (livido_port_t *port, property_desc_t *properties, int porttype, char *portdesc);
|
|
||||||
|
|
||||||
|
|
||||||
#define DESC_END {-1, 0, 0, "", 0, 0, 0 , NULL}
|
|
||||||
|
|
||||||
|
|
||||||
property_desc_t port_plugininfo_desc[] = {
|
|
||||||
{1, 2, 1, "type", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "filters", LIVIDO_ATOM_TYPE_PORTPTR, 1, -1 , &deep_plugininfo_filters},
|
|
||||||
{1, 2, 1, "maintainer", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "version", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "url", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_filterclass_desc[] = {
|
|
||||||
{1, 2, 1, "type", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "name", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "description", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "version", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "api_version", LIVIDO_ATOM_TYPE_INT, 1, 1 , &deep_filter_api_version},
|
|
||||||
{1, 2, 1, "license", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "flags", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "init_func", LIVIDO_ATOM_TYPE_VOIDPTR, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "process_func", LIVIDO_ATOM_TYPE_VOIDPTR, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "deinit_func", LIVIDO_ATOM_TYPE_VOIDPTR, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "in_channel_templates", LIVIDO_ATOM_TYPE_PORTPTR, 0, -1 , &deep_channel_templates},
|
|
||||||
{1, 2, 1, "out_channel_templates", LIVIDO_ATOM_TYPE_PORTPTR, 0, -1 , &deep_channel_templates},
|
|
||||||
{1, 2, 1, "in_parameter_templates", LIVIDO_ATOM_TYPE_PORTPTR, 0, -1 , &deep_parameter_templates},
|
|
||||||
{1, 2, 1, "out_parameter_templates", LIVIDO_ATOM_TYPE_PORTPTR, 0, -1 , &deep_parameter_templates},
|
|
||||||
{1, 2, 0, "url", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_chantemplate_desc[] = {
|
|
||||||
{1, 2, 1, "type", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "name", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "flags", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "palette_list", LIVIDO_ATOM_TYPE_INT, 1, -1 , NULL},
|
|
||||||
{1, 2, 0, "description", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "width", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "height", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "same_as_size", LIVIDO_ATOM_TYPE_PORTPTR, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "same_as_palette", LIVIDO_ATOM_TYPE_PORTPTR, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "optional", LIVIDO_ATOM_TYPE_BOOLEAN, 1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_paramtemplate_desc[] = {
|
|
||||||
{1, 2, 1, "type", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "name", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "kind", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "flags", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "description", LIVIDO_ATOM_TYPE_STRING, 1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_paramtemplate_number_desc[] = {
|
|
||||||
{1, 2, 1, "default", LIVIDO_ATOM_TYPE_DOUBLE, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "min", LIVIDO_ATOM_TYPE_DOUBLE, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "max", LIVIDO_ATOM_TYPE_DOUBLE, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "wrap", LIVIDO_ATOM_TYPE_BOOLEAN, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "transition", LIVIDO_ATOM_TYPE_BOOLEAN, 1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_paramtemplate_index_desc[] = {
|
|
||||||
{1, 2, 1, "default", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "min", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 1, "max", LIVIDO_ATOM_TYPE_INT, 1, 1 , NULL},
|
|
||||||
{1, 2, 0, "wrap", LIVIDO_ATOM_TYPE_BOOLEAN, 1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
property_desc_t port_paramtemplate_text_desc[] = {
|
|
||||||
{1, 2, 1, "default", LIVIDO_ATOM_TYPE_STRING,1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_paramtemplate_switch_desc[] = {
|
|
||||||
{1, 2, 1, "default", LIVIDO_ATOM_TYPE_BOOLEAN,1, 1 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_paramtemplate_colorrgba_desc[] = {
|
|
||||||
{1, 2, 1, "default", LIVIDO_ATOM_TYPE_DOUBLE,3, 4 , NULL},
|
|
||||||
{1, 2, 1, "min", LIVIDO_ATOM_TYPE_DOUBLE,3, 4 , NULL},
|
|
||||||
{1, 2, 1, "max", LIVIDO_ATOM_TYPE_DOUBLE,3, 4 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
property_desc_t port_paramtemplate_coordinate_desc[] = {
|
|
||||||
{1, 2, 1, "default", LIVIDO_ATOM_TYPE_DOUBLE,2, 2 , NULL},
|
|
||||||
{1, 2, 1, "min", LIVIDO_ATOM_TYPE_DOUBLE,2, 2 , NULL},
|
|
||||||
{1, 2, 1, "max", LIVIDO_ATOM_TYPE_DOUBLE,2, 2 , NULL},
|
|
||||||
DESC_END
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
char *name;
|
|
||||||
property_desc_t *property_desc;
|
|
||||||
} kind_parameter_desc_t;
|
|
||||||
|
|
||||||
kind_parameter_desc_t kind_descs[] = {
|
|
||||||
{"INDEX", port_paramtemplate_index_desc},
|
|
||||||
{"NUMBER", port_paramtemplate_number_desc},
|
|
||||||
{"TEXT", port_paramtemplate_text_desc},
|
|
||||||
{"SWITCH", port_paramtemplate_switch_desc},
|
|
||||||
{"COLOR_RGBA", port_paramtemplate_colorrgba_desc},
|
|
||||||
{"COORDINATE", port_paramtemplate_coordinate_desc},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
property_desc_t *create_joint(property_desc_t *p1, property_desc_t *p2)
|
|
||||||
{
|
|
||||||
int p1num, p2num;
|
|
||||||
property_desc_t *joint;
|
|
||||||
|
|
||||||
for (p1num = 0; p1[p1num].ver != -1; p1num++);
|
|
||||||
for (p2num = 0; p2[p2num].ver != -1; p2num++);
|
|
||||||
|
|
||||||
joint = malloc(sizeof(property_desc_t) * (p1num + p2num + 1));
|
|
||||||
memcpy (joint, p1, sizeof(property_desc_t) * p1num);
|
|
||||||
memcpy (joint + p1num, p2, sizeof(property_desc_t) * (p2num + 1));
|
|
||||||
|
|
||||||
return joint;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int deep_filter_api_version(livido_port_t *port, char *propname)
|
|
||||||
{
|
|
||||||
int error;
|
|
||||||
int api_version = livido_get_int_value(port, propname, &error);
|
|
||||||
if (api_version != 100)
|
|
||||||
{
|
|
||||||
printf("WARNING: Filter's api_version is %i, this host has 100\n", api_version );
|
|
||||||
warningcount++;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int deep_channel_templates(livido_port_t *port, char *propname)
|
|
||||||
{
|
|
||||||
int numtemplates = livido_property_num_elements(port, propname);
|
|
||||||
int error;
|
|
||||||
livido_port_t **ports = (livido_port_t **) livido_get_portptr_array (port, propname, &error);
|
|
||||||
for (int i = 0; i < numtemplates; i++)
|
|
||||||
{
|
|
||||||
char tmp[1024];
|
|
||||||
sprintf(tmp, "%s number %i inside PLUGIN_INFO", propname, i);
|
|
||||||
test_port(ports[i], port_chantemplate_desc, LIVIDO_PORT_TYPE_CHANNEL_TEMPLATE, tmp);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int deep_parameter_templates(livido_port_t *port, char *propname)
|
|
||||||
{
|
|
||||||
int numtemplates = livido_property_num_elements(port, propname);
|
|
||||||
int error;
|
|
||||||
livido_port_t **ports = (livido_port_t **) livido_get_portptr_array (port, propname, &error);
|
|
||||||
for (int i = 0; i < numtemplates; i++)
|
|
||||||
{
|
|
||||||
char tmp[1024];
|
|
||||||
sprintf(tmp, "%s number %i inside PLUGIN_INFO", propname, i);
|
|
||||||
property_desc_t *curport;
|
|
||||||
char *kindstr = livido_get_string_value(ports[i], "kind", &error);
|
|
||||||
if (error || kindstr == NULL)
|
|
||||||
{
|
|
||||||
printf("ERROR: Parameter template port (%i) does not have '''kind''' property", i);
|
|
||||||
errorcount++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find the kind desc and join it with general parameter template desc
|
|
||||||
kind_parameter_desc_t *kinds;
|
|
||||||
for (kinds = kind_descs; (kinds->name != NULL) && strcmp(kindstr, kinds->name); kinds++);
|
|
||||||
|
|
||||||
if (kinds->name == NULL)
|
|
||||||
{
|
|
||||||
printf("ERROR: Uknown '''kind''' %s of parameter template port %i\n", kindstr, i);
|
|
||||||
errorcount++;
|
|
||||||
continue; // since we didn't do the join skip the check;
|
|
||||||
|
|
||||||
} else
|
|
||||||
{
|
|
||||||
curport = create_joint(port_paramtemplate_desc, kinds->property_desc);
|
|
||||||
};
|
|
||||||
|
|
||||||
test_port(ports[i], curport, LIVIDO_PORT_TYPE_PARAMETER_TEMPLATE, tmp);
|
|
||||||
free(curport);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
int deep_plugininfo_filters(livido_port_t *port, char *propname)
|
|
||||||
{
|
|
||||||
int numfilters = livido_property_num_elements(port, propname);
|
|
||||||
int error;
|
|
||||||
livido_port_t **ports = (livido_port_t **) livido_get_portptr_array (port, propname, &error);
|
|
||||||
for (int i = 0; i < numfilters; i++)
|
|
||||||
{
|
|
||||||
char tmp[1024];
|
|
||||||
sprintf(tmp, "FILTER_CLASS number %i inside PLUGIN_INFO", i);
|
|
||||||
test_port(ports[i], port_filterclass_desc, LIVIDO_PORT_TYPE_FILTER_CLASS, tmp);
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Implementation of default malloc/free/memset/memcpy
|
|
||||||
void *livido_malloc_f (size_t size) { return malloc(size); }
|
|
||||||
void livido_free_f (void *ptr) { free(ptr); }
|
|
||||||
void *livido_memset_f (void *s, int c, size_t n) { return memset(s, c, n); }
|
|
||||||
void *livido_memcpy_f (void *dest, const void *src, size_t n) { return memcpy( dest, src, n); }
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
int check_property_mandatory (livido_port_t *port, char *propname, char *propdesc)
|
|
||||||
{
|
|
||||||
int error = livido_property_get(port, propname, 0, NULL);
|
|
||||||
if (error)
|
|
||||||
{
|
|
||||||
printf("ERROR: Missing mandatory property \'\'%s\'\' of port %s, code: %i\n", propname, propdesc, error);
|
|
||||||
errorcount ++;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
int check_property_type (livido_port_t *port, char *propname, int atom_type, char *propdesc)
|
|
||||||
{
|
|
||||||
int error = livido_property_get(port, propname, 0, NULL);
|
|
||||||
if (!error)
|
|
||||||
{
|
|
||||||
int real_atomtype = livido_property_atom_type(port, propname);
|
|
||||||
if (real_atomtype != atom_type)
|
|
||||||
{
|
|
||||||
printf("ERROR: Type of property %s is %i, must be: %i\n", propdesc, real_atomtype, atom_type);
|
|
||||||
errorcount ++;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return 0; // returning ok when no type defined
|
|
||||||
}
|
|
||||||
int check_property_type_mandatory (livido_port_t *port, char *propname, int atom_type, char *propdesc)
|
|
||||||
{
|
|
||||||
int retval = check_property_mandatory(port, propname, propdesc);
|
|
||||||
if (retval)
|
|
||||||
return retval;
|
|
||||||
return check_property_type(port, propname, atom_type, propdesc);
|
|
||||||
}
|
|
||||||
|
|
||||||
int check_property_type_mandatory_one (livido_port_t *port, char *propname, int atom_type, char *propdesc)
|
|
||||||
{
|
|
||||||
int retval = check_property_type_mandatory(port, propname, atom_type, propdesc);
|
|
||||||
if (retval)
|
|
||||||
return retval;
|
|
||||||
if (livido_property_num_elements(port, propname) != 1)
|
|
||||||
return -1;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// checks if "type" property of the port exists and is of correct atom type, and then check if the value matches porttype
|
|
||||||
void check_port_type (livido_port_t *port, int porttype, char *portdesc)
|
|
||||||
{
|
|
||||||
char tmp[1024];
|
|
||||||
sprintf(tmp, "type property of port %s\n", portdesc);
|
|
||||||
int retval = check_property_type_mandatory(port, "type", LIVIDO_ATOM_TYPE_INT, tmp);
|
|
||||||
if (retval)
|
|
||||||
{
|
|
||||||
printf("FATAL: Last error was fatal\n");
|
|
||||||
exit(1);
|
|
||||||
} else
|
|
||||||
{
|
|
||||||
int error;
|
|
||||||
int real_type = livido_get_int_value(port, "type", &error);
|
|
||||||
// error cannot happen at this point, since we already checked mandatority and atom type
|
|
||||||
if (real_type != porttype)
|
|
||||||
{
|
|
||||||
printf("FATAL: Type of port %s must be %i, but is %i\n", portdesc, porttype, real_type);
|
|
||||||
exit(1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int test_port (livido_port_t *port, property_desc_t *properties, int porttype, char *portdesc)
|
|
||||||
{
|
|
||||||
// First test the port type
|
|
||||||
check_port_type(port, porttype, portdesc);
|
|
||||||
|
|
||||||
// Now check for properties not in standard
|
|
||||||
char **property_names = livido_list_properties(port); // FIXME: Who frees this memory?
|
|
||||||
for (char **lookup_key = property_names; *lookup_key != 0; lookup_key++ )
|
|
||||||
{
|
|
||||||
int property_in_standard = 0;
|
|
||||||
for (property_desc_t *standard_property = properties; standard_property->ver != -1; standard_property++)
|
|
||||||
{
|
|
||||||
if (!strcmp(standard_property->name, *lookup_key))
|
|
||||||
property_in_standard = 1;
|
|
||||||
}
|
|
||||||
if (!strncmp(*lookup_key, "PLUGIN_", 7))
|
|
||||||
property_in_standard = 1;
|
|
||||||
|
|
||||||
if (!strncmp(*lookup_key, "HOST_", 5))
|
|
||||||
property_in_standard = 1;
|
|
||||||
|
|
||||||
if (!property_in_standard)
|
|
||||||
{
|
|
||||||
printf("WARNING: Property \'%s\' of port %s is not defined in standard\n", *lookup_key, portdesc);
|
|
||||||
warningcount++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// now go trough a list of port's properties defined by standard and check them
|
|
||||||
for (property_desc_t *standard_property = properties; standard_property->ver != -1; standard_property++)
|
|
||||||
{
|
|
||||||
char *propname = standard_property->name;
|
|
||||||
// check existence
|
|
||||||
int error = livido_property_get(port, propname, 0, NULL);
|
|
||||||
if (error == LIVIDO_ERROR_NOSUCH_PROPERTY) // we ignore no such element property here, we deal with that later!
|
|
||||||
{
|
|
||||||
// property does not exist
|
|
||||||
if (standard_property->mand)
|
|
||||||
{
|
|
||||||
printf("ERROR: Missing mandatory property \'\'%s\'\' of port %s\n", propname, portdesc);
|
|
||||||
errorcount ++;
|
|
||||||
}
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
// Property exists, check type
|
|
||||||
int atomtype = livido_property_atom_type(port, propname);
|
|
||||||
if (standard_property->atomtype >= 0 && standard_property->atomtype != atomtype)
|
|
||||||
{
|
|
||||||
printf("ERROR: Type of property \'\'%s\'\' (of port %s) is %i, must be: %i\n", propname, portdesc, atomtype, standard_property->atomtype);
|
|
||||||
errorcount ++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
// Property exists and has right type, check if array is properly laid out
|
|
||||||
int numelements = livido_property_num_elements(port, propname);
|
|
||||||
if (standard_property->minc >= 0 && standard_property->minc > numelements)
|
|
||||||
{
|
|
||||||
printf("ERROR: Property \'\'%s\'\' (of port %s) has %i elements, which is less than minimum of %i\n", propname, portdesc, numelements, standard_property->minc);
|
|
||||||
errorcount ++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if (standard_property->maxc >= 0 && standard_property->maxc < numelements)
|
|
||||||
{
|
|
||||||
printf("ERROR: Property \'\'%s\'\' (of port %s) has %i elements, which is more than maximum of %i\n", propname, portdesc, numelements, standard_property->minc);
|
|
||||||
errorcount ++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
// FIXME: We might want to call deep check functions when we already checked _all_ properties
|
|
||||||
if (standard_property->func)
|
|
||||||
{
|
|
||||||
standard_property->func(port, propname);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(int argc, char **argv)
|
|
||||||
{
|
|
||||||
|
|
||||||
char *name;
|
|
||||||
void *handle;
|
|
||||||
livido_setup_f livido_setup;
|
|
||||||
livido_port_t *plugin_info;
|
|
||||||
|
|
||||||
|
|
||||||
if (argc != 2) {
|
|
||||||
printf("Livido conformance testing host 0.1\n");
|
|
||||||
printf("Usage: testhost plugin_name.so\n");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
name = argv[1];
|
|
||||||
|
|
||||||
handle = dlopen(name, RTLD_NOW); // We want the whole load _now_
|
|
||||||
if (!handle) { printf("FATAL: dlopen failed on %s because of %s\n", name, dlerror()); return 1; };
|
|
||||||
|
|
||||||
livido_setup = (livido_setup_f) dlsym(handle, "livido_setup");
|
|
||||||
if (!livido_setup) { printf("FATAL: function livido_setup not found in %s\n", name); return 1; };
|
|
||||||
|
|
||||||
plugin_info = livido_setup();
|
|
||||||
if (!plugin_info) { printf("FATAL: livido_setup() did not return a pointer to livido port, finishing\n"); return 1; };
|
|
||||||
printf("CHECKPOINT: Loading of plugin and running livido_setup() successeful\n");
|
|
||||||
|
|
||||||
|
|
||||||
test_port(plugin_info, port_plugininfo_desc, LIVIDO_PORT_TYPE_PLUGIN_INFO, "returned by livido_setup()");
|
|
||||||
|
|
||||||
|
|
||||||
dlclose(handle);
|
|
||||||
|
|
||||||
printf("\nPlugin %s has produced %i errors and %i warnings\n", name, errorcount, warningcount);
|
|
||||||
|
|
||||||
// FIXME: Do the freeing of the all template ports
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -16,23 +16,14 @@
|
|||||||
LiViDO is developed by:
|
LiViDO is developed by:
|
||||||
|
|
||||||
Niels Elburg - http://veejay.sf.net
|
Niels Elburg - http://veejay.sf.net
|
||||||
|
|
||||||
Gabriel "Salsaman" Finch - http://lives.sourceforge.net
|
Gabriel "Salsaman" Finch - http://lives.sourceforge.net
|
||||||
|
|
||||||
Denis "Jaromil" Rojo - http://freej.dyne.org
|
Denis "Jaromil" Rojo - http://freej.dyne.org
|
||||||
|
|
||||||
Tom Schouten - http://zwizwa.fartit.com
|
Tom Schouten - http://zwizwa.fartit.com
|
||||||
|
|
||||||
Andraz Tori - http://cvs.cinelerra.org
|
Andraz Tori - http://cvs.cinelerra.org
|
||||||
|
|
||||||
reviewed with suggestions and contributions from:
|
reviewed with suggestions and contributions from:
|
||||||
|
|
||||||
Silvano "Kysucix" Galliani - http://freej.dyne.org
|
Silvano "Kysucix" Galliani - http://freej.dyne.org
|
||||||
|
|
||||||
Kentaro Fukuchi - http://megaui.net/fukuchi
|
Kentaro Fukuchi - http://megaui.net/fukuchi
|
||||||
|
|
||||||
Jun Iio - http://www.malib.net
|
Jun Iio - http://www.malib.net
|
||||||
|
|
||||||
Carlo Prelz - http://www2.fluido.as:8080/
|
Carlo Prelz - http://www2.fluido.as:8080/
|
||||||
|
|
||||||
*/
|
*/
|
||||||
@@ -40,18 +31,24 @@
|
|||||||
#define __LIVIDO_H__
|
#define __LIVIDO_H__
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
extern "C" {
|
#define LIVIDO_BEGIN_DECLS extern "C" {
|
||||||
#endif /* __cplusplus */
|
#define LIVIDO_END_DECLS }
|
||||||
|
#else
|
||||||
|
#define LIVIDO_BEGIN_DECLS
|
||||||
|
#define LIVIDO_END_DECLS
|
||||||
|
#endif
|
||||||
|
|
||||||
/* for size_t */
|
#ifndef FALSE
|
||||||
|
#define FALSE (0)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef TRUE
|
||||||
|
#define TRUE (!FALSE)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
LIVIDO_BEGIN_DECLS
|
||||||
#include <sys/types.h>
|
#include <sys/types.h>
|
||||||
|
|
||||||
/* API version * 100 */
|
|
||||||
#define LIVIDO_API_VERSION 100
|
#define LIVIDO_API_VERSION 100
|
||||||
|
|
||||||
/* Palette types */
|
|
||||||
#
|
|
||||||
/* RGB palettes */
|
|
||||||
#define LIVIDO_PALETTE_RGB888 1
|
#define LIVIDO_PALETTE_RGB888 1
|
||||||
#define LIVIDO_PALETTE_RGB24 1
|
#define LIVIDO_PALETTE_RGB24 1
|
||||||
#define LIVIDO_PALETTE_BGR888 2
|
#define LIVIDO_PALETTE_BGR888 2
|
||||||
@@ -63,150 +60,54 @@ extern "C" {
|
|||||||
#define LIVIDO_PALETTE_RGBFLOAT 5
|
#define LIVIDO_PALETTE_RGBFLOAT 5
|
||||||
#define LIVIDO_PALETTE_ARGBFLOAT 6
|
#define LIVIDO_PALETTE_ARGBFLOAT 6
|
||||||
#define LIVIDO_PALETTE_RGB565 7
|
#define LIVIDO_PALETTE_RGB565 7
|
||||||
|
|
||||||
/* YUV palettes */
|
|
||||||
#define LIVIDO_PALETTE_YUV422P 513
|
#define LIVIDO_PALETTE_YUV422P 513
|
||||||
#define LIVIDO_PALETTE_YV16 513
|
#define LIVIDO_PALETTE_YV16 513
|
||||||
|
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUV422P LIVIDO_PALETTE_YV16
|
|
||||||
[Official name 'YV16', 8 bit Y plane followed by 8
|
|
||||||
bit 2x1 subsampled V and U planes. Planar.]
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUV420P LIVIDO_PALETTE_YV12
|
|
||||||
[8 bit Y plane followed by 8 bit 2x2 subsampled V and U planes. Planar
|
|
||||||
(Official name YV12)]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_YUV420P 514
|
#define LIVIDO_PALETTE_YUV420P 514
|
||||||
#define LIVIDO_PALETTE_YV12 514
|
#define LIVIDO_PALETTE_YV12 514
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YVU420P LIVIDO_PALETTE_I420
|
|
||||||
[Same as YUV420P , but U and V are swapped. Planar.]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_YVU420P 515
|
#define LIVIDO_PALETTE_YVU420P 515
|
||||||
#define LIVIDO_PALETTE_I420 515
|
#define LIVIDO_PALETTE_I420 515
|
||||||
|
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUV444P
|
|
||||||
[Unofficial , 8 bit Y plane followed by 8 bit U and V planes, no
|
|
||||||
subsampling. Planar.]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_YUV444P 516
|
#define LIVIDO_PALETTE_YUV444P 516
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUVA4444P LIVIDO_PALETTE_YUV4444P
|
|
||||||
[Unofficial, like YUV444P but with Alpha. Planar.]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_YUV4444P 517
|
#define LIVIDO_PALETTE_YUV4444P 517
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUYV8888
|
|
||||||
[Like YUV 4:2:2 but with different component ordering within the
|
|
||||||
u_int32 macropixel. Packed.]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_YUYV8888 518
|
#define LIVIDO_PALETTE_YUYV8888 518
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUYV8888
|
|
||||||
[Like YUV 4:2:2 but with different component ordering within the
|
|
||||||
u_int32 macropixel. Packed.]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_UYVY8888 519
|
#define LIVIDO_PALETTE_UYVY8888 519
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_UYVY8888
|
|
||||||
[YUV 4:2:2 (Y sample at every pixel, U and V sampled at every second
|
|
||||||
pixel horizontally on each line). A macropixel contains 2 pixels in 1
|
|
||||||
u_int32. Packed.]
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_YUV411 520
|
#define LIVIDO_PALETTE_YUV411 520
|
||||||
/*
|
|
||||||
LIVIDO_PALETTE_YUV411
|
|
||||||
[IEEE 1394 Digital Camera 1.04 spec. Is packed YUV format
|
|
||||||
with a 6 pixel macroblock structure containing 4 pixels.
|
|
||||||
Ordering is U2 Y0 Y1 V2 Y2 Y3. Uses same bandwith as YUV420P
|
|
||||||
Only used for SMPTE DV NTSC.]
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/* Pending: PALETTE YUV888, YUVA888 needed in cinerella */
|
|
||||||
#define LIVIDO_PALETTE_YUV888 521
|
#define LIVIDO_PALETTE_YUV888 521
|
||||||
#define LIVIDO_PALETTE_YUVA8888 522
|
#define LIVIDO_PALETTE_YUVA8888 522
|
||||||
|
|
||||||
/* Alpha palettes */
|
|
||||||
/*
|
|
||||||
Alpha palettes have two uses: 1) for masks, 2) to split colour inputs into single colour channels, or to combine single colour channels into a combined channel. The order of colour channels is the same as the order in the combined channel. For example if an input in RGB24 palette is split into 3 non-mask alpha channels, then the alpha channels will be in the order: Red, Green, Blue. A single non-mask alpha channel would represent the luminance.
|
|
||||||
|
|
||||||
*/
|
|
||||||
#define LIVIDO_PALETTE_A1 1025
|
#define LIVIDO_PALETTE_A1 1025
|
||||||
#define LIVIDO_PALETTE_A8 1026
|
#define LIVIDO_PALETTE_A8 1026
|
||||||
#define LIVIDO_PALETTE_AFLOAT 1027
|
#define LIVIDO_PALETTE_AFLOAT 1027
|
||||||
|
|
||||||
/* Filter flags */
|
|
||||||
#define LIVIDO_FILTER_NON_REALTIME (1<<0)
|
#define LIVIDO_FILTER_NON_REALTIME (1<<0)
|
||||||
#define LIVIDO_FILTER_CAN_DO_INPLACE (1<<1)
|
#define LIVIDO_FILTER_CAN_DO_INPLACE (1<<1)
|
||||||
#define LIVIDO_FILTER_STATELESS (1<<2)
|
#define LIVIDO_FILTER_NON_STATELESS (1<<2)
|
||||||
#define LIVIDO_FILTER_IS_CONVERTOR (1<<3)
|
#define LIVIDO_FILTER_IS_CONVERTOR (1<<3)
|
||||||
|
|
||||||
/* Channel flags */
|
|
||||||
#define LIVIDO_CHANNEL_CHANGE_UNADVISED (1<<0)
|
#define LIVIDO_CHANNEL_CHANGE_UNADVISED (1<<0)
|
||||||
/*
|
|
||||||
LIVIDO_CHANNEL_CHANGE_UNADVISED
|
|
||||||
plugin MAY use this flag to tell the host, that changing of channel size causes possibly unwanted behaviour of the filter. Unwanted behaviour can for example be reseting the accumulated values which causes the visual result of filter to change in unexpected way or maybe the next call to process function will take disproportional amount of time due to reinitialization. Host is safe to ignore the flag and plugin MUST still be useful, though functionality may suffer.
|
|
||||||
*/
|
|
||||||
#define LIVIDO_CHANNEL_PALETTE_UNADVISED (1<<1)
|
#define LIVIDO_CHANNEL_PALETTE_UNADVISED (1<<1)
|
||||||
/*
|
|
||||||
LIVIDO_CHANNEL_PALETTE_UNADVISED
|
|
||||||
plugin MAY use this flag to tell the host, that changing of channel palette causes possibly unwanted behaviour of the filter. Unwanted behaviour can for example be reseting the accumulated values which causes the visual result of filter to change in unexpected way or maybe the next call to process function will take disproportional amount of time due to reinitialization. Host is safe to ignore the flag and plugin MUST still be useful, though functionality may suffer.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Parameter flags */
|
|
||||||
#define LIVIDO_PARAMETER_CHANGE_UNADVISED (1<<0)
|
#define LIVIDO_PARAMETER_CHANGE_UNADVISED (1<<0)
|
||||||
/*
|
|
||||||
plugin MAY use this flag to tell the host, that changing of this parameter causes possibly unwanted behaviour of the filter. Unwanted behaviour can for example be reseting the accumulated values which causes the visual result of filter to change in unexpected way or maybe the next call to process function will take disproportional amount of time due to reinitialization. Host is safe to ignore the flag and plugin MUST still be useful, though functionality may suffer.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/* Property flags */
|
|
||||||
#define LIVIDO_PROPERTY_READONLY (1<<0)
|
#define LIVIDO_PROPERTY_READONLY (1<<0)
|
||||||
|
|
||||||
/* YUV sampling types */
|
|
||||||
#define LIVIDO_YUV_SAMPLING_NONE 0
|
#define LIVIDO_YUV_SAMPLING_NONE 0
|
||||||
#define LIVIDO_YUV_SAMPLING_SMPTE 1
|
#define LIVIDO_YUV_SAMPLING_SMPTE 1
|
||||||
#define LIVIDO_YUV_SAMPLING_JPEG 2
|
#define LIVIDO_YUV_SAMPLING_JPEG 2
|
||||||
#define LIVIDO_YUV_SAMPLING_MPEG2 3
|
#define LIVIDO_YUV_SAMPLING_MPEG2 3
|
||||||
#define LIVIDO_YUV_SAMPLING_DVPAL 4
|
#define LIVIDO_YUV_SAMPLING_DVPAL 4
|
||||||
#define LIVIDO_YUV_SAMPLING_DVNTSC 5
|
#define LIVIDO_YUV_SAMPLING_DVNTSC 5
|
||||||
|
|
||||||
/* Interlace types */
|
|
||||||
#define LIVIDO_INTERLACE_NONE 0
|
#define LIVIDO_INTERLACE_NONE 0
|
||||||
#define LIVIDO_INTERLACE_TOPFIRST 1
|
#define LIVIDO_INTERLACE_TOPFIRST 1
|
||||||
#define LIVIDO_INTERLACE_BOTTOMFIRST 2
|
#define LIVIDO_INTERLACE_BOTTOMFIRST 2
|
||||||
#define LIVIDO_INTERLACE_PROGRESSIVE 3
|
#define LIVIDO_INTERLACE_PROGRESSIVE 3
|
||||||
|
|
||||||
/* Livido errors */
|
|
||||||
/* Core errors */
|
|
||||||
#define LIVIDO_NO_ERROR 0
|
#define LIVIDO_NO_ERROR 0
|
||||||
#define LIVIDO_ERROR_MEMORY_ALLOCATION 1
|
#define LIVIDO_ERROR_MEMORY_ALLOCATION 1
|
||||||
#define LIVIDO_ERROR_PROPERTY_READONLY 2
|
#define LIVIDO_ERROR_PROPERTY_READONLY 2
|
||||||
#define LIVIDO_ERROR_NOSUCH_ELEMENT 3
|
#define LIVIDO_ERROR_NOSUCH_ELEMENT 3
|
||||||
#define LIVIDO_ERROR_NOSUCH_PROPERTY 4
|
#define LIVIDO_ERROR_NOSUCH_PROPERTY 4
|
||||||
#define LIVIDO_ERROR_WRONG_ATOM_TYPE 5
|
#define LIVIDO_ERROR_WRONG_ATOM_TYPE 5
|
||||||
|
|
||||||
/* Plugin errors */
|
|
||||||
#define LIVIDO_ERROR_TOO_MANY_INSTANCES 6
|
#define LIVIDO_ERROR_TOO_MANY_INSTANCES 6
|
||||||
#define LIVIDO_ERROR_HARDWARE 7
|
#define LIVIDO_ERROR_HARDWARE 7
|
||||||
|
|
||||||
/* Atom types */
|
|
||||||
/* Fundamental atoms */
|
|
||||||
#define LIVIDO_ATOM_TYPE_INT 1
|
#define LIVIDO_ATOM_TYPE_INT 1
|
||||||
#define LIVIDO_ATOM_TYPE_DOUBLE 2
|
#define LIVIDO_ATOM_TYPE_DOUBLE 2
|
||||||
#define LIVIDO_ATOM_TYPE_BOOLEAN 3
|
#define LIVIDO_ATOM_TYPE_BOOLEAN 3
|
||||||
#define LIVIDO_ATOM_TYPE_STRING 4
|
#define LIVIDO_ATOM_TYPE_STRING 4
|
||||||
|
|
||||||
/* Pointer atoms */
|
|
||||||
#define LIVIDO_ATOM_TYPE_VOIDPTR 65
|
#define LIVIDO_ATOM_TYPE_VOIDPTR 65
|
||||||
#define LIVIDO_ATOM_TYPE_PORTPTR 66
|
#define LIVIDO_ATOM_TYPE_PORTPTR 66
|
||||||
|
|
||||||
/* Port types */
|
|
||||||
#define LIVIDO_PORT_TYPE_PLUGIN_INFO 1
|
#define LIVIDO_PORT_TYPE_PLUGIN_INFO 1
|
||||||
#define LIVIDO_PORT_TYPE_FILTER_CLASS 2
|
#define LIVIDO_PORT_TYPE_FILTER_CLASS 2
|
||||||
#define LIVIDO_PORT_TYPE_FILTER_INSTANCE 3
|
#define LIVIDO_PORT_TYPE_FILTER_INSTANCE 3
|
||||||
@@ -216,65 +117,70 @@ plugin MAY use this flag to tell the host, that changing of this parameter cause
|
|||||||
#define LIVIDO_PORT_TYPE_PARAMETER 7
|
#define LIVIDO_PORT_TYPE_PARAMETER 7
|
||||||
#define LIVIDO_PORT_TYPE_GUI 8
|
#define LIVIDO_PORT_TYPE_GUI 8
|
||||||
|
|
||||||
|
//#define FUNCSTRUCT
|
||||||
/*
|
/*
|
||||||
|
Uncomment the #define above and recompile all
|
||||||
A port is a set of one or more properties
|
|
||||||
|
|
||||||
Each port has a mandatory property called "type" (see below), depending upon "type" property port has other mandatory and optional properties.
|
|
||||||
|
|
||||||
"type" can be one of:
|
|
||||||
|
|
||||||
* LIVIDO_PORT_TYPE_PLUGIN_INFO : Information about plugin and list of filter classes it includes
|
|
||||||
* LIVIDO_PORT_TYPE_FILTER_CLASS : Descriptive information about single filter class
|
|
||||||
* LIVIDO_PORT_TYPE_CHANNEL_TEMPLATE : Information about what kinds of channels filter accepts
|
|
||||||
* LIVIDO_PORT_TYPE_PARAMETER_TEMPLATE : Information about what kinds of parameters filter has
|
|
||||||
* LIVIDO_PORT_TYPE_FILTER_INSTANCE : All data about an instance
|
|
||||||
* LIVIDO_PORT_TYPE_CHANNEL : Instantination of a channel
|
|
||||||
* LIVIDO_PORT_TYPE_PARAMETER : Instantination of a parameter
|
|
||||||
|
|
||||||
* LIVIDO_PORT_TYPE_GUI : described in the separate livido GUI extension (TODO)
|
|
||||||
|
|
||||||
"type" is a single valued property with atom_type LIVIDO_ATOM_TYPE_INT.
|
|
||||||
|
|
||||||
The host should provide its own mediation layer for providing a datacontainer for its port.
|
|
||||||
This host uses the mediation layer, where a new port is defined.
|
|
||||||
|
|
||||||
*/
|
*/
|
||||||
#ifndef HAVE_LIVIDO_PORT_T
|
|
||||||
#define HAVE_LIVIDO_PORT_T
|
|
||||||
typedef void livido_port_t;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
extern void livido_port_free(livido_port_t * port);
|
|
||||||
extern livido_port_t *livido_port_new(int port_type);
|
|
||||||
|
|
||||||
extern int livido_property_set(livido_port_t * port, const char *key,
|
|
||||||
int atom_type, int num_elems,
|
|
||||||
void *value);
|
|
||||||
extern int livido_property_get(livido_port_t * port, const char *key,
|
|
||||||
int idx, void *value);
|
|
||||||
|
|
||||||
extern int livido_property_num_elements(livido_port_t * port,
|
|
||||||
const char *key);
|
|
||||||
extern int livido_property_atom_type(livido_port_t * port,
|
|
||||||
const char *key);
|
|
||||||
extern size_t livido_property_element_size(livido_port_t * port,
|
|
||||||
const char *key,
|
|
||||||
const int idx);
|
|
||||||
extern char **livido_list_properties(livido_port_t * port);
|
|
||||||
|
|
||||||
extern void *livido_malloc_f(size_t size);
|
|
||||||
extern void livido_free_f(void *ptr);
|
|
||||||
extern void *livido_memset_f(void *s, int c, size_t n);
|
|
||||||
extern void *livido_memcpy_f(void *dest, const void *src, size_t n);
|
|
||||||
|
|
||||||
typedef livido_port_t *(*livido_setup_f) (void);
|
|
||||||
typedef int (*livido_init_f) (livido_port_t * filter_instance);
|
typedef int (*livido_init_f) (livido_port_t * filter_instance);
|
||||||
typedef int (*livido_process_f) (livido_port_t * filter_instance,
|
typedef int (*livido_process_f) (livido_port_t * filter_instance,
|
||||||
double timestamp);
|
double timestamp);
|
||||||
typedef int (*livido_deinit_f) (livido_port_t * filter_instance);
|
typedef int (*livido_deinit_f) (livido_port_t * filter_instance);
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
|
typedef void *(*livido_malloc_f) (size_t size);
|
||||||
|
typedef void (*livido_free_f) (void *ptr);
|
||||||
|
typedef void *(*livido_memset_f) (void *s, int c, size_t n);
|
||||||
|
typedef void *(*livido_memcpy_f) (void *dest, const void *src, size_t n);
|
||||||
|
typedef livido_port_t *(*livido_port_new_f) (int);
|
||||||
|
typedef void (*livido_port_free_f) (livido_port_t * port);
|
||||||
|
typedef int (*livido_property_set_f) (livido_port_t *, const char *, int, int, void *);
|
||||||
|
typedef int (*livido_property_get_f) (livido_port_t *, const char *, int, void *);
|
||||||
|
typedef int (*livido_property_num_elements_f) (livido_port_t *, const char *);
|
||||||
|
typedef size_t(*livido_property_element_size_f) (livido_port_t *, const char *, const int);
|
||||||
|
typedef int (*livido_property_atom_type_f) (livido_port_t *, const char *);
|
||||||
|
typedef char **(*livido_list_properties_f) (livido_port_t *);
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
void (*f)();
|
||||||
|
// void *f;
|
||||||
|
} livido_setup_t;
|
||||||
|
typedef livido_port_t *(*livido_setup_f) (const livido_setup_t list[], int );
|
||||||
|
|
||||||
|
#define LIVIDO_PLUGIN \
|
||||||
|
static livido_port_t *(*livido_port_new) (int) = 0;\
|
||||||
|
static void (*livido_port_free) (livido_port_t * port) = 0;\
|
||||||
|
static int (*livido_property_set) (livido_port_t * port,const char *key, int atom_type, int num_elems, void *value) = 0;\
|
||||||
|
static int (*livido_property_get) (livido_port_t * port,const char *key, int idx, void *value) = 0;\
|
||||||
|
static int (*livido_property_num_elements) (livido_port_t * port,const char *key) = 0;\
|
||||||
|
static int (*livido_property_atom_type) (livido_port_t * port,const char *key) = 0;\
|
||||||
|
static size_t(*livido_property_element_size) (livido_port_t * port,const char *key, const int idx) = 0;\
|
||||||
|
static char **(*livido_list_properties) (livido_port_t * port) = 0;\
|
||||||
|
static void *(*livido_malloc) (size_t size) = 0;\
|
||||||
|
static void (*livido_free) (void *ptr) = 0;\
|
||||||
|
static void *(*livido_memset) (void *s, int c, size_t n) = 0;\
|
||||||
|
static void *(*livido_memcpy) (void *dest, const void *src, size_t n) = 0;\
|
||||||
|
|
||||||
|
|
||||||
|
/* Using void* to pass base address of function, needs explicit typecast and host
|
||||||
|
must match ordering */
|
||||||
|
#define LIVIDO_IMPORT(list) \
|
||||||
|
{\
|
||||||
|
livido_malloc = (livido_malloc_f) list[0].f;\
|
||||||
|
livido_free = (livido_free_f) list[1].f;\
|
||||||
|
livido_memset = (livido_memset_f) list[2].f;\
|
||||||
|
livido_memcpy = (livido_memcpy_f) list[3].f;\
|
||||||
|
livido_port_free = (livido_port_free_f) list[5].f;\
|
||||||
|
livido_port_new = (livido_port_new_f) list[4].f;\
|
||||||
|
livido_property_set = (livido_property_set_f) list[6].f;\
|
||||||
|
livido_property_get = (livido_property_get_f) list[7].f;\
|
||||||
|
livido_property_num_elements = (livido_property_num_elements_f) list[8].f;\
|
||||||
|
livido_property_atom_type = (livido_property_atom_type_f) list[9].f;\
|
||||||
|
livido_property_element_size = (livido_property_element_size_f) list[10].f;\
|
||||||
|
livido_list_properties = (livido_list_properties_f) list[11].f;\
|
||||||
}
|
}
|
||||||
#endif /* __cplusplus */
|
|
||||||
|
LIVIDO_END_DECLS
|
||||||
#endif // #ifndef __LIVIDO_H__
|
#endif // #ifndef __LIVIDO_H__
|
||||||
|
|||||||
36
vevo-current/include/lowlevel.h
Normal file
36
vevo-current/include/lowlevel.h
Normal file
@@ -0,0 +1,36 @@
|
|||||||
|
/*
|
||||||
|
Copyright (c) 2004-2005 N.Elburg <nelburg@looze.net>
|
||||||
|
|
||||||
|
All rights reserved.
|
||||||
|
|
||||||
|
Redistribution and use in source and binary forms, with or without
|
||||||
|
modification, are permitted provided that the following conditions
|
||||||
|
are met:
|
||||||
|
1. Redistributions of source code must retain the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer.
|
||||||
|
2. Redistributions in binary form must reproduce the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer in the
|
||||||
|
documentation and/or other materials provided with the distribution.
|
||||||
|
3. The name of the author may not be used to endorse or promote products
|
||||||
|
derived from this software without specific prior written permission.
|
||||||
|
|
||||||
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||||
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||||
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||||
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||||
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||||
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||||
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
*/
|
||||||
|
#ifndef VEVO_LOW_LEVEL_H
|
||||||
|
#define VEVO_LOW_LEVEL_H
|
||||||
|
/* Mediation layer structures, provided by this host */
|
||||||
|
typedef struct {
|
||||||
|
int type;
|
||||||
|
void *value;
|
||||||
|
size_t size;
|
||||||
|
} atom_t;
|
||||||
|
#endif
|
||||||
53
vevo-current/include/pool.h
Normal file
53
vevo-current/include/pool.h
Normal file
@@ -0,0 +1,53 @@
|
|||||||
|
/*
|
||||||
|
Copyright (c) 2004-2005 N.Elburg <nelburg@looze.net>
|
||||||
|
|
||||||
|
All rights reserved.
|
||||||
|
|
||||||
|
Redistribution and use in source and binary forms, with or without
|
||||||
|
modification, are permitted provided that the following conditions
|
||||||
|
are met:
|
||||||
|
1. Redistributions of source code must retain the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer.
|
||||||
|
2. Redistributions in binary form must reproduce the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer in the
|
||||||
|
documentation and/or other materials provided with the distribution.
|
||||||
|
3. The name of the author may not be used to endorse or promote products
|
||||||
|
derived from this software without specific prior written permission.
|
||||||
|
|
||||||
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||||
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||||
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||||
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||||
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||||
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||||
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef VEVO_POOL_H
|
||||||
|
#define VEVO_POOL_H
|
||||||
|
#ifdef VEVO_MEMPOOL
|
||||||
|
/* Have 160 atoms and 160 atom slots available ,
|
||||||
|
uses aprox. 4Kb of memory.
|
||||||
|
Use a value that is a multiple of 4
|
||||||
|
*/
|
||||||
|
#ifndef VEVO_MEM_LIMIT
|
||||||
|
#define VEVO_MEM_LIMIT 2048
|
||||||
|
#endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define ATOM_INT 0
|
||||||
|
#define ATOM_PTR 1
|
||||||
|
#define ATOM_DBL 2
|
||||||
|
#define ATOM_ATOM 3
|
||||||
|
|
||||||
|
void *vevo_new_pool(void);
|
||||||
|
void vevo_free_pool(void *v);
|
||||||
|
|
||||||
|
void *vevo_malloc(void *v, int vevo_type);
|
||||||
|
int vevo_pool_verify(void *v);
|
||||||
|
void vevo_free(void *v, void *ptr, int vevo_type);
|
||||||
|
|
||||||
|
#endif
|
||||||
@@ -1,17 +1,29 @@
|
|||||||
/* VeVo is free software; you can redistribute it and/or
|
/*
|
||||||
modify it under the terms of the GNU Lesser General Public
|
Copyright (c) 2004-2005 N.Elburg <nelburg@looze.net>
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
VeVo is distributed in the hope that it will be useful,
|
All rights reserved.
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
Redistribution and use in source and binary forms, with or without
|
||||||
License along with this source code; if not, write to the Free Software
|
modification, are permitted provided that the following conditions
|
||||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
are met:
|
||||||
|
1. Redistributions of source code must retain the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer.
|
||||||
|
2. Redistributions in binary form must reproduce the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer in the
|
||||||
|
documentation and/or other materials provided with the distribution.
|
||||||
|
3. The name of the author may not be used to endorse or promote products
|
||||||
|
derived from this software without specific prior written permission.
|
||||||
|
|
||||||
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||||
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||||
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||||
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||||
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||||
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||||
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
# ifndef VEVO_H_INCLUDED
|
# ifndef VEVO_H_INCLUDED
|
||||||
@@ -27,6 +39,30 @@
|
|||||||
#define TRUE 1
|
#define TRUE 1
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define HAVE_LIVIDO_PORT_T
|
#define HAVE_VEVO_PORT_T
|
||||||
typedef void livido_port_t;
|
typedef void livido_port_t;
|
||||||
|
|
||||||
|
|
||||||
|
///# sed s/LIVIDO/VEVO
|
||||||
|
#define VEVO_PROPERTY_READONLY (1<<0)
|
||||||
|
|
||||||
|
#define VEVO_NO_ERROR 0
|
||||||
|
#define VEVO_ERROR_MEMORY_ALLOCATION 1
|
||||||
|
#define VEVO_ERROR_PROPERTY_READONLY 2
|
||||||
|
#define VEVO_ERROR_NOSUCH_ELEMENT 3
|
||||||
|
#define VEVO_ERROR_NOSUCH_PROPERTY 4
|
||||||
|
#define VEVO_ERROR_WRONG_ATOM_TYPE 5
|
||||||
|
#define VEVO_ERROR_TOO_MANY_INSTANCES 6
|
||||||
|
#define VEVO_ERROR_HARDWARE 7
|
||||||
|
#define VEVO_ATOM_TYPE_INT 1
|
||||||
|
#define VEVO_ATOM_TYPE_DOUBLE 2
|
||||||
|
#define VEVO_ATOM_TYPE_BOOLEAN 3
|
||||||
|
#define VEVO_ATOM_TYPE_STRING 4
|
||||||
|
#define VEVO_ATOM_TYPE_VOIDPTR 65
|
||||||
|
#define VEVO_ATOM_TYPE_PORTPTR 66
|
||||||
|
|
||||||
|
|
||||||
# endif
|
# endif
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@@ -1,96 +0,0 @@
|
|||||||
#include <stddef.h>
|
|
||||||
#include "stdio.h"
|
|
||||||
#include "../include/livido.h"
|
|
||||||
|
|
||||||
#include "../src/livido-utils.c"
|
|
||||||
|
|
||||||
#define num_palettes 5
|
|
||||||
|
|
||||||
int palettes[num_palettes] = { LIVIDO_PALETTE_RGB565,
|
|
||||||
LIVIDO_PALETTE_RGB888,
|
|
||||||
LIVIDO_PALETTE_RGBA8888,
|
|
||||||
LIVIDO_PALETTE_YUV888,
|
|
||||||
LIVIDO_PALETTE_YUVA8888
|
|
||||||
} ;
|
|
||||||
|
|
||||||
|
|
||||||
livido_init_f init_instance (livido_port_t *my_instance)
|
|
||||||
{
|
|
||||||
livido_set_string_value(my_instance, "PLUGIN_mydata", "My personal data, that the host won't touch!!!");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
livido_init_f deinit_instance (livido_port_t* my_instance)
|
|
||||||
{
|
|
||||||
// we would do cleanup and freeing here, but we have nothing to do
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
livido_process_f process_frame( livido_port_t *my_instance,
|
|
||||||
double timecode)
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
livido_port_t *livido_setup(void)
|
|
||||||
{
|
|
||||||
livido_port_t *info;
|
|
||||||
livido_port_t *filter1;
|
|
||||||
livido_port_t *in_chann, *out_chann, *in_param, *out_param;
|
|
||||||
info = livido_port_new(LIVIDO_PORT_TYPE_PLUGIN_INFO);
|
|
||||||
livido_set_string_value(info, "maintainer", "Andraz Tori");
|
|
||||||
livido_set_string_value(info, "version", "1.0");
|
|
||||||
|
|
||||||
filter1 = livido_port_new(LIVIDO_PORT_TYPE_FILTER_CLASS);
|
|
||||||
livido_set_string_value (filter1, "name", "Fade plugin");
|
|
||||||
livido_set_string_value (filter1, "description", "Fades the image with alpha channel when exists or to black when it does not");
|
|
||||||
livido_set_int_value (filter1, "version", 1);
|
|
||||||
livido_set_int_value (filter1, "api_version", 100);
|
|
||||||
livido_set_string_value (filter1, "license", "Public domain");
|
|
||||||
livido_set_int_value (filter1, "flags", LIVIDO_FILTER_CAN_DO_INPLACE | LIVIDO_FILTER_STATELESS);
|
|
||||||
livido_set_voidptr_value(filter1, "process_func", &process_frame);
|
|
||||||
livido_set_voidptr_value(filter1, "init_func", &init_instance);
|
|
||||||
livido_set_voidptr_value(filter1, "deinit_func", &deinit_instance);
|
|
||||||
|
|
||||||
in_chann = livido_port_new(LIVIDO_PORT_TYPE_CHANNEL_TEMPLATE);
|
|
||||||
livido_set_string_value (in_chann, "name", "input");
|
|
||||||
livido_set_int_value (in_chann, "flags", 0);
|
|
||||||
livido_set_int_array (in_chann, "palette_list", num_palettes, palettes);
|
|
||||||
livido_set_portptr_value(filter1, "in_channel_templates", in_chann);
|
|
||||||
|
|
||||||
out_chann = livido_port_new(LIVIDO_PORT_TYPE_CHANNEL_TEMPLATE);
|
|
||||||
livido_set_string_value (out_chann, "name", "faded output");
|
|
||||||
livido_set_int_value (out_chann, "flags", 0);
|
|
||||||
livido_set_int_array (out_chann, "palette_list", num_palettes, palettes);
|
|
||||||
livido_set_voidptr_value (out_chann, "same_as_size", in_chann);
|
|
||||||
livido_set_voidptr_value (out_chann, "same_as_palette", in_chann);
|
|
||||||
livido_set_portptr_value(filter1, "out_channel_templates", in_chann);
|
|
||||||
|
|
||||||
in_param = livido_port_new(LIVIDO_PORT_TYPE_PARAMETER_TEMPLATE);
|
|
||||||
livido_set_string_value (in_param, "name", "Fade percentage");
|
|
||||||
livido_set_int_value (in_param, "flags", 0);
|
|
||||||
livido_set_string_value (in_param, "kind", "NUMBER");
|
|
||||||
livido_set_string_value (in_param, "PLUGIN_kinda", "NUMBER");
|
|
||||||
livido_set_double_value (in_param, "default", 0.5);
|
|
||||||
livido_set_double_value (in_param, "min", 0.0);
|
|
||||||
livido_set_double_value (in_param, "max", 0.0);
|
|
||||||
livido_set_boolean_value (in_param, "transition", 1);
|
|
||||||
|
|
||||||
livido_set_portptr_value(filter1, "in_parameter_templates", in_param);
|
|
||||||
|
|
||||||
// Create an empty array of output templates
|
|
||||||
livido_set_portptr_array(filter1, "out_parameter_templates", 0, 0);
|
|
||||||
|
|
||||||
|
|
||||||
// Just to demonstrate - conformancy checking host will not complain about our own PLUGIN_ variable
|
|
||||||
livido_set_string_value (filter1, "PLUGIN_my_stuff", "I can put here whatever i want");
|
|
||||||
|
|
||||||
livido_set_portptr_value(info, "filters", filter1);
|
|
||||||
|
|
||||||
return info;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@@ -1,35 +0,0 @@
|
|||||||
CC = gcc
|
|
||||||
LINKER = ld
|
|
||||||
CFLAGS = -I. -I../include -I ../ -Wall -g $(shell vevo-config --cflags)
|
|
||||||
all:
|
|
||||||
# vevo - veejay video objects
|
|
||||||
#
|
|
||||||
# plugins :
|
|
||||||
# bathroom
|
|
||||||
# opacity
|
|
||||||
#
|
|
||||||
# compile: make plugins
|
|
||||||
# run:
|
|
||||||
# export LD_LIBRARY_PATH=`pwd`
|
|
||||||
# host <plugin.so>
|
|
||||||
|
|
||||||
plugins: fade_plugin.so
|
|
||||||
|
|
||||||
|
|
||||||
fade.so: fade_plugin.o
|
|
||||||
|
|
||||||
clean:
|
|
||||||
rm -rf *.o *.so
|
|
||||||
|
|
||||||
# generic make rules
|
|
||||||
|
|
||||||
%: %.c
|
|
||||||
$(CC) $(CFLAGS) -o $@ $< -ldl
|
|
||||||
|
|
||||||
%.o: %.c
|
|
||||||
$(CC) $(CFLAGS) -c -o $@ $<
|
|
||||||
%.so: %.o
|
|
||||||
$(LINKER) -shared $^ -o $@
|
|
||||||
# $(LINKER) -E -z now -shared $^ -o $@
|
|
||||||
|
|
||||||
|
|
||||||
@@ -1,355 +0,0 @@
|
|||||||
/* LiViDO is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
LiViDO 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
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this source code; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
||||||
|
|
||||||
|
|
||||||
LiViDO is developed by:
|
|
||||||
|
|
||||||
Niels Elburg - http://veejay.sf.net
|
|
||||||
|
|
||||||
Gabriel "Salsaman" Finch - http://lives.sourceforge.net
|
|
||||||
|
|
||||||
Denis "Jaromil" Rojo - http://freej.dyne.org
|
|
||||||
|
|
||||||
Tom Schouten - http://zwizwa.fartit.com
|
|
||||||
|
|
||||||
Andraz Tori - http://cvs.cinelerra.org
|
|
||||||
|
|
||||||
reviewed with suggestions and contributions from:
|
|
||||||
|
|
||||||
Silvano "Kysucix" Galliani - http://freej.dyne.org
|
|
||||||
|
|
||||||
Kentaro Fukuchi - http://megaui.net/fukuchi
|
|
||||||
|
|
||||||
Jun Iio - http://www.malib.net
|
|
||||||
|
|
||||||
Carlo Prelz - http://www2.fluido.as:8080/
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* (C) Gabriel "Salsaman" Finch, 2005 */
|
|
||||||
|
|
||||||
|
|
||||||
/////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
int livido_has_property (livido_port_t *port, const char *key) {
|
|
||||||
if (livido_property_get(port,key,0,NULL)==LIVIDO_ERROR_NOSUCH_PROPERTY) return 0;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
#include "livido.h"
|
|
||||||
|
|
||||||
/////////////////////////////////////////////////////////////////
|
|
||||||
// property setters
|
|
||||||
|
|
||||||
int livido_set_int_value (livido_port_t *port, const char *key, int value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_INT,1,&value);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_double_value (livido_port_t *port, const char *key, double value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_DOUBLE,1,&value);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_boolean_value (livido_port_t *port, const char *key, int value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_BOOLEAN,1,&value);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_string_value (livido_port_t *port, const char *key, char *value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_STRING,1,&value);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_portptr_value (livido_port_t *port, const char *key, void *value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_PORTPTR,1,&value);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_voidptr_value (livido_port_t *port, const char *key, void *value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_VOIDPTR,1,&value);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/////////// these functions need a size ////////////
|
|
||||||
|
|
||||||
|
|
||||||
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// general property getter
|
|
||||||
|
|
||||||
inline int livido_get_value (livido_port_t *port, const char *key, void *value) {
|
|
||||||
// returns a LIVIDO_ERROR
|
|
||||||
return livido_property_get( port, key, 0, value);
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
int livido_get_int_value (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int retval=0;
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_INT) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
else *error=livido_get_value (port,key,&retval);
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
double livido_get_double_value (livido_port_t *port, const char *key, int *error) {
|
|
||||||
double retval=0.;
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_DOUBLE) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
*error=livido_get_value (port,key,&retval);
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_get_boolean_value (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int retval=0;
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_BOOLEAN) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
*error=livido_get_value (port,key,&retval);
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
char *livido_get_string_value (livido_port_t *port, const char *key, int *error) {
|
|
||||||
char *retval=NULL;
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_STRING) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
if ((retval=(char *)livido_malloc_f(livido_property_element_size(port,key,0)+1))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
if ((*error=livido_get_value (port,key,&retval))!=LIVIDO_NO_ERROR) {
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
void *livido_get_voidptr_value (livido_port_t *port, const char *key, int *error) {
|
|
||||||
void *retval=NULL;
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_VOIDPTR) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
*error=livido_get_value (port,key,&retval);
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
livido_port_t *livido_get_portptr_value (livido_port_t *port, const char *key, int *error) {
|
|
||||||
livido_port_t *retval=NULL;
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_PORTPTR) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
*error=livido_get_value (port,key,&retval);
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
int *livido_get_int_array (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int i;
|
|
||||||
int num_elems;
|
|
||||||
int *retval;
|
|
||||||
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_INT) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ((num_elems=livido_property_num_elements (port,key))==0) return NULL;
|
|
||||||
|
|
||||||
if ((retval=(int *)livido_malloc_f(num_elems*sizeof(int)))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i=0;i<num_elems;i++) {
|
|
||||||
if ((*error=livido_property_get(port, key, i, &retval[i]))!=LIVIDO_NO_ERROR) {
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
double *livido_get_double_array (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int i;
|
|
||||||
int num_elems;
|
|
||||||
double *retval;
|
|
||||||
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_DOUBLE) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
if ((num_elems=livido_property_num_elements (port,key))==0) return NULL;
|
|
||||||
|
|
||||||
if ((retval=(double *)livido_malloc_f(num_elems*sizeof(double)))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i=0;i<num_elems;i++) {
|
|
||||||
if ((*error=livido_property_get(port, key, i, &retval[i]))!=LIVIDO_NO_ERROR) {
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
int *livido_get_boolean_array (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int i;
|
|
||||||
int num_elems;
|
|
||||||
int *retval;
|
|
||||||
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_BOOLEAN) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ((num_elems=livido_property_num_elements (port,key))==0) return NULL;
|
|
||||||
|
|
||||||
if ((retval=(int *)livido_malloc_f(num_elems*sizeof(int)))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i=0;i<num_elems;i++) {
|
|
||||||
if ((*error=livido_property_get(port, key, i, &retval[i]))!=LIVIDO_NO_ERROR) {
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
char **livido_get_string_array (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int i;
|
|
||||||
int num_elems;
|
|
||||||
char **retval;
|
|
||||||
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_STRING) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ((num_elems=livido_property_num_elements (port,key))==0) return NULL;
|
|
||||||
|
|
||||||
if ((retval=(char **)livido_malloc_f(num_elems*sizeof(char *)))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i=0;i<num_elems;i++) {
|
|
||||||
if ((retval[i]=(char *)livido_malloc_f(livido_property_element_size(port,key,i)+1))==NULL) {
|
|
||||||
for (--i;i>=0;i--) livido_free_f(retval[i]);
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
if ((*error=livido_property_get(port, key, i, &retval[i]))!=LIVIDO_NO_ERROR) {
|
|
||||||
for (--i;i>=0;i--) livido_free_f(retval[i]);
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
void **livido_get_voidptr_array (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int i;
|
|
||||||
int num_elems;
|
|
||||||
void **retval;
|
|
||||||
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_VOIDPTR) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ((num_elems=livido_property_num_elements (port,key))==0) return NULL;
|
|
||||||
|
|
||||||
if ((retval=(void **)livido_malloc_f(num_elems*sizeof(void *)))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i=0;i<num_elems;i++) {
|
|
||||||
if ((*error=livido_property_get(port, key, i, &retval[i]))!=LIVIDO_NO_ERROR) {
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
livido_port_t **livido_get_portptr_array (livido_port_t *port, const char *key, int *error) {
|
|
||||||
int i;
|
|
||||||
int num_elems;
|
|
||||||
livido_port_t **retval;
|
|
||||||
|
|
||||||
if (livido_has_property(port,key)&&livido_property_atom_type(port,key)!=LIVIDO_ATOM_TYPE_PORTPTR) {
|
|
||||||
*error=LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ((num_elems=livido_property_num_elements (port,key))==0) return NULL;
|
|
||||||
|
|
||||||
if ((retval=(livido_port_t **)livido_malloc_f(num_elems*sizeof(livido_port_t *)))==NULL) {
|
|
||||||
*error=LIVIDO_ERROR_MEMORY_ALLOCATION;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i=0;i<num_elems;i++) {
|
|
||||||
if ((*error=livido_property_get(port, key, i, &retval[i]))!=LIVIDO_NO_ERROR) {
|
|
||||||
livido_free_f (retval);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return retval;
|
|
||||||
}
|
|
||||||
|
|
||||||
/////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
int livido_set_int_array (livido_port_t *port, const char *key, int num_elems, int *values) {
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_INT,num_elems,values);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_double_array (livido_port_t *port, const char *key, int num_elems, double *values) {
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_DOUBLE,num_elems,values);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_boolean_array (livido_port_t *port, const char *key, int num_elems, int *values) {
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_BOOLEAN,num_elems,values);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_string_array (livido_port_t *port, const char *key, int num_elems, char **values) {
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_STRING,num_elems,values);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_voidptr_array (livido_port_t *port, const char *key, int num_elems, void **values) {
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_VOIDPTR,num_elems,values);
|
|
||||||
}
|
|
||||||
|
|
||||||
int livido_set_portptr_array (livido_port_t *port, const char *key, int num_elems, livido_port_t **values) {
|
|
||||||
return livido_property_set (port,key,LIVIDO_ATOM_TYPE_PORTPTR,num_elems,values);
|
|
||||||
}
|
|
||||||
|
|
||||||
260
vevo-current/src/pool.c
Normal file
260
vevo-current/src/pool.c
Normal file
@@ -0,0 +1,260 @@
|
|||||||
|
/*
|
||||||
|
Copyright (c) 2004-2005 N.Elburg <nelburg@looze.net>
|
||||||
|
|
||||||
|
All rights reserved.
|
||||||
|
|
||||||
|
Redistribution and use in source and binary forms, with or without
|
||||||
|
modification, are permitted provided that the following conditions
|
||||||
|
are met:
|
||||||
|
1. Redistributions of source code must retain the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer.
|
||||||
|
2. Redistributions in binary form must reproduce the above copyright
|
||||||
|
notice, this list of conditions and the following disclaimer in the
|
||||||
|
documentation and/or other materials provided with the distribution.
|
||||||
|
3. The name of the author may not be used to endorse or promote products
|
||||||
|
derived from this software without specific prior written permission.
|
||||||
|
|
||||||
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||||
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||||
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||||
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||||
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||||
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||||
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
*/
|
||||||
|
#ifdef VEVO_MEMPOOL
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <assert.h>
|
||||||
|
#include <sys/mman.h>
|
||||||
|
|
||||||
|
#include <libvevo/lowlevel.h>
|
||||||
|
#include <libvevo/pool.h>
|
||||||
|
#define FREE_LISTS 5
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
int vevo_type;
|
||||||
|
size_t size;
|
||||||
|
void *ptr;
|
||||||
|
void *next;
|
||||||
|
} free_node_t;
|
||||||
|
|
||||||
|
typedef free_node_t free_list_t;
|
||||||
|
typedef struct {
|
||||||
|
size_t l[2];
|
||||||
|
void *a4;
|
||||||
|
void *p4;
|
||||||
|
void *t;
|
||||||
|
double *d;
|
||||||
|
void *s;
|
||||||
|
free_list_t **f;
|
||||||
|
int idx[2];
|
||||||
|
} pool_t;
|
||||||
|
|
||||||
|
static struct {
|
||||||
|
int index;
|
||||||
|
size_t size;
|
||||||
|
} type_list[] = {
|
||||||
|
{
|
||||||
|
ATOM_INT, sizeof(int32_t)}
|
||||||
|
, {
|
||||||
|
ATOM_PTR, sizeof(void *)}, {
|
||||||
|
ATOM_DBL, sizeof(double)}, {
|
||||||
|
ATOM_ATOM, sizeof(atom_t)}
|
||||||
|
,};
|
||||||
|
|
||||||
|
//clean up todo!
|
||||||
|
static free_node_t *vevo_new_node(int vevo_type, void *area)
|
||||||
|
{
|
||||||
|
free_node_t *n = (free_node_t *) malloc(sizeof(free_node_t));
|
||||||
|
n->size = type_list[vevo_type].size;
|
||||||
|
n->ptr = area;
|
||||||
|
n->next = NULL;
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void vevo_node_free(free_node_t * n)
|
||||||
|
{
|
||||||
|
if (n)
|
||||||
|
free(n);
|
||||||
|
n = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void append_node_to_freelist(pool_t * p, int vevo_type,
|
||||||
|
size_t offset, void *base)
|
||||||
|
{
|
||||||
|
free_node_t *n = vevo_new_node(vevo_type, base);
|
||||||
|
free_node_t *c = NULL;
|
||||||
|
free_list_t *l = p->f[vevo_type];
|
||||||
|
if (l == NULL)
|
||||||
|
p->f[vevo_type] = n;
|
||||||
|
else {
|
||||||
|
while (l != NULL) {
|
||||||
|
c = (free_node_t *) l->next;
|
||||||
|
if (c == NULL) {
|
||||||
|
l->next = (void *) n;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
l = c;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void *vevo_new_pool(void)
|
||||||
|
{
|
||||||
|
pool_t *p = (pool_t *) malloc(sizeof(pool_t));
|
||||||
|
memset(p, 0, sizeof(pool_t));
|
||||||
|
p->f = (free_list_t **) malloc(sizeof(free_list_t *) * FREE_LISTS);
|
||||||
|
memset(p->f, 0, sizeof(free_list_t *) * FREE_LISTS);
|
||||||
|
|
||||||
|
p->l[0] = (VEVO_MEM_LIMIT / 4) * 3;
|
||||||
|
p->l[1] = (VEVO_MEM_LIMIT / 4) * 1;
|
||||||
|
|
||||||
|
size_t chunk = (p->l[0] / 2) * sizeof(int32_t);
|
||||||
|
size_t d_chunk = p->l[1] * sizeof(double);
|
||||||
|
size_t t_chunk = VEVO_MEM_LIMIT * sizeof(atom_t);
|
||||||
|
|
||||||
|
p->a4 = (void *) malloc(p->l[0] * sizeof(int32_t)); // int and bool
|
||||||
|
p->p4 = (void *) malloc(p->l[0] * sizeof(void *)); // port and ptr
|
||||||
|
p->d = (double *) malloc(p->l[1] * sizeof(double)); // double
|
||||||
|
p->t = (atom_t *) malloc(VEVO_MEM_LIMIT * sizeof(atom_t));
|
||||||
|
|
||||||
|
memset(p->a4, 0, p->l[0] * sizeof(int32_t));
|
||||||
|
memset(p->p4, 0, p->l[0] * sizeof(void *));
|
||||||
|
memset(p->d, 0, p->l[1] * sizeof(double));
|
||||||
|
memset(p->t, 0, VEVO_MEM_LIMIT * sizeof(atom_t));
|
||||||
|
|
||||||
|
void *base = NULL;
|
||||||
|
|
||||||
|
int n = 0;
|
||||||
|
/* initialize free lists for int and bool types */
|
||||||
|
size_t it = 0;
|
||||||
|
while (it < chunk) {
|
||||||
|
base = ((int32_t *) p->a4 + it);
|
||||||
|
append_node_to_freelist(p, ATOM_INT, chunk, base);
|
||||||
|
it += type_list[ATOM_INT].size;
|
||||||
|
n++;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* initalize ptr free lists */
|
||||||
|
it = 0;
|
||||||
|
while (it < chunk) {
|
||||||
|
base = ((void **) p->p4 + (ATOM_PTR * chunk + it));
|
||||||
|
append_node_to_freelist(p, ATOM_PTR, chunk, base);
|
||||||
|
it += type_list[ATOM_PTR].size;
|
||||||
|
n++;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* initialize double free lists */
|
||||||
|
it = 0;
|
||||||
|
while (it < d_chunk) {
|
||||||
|
base = (void *) ((double *) p->d + it);
|
||||||
|
append_node_to_freelist(p, ATOM_DBL, d_chunk, base);
|
||||||
|
it += type_list[ATOM_DBL].size;
|
||||||
|
n++;
|
||||||
|
}
|
||||||
|
/* fill to hold atom container */
|
||||||
|
it = 0;
|
||||||
|
while (it < t_chunk) {
|
||||||
|
base = (void *) ((double *) p->t + it);
|
||||||
|
append_node_to_freelist(p, ATOM_ATOM, t_chunk, base);
|
||||||
|
it += type_list[ATOM_ATOM].size;
|
||||||
|
}
|
||||||
|
|
||||||
|
p->idx[0] = n;
|
||||||
|
p->idx[1] = 0;
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(p->idx[0] != 0);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return (void *) p;
|
||||||
|
}
|
||||||
|
|
||||||
|
void vevo_free_pool(void *v)
|
||||||
|
{
|
||||||
|
int n = 0;
|
||||||
|
pool_t *p = (pool_t *) v;
|
||||||
|
if (p) {
|
||||||
|
if (p->a4)
|
||||||
|
free(p->a4);
|
||||||
|
if (p->p4)
|
||||||
|
free(p->p4);
|
||||||
|
if (p->d)
|
||||||
|
free(p->d);
|
||||||
|
if (p->t)
|
||||||
|
free(p->t);
|
||||||
|
for (n = 0; n < FREE_LISTS; n++) {
|
||||||
|
free_node_t *node = NULL;
|
||||||
|
while (p->f[n] != NULL) {
|
||||||
|
node = (free_node_t *) p->f[n]->next;
|
||||||
|
vevo_node_free(p->f[n]);
|
||||||
|
p->f[n] = node;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
free(p->f);
|
||||||
|
free(p);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void *vevo_malloc(void *v, int vevo_type)
|
||||||
|
{
|
||||||
|
pool_t *p = (pool_t *) v;
|
||||||
|
free_node_t *l = p->f[vevo_type];
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(l != NULL);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
while (l != NULL) {
|
||||||
|
if (l->size == 0)
|
||||||
|
l = l->next;
|
||||||
|
else { /* found memory */
|
||||||
|
void *res = l->ptr;
|
||||||
|
free_node_t *next = l->next;
|
||||||
|
l->size = 0;
|
||||||
|
l->vevo_type = vevo_type;
|
||||||
|
l = next;
|
||||||
|
p->idx[1]++;
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(p->idx[1] < p->idx[0]);
|
||||||
|
#endif
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(0);
|
||||||
|
#endif
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
int vevo_pool_verify(void *v)
|
||||||
|
{
|
||||||
|
pool_t *p = (pool_t *) v;
|
||||||
|
return (p->idx[0] > p->idx[1] ? 1 : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void vevo_free(void *v, void *ptr, int vevo_type)
|
||||||
|
{
|
||||||
|
pool_t *p = (pool_t *) v;
|
||||||
|
free_node_t *l = NULL;
|
||||||
|
l = p->f[vevo_type];
|
||||||
|
while (l != NULL) {
|
||||||
|
if (l->ptr == ptr) {
|
||||||
|
l->size = type_list[vevo_type].size;
|
||||||
|
p->idx[1]--;
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(p->idx[1] >= 0);
|
||||||
|
#endif
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
l = l->next;
|
||||||
|
}
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(0);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
@@ -27,32 +27,23 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
#define _GNU_SOURCE
|
#define _GNU_SOURCE
|
||||||
|
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <stdarg.h>
|
#include <stdarg.h>
|
||||||
|
#include <include/lowlevel.h>
|
||||||
#include <include/vevo.h>
|
#include <include/vevo.h>
|
||||||
#include <include/livido.h>
|
|
||||||
#include <include/hash.h>
|
#include <include/hash.h>
|
||||||
|
|
||||||
/**
|
#ifdef VEVO_MEMPOOL
|
||||||
libVeVo - Veejay's Video Objects Library
|
#include <include/pool.h>
|
||||||
-----------------------------------------
|
#endif
|
||||||
|
|
||||||
This (shared) library attempts to provide a leightweight and efficient
|
|
||||||
framework for handling Livido plugins.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
#include <assert.h>
|
#include <assert.h>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Mediation layer structures, provided by this host */
|
/* The storage container, this holds the atoms of a property */
|
||||||
typedef struct {
|
|
||||||
void *value;
|
|
||||||
size_t size;
|
|
||||||
} atom_t;
|
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
int atom_type;
|
int atom_type;
|
||||||
union {
|
union {
|
||||||
@@ -63,19 +54,95 @@ typedef struct {
|
|||||||
int flags;
|
int flags;
|
||||||
} livido_storage_t;
|
} livido_storage_t;
|
||||||
|
|
||||||
/* For fast indexing of livido keys, define the port index: */
|
/* For livido ports use a linked list , especially
|
||||||
|
when a port does not hold a large number of properties
|
||||||
|
a linked list is usually faster.
|
||||||
|
Non livido ports are initialized with a hash, which
|
||||||
|
is efficient for a large number of properties */
|
||||||
|
typedef struct {
|
||||||
|
livido_storage_t *st;
|
||||||
|
int key;
|
||||||
|
void *next;
|
||||||
|
} livido_property_t;
|
||||||
|
|
||||||
|
/* For fast indexing of livido keys, define the port index
|
||||||
|
The function livido_property_set adds a key to the port index
|
||||||
|
if the property does not exist yet.
|
||||||
|
*/
|
||||||
typedef struct {
|
typedef struct {
|
||||||
const char *key;
|
const char *key;
|
||||||
int hash_code;
|
int hash_code; /* vevo uses a integer representation of key, eliminates strcmp */
|
||||||
void *next;
|
void *next;
|
||||||
} port_index_t;
|
} port_index_t;
|
||||||
|
|
||||||
/* Now, define our port structure */
|
/* Now, define our port structure */
|
||||||
typedef struct {
|
typedef struct {
|
||||||
hash_t *table;
|
hash_t *table; /* hashtable for custom ports */
|
||||||
port_index_t *index;
|
livido_property_t *list; /* linked list for livido ports */
|
||||||
} vevo_port_t;
|
port_index_t *index; /* key index */
|
||||||
|
void *pool; /* memory pool (compile option) */
|
||||||
|
int atom_types[70]; /* atom types to vevo types */
|
||||||
|
} __vevo_port_t;
|
||||||
|
|
||||||
|
|
||||||
|
/* Functions for creating new 'properties' */
|
||||||
|
static livido_property_t *prop_node_new(int hash_key,
|
||||||
|
livido_storage_t * stor)
|
||||||
|
{
|
||||||
|
livido_property_t *p =
|
||||||
|
(livido_property_t *) malloc(sizeof(livido_property_t));
|
||||||
|
p->st = stor;
|
||||||
|
p->key = hash_key;
|
||||||
|
p->next = NULL;
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void prop_node_free(livido_property_t * p)
|
||||||
|
{
|
||||||
|
if (p) {
|
||||||
|
free(p);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static livido_property_t *prop_node_append(livido_port_t * p, int key,
|
||||||
|
livido_storage_t * t)
|
||||||
|
{
|
||||||
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
|
livido_property_t *node = prop_node_new(key, t);
|
||||||
|
livido_property_t *next;
|
||||||
|
livido_property_t *list = port->list;
|
||||||
|
if (list == NULL)
|
||||||
|
port->list = node;
|
||||||
|
else {
|
||||||
|
while (list != NULL) {
|
||||||
|
next = list->next;
|
||||||
|
if (next == NULL) {
|
||||||
|
list->next = node;
|
||||||
|
return node;
|
||||||
|
}
|
||||||
|
list = next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return node;
|
||||||
|
}
|
||||||
|
|
||||||
|
static livido_property_t *prop_node_get(livido_port_t * p, int key)
|
||||||
|
{
|
||||||
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert( port != NULL );
|
||||||
|
#endif
|
||||||
|
livido_property_t *l = port->list;
|
||||||
|
while (l != NULL) {
|
||||||
|
if (key == l->key)
|
||||||
|
return l;
|
||||||
|
l = l->next;
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Functions for new key items */
|
||||||
static inline port_index_t *port_node_new(const char *key, int hash_key)
|
static inline port_index_t *port_node_new(const char *key, int hash_key)
|
||||||
{
|
{
|
||||||
port_index_t *i = (port_index_t *) malloc(sizeof(port_index_t));
|
port_index_t *i = (port_index_t *) malloc(sizeof(port_index_t));
|
||||||
@@ -101,6 +168,7 @@ static inline void port_node_free(port_index_t * node)
|
|||||||
}
|
}
|
||||||
node = NULL;
|
node = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline void port_node_append(livido_port_t * p, const char *key,
|
static inline void port_node_append(livido_port_t * p, const char *key,
|
||||||
int hash_key)
|
int hash_key)
|
||||||
{
|
{
|
||||||
@@ -109,7 +177,7 @@ static inline void port_node_append(livido_port_t * p, const char *key,
|
|||||||
assert(key != NULL);
|
assert(key != NULL);
|
||||||
assert(hash_key != 0);
|
assert(hash_key != 0);
|
||||||
#endif
|
#endif
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
port_index_t *node = port_node_new(key, hash_key);
|
port_index_t *node = port_node_new(key, hash_key);
|
||||||
port_index_t *next;
|
port_index_t *next;
|
||||||
port_index_t *list = port->index;
|
port_index_t *list = port->index;
|
||||||
@@ -132,7 +200,7 @@ static inline void port_node_append(livido_port_t * p, const char *key,
|
|||||||
|
|
||||||
#define atom_store__(value) {\
|
#define atom_store__(value) {\
|
||||||
for (i = 0; i < d->num_elements; i++)\
|
for (i = 0; i < d->num_elements; i++)\
|
||||||
d->elements.array[i] = livido_put_atom( &value[i], v ); }
|
d->elements.array[i] = livido_put_atom(port, &value[i], v ); }
|
||||||
|
|
||||||
#define array_load__(value) {\
|
#define array_load__(value) {\
|
||||||
for( i = 0; i < t->num_elements ; i ++ )\
|
for( i = 0; i < t->num_elements ; i ++ )\
|
||||||
@@ -154,25 +222,36 @@ static inline int hash_key_code(const char *key)
|
|||||||
|
|
||||||
static int livido_property_finalize(livido_port_t * p, const char *key)
|
static int livido_property_finalize(livido_port_t * p, const char *key)
|
||||||
{
|
{
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
hnode_t *node = NULL;
|
|
||||||
int hash_key = hash_key_code(key);
|
int hash_key = hash_key_code(key);
|
||||||
|
|
||||||
|
if (!port->table) {
|
||||||
|
livido_property_t *node = NULL;
|
||||||
|
if ((node = prop_node_get(port, hash_key)) != NULL) {
|
||||||
|
node->st->flags |= VEVO_PROPERTY_READONLY;
|
||||||
|
return VEVO_NO_ERROR;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
hnode_t *node = NULL;
|
||||||
if ((node = property_exists(port, hash_key)) != NULL) {
|
if ((node = property_exists(port, hash_key)) != NULL) {
|
||||||
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
||||||
stor->flags |= LIVIDO_PROPERTY_READONLY;
|
stor->flags |= VEVO_PROPERTY_READONLY;
|
||||||
hnode_t *new_node = hnode_create((void *) stor);
|
hnode_t *new_node = hnode_create((void *) stor);
|
||||||
hnode_put(new_node, (void *) hash_key);
|
hnode_put(new_node, (void *) hash_key);
|
||||||
hnode_destroy(new_node);
|
hnode_destroy(new_node);
|
||||||
|
return VEVO_NO_ERROR;
|
||||||
}
|
}
|
||||||
|
|
||||||
return LIVIDO_NO_ERROR;
|
}
|
||||||
|
//fixme: error is wrong
|
||||||
|
return VEVO_NO_ERROR;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int atom_get_value(livido_storage_t * t, int idx, void *dst)
|
static int atom_get_value(livido_storage_t * t, int idx, void *dst)
|
||||||
{
|
{
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(t != NULL);
|
assert(t != NULL);
|
||||||
|
assert(dst != NULL);
|
||||||
#endif
|
#endif
|
||||||
atom_t *atom = NULL;
|
atom_t *atom = NULL;
|
||||||
|
|
||||||
@@ -183,12 +262,12 @@ static int atom_get_value(livido_storage_t * t, int idx, void *dst)
|
|||||||
atom = t->elements.array[idx];
|
atom = t->elements.array[idx];
|
||||||
|
|
||||||
if (!atom)
|
if (!atom)
|
||||||
return LIVIDO_ERROR_NOSUCH_ELEMENT;
|
return VEVO_ERROR_NOSUCH_ELEMENT;
|
||||||
|
|
||||||
if (atom->size <= 0)
|
if (atom->size <= 0)
|
||||||
return LIVIDO_NO_ERROR;
|
return VEVO_NO_ERROR;
|
||||||
|
|
||||||
if (t->atom_type != LIVIDO_ATOM_TYPE_STRING) {
|
if (t->atom_type != VEVO_ATOM_TYPE_STRING) {
|
||||||
memcpy(dst, atom->value, atom->size);
|
memcpy(dst, atom->value, atom->size);
|
||||||
} else {
|
} else {
|
||||||
char **ptr = (char **) dst;
|
char **ptr = (char **) dst;
|
||||||
@@ -197,24 +276,24 @@ static int atom_get_value(livido_storage_t * t, int idx, void *dst)
|
|||||||
p[atom->size - 1] = '\0';
|
p[atom->size - 1] = '\0';
|
||||||
}
|
}
|
||||||
|
|
||||||
return LIVIDO_NO_ERROR;
|
return VEVO_NO_ERROR;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static size_t livido_atom_size(int atom_type)
|
static size_t livido_atom_size(int atom_type)
|
||||||
{
|
{
|
||||||
switch (atom_type) {
|
switch (atom_type) {
|
||||||
case LIVIDO_ATOM_TYPE_DOUBLE:
|
case VEVO_ATOM_TYPE_DOUBLE:
|
||||||
return sizeof(double);
|
return sizeof(double);
|
||||||
case LIVIDO_ATOM_TYPE_INT:
|
case VEVO_ATOM_TYPE_INT:
|
||||||
return sizeof(int32_t);
|
return sizeof(int32_t);
|
||||||
case LIVIDO_ATOM_TYPE_VOIDPTR:
|
case VEVO_ATOM_TYPE_VOIDPTR:
|
||||||
return sizeof(void *);
|
return sizeof(void *);
|
||||||
case LIVIDO_ATOM_TYPE_STRING:
|
case VEVO_ATOM_TYPE_STRING:
|
||||||
return 0;
|
return 0;
|
||||||
case LIVIDO_ATOM_TYPE_PORTPTR:
|
case VEVO_ATOM_TYPE_PORTPTR:
|
||||||
return sizeof(livido_port_t *);
|
return sizeof(livido_port_t *);
|
||||||
case LIVIDO_ATOM_TYPE_BOOLEAN:
|
case VEVO_ATOM_TYPE_BOOLEAN:
|
||||||
return sizeof(int32_t);
|
return sizeof(int32_t);
|
||||||
default:
|
default:
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
@@ -226,41 +305,66 @@ static size_t livido_atom_size(int atom_type)
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static atom_t *livido_new_atom(int atom_type, size_t atom_size)
|
static atom_t *livido_new_atom(__vevo_port_t * port, int atom_type,
|
||||||
|
size_t atom_size)
|
||||||
{
|
{
|
||||||
|
#ifdef VEVO_MEMPOOL
|
||||||
|
atom_t *atom = (atom_t *) vevo_malloc(port->pool, ATOM_ATOM);
|
||||||
|
#else
|
||||||
atom_t *atom = (atom_t *) malloc(sizeof(atom_t));
|
atom_t *atom = (atom_t *) malloc(sizeof(atom_t));
|
||||||
|
#endif
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(atom != NULL);
|
assert(atom != NULL);
|
||||||
#endif
|
#endif
|
||||||
atom->size = atom_size;
|
atom->size = atom_size;
|
||||||
|
#ifndef VEVO_MEMPOOL
|
||||||
atom->value = (atom_size > 0 ? (void *) malloc(atom_size) : NULL);
|
atom->value = (atom_size > 0 ? (void *) malloc(atom_size) : NULL);
|
||||||
|
#else
|
||||||
|
atom->type = port->atom_types[atom_type];
|
||||||
|
if (atom->type >= 0) {
|
||||||
|
atom->value =
|
||||||
|
(atom_size >
|
||||||
|
0 ? (void *) vevo_malloc(port->pool, atom->type) : NULL);
|
||||||
|
} else
|
||||||
|
atom->value = (atom_size > 0 ? (void *) malloc(atom_size) : NULL);
|
||||||
|
#endif
|
||||||
#ifdef STRICT_CHECING
|
#ifdef STRICT_CHECING
|
||||||
assert(atom->value != NULL);
|
assert(atom->value != NULL);
|
||||||
#endif
|
#endif
|
||||||
return atom;
|
return atom;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void livido_free_atom(atom_t * atom)
|
static void livido_free_atom(void *pool, atom_t * atom)
|
||||||
{
|
{
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(atom != NULL);
|
assert(atom != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (atom) {
|
if (atom) {
|
||||||
|
#ifndef VEVO_MEMPOOL
|
||||||
free(atom->value);
|
free(atom->value);
|
||||||
free(atom);
|
free(atom);
|
||||||
|
#else
|
||||||
|
if (atom->type >= 0)
|
||||||
|
vevo_free(pool, atom->value, atom->type);
|
||||||
|
else
|
||||||
|
free(atom->value);
|
||||||
|
vevo_free(pool, atom, ATOM_ATOM);
|
||||||
|
#endif
|
||||||
}
|
}
|
||||||
atom = NULL;
|
atom = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static atom_t *livido_put_atom(void *dst, int atom_type)
|
static atom_t *livido_put_atom(__vevo_port_t * port, void *dst,
|
||||||
|
int atom_type)
|
||||||
{
|
{
|
||||||
atom_t *atom = NULL;
|
atom_t *atom = NULL;
|
||||||
size_t atom_size = livido_atom_size(atom_type);
|
size_t atom_size = livido_atom_size(atom_type);
|
||||||
if (atom_type == LIVIDO_ATOM_TYPE_STRING) {
|
|
||||||
|
if (atom_type == VEVO_ATOM_TYPE_STRING) {
|
||||||
char **s = (char **) dst;
|
char **s = (char **) dst;
|
||||||
atom_size = strlen(*s) + 1;
|
atom_size = strlen(*s) + 1;
|
||||||
atom = livido_new_atom(atom_type, atom_size);
|
atom = livido_new_atom(port, atom_type, atom_size);
|
||||||
if (atom_size > 0)
|
if (atom_size > 0)
|
||||||
memcpy(atom->value, *s, (atom_size - 1));
|
memcpy(atom->value, *s, (atom_size - 1));
|
||||||
} else {
|
} else {
|
||||||
@@ -269,19 +373,23 @@ static atom_t *livido_put_atom(void *dst, int atom_type)
|
|||||||
assert(atom_size > 0);
|
assert(atom_size > 0);
|
||||||
assert(dst != NULL);
|
assert(dst != NULL);
|
||||||
#endif
|
#endif
|
||||||
atom = livido_new_atom(atom_type, atom_size);
|
atom = livido_new_atom(port, atom_type, atom_size);
|
||||||
|
|
||||||
#ifdef STRICT_CHECING
|
#ifdef STRICT_CHECING
|
||||||
assert(atom != NULL);
|
assert(atom != NULL);
|
||||||
|
assert(atom->value != NULL);
|
||||||
|
#else
|
||||||
|
if (!atom)
|
||||||
|
return NULL;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
memcpy(atom->value, dst, atom_size);
|
memcpy(atom->value, dst, atom_size);
|
||||||
}
|
}
|
||||||
return atom;
|
return atom;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
storage_put_atom_value(void *src, int n, livido_storage_t * d, int v)
|
storage_put_atom_value(__vevo_port_t * port, void *src, int n,
|
||||||
|
livido_storage_t * d, int v)
|
||||||
{
|
{
|
||||||
int i;
|
int i;
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
@@ -292,11 +400,11 @@ storage_put_atom_value(void *src, int n, livido_storage_t * d, int v)
|
|||||||
if (d->num_elements >= 0) {
|
if (d->num_elements >= 0) {
|
||||||
if (d->num_elements >= 0 && d->num_elements <= 1) {
|
if (d->num_elements >= 0 && d->num_elements <= 1) {
|
||||||
if (d->elements.atom)
|
if (d->elements.atom)
|
||||||
livido_free_atom(d->elements.atom);
|
livido_free_atom(port->pool, d->elements.atom);
|
||||||
} else if (d->num_elements > 1) {
|
} else if (d->num_elements > 1) {
|
||||||
if (d->elements.array) {
|
if (d->elements.array) {
|
||||||
for (i = 0; i < d->num_elements; i++)
|
for (i = 0; i < d->num_elements; i++)
|
||||||
livido_free_atom(d->elements.array[i]);
|
livido_free_atom(port->pool, d->elements.array[i]);
|
||||||
free(d->elements.array);
|
free(d->elements.array);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -307,19 +415,19 @@ storage_put_atom_value(void *src, int n, livido_storage_t * d, int v)
|
|||||||
|
|
||||||
switch (n) {
|
switch (n) {
|
||||||
case 0:
|
case 0:
|
||||||
d->elements.atom = livido_new_atom(v, livido_atom_size(v));
|
d->elements.atom = livido_new_atom(port, v, livido_atom_size(v));
|
||||||
break;
|
break;
|
||||||
case 1:
|
case 1:
|
||||||
d->elements.atom = livido_put_atom(src, v);
|
d->elements.atom = livido_put_atom(port, src, v);
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
d->elements.array = (atom_t **) malloc(sizeof(atom_t *) * n);
|
d->elements.array = (atom_t **) malloc(sizeof(atom_t *) * n);
|
||||||
if (d->atom_type == LIVIDO_ATOM_TYPE_DOUBLE) {
|
if (d->atom_type == VEVO_ATOM_TYPE_DOUBLE) {
|
||||||
double *value = (double *) src;
|
double *value = (double *) src;
|
||||||
atom_store__(value);
|
atom_store__(value);
|
||||||
} else {
|
} else {
|
||||||
if (d->atom_type == LIVIDO_ATOM_TYPE_INT
|
if (d->atom_type == VEVO_ATOM_TYPE_INT
|
||||||
|| d->atom_type == LIVIDO_ATOM_TYPE_BOOLEAN) {
|
|| d->atom_type == VEVO_ATOM_TYPE_BOOLEAN) {
|
||||||
int32_t *value = (int *) src;
|
int32_t *value = (int *) src;
|
||||||
atom_store__(value);
|
atom_store__(value);
|
||||||
} else {
|
} else {
|
||||||
@@ -335,23 +443,26 @@ static inline livido_storage_t *livido_new_storage(int num_elements)
|
|||||||
{
|
{
|
||||||
livido_storage_t *d =
|
livido_storage_t *d =
|
||||||
(livido_storage_t *) malloc(sizeof(livido_storage_t));
|
(livido_storage_t *) malloc(sizeof(livido_storage_t));
|
||||||
|
#ifdef HAVE_STRICT
|
||||||
|
assert(d != NULL);
|
||||||
|
#endif
|
||||||
d->elements.atom = NULL;
|
d->elements.atom = NULL;
|
||||||
d->num_elements = num_elements;
|
d->num_elements = num_elements;
|
||||||
d->flags = 0;
|
d->flags = 0;
|
||||||
return d;
|
return d;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline void livido_free_storage(livido_storage_t * t)
|
static inline void livido_free_storage(void *pool, livido_storage_t * t)
|
||||||
{
|
{
|
||||||
if (t) {
|
if (t) {
|
||||||
if (t->num_elements > 1) {
|
if (t->num_elements > 1) {
|
||||||
int i;
|
int i;
|
||||||
for (i = 0; i < t->num_elements; i++)
|
for (i = 0; i < t->num_elements; i++)
|
||||||
livido_free_atom(t->elements.array[i]);
|
livido_free_atom(pool, t->elements.array[i]);
|
||||||
free(t->elements.array);
|
free(t->elements.array);
|
||||||
}
|
}
|
||||||
if (t->num_elements <= 1)
|
if (t->num_elements <= 1)
|
||||||
livido_free_atom(t->elements.atom);
|
livido_free_atom(pool, t->elements.atom);
|
||||||
free(t);
|
free(t);
|
||||||
}
|
}
|
||||||
t = NULL;
|
t = NULL;
|
||||||
@@ -367,22 +478,35 @@ static inline int key_compare(const void *key1, const void *key2)
|
|||||||
return ((int) key1 == (int) key2 ? 0 : 1);
|
return ((int) key1 == (int) key2 ? 0 : 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
Livido API implementation, public functions follow below
|
||||||
|
*/
|
||||||
|
|
||||||
int livido_property_num_elements(livido_port_t * p, const char *key)
|
int livido_property_num_elements(livido_port_t * p, const char *key)
|
||||||
{
|
{
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(p != NULL);
|
assert(p != NULL);
|
||||||
assert(key != NULL);
|
assert(key != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
if(!p) return -1;
|
||||||
|
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
hnode_t *node = NULL;
|
|
||||||
int hash_key = hash_key_code(key);
|
int hash_key = hash_key_code(key);
|
||||||
|
|
||||||
|
if (!port->table) {
|
||||||
|
livido_property_t *node;
|
||||||
|
if ((node = prop_node_get(port, hash_key)) != NULL)
|
||||||
|
return node->st->num_elements;
|
||||||
|
} else {
|
||||||
|
hnode_t *node = NULL;
|
||||||
if ((node = property_exists(port, hash_key)) != NULL) {
|
if ((node = property_exists(port, hash_key)) != NULL) {
|
||||||
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
||||||
if (stor)
|
if (stor)
|
||||||
return stor->num_elements;
|
return stor->num_elements;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -392,15 +516,29 @@ int livido_property_atom_type(livido_port_t * p, const char *key)
|
|||||||
assert(p != NULL);
|
assert(p != NULL);
|
||||||
assert(key != NULL);
|
assert(key != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
vevo_port_t *port = (vevo_port_t *) port;
|
#ifdef STRICT_CHECKING
|
||||||
hnode_t *node = NULL;
|
assert(port != NULL);
|
||||||
|
#endif
|
||||||
int hash_key = hash_key_code(key);
|
int hash_key = hash_key_code(key);
|
||||||
|
|
||||||
|
if (!port->table) {
|
||||||
|
livido_property_t *node;
|
||||||
|
if ((node = prop_node_get(port, hash_key)) != NULL)
|
||||||
|
return node->st->atom_type;
|
||||||
|
} else {
|
||||||
|
hnode_t *node = NULL;
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(port->table != NULL);
|
||||||
|
assert(hash_verify(port->table) != 0);
|
||||||
|
#endif
|
||||||
|
|
||||||
if ((node = property_exists(port, hash_key)) != NULL) {
|
if ((node = property_exists(port, hash_key)) != NULL) {
|
||||||
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
||||||
if (stor)
|
if (stor)
|
||||||
return stor->atom_type;
|
return stor->atom_type;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -411,77 +549,97 @@ livido_property_element_size(livido_port_t * p, const char *key,
|
|||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(p != NULL);
|
assert(p != NULL);
|
||||||
assert(key != NULL);
|
assert(key != NULL);
|
||||||
|
assert(idx >= 0);
|
||||||
#endif
|
#endif
|
||||||
|
if(!p) return -1;
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
hnode_t *node = NULL;
|
|
||||||
int hash_key = hash_key_code(key);
|
int hash_key = hash_key_code(key);
|
||||||
|
|
||||||
|
if (!port->table) {
|
||||||
|
livido_property_t *node;
|
||||||
|
if ((node = prop_node_get(port, hash_key)) != NULL) {
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
if (idx > 0)
|
||||||
|
assert(idx < node->st->num_elements);
|
||||||
|
#endif
|
||||||
|
if (node->st->num_elements == 1)
|
||||||
|
return node->st->elements.atom->size;
|
||||||
|
else if (node->st->num_elements > 1)
|
||||||
|
return node->st->elements.array[idx]->size;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
hnode_t *node = NULL;
|
||||||
if ((node = property_exists(port, hash_key)) != NULL) {
|
if ((node = property_exists(port, hash_key)) != NULL) {
|
||||||
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
livido_storage_t *stor = (livido_storage_t *) hnode_get(node);
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(stor != NULL);
|
assert(idx < stor->num_elements);
|
||||||
#endif
|
#endif
|
||||||
//todo: sum all element sizes for index of -1
|
//todo: sum all element sizes for index of -1
|
||||||
if (stor->num_elements == 1) {
|
if (stor->num_elements == 1) {
|
||||||
return stor->elements.atom->size;
|
return stor->elements.atom->size;
|
||||||
} else if (stor->num_elements > 1) {
|
} else if (stor->num_elements > 1) {
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
|
||||||
assert(idx >= 0);
|
|
||||||
assert(idx < stor->num_elements);
|
|
||||||
assert(stor->elements.array[idx] != NULL);
|
|
||||||
#endif
|
|
||||||
return stor->elements.array[idx]->size;
|
return stor->elements.array[idx]->size;
|
||||||
} else {
|
} else {
|
||||||
if (stor->num_elements == 0)
|
if (stor->num_elements == 0)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
livido_port_t *livido_port_new(int port_type)
|
livido_port_t *livido_port_new(int port_type)
|
||||||
{
|
{
|
||||||
vevo_port_t *port = (vevo_port_t *) malloc(sizeof(vevo_port_t));
|
__vevo_port_t *port = (__vevo_port_t *) malloc(sizeof(__vevo_port_t));
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(port != NULL);
|
assert(port != NULL);
|
||||||
#endif
|
#endif
|
||||||
port->index = NULL;
|
port->index = NULL;
|
||||||
|
port->list = NULL;
|
||||||
|
port->table = NULL;
|
||||||
|
|
||||||
|
/* If the port type is a Livido port this or that */
|
||||||
|
if (port_type >= 1 && port_type <= 10)
|
||||||
|
port->list = NULL;
|
||||||
|
else
|
||||||
port->table = hash_create(HASHCOUNT_T_MAX, key_compare, int_hash);
|
port->table = hash_create(HASHCOUNT_T_MAX, key_compare, int_hash);
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef VEVO_MEMPOOL
|
||||||
assert(port->table != NULL);
|
port->pool = vevo_new_pool();
|
||||||
#endif
|
|
||||||
|
port->atom_types[VEVO_ATOM_TYPE_INT] = ATOM_INT;
|
||||||
livido_property_set(port, "type", LIVIDO_ATOM_TYPE_INT, 1, &port_type);
|
port->atom_types[VEVO_ATOM_TYPE_DOUBLE] = ATOM_DBL;
|
||||||
#ifdef STRICT_CHECKING
|
port->atom_types[VEVO_ATOM_TYPE_BOOLEAN] = ATOM_INT;
|
||||||
int hash_key = hash_key_code("type");
|
port->atom_types[VEVO_ATOM_TYPE_VOIDPTR] = ATOM_PTR;
|
||||||
assert(property_exists(port, hash_key) != NULL);
|
port->atom_types[VEVO_ATOM_TYPE_PORTPTR] = ATOM_PTR;
|
||||||
|
port->atom_types[VEVO_ATOM_TYPE_STRING] = -1;
|
||||||
|
#else
|
||||||
|
port->pool = NULL;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
if(port_type <= 1024)
|
||||||
|
{
|
||||||
|
livido_property_set(port, "type", VEVO_ATOM_TYPE_INT, 1, &port_type);
|
||||||
livido_property_finalize(port, "type");
|
livido_property_finalize(port, "type");
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(livido_property_set
|
assert(livido_property_set
|
||||||
(port, "type", LIVIDO_ATOM_TYPE_INT, 1, &port_type)
|
(port, "type", VEVO_ATOM_TYPE_INT, 1, &port_type)
|
||||||
!= LIVIDO_PROPERTY_READONLY);
|
!= VEVO_PROPERTY_READONLY);
|
||||||
#endif
|
#endif
|
||||||
|
}
|
||||||
return (livido_port_t *) port;
|
return (livido_port_t *) port;
|
||||||
}
|
}
|
||||||
|
|
||||||
void livido_port_free(livido_port_t * p)
|
void livido_port_free(livido_port_t * p)
|
||||||
{
|
{
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
|
|
||||||
if (port) {
|
if (port) {
|
||||||
#ifdef STRICT_CHECKING
|
if (port->table) {
|
||||||
assert(port->table != NULL);
|
|
||||||
#endif
|
|
||||||
if (!hash_isempty((hash_t *) port->table)) {
|
if (!hash_isempty((hash_t *) port->table)) {
|
||||||
hscan_t scan;
|
hscan_t scan;
|
||||||
hash_scan_begin(&scan, (hash_t *) port->table);
|
hash_scan_begin(&scan, (hash_t *) port->table);
|
||||||
@@ -495,11 +653,22 @@ void livido_port_free(livido_port_t * p)
|
|||||||
assert(node != NULL);
|
assert(node != NULL);
|
||||||
assert((const char *) hnode_getkey(node) != NULL);
|
assert((const char *) hnode_getkey(node) != NULL);
|
||||||
#endif
|
#endif
|
||||||
livido_free_storage(stor);
|
livido_free_storage(port->pool, stor);
|
||||||
}
|
}
|
||||||
hash_free_nodes((hash_t *) port->table);
|
hash_free_nodes((hash_t *) port->table);
|
||||||
hash_destroy((hash_t *) port->table);
|
hash_destroy((hash_t *) port->table);
|
||||||
}
|
}
|
||||||
|
} else {
|
||||||
|
livido_property_t *l = port->list;
|
||||||
|
livido_property_t *n;
|
||||||
|
while (l != NULL) {
|
||||||
|
n = l->next;
|
||||||
|
livido_free_storage(port->pool, l->st);
|
||||||
|
prop_node_free(l);
|
||||||
|
l = n;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
if (port->index) {
|
if (port->index) {
|
||||||
port_index_t *l = port->index;
|
port_index_t *l = port->index;
|
||||||
@@ -510,10 +679,12 @@ void livido_port_free(livido_port_t * p)
|
|||||||
l = n;
|
l = n;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
#ifdef VEVO_MEMPOOL
|
||||||
|
vevo_free_pool(port->pool);
|
||||||
|
#endif
|
||||||
free(port);
|
free(port);
|
||||||
}
|
}
|
||||||
port = NULL;
|
p = port = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
int
|
int
|
||||||
@@ -524,45 +695,80 @@ livido_property_set(livido_port_t * p,
|
|||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(p != NULL);
|
assert(p != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
|
||||||
hnode_t *old_node = NULL;
|
|
||||||
int hash_key = hash_key_code(key);
|
int hash_key = hash_key_code(key);
|
||||||
|
int new = 1;
|
||||||
|
void *node = NULL;
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert( port != NULL );
|
||||||
|
#endif
|
||||||
|
if (!port->table) {
|
||||||
|
livido_property_t *pnode = NULL;
|
||||||
|
if ((pnode = prop_node_get(port, hash_key)) != NULL) {
|
||||||
|
if (pnode->st->atom_type != atom_type)
|
||||||
|
return VEVO_ERROR_WRONG_ATOM_TYPE;
|
||||||
|
if (pnode->st->flags & VEVO_PROPERTY_READONLY)
|
||||||
|
return VEVO_ERROR_PROPERTY_READONLY;
|
||||||
|
livido_free_storage(port->pool, pnode->st);
|
||||||
|
new = 0;
|
||||||
|
node = (void *) pnode;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
hnode_t *old_node = NULL;
|
||||||
if ((old_node = property_exists(port, hash_key)) != NULL) {
|
if ((old_node = property_exists(port, hash_key)) != NULL) {
|
||||||
livido_storage_t *oldstor =
|
livido_storage_t *oldstor =
|
||||||
(livido_storage_t *) hnode_get(old_node);
|
(livido_storage_t *) hnode_get(old_node);
|
||||||
if (oldstor->atom_type != atom_type)
|
if (oldstor->atom_type != atom_type)
|
||||||
return LIVIDO_ERROR_WRONG_ATOM_TYPE;
|
return VEVO_ERROR_WRONG_ATOM_TYPE;
|
||||||
|
|
||||||
if (oldstor->flags & LIVIDO_PROPERTY_READONLY)
|
if (oldstor->flags & VEVO_PROPERTY_READONLY)
|
||||||
return LIVIDO_ERROR_PROPERTY_READONLY;
|
return VEVO_ERROR_PROPERTY_READONLY;
|
||||||
|
|
||||||
livido_free_storage(oldstor);
|
livido_free_storage(port->pool, oldstor);
|
||||||
|
|
||||||
hash_delete((hash_t *) port->table, old_node);
|
hash_delete((hash_t *) port->table, old_node);
|
||||||
hnode_destroy(old_node);
|
hnode_destroy(old_node);
|
||||||
} else {
|
new = 0;
|
||||||
port_node_append(port, key, hash_key);
|
}
|
||||||
}
|
}
|
||||||
livido_storage_t *stor = livido_new_storage(num_elements);
|
livido_storage_t *stor = livido_new_storage(num_elements);
|
||||||
|
storage_put_atom_value(port, src, num_elements, stor, atom_type);
|
||||||
|
|
||||||
|
if (new) {
|
||||||
|
#ifdef VEVO_MEMPOOL
|
||||||
|
if (!vevo_pool_verify(port->pool))
|
||||||
|
return VEVO_ERROR_MEMORY_ALLOCATION;
|
||||||
|
#endif
|
||||||
|
port_node_append(port, key, hash_key);
|
||||||
|
if (!port->table)
|
||||||
|
node = (void *) prop_node_append(port, hash_key, stor);
|
||||||
|
}
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(stor != NULL);
|
assert(stor != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
storage_put_atom_value(src, num_elements, stor, atom_type);
|
if (!port->table) {
|
||||||
|
|
||||||
hnode_t *node = hnode_create(stor);
|
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(node != NULL);
|
assert(node != NULL);
|
||||||
|
#endif
|
||||||
|
if (!new) {
|
||||||
|
livido_property_t *current = (livido_property_t *) node;
|
||||||
|
current->st = stor;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
hnode_t *node2 = hnode_create(stor);
|
||||||
|
|
||||||
|
#ifdef STRICT_CHECKING
|
||||||
|
assert(node2 != NULL);
|
||||||
assert(!hash_isfull((hash_t *) port->table));
|
assert(!hash_isfull((hash_t *) port->table));
|
||||||
assert(!property_exists(port, hash_key));
|
assert(!property_exists(port, hash_key));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
hash_insert((hash_t *) port->table, node, (const void *) hash_key);
|
hash_insert((hash_t *) port->table, node2,
|
||||||
|
(const void *) hash_key);
|
||||||
|
}
|
||||||
|
|
||||||
return LIVIDO_NO_ERROR;
|
return VEVO_NO_ERROR;
|
||||||
}
|
}
|
||||||
|
|
||||||
int
|
int
|
||||||
@@ -571,46 +777,56 @@ livido_property_get(livido_port_t * p, const char *key, int idx, void *dst)
|
|||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(p != NULL);
|
assert(p != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
if(!p) return VEVO_ERROR_NOSUCH_PROPERTY;
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(port->table != NULL);
|
|
||||||
assert(key != NULL);
|
assert(key != NULL);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
hnode_t *node = NULL;
|
|
||||||
int hash_key = hash_key_code(key);
|
int hash_key = hash_key_code(key);
|
||||||
|
|
||||||
|
if (!port->table) {
|
||||||
|
livido_property_t *node = NULL;
|
||||||
|
if ((node = prop_node_get(port, hash_key)) != NULL) {
|
||||||
|
if (dst == NULL)
|
||||||
|
return VEVO_NO_ERROR;
|
||||||
|
else
|
||||||
|
return atom_get_value(node->st, idx, dst);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
hnode_t *node = NULL;
|
||||||
if ((node = property_exists(port, hash_key)) != NULL) {
|
if ((node = property_exists(port, hash_key)) != NULL) {
|
||||||
if (dst == NULL)
|
if (dst == NULL)
|
||||||
return LIVIDO_NO_ERROR;
|
return VEVO_NO_ERROR;
|
||||||
else {
|
else
|
||||||
livido_storage_t *stor = hnode_get(node);
|
return atom_get_value((livido_storage_t *) hnode_get(node),
|
||||||
|
idx, dst);
|
||||||
#ifdef STRICT_CHECKING
|
|
||||||
assert(stor != NULL);
|
|
||||||
#endif
|
|
||||||
return atom_get_value(stor, idx, dst);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return LIVIDO_ERROR_NOSUCH_PROPERTY;
|
return VEVO_ERROR_NOSUCH_PROPERTY;
|
||||||
}
|
}
|
||||||
|
|
||||||
char **livido_list_properties(livido_port_t * p)
|
char **livido_list_properties(livido_port_t * p)
|
||||||
{
|
{
|
||||||
vevo_port_t *port = (vevo_port_t *) p;
|
__vevo_port_t *port = (__vevo_port_t *) p;
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
assert(port != NULL);
|
assert(port != NULL);
|
||||||
assert(port->table != NULL);
|
|
||||||
assert(hash_isempty((hash_t *) port->table) == 0);
|
|
||||||
#endif
|
#endif
|
||||||
|
if(!p) return NULL;
|
||||||
char **list = NULL;
|
char **list = NULL;
|
||||||
|
|
||||||
#ifdef STRICT_CHECKING
|
#ifdef STRICT_CHECKING
|
||||||
int nn = hash_count((hash_t *) port->table);
|
int nn = 1;
|
||||||
|
if (port->table)
|
||||||
|
nn += hash_count((hash_t *) port->table);
|
||||||
|
else {
|
||||||
|
livido_property_t *c = port->list;
|
||||||
|
while (c != NULL) {
|
||||||
|
c = c->next;
|
||||||
|
nn++;
|
||||||
|
}
|
||||||
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
int n = 1; // null terminated list of keys
|
int n = 1; // null terminated list of keys
|
||||||
|
|||||||
Reference in New Issue
Block a user