build.h   build.h 
/* /*
(c) Copyright 2000-2002 convergence integrated media GmbH. (c) Copyright 2001-2011 The world wide DirectFB Open Source Community (
(c) Copyright 2002-2004 convergence GmbH. directfb.org)
(c) Copyright 2000-2004 Convergence (integrated media) GmbH
All rights reserved. All rights reserved.
Written by Denis Oliver Kropp <dok@directfb.org>, Written by Denis Oliver Kropp <dok@directfb.org>,
Andreas Hundt <andi@fischlustig.de>, Andreas Hundt <andi@fischlustig.de>,
Sven Neumann <neo@directfb.org> and Sven Neumann <neo@directfb.org>,
Ville Syrjälä <syrjala@sci.fi>. Ville Syrjälä <syrjala@sci.fi> and
Claudio Ciccani <klan@users.sf.net>.
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version. version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330, Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
*/ */
#ifndef __FUSION__BUILD_H__ #ifndef __DIRECT__BUILD_H__
#define __FUSION__BUILD_H__ #define __DIRECT__BUILD_H__
#define FUSION_BUILD_MULTI (0) #define DIRECT_OS_LINUX_GNU_LIBC (0)
#define FUSION_BUILD_KERNEL (1) #define DIRECT_OS_LINUX_KERNEL (1)
#define FUSION_MESSAGE_SIZE (16384) #define DIRECT_OS_PSP (2)
#define DIRECT_OS_WIN32 (3)
#define DIRECT_OS_FAMOS (4)
#define DIRECT_BUILD_DEBUG (0)
#define DIRECT_BUILD_DEBUGS (1)
#define DIRECT_BUILD_TRACE (0)
#define DIRECT_BUILD_TEXT (1)
#define DIRECT_BUILD_GETTID (1)
#define DIRECT_BUILD_NETWORK (1)
#define DIRECT_BUILD_STDBOOL (1)
#define DIRECT_BUILD_DYNLOAD (1)
#define DIRECT_BUILD_MULTICORE (1)
#define DIRECT_BUILD_OSTYPE (DIRECT_OS_LINUX_GNU_LIBC)
#define DIRECT_BUILD_GCC_ATOMICS (0)
#if !DIRECT_BUILD_DEBUGS
#if defined(DIRECT_ENABLE_DEBUG) || defined(DIRECT_FORCE_DEBUG)
#define DIRECT_MINI_DEBUG
#endif
#undef DIRECT_ENABLE_DEBUG
#ifdef DIRECT_FORCE_DEBUG
#warning DIRECT_FORCE_DEBUG used with 'pure release' library headers.
#undef DIRECT_FORCE_DEBUG
#endif
#endif
#endif #endif
 End of changes. 4 change blocks. 
9 lines changed or deleted 36 lines changed or added


 directfb_keynames.h   directfb_keynames.h 
skipping to change at line 519 skipping to change at line 519
{ DIKS_CUSTOM246, "CUSTOM246" }, \ { DIKS_CUSTOM246, "CUSTOM246" }, \
{ DIKS_CUSTOM247, "CUSTOM247" }, \ { DIKS_CUSTOM247, "CUSTOM247" }, \
{ DIKS_CUSTOM248, "CUSTOM248" }, \ { DIKS_CUSTOM248, "CUSTOM248" }, \
{ DIKS_CUSTOM249, "CUSTOM249" }, \ { DIKS_CUSTOM249, "CUSTOM249" }, \
{ DIKS_CUSTOM250, "CUSTOM250" }, \ { DIKS_CUSTOM250, "CUSTOM250" }, \
{ DIKS_CUSTOM251, "CUSTOM251" }, \ { DIKS_CUSTOM251, "CUSTOM251" }, \
{ DIKS_CUSTOM252, "CUSTOM252" }, \ { DIKS_CUSTOM252, "CUSTOM252" }, \
{ DIKS_CUSTOM253, "CUSTOM253" }, \ { DIKS_CUSTOM253, "CUSTOM253" }, \
{ DIKS_CUSTOM254, "CUSTOM254" }, \ { DIKS_CUSTOM254, "CUSTOM254" }, \
{ DIKS_CUSTOM255, "CUSTOM255" }, \ { DIKS_CUSTOM255, "CUSTOM255" }, \
{ DIKS_NULL, "NULL" } \ { (DFBInputDeviceKeySymbol) DIKS_NULL, "NULL" } \
}; };
struct DFBKeyIdentifierName { struct DFBKeyIdentifierName {
DFBInputDeviceKeyIdentifier identifier; DFBInputDeviceKeyIdentifier identifier;
const char *name; const char *name;
}; };
#define DirectFBKeyIdentifierNames(Identifier) struct DFBKeyIdentifierName Identifier[] = { \ #define DirectFBKeyIdentifierNames(Identifier) struct DFBKeyIdentifierName Identifier[] = { \
{ DIKI_A, "A" }, \ { DIKI_A, "A" }, \
{ DIKI_B, "B" }, \ { DIKI_B, "B" }, \
skipping to change at line 644 skipping to change at line 644
{ DIKI_KP_0, "KP_0" }, \ { DIKI_KP_0, "KP_0" }, \
{ DIKI_KP_1, "KP_1" }, \ { DIKI_KP_1, "KP_1" }, \
{ DIKI_KP_2, "KP_2" }, \ { DIKI_KP_2, "KP_2" }, \
{ DIKI_KP_3, "KP_3" }, \ { DIKI_KP_3, "KP_3" }, \
{ DIKI_KP_4, "KP_4" }, \ { DIKI_KP_4, "KP_4" }, \
{ DIKI_KP_5, "KP_5" }, \ { DIKI_KP_5, "KP_5" }, \
{ DIKI_KP_6, "KP_6" }, \ { DIKI_KP_6, "KP_6" }, \
{ DIKI_KP_7, "KP_7" }, \ { DIKI_KP_7, "KP_7" }, \
{ DIKI_KP_8, "KP_8" }, \ { DIKI_KP_8, "KP_8" }, \
{ DIKI_KP_9, "KP_9" }, \ { DIKI_KP_9, "KP_9" }, \
{ DIKI_UNKNOWN, "UNKNOWN" } \ { (DFBInputDeviceKeyIdentifier) DIKI_UNKNOWN, "UNKNOWN" } \
}; };
#endif #endif
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 directfb_strings.h   directfb_strings.h 
skipping to change at line 53 skipping to change at line 53
{ DSPF_ARGB8565, "ARGB8565" }, \ { DSPF_ARGB8565, "ARGB8565" }, \
{ DSPF_AVYU, "AVYU" }, \ { DSPF_AVYU, "AVYU" }, \
{ DSPF_VYU, "VYU" }, \ { DSPF_VYU, "VYU" }, \
{ DSPF_A1_LSB, "A1_LSB" }, \ { DSPF_A1_LSB, "A1_LSB" }, \
{ DSPF_YV16, "YV16" }, \ { DSPF_YV16, "YV16" }, \
{ DSPF_ABGR, "ABGR" }, \ { DSPF_ABGR, "ABGR" }, \
{ DSPF_RGBAF88871, "RGBAF88871" }, \ { DSPF_RGBAF88871, "RGBAF88871" }, \
{ DSPF_LUT4, "LUT4" }, \ { DSPF_LUT4, "LUT4" }, \
{ DSPF_ALUT8, "ALUT8" }, \ { DSPF_ALUT8, "ALUT8" }, \
{ DSPF_LUT1, "LUT1" }, \ { DSPF_LUT1, "LUT1" }, \
{ DSPF_UNKNOWN, "UNKNOWN" } \ { (DFBSurfacePixelFormat) DSPF_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBPorterDuffRuleName { struct DFBPorterDuffRuleName {
DFBSurfacePorterDuffRule rule; DFBSurfacePorterDuffRule rule;
const char *name; const char *name;
}; };
#define DirectFBPorterDuffRuleNames(Identifier) struct DFBPorterDuffRuleNam e Identifier[] = { \ #define DirectFBPorterDuffRuleNames(Identifier) struct DFBPorterDuffRuleNam e Identifier[] = { \
{ DSPD_CLEAR, "CLEAR" }, \ { DSPD_CLEAR, "CLEAR" }, \
{ DSPD_SRC, "SRC" }, \ { DSPD_SRC, "SRC" }, \
skipping to change at line 75 skipping to change at line 75
{ DSPD_DST_OVER, "DST_OVER" }, \ { DSPD_DST_OVER, "DST_OVER" }, \
{ DSPD_SRC_IN, "SRC_IN" }, \ { DSPD_SRC_IN, "SRC_IN" }, \
{ DSPD_DST_IN, "DST_IN" }, \ { DSPD_DST_IN, "DST_IN" }, \
{ DSPD_SRC_OUT, "SRC_OUT" }, \ { DSPD_SRC_OUT, "SRC_OUT" }, \
{ DSPD_DST_OUT, "DST_OUT" }, \ { DSPD_DST_OUT, "DST_OUT" }, \
{ DSPD_SRC_ATOP, "SRC_ATOP" }, \ { DSPD_SRC_ATOP, "SRC_ATOP" }, \
{ DSPD_DST_ATOP, "DST_ATOP" }, \ { DSPD_DST_ATOP, "DST_ATOP" }, \
{ DSPD_ADD, "ADD" }, \ { DSPD_ADD, "ADD" }, \
{ DSPD_XOR, "XOR" }, \ { DSPD_XOR, "XOR" }, \
{ DSPD_DST, "DST" }, \ { DSPD_DST, "DST" }, \
{ DSPD_NONE, "NONE" } \ { (DFBSurfacePorterDuffRule) DSPD_NONE, "NONE" } \
}; };
struct DFBSurfaceCapabilitiesName { struct DFBSurfaceCapabilitiesName {
DFBSurfaceCapabilities capability; DFBSurfaceCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBSurfaceCapabilitiesNames(Identifier) struct DFBSurfaceCapab ilitiesName Identifier[] = { \ #define DirectFBSurfaceCapabilitiesNames(Identifier) struct DFBSurfaceCapab ilitiesName Identifier[] = { \
{ DSCAPS_PRIMARY, "PRIMARY" }, \ { DSCAPS_PRIMARY, "PRIMARY" }, \
{ DSCAPS_SYSTEMONLY, "SYSTEMONLY" }, \ { DSCAPS_SYSTEMONLY, "SYSTEMONLY" }, \
skipping to change at line 100 skipping to change at line 100
{ DSCAPS_INTERLACED, "INTERLACED" }, \ { DSCAPS_INTERLACED, "INTERLACED" }, \
{ DSCAPS_SEPARATED, "SEPARATED" }, \ { DSCAPS_SEPARATED, "SEPARATED" }, \
{ DSCAPS_SEPARATED, "SEPARATED" }, \ { DSCAPS_SEPARATED, "SEPARATED" }, \
{ DSCAPS_STATIC_ALLOC, "STATIC_ALLOC" }, \ { DSCAPS_STATIC_ALLOC, "STATIC_ALLOC" }, \
{ DSCAPS_TRIPLE, "TRIPLE" }, \ { DSCAPS_TRIPLE, "TRIPLE" }, \
{ DSCAPS_PREMULTIPLIED, "PREMULTIPLIED" }, \ { DSCAPS_PREMULTIPLIED, "PREMULTIPLIED" }, \
{ DSCAPS_DEPTH, "DEPTH" }, \ { DSCAPS_DEPTH, "DEPTH" }, \
{ DSCAPS_STEREO, "STEREO" }, \ { DSCAPS_STEREO, "STEREO" }, \
{ DSCAPS_SHARED, "SHARED" }, \ { DSCAPS_SHARED, "SHARED" }, \
{ DSCAPS_ROTATED, "ROTATED" }, \ { DSCAPS_ROTATED, "ROTATED" }, \
{ DSCAPS_NONE, "NONE" } \ { (DFBSurfaceCapabilities) DSCAPS_NONE, "NONE" } \
}; };
struct DFBColorSpaceName { struct DFBColorSpaceName {
DFBSurfaceColorSpace colorspace; DFBSurfaceColorSpace colorspace;
const char *name; const char *name;
}; };
#define DirectFBColorSpaceNames(Identifier) struct DFBColorSpaceName Identi fier[] = { \ #define DirectFBColorSpaceNames(Identifier) struct DFBColorSpaceName Identi fier[] = { \
{ DSCS_RGB, "RGB" }, \ { DSCS_RGB, "RGB" }, \
{ DSCS_BT601, "BT601" }, \ { DSCS_BT601, "BT601" }, \
{ DSCS_BT601_FULLRANGE, "BT601_FULLRANGE" }, \ { DSCS_BT601_FULLRANGE, "BT601_FULLRANGE" }, \
{ DSCS_BT709, "BT709" }, \ { DSCS_BT709, "BT709" }, \
{ DSCS_UNKNOWN, "UNKNOWN" } \ { (DFBSurfaceColorSpace) DSCS_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBInputDeviceTypeFlagsName { struct DFBInputDeviceTypeFlagsName {
DFBInputDeviceTypeFlags type; DFBInputDeviceTypeFlags type;
const char *name; const char *name;
}; };
#define DirectFBInputDeviceTypeFlagsNames(Identifier) struct DFBInputDevice TypeFlagsName Identifier[] = { \ #define DirectFBInputDeviceTypeFlagsNames(Identifier) struct DFBInputDevice TypeFlagsName Identifier[] = { \
{ DIDTF_KEYBOARD, "KEYBOARD" }, \ { DIDTF_KEYBOARD, "KEYBOARD" }, \
{ DIDTF_MOUSE, "MOUSE" }, \ { DIDTF_MOUSE, "MOUSE" }, \
{ DIDTF_JOYSTICK, "JOYSTICK" }, \ { DIDTF_JOYSTICK, "JOYSTICK" }, \
{ DIDTF_REMOTE, "REMOTE" }, \ { DIDTF_REMOTE, "REMOTE" }, \
{ DIDTF_VIRTUAL, "VIRTUAL" }, \ { DIDTF_VIRTUAL, "VIRTUAL" }, \
{ DIDTF_NONE, "NONE" } \ { (DFBInputDeviceTypeFlags) DIDTF_NONE, "NONE" } \
}; };
struct DFBSurfaceDrawingFlagsName { struct DFBSurfaceDrawingFlagsName {
DFBSurfaceDrawingFlags flag; DFBSurfaceDrawingFlags flag;
const char *name; const char *name;
}; };
#define DirectFBSurfaceDrawingFlagsNames(Identifier) struct DFBSurfaceDrawi ngFlagsName Identifier[] = { \ #define DirectFBSurfaceDrawingFlagsNames(Identifier) struct DFBSurfaceDrawi ngFlagsName Identifier[] = { \
{ DSDRAW_BLEND, "BLEND" }, \ { DSDRAW_BLEND, "BLEND" }, \
{ DSDRAW_DST_COLORKEY, "DST_COLORKEY" }, \ { DSDRAW_DST_COLORKEY, "DST_COLORKEY" }, \
{ DSDRAW_SRC_PREMULTIPLY, "SRC_PREMULTIPLY" }, \ { DSDRAW_SRC_PREMULTIPLY, "SRC_PREMULTIPLY" }, \
{ DSDRAW_DST_PREMULTIPLY, "DST_PREMULTIPLY" }, \ { DSDRAW_DST_PREMULTIPLY, "DST_PREMULTIPLY" }, \
{ DSDRAW_DEMULTIPLY, "DEMULTIPLY" }, \ { DSDRAW_DEMULTIPLY, "DEMULTIPLY" }, \
{ DSDRAW_XOR, "XOR" }, \ { DSDRAW_XOR, "XOR" }, \
{ DSDRAW_NOFX, "NOFX" } \ { (DFBSurfaceDrawingFlags) DSDRAW_NOFX, "NOFX" } \
}; };
struct DFBSurfaceBlittingFlagsName { struct DFBSurfaceBlittingFlagsName {
DFBSurfaceBlittingFlags flag; DFBSurfaceBlittingFlags flag;
const char *name; const char *name;
}; };
#define DirectFBSurfaceBlittingFlagsNames(Identifier) struct DFBSurfaceBlit tingFlagsName Identifier[] = { \ #define DirectFBSurfaceBlittingFlagsNames(Identifier) struct DFBSurfaceBlit tingFlagsName Identifier[] = { \
{ DSBLIT_BLEND_ALPHACHANNEL, "BLEND_ALPHACHANNEL" }, \ { DSBLIT_BLEND_ALPHACHANNEL, "BLEND_ALPHACHANNEL" }, \
{ DSBLIT_BLEND_COLORALPHA, "BLEND_COLORALPHA" }, \ { DSBLIT_BLEND_COLORALPHA, "BLEND_COLORALPHA" }, \
skipping to change at line 176 skipping to change at line 176
{ DSBLIT_COLORKEY_PROTECT, "COLORKEY_PROTECT" }, \ { DSBLIT_COLORKEY_PROTECT, "COLORKEY_PROTECT" }, \
{ DSBLIT_SRC_COLORKEY_EXTENDED, "SRC_COLORKEY_EXTENDED" }, \ { DSBLIT_SRC_COLORKEY_EXTENDED, "SRC_COLORKEY_EXTENDED" }, \
{ DSBLIT_DST_COLORKEY_EXTENDED, "DST_COLORKEY_EXTENDED" }, \ { DSBLIT_DST_COLORKEY_EXTENDED, "DST_COLORKEY_EXTENDED" }, \
{ DSBLIT_SRC_MASK_ALPHA, "SRC_MASK_ALPHA" }, \ { DSBLIT_SRC_MASK_ALPHA, "SRC_MASK_ALPHA" }, \
{ DSBLIT_SRC_MASK_COLOR, "SRC_MASK_COLOR" }, \ { DSBLIT_SRC_MASK_COLOR, "SRC_MASK_COLOR" }, \
{ DSBLIT_FLIP_HORIZONTAL, "FLIP_HORIZONTAL" }, \ { DSBLIT_FLIP_HORIZONTAL, "FLIP_HORIZONTAL" }, \
{ DSBLIT_FLIP_VERTICAL, "FLIP_VERTICAL" }, \ { DSBLIT_FLIP_VERTICAL, "FLIP_VERTICAL" }, \
{ DSBLIT_ROP, "ROP" }, \ { DSBLIT_ROP, "ROP" }, \
{ DSBLIT_SRC_COLORMATRIX, "SRC_COLORMATRIX" }, \ { DSBLIT_SRC_COLORMATRIX, "SRC_COLORMATRIX" }, \
{ DSBLIT_SRC_CONVOLUTION, "SRC_CONVOLUTION" }, \ { DSBLIT_SRC_CONVOLUTION, "SRC_CONVOLUTION" }, \
{ DSBLIT_NOFX, "NOFX" } \ { (DFBSurfaceBlittingFlags) DSBLIT_NOFX, "NOFX" } \
}; };
struct DFBSurfaceFlipFlagsName { struct DFBSurfaceFlipFlagsName {
DFBSurfaceFlipFlags flag; DFBSurfaceFlipFlags flag;
const char *name; const char *name;
}; };
#define DirectFBSurfaceFlipFlagsNames(Identifier) struct DFBSurfaceFlipFlag sName Identifier[] = { \ #define DirectFBSurfaceFlipFlagsNames(Identifier) struct DFBSurfaceFlipFlag sName Identifier[] = { \
{ DSFLIP_WAIT, "WAIT" }, \ { DSFLIP_WAIT, "WAIT" }, \
{ DSFLIP_BLIT, "BLIT" }, \ { DSFLIP_BLIT, "BLIT" }, \
{ DSFLIP_ONSYNC, "ONSYNC" }, \ { DSFLIP_ONSYNC, "ONSYNC" }, \
{ DSFLIP_WAIT, "WAIT" }, \ { DSFLIP_WAIT, "WAIT" }, \
{ DSFLIP_PIPELINE, "PIPELINE" }, \ { DSFLIP_PIPELINE, "PIPELINE" }, \
{ DSFLIP_ONCE, "ONCE" }, \ { DSFLIP_ONCE, "ONCE" }, \
{ DSFLIP_QUEUE, "QUEUE" }, \ { DSFLIP_QUEUE, "QUEUE" }, \
{ DSFLIP_FLUSH, "FLUSH" }, \ { DSFLIP_FLUSH, "FLUSH" }, \
{ DSFLIP_SWAP, "SWAP" }, \ { DSFLIP_SWAP, "SWAP" }, \
{ DSFLIP_UPDATE, "UPDATE" }, \ { DSFLIP_UPDATE, "UPDATE" }, \
{ DSFLIP_WAITFORSYNC, "WAITFORSYNC" }, \ { DSFLIP_WAITFORSYNC, "WAITFORSYNC" }, \
{ DSFLIP_NONE, "NONE" } \ { (DFBSurfaceFlipFlags) DSFLIP_NONE, "NONE" } \
}; };
struct DFBSurfaceBlendFunctionName { struct DFBSurfaceBlendFunctionName {
DFBSurfaceBlendFunction function; DFBSurfaceBlendFunction function;
const char *name; const char *name;
}; };
#define DirectFBSurfaceBlendFunctionNames(Identifier) struct DFBSurfaceBlen dFunctionName Identifier[] = { \ #define DirectFBSurfaceBlendFunctionNames(Identifier) struct DFBSurfaceBlen dFunctionName Identifier[] = { \
{ DSBF_ZERO, "ZERO" }, \ { DSBF_ZERO, "ZERO" }, \
{ DSBF_ONE, "ONE" }, \ { DSBF_ONE, "ONE" }, \
{ DSBF_SRCCOLOR, "SRCCOLOR" }, \ { DSBF_SRCCOLOR, "SRCCOLOR" }, \
{ DSBF_INVSRCCOLOR, "INVSRCCOLOR" }, \ { DSBF_INVSRCCOLOR, "INVSRCCOLOR" }, \
{ DSBF_SRCALPHA, "SRCALPHA" }, \ { DSBF_SRCALPHA, "SRCALPHA" }, \
{ DSBF_INVSRCALPHA, "INVSRCALPHA" }, \ { DSBF_INVSRCALPHA, "INVSRCALPHA" }, \
{ DSBF_DESTALPHA, "DESTALPHA" }, \ { DSBF_DESTALPHA, "DESTALPHA" }, \
{ DSBF_INVDESTALPHA, "INVDESTALPHA" }, \ { DSBF_INVDESTALPHA, "INVDESTALPHA" }, \
{ DSBF_DESTCOLOR, "DESTCOLOR" }, \ { DSBF_DESTCOLOR, "DESTCOLOR" }, \
{ DSBF_INVDESTCOLOR, "INVDESTCOLOR" }, \ { DSBF_INVDESTCOLOR, "INVDESTCOLOR" }, \
{ DSBF_SRCALPHASAT, "SRCALPHASAT" }, \ { DSBF_SRCALPHASAT, "SRCALPHASAT" }, \
{ DSBF_UNKNOWN, "UNKNOWN" } \ { (DFBSurfaceBlendFunction) DSBF_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBInputDeviceCapabilitiesName { struct DFBInputDeviceCapabilitiesName {
DFBInputDeviceCapabilities capability; DFBInputDeviceCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBInputDeviceCapabilitiesNames(Identifier) struct DFBInputDev iceCapabilitiesName Identifier[] = { \ #define DirectFBInputDeviceCapabilitiesNames(Identifier) struct DFBInputDev iceCapabilitiesName Identifier[] = { \
{ DICAPS_KEYS, "KEYS" }, \ { DICAPS_KEYS, "KEYS" }, \
{ DICAPS_AXES, "AXES" }, \ { DICAPS_AXES, "AXES" }, \
{ DICAPS_BUTTONS, "BUTTONS" }, \ { DICAPS_BUTTONS, "BUTTONS" }, \
{ DICAPS_NONE, "NONE" } \ { (DFBInputDeviceCapabilities) DICAPS_NONE, "NONE" } \
}; };
struct DFBDisplayLayerTypeFlagsName { struct DFBDisplayLayerTypeFlagsName {
DFBDisplayLayerTypeFlags type; DFBDisplayLayerTypeFlags type;
const char *name; const char *name;
}; };
#define DirectFBDisplayLayerTypeFlagsNames(Identifier) struct DFBDisplayLay erTypeFlagsName Identifier[] = { \ #define DirectFBDisplayLayerTypeFlagsNames(Identifier) struct DFBDisplayLay erTypeFlagsName Identifier[] = { \
{ DLTF_GRAPHICS, "GRAPHICS" }, \ { DLTF_GRAPHICS, "GRAPHICS" }, \
{ DLTF_VIDEO, "VIDEO" }, \ { DLTF_VIDEO, "VIDEO" }, \
{ DLTF_STILL_PICTURE, "STILL_PICTURE" }, \ { DLTF_STILL_PICTURE, "STILL_PICTURE" }, \
{ DLTF_BACKGROUND, "BACKGROUND" }, \ { DLTF_BACKGROUND, "BACKGROUND" }, \
{ DLTF_NONE, "NONE" } \ { (DFBDisplayLayerTypeFlags) DLTF_NONE, "NONE" } \
}; };
struct DFBDisplayLayerCapabilitiesName { struct DFBDisplayLayerCapabilitiesName {
DFBDisplayLayerCapabilities capability; DFBDisplayLayerCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBDisplayLayerCapabilitiesNames(Identifier) struct DFBDisplay LayerCapabilitiesName Identifier[] = { \ #define DirectFBDisplayLayerCapabilitiesNames(Identifier) struct DFBDisplay LayerCapabilitiesName Identifier[] = { \
{ DLCAPS_SURFACE, "SURFACE" }, \ { DLCAPS_SURFACE, "SURFACE" }, \
{ DLCAPS_OPACITY, "OPACITY" }, \ { DLCAPS_OPACITY, "OPACITY" }, \
skipping to change at line 273 skipping to change at line 273
{ DLCAPS_FIELD_PARITY, "FIELD_PARITY" }, \ { DLCAPS_FIELD_PARITY, "FIELD_PARITY" }, \
{ DLCAPS_WINDOWS, "WINDOWS" }, \ { DLCAPS_WINDOWS, "WINDOWS" }, \
{ DLCAPS_SOURCES, "SOURCES" }, \ { DLCAPS_SOURCES, "SOURCES" }, \
{ DLCAPS_ALPHA_RAMP, "ALPHA_RAMP" }, \ { DLCAPS_ALPHA_RAMP, "ALPHA_RAMP" }, \
{ DLCAPS_PREMULTIPLIED, "PREMULTIPLIED" }, \ { DLCAPS_PREMULTIPLIED, "PREMULTIPLIED" }, \
{ DLCAPS_SCREEN_POSITION, "SCREEN_POSITION" }, \ { DLCAPS_SCREEN_POSITION, "SCREEN_POSITION" }, \
{ DLCAPS_SCREEN_SIZE, "SCREEN_SIZE" }, \ { DLCAPS_SCREEN_SIZE, "SCREEN_SIZE" }, \
{ DLCAPS_CLIP_REGIONS, "CLIP_REGIONS" }, \ { DLCAPS_CLIP_REGIONS, "CLIP_REGIONS" }, \
{ DLCAPS_LR_MONO, "LR_MONO" }, \ { DLCAPS_LR_MONO, "LR_MONO" }, \
{ DLCAPS_STEREO, "STEREO" }, \ { DLCAPS_STEREO, "STEREO" }, \
{ DLCAPS_NONE, "NONE" } \ { (DFBDisplayLayerCapabilities) DLCAPS_NONE, "NONE" } \
}; };
struct DFBDisplayLayerBufferModeName { struct DFBDisplayLayerBufferModeName {
DFBDisplayLayerBufferMode mode; DFBDisplayLayerBufferMode mode;
const char *name; const char *name;
}; };
#define DirectFBDisplayLayerBufferModeNames(Identifier) struct DFBDisplayLa yerBufferModeName Identifier[] = { \ #define DirectFBDisplayLayerBufferModeNames(Identifier) struct DFBDisplayLa yerBufferModeName Identifier[] = { \
{ DLBM_FRONTONLY, "FRONTONLY" }, \ { DLBM_FRONTONLY, "FRONTONLY" }, \
{ DLBM_BACKVIDEO, "BACKVIDEO" }, \ { DLBM_BACKVIDEO, "BACKVIDEO" }, \
{ DLBM_BACKSYSTEM, "BACKSYSTEM" }, \ { DLBM_BACKSYSTEM, "BACKSYSTEM" }, \
{ DLBM_TRIPLE, "TRIPLE" }, \ { DLBM_TRIPLE, "TRIPLE" }, \
{ DLBM_WINDOWS, "WINDOWS" }, \ { DLBM_WINDOWS, "WINDOWS" }, \
{ DLBM_UNKNOWN, "UNKNOWN" } \ { (DFBDisplayLayerBufferMode) DLBM_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBWindowCapabilitiesName { struct DFBWindowCapabilitiesName {
DFBWindowCapabilities capability; DFBWindowCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBWindowCapabilitiesNames(Identifier) struct DFBWindowCapabil itiesName Identifier[] = { \ #define DirectFBWindowCapabilitiesNames(Identifier) struct DFBWindowCapabil itiesName Identifier[] = { \
{ DWCAPS_LR_MONO, "LR_MONO" }, \ { DWCAPS_LR_MONO, "LR_MONO" }, \
{ DWCAPS_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DWCAPS_ALPHACHANNEL, "ALPHACHANNEL" }, \
{ DWCAPS_DOUBLEBUFFER, "DOUBLEBUFFER" }, \ { DWCAPS_DOUBLEBUFFER, "DOUBLEBUFFER" }, \
{ DWCAPS_INPUTONLY, "INPUTONLY" }, \ { DWCAPS_INPUTONLY, "INPUTONLY" }, \
{ DWCAPS_NODECORATION, "NODECORATION" }, \ { DWCAPS_NODECORATION, "NODECORATION" }, \
{ DWCAPS_SUBWINDOW, "SUBWINDOW" }, \ { DWCAPS_SUBWINDOW, "SUBWINDOW" }, \
{ DWCAPS_COLOR, "COLOR" }, \ { DWCAPS_COLOR, "COLOR" }, \
{ DWCAPS_NOFOCUS, "NOFOCUS" }, \ { DWCAPS_NOFOCUS, "NOFOCUS" }, \
{ DWCAPS_LR_MONO, "LR_MONO" }, \ { DWCAPS_LR_MONO, "LR_MONO" }, \
{ DWCAPS_STEREO, "STEREO" }, \ { DWCAPS_STEREO, "STEREO" }, \
{ DWCAPS_NONE, "NONE" } \ { (DFBWindowCapabilities) DWCAPS_NONE, "NONE" } \
}; };
struct DFBDisplayLayerOptionsName { struct DFBDisplayLayerOptionsName {
DFBDisplayLayerOptions option; DFBDisplayLayerOptions option;
const char *name; const char *name;
}; };
#define DirectFBDisplayLayerOptionsNames(Identifier) struct DFBDisplayLayer OptionsName Identifier[] = { \ #define DirectFBDisplayLayerOptionsNames(Identifier) struct DFBDisplayLayer OptionsName Identifier[] = { \
{ DLOP_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DLOP_ALPHACHANNEL, "ALPHACHANNEL" }, \
{ DLOP_FLICKER_FILTERING, "FLICKER_FILTERING" }, \ { DLOP_FLICKER_FILTERING, "FLICKER_FILTERING" }, \
{ DLOP_DEINTERLACING, "DEINTERLACING" }, \ { DLOP_DEINTERLACING, "DEINTERLACING" }, \
{ DLOP_SRC_COLORKEY, "SRC_COLORKEY" }, \ { DLOP_SRC_COLORKEY, "SRC_COLORKEY" }, \
{ DLOP_DST_COLORKEY, "DST_COLORKEY" }, \ { DLOP_DST_COLORKEY, "DST_COLORKEY" }, \
{ DLOP_OPACITY, "OPACITY" }, \ { DLOP_OPACITY, "OPACITY" }, \
{ DLOP_FIELD_PARITY, "FIELD_PARITY" }, \ { DLOP_FIELD_PARITY, "FIELD_PARITY" }, \
{ DLOP_LR_MONO, "LR_MONO" }, \ { DLOP_LR_MONO, "LR_MONO" }, \
{ DLOP_STEREO, "STEREO" }, \ { DLOP_STEREO, "STEREO" }, \
{ DLOP_STEREO, "STEREO" }, \ { DLOP_STEREO, "STEREO" }, \
{ DLOP_NONE, "NONE" } \ { (DFBDisplayLayerOptions) DLOP_NONE, "NONE" } \
}; };
struct DFBWindowOptionsName { struct DFBWindowOptionsName {
DFBWindowOptions option; DFBWindowOptions option;
const char *name; const char *name;
}; };
#define DirectFBWindowOptionsNames(Identifier) struct DFBWindowOptionsName Identifier[] = { \ #define DirectFBWindowOptionsNames(Identifier) struct DFBWindowOptionsName Identifier[] = { \
{ DWOP_COLORKEYING, "COLORKEYING" }, \ { DWOP_COLORKEYING, "COLORKEYING" }, \
{ DWOP_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DWOP_ALPHACHANNEL, "ALPHACHANNEL" }, \
skipping to change at line 350 skipping to change at line 350
{ DWOP_KEEP_SIZE, "KEEP_SIZE" }, \ { DWOP_KEEP_SIZE, "KEEP_SIZE" }, \
{ DWOP_KEEP_STACKING, "KEEP_STACKING" }, \ { DWOP_KEEP_STACKING, "KEEP_STACKING" }, \
{ DWOP_GHOST, "GHOST" }, \ { DWOP_GHOST, "GHOST" }, \
{ DWOP_INDESTRUCTIBLE, "INDESTRUCTIBLE" }, \ { DWOP_INDESTRUCTIBLE, "INDESTRUCTIBLE" }, \
{ DWOP_INPUTONLY, "INPUTONLY" }, \ { DWOP_INPUTONLY, "INPUTONLY" }, \
{ DWOP_STEREO_SIDE_BY_SIDE_HALF, "STEREO_SIDE_BY_SIDE_HALF" }, \ { DWOP_STEREO_SIDE_BY_SIDE_HALF, "STEREO_SIDE_BY_SIDE_HALF" }, \
{ DWOP_SCALE, "SCALE" }, \ { DWOP_SCALE, "SCALE" }, \
{ DWOP_KEEP_ABOVE, "KEEP_ABOVE" }, \ { DWOP_KEEP_ABOVE, "KEEP_ABOVE" }, \
{ DWOP_KEEP_UNDER, "KEEP_UNDER" }, \ { DWOP_KEEP_UNDER, "KEEP_UNDER" }, \
{ DWOP_FOLLOW_BOUNDS, "FOLLOW_BOUNDS" }, \ { DWOP_FOLLOW_BOUNDS, "FOLLOW_BOUNDS" }, \
{ DWOP_NONE, "NONE" } \ { (DFBWindowOptions) DWOP_NONE, "NONE" } \
}; };
struct DFBScreenCapabilitiesName { struct DFBScreenCapabilitiesName {
DFBScreenCapabilities capability; DFBScreenCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBScreenCapabilitiesNames(Identifier) struct DFBScreenCapabil itiesName Identifier[] = { \ #define DirectFBScreenCapabilitiesNames(Identifier) struct DFBScreenCapabil itiesName Identifier[] = { \
{ DSCCAPS_VSYNC, "VSYNC" }, \ { DSCCAPS_VSYNC, "VSYNC" }, \
{ DSCCAPS_POWER_MANAGEMENT, "POWER_MANAGEMENT" }, \ { DSCCAPS_POWER_MANAGEMENT, "POWER_MANAGEMENT" }, \
{ DSCCAPS_MIXERS, "MIXERS" }, \ { DSCCAPS_MIXERS, "MIXERS" }, \
{ DSCCAPS_ENCODERS, "ENCODERS" }, \ { DSCCAPS_ENCODERS, "ENCODERS" }, \
{ DSCCAPS_OUTPUTS, "OUTPUTS" }, \ { DSCCAPS_OUTPUTS, "OUTPUTS" }, \
{ DSCCAPS_NONE, "NONE" } \ { (DFBScreenCapabilities) DSCCAPS_NONE, "NONE" } \
}; };
struct DFBScreenEncoderCapabilitiesName { struct DFBScreenEncoderCapabilitiesName {
DFBScreenEncoderCapabilities capability; DFBScreenEncoderCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderCapabilitiesNames(Identifier) struct DFBScreen EncoderCapabilitiesName Identifier[] = { \ #define DirectFBScreenEncoderCapabilitiesNames(Identifier) struct DFBScreen EncoderCapabilitiesName Identifier[] = { \
{ DSECAPS_TV_STANDARDS, "TV_STANDARDS" }, \ { DSECAPS_TV_STANDARDS, "TV_STANDARDS" }, \
{ DSECAPS_TEST_PICTURE, "TEST_PICTURE" }, \ { DSECAPS_TEST_PICTURE, "TEST_PICTURE" }, \
skipping to change at line 388 skipping to change at line 388
{ DSECAPS_FREQUENCY, "FREQUENCY" }, \ { DSECAPS_FREQUENCY, "FREQUENCY" }, \
{ DSECAPS_BRIGHTNESS, "BRIGHTNESS" }, \ { DSECAPS_BRIGHTNESS, "BRIGHTNESS" }, \
{ DSECAPS_CONTRAST, "CONTRAST" }, \ { DSECAPS_CONTRAST, "CONTRAST" }, \
{ DSECAPS_HUE, "HUE" }, \ { DSECAPS_HUE, "HUE" }, \
{ DSECAPS_SATURATION, "SATURATION" }, \ { DSECAPS_SATURATION, "SATURATION" }, \
{ DSECAPS_CONNECTORS, "CONNECTORS" }, \ { DSECAPS_CONNECTORS, "CONNECTORS" }, \
{ DSECAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \ { DSECAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \
{ DSECAPS_RESOLUTION, "RESOLUTION" }, \ { DSECAPS_RESOLUTION, "RESOLUTION" }, \
{ DSECAPS_FRAMING, "FRAMING" }, \ { DSECAPS_FRAMING, "FRAMING" }, \
{ DSECAPS_ASPECT_RATIO, "ASPECT_RATIO" }, \ { DSECAPS_ASPECT_RATIO, "ASPECT_RATIO" }, \
{ DSECAPS_NONE, "NONE" } \ { (DFBScreenEncoderCapabilities) DSECAPS_NONE, "NONE" } \
}; };
struct DFBScreenEncoderTypeName { struct DFBScreenEncoderTypeName {
DFBScreenEncoderType type; DFBScreenEncoderType type;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderTypeNames(Identifier) struct DFBScreenEncoderT ypeName Identifier[] = { \ #define DirectFBScreenEncoderTypeNames(Identifier) struct DFBScreenEncoderT ypeName Identifier[] = { \
{ DSET_CRTC, "CRTC" }, \ { DSET_CRTC, "CRTC" }, \
{ DSET_TV, "TV" }, \ { DSET_TV, "TV" }, \
{ DSET_DIGITAL, "DIGITAL" }, \ { DSET_DIGITAL, "DIGITAL" }, \
{ DSET_UNKNOWN, "UNKNOWN" } \ { (DFBScreenEncoderType) DSET_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenEncoderTVStandardsName { struct DFBScreenEncoderTVStandardsName {
DFBScreenEncoderTVStandards standard; DFBScreenEncoderTVStandards standard;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderTVStandardsNames(Identifier) struct DFBScreenE ncoderTVStandardsName Identifier[] = { \ #define DirectFBScreenEncoderTVStandardsNames(Identifier) struct DFBScreenE ncoderTVStandardsName Identifier[] = { \
{ DSETV_PAL, "PAL" }, \ { DSETV_PAL, "PAL" }, \
{ DSETV_NTSC, "NTSC" }, \ { DSETV_NTSC, "NTSC" }, \
{ DSETV_SECAM, "SECAM" }, \ { DSETV_SECAM, "SECAM" }, \
{ DSETV_PAL_60, "PAL_60" }, \ { DSETV_PAL_60, "PAL_60" }, \
{ DSETV_PAL_BG, "PAL_BG" }, \ { DSETV_PAL_BG, "PAL_BG" }, \
{ DSETV_PAL_I, "PAL_I" }, \ { DSETV_PAL_I, "PAL_I" }, \
{ DSETV_PAL_M, "PAL_M" }, \ { DSETV_PAL_M, "PAL_M" }, \
{ DSETV_PAL_N, "PAL_N" }, \ { DSETV_PAL_N, "PAL_N" }, \
{ DSETV_PAL_NC, "PAL_NC" }, \ { DSETV_PAL_NC, "PAL_NC" }, \
{ DSETV_NTSC_M_JPN, "NTSC_M_JPN" }, \ { DSETV_NTSC_M_JPN, "NTSC_M_JPN" }, \
{ DSETV_DIGITAL, "DIGITAL" }, \ { DSETV_DIGITAL, "DIGITAL" }, \
{ DSETV_NTSC_443, "NTSC_443" }, \ { DSETV_NTSC_443, "NTSC_443" }, \
{ DSETV_UNKNOWN, "UNKNOWN" } \ { (DFBScreenEncoderTVStandards) DSETV_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenOutputCapabilitiesName { struct DFBScreenOutputCapabilitiesName {
DFBScreenOutputCapabilities capability; DFBScreenOutputCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBScreenOutputCapabilitiesNames(Identifier) struct DFBScreenO utputCapabilitiesName Identifier[] = { \ #define DirectFBScreenOutputCapabilitiesNames(Identifier) struct DFBScreenO utputCapabilitiesName Identifier[] = { \
{ DSOCAPS_CONNECTORS, "CONNECTORS" }, \ { DSOCAPS_CONNECTORS, "CONNECTORS" }, \
{ DSOCAPS_ENCODER_SEL, "ENCODER_SEL" }, \ { DSOCAPS_ENCODER_SEL, "ENCODER_SEL" }, \
{ DSOCAPS_SIGNAL_SEL, "SIGNAL_SEL" }, \ { DSOCAPS_SIGNAL_SEL, "SIGNAL_SEL" }, \
{ DSOCAPS_CONNECTOR_SEL, "CONNECTOR_SEL" }, \ { DSOCAPS_CONNECTOR_SEL, "CONNECTOR_SEL" }, \
{ DSOCAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \ { DSOCAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \
{ DSOCAPS_RESOLUTION, "RESOLUTION" }, \ { DSOCAPS_RESOLUTION, "RESOLUTION" }, \
{ DSOCAPS_NONE, "NONE" } \ { (DFBScreenOutputCapabilities) DSOCAPS_NONE, "NONE" } \
}; };
struct DFBScreenOutputConnectorsName { struct DFBScreenOutputConnectorsName {
DFBScreenOutputConnectors connector; DFBScreenOutputConnectors connector;
const char *name; const char *name;
}; };
#define DirectFBScreenOutputConnectorsNames(Identifier) struct DFBScreenOut putConnectorsName Identifier[] = { \ #define DirectFBScreenOutputConnectorsNames(Identifier) struct DFBScreenOut putConnectorsName Identifier[] = { \
{ DSOC_VGA, "VGA" }, \ { DSOC_VGA, "VGA" }, \
{ DSOC_SCART, "SCART" }, \ { DSOC_SCART, "SCART" }, \
{ DSOC_YC, "YC" }, \ { DSOC_YC, "YC" }, \
{ DSOC_CVBS, "CVBS" }, \ { DSOC_CVBS, "CVBS" }, \
{ DSOC_SCART2, "SCART2" }, \ { DSOC_SCART2, "SCART2" }, \
{ DSOC_COMPONENT, "COMPONENT" }, \ { DSOC_COMPONENT, "COMPONENT" }, \
{ DSOC_HDMI, "HDMI" }, \ { DSOC_HDMI, "HDMI" }, \
{ DSOC_656, "656" }, \ { DSOC_656, "656" }, \
{ DSOC_UNKNOWN, "UNKNOWN" } \ { (DFBScreenOutputConnectors) DSOC_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenOutputSignalsName { struct DFBScreenOutputSignalsName {
DFBScreenOutputSignals signal; DFBScreenOutputSignals signal;
const char *name; const char *name;
}; };
#define DirectFBScreenOutputSignalsNames(Identifier) struct DFBScreenOutput SignalsName Identifier[] = { \ #define DirectFBScreenOutputSignalsNames(Identifier) struct DFBScreenOutput SignalsName Identifier[] = { \
{ DSOS_VGA, "VGA" }, \ { DSOS_VGA, "VGA" }, \
{ DSOS_YC, "YC" }, \ { DSOS_YC, "YC" }, \
{ DSOS_CVBS, "CVBS" }, \ { DSOS_CVBS, "CVBS" }, \
{ DSOS_RGB, "RGB" }, \ { DSOS_RGB, "RGB" }, \
{ DSOS_YCBCR, "YCBCR" }, \ { DSOS_YCBCR, "YCBCR" }, \
{ DSOS_HDMI, "HDMI" }, \ { DSOS_HDMI, "HDMI" }, \
{ DSOS_656, "656" }, \ { DSOS_656, "656" }, \
{ DSOS_NONE, "NONE" } \ { (DFBScreenOutputSignals) DSOS_NONE, "NONE" } \
}; };
struct DFBScreenOutputSlowBlankingSignalsName { struct DFBScreenOutputSlowBlankingSignalsName {
DFBScreenOutputSlowBlankingSignals slow_signal; DFBScreenOutputSlowBlankingSignals slow_signal;
const char *name; const char *name;
}; };
#define DirectFBScreenOutputSlowBlankingSignalsNames(Identifier) struct DFB ScreenOutputSlowBlankingSignalsName Identifier[] = { \ #define DirectFBScreenOutputSlowBlankingSignalsNames(Identifier) struct DFB ScreenOutputSlowBlankingSignalsName Identifier[] = { \
{ DSOSB_16x9, "16x9" }, \ { DSOSB_16x9, "16x9" }, \
{ DSOSB_4x3, "4x3" }, \ { DSOSB_4x3, "4x3" }, \
{ DSOSB_FOLLOW, "FOLLOW" }, \ { DSOSB_FOLLOW, "FOLLOW" }, \
{ DSOSB_MONITOR, "MONITOR" }, \ { DSOSB_MONITOR, "MONITOR" }, \
{ DSOSB_OFF, "OFF" } \ { (DFBScreenOutputSlowBlankingSignals) DSOSB_OFF, "OFF" } \
}; };
struct DFBScreenOutputResolutionName { struct DFBScreenOutputResolutionName {
DFBScreenOutputResolution resolution; DFBScreenOutputResolution resolution;
const char *name; const char *name;
}; };
#define DirectFBScreenOutputResolutionNames(Identifier) struct DFBScreenOut putResolutionName Identifier[] = { \ #define DirectFBScreenOutputResolutionNames(Identifier) struct DFBScreenOut putResolutionName Identifier[] = { \
{ DSOR_640_480, "640_480" }, \ { DSOR_640_480, "640_480" }, \
{ DSOR_720_480, "720_480" }, \ { DSOR_720_480, "720_480" }, \
skipping to change at line 514 skipping to change at line 514
{ DSOR_960_540, "960_540" }, \ { DSOR_960_540, "960_540" }, \
{ DSOR_1440_540, "1440_540" }, \ { DSOR_1440_540, "1440_540" }, \
{ DSOR_800_480, "800_480" }, \ { DSOR_800_480, "800_480" }, \
{ DSOR_1024_600, "1024_600" }, \ { DSOR_1024_600, "1024_600" }, \
{ DSOR_1366_768, "1366_768" }, \ { DSOR_1366_768, "1366_768" }, \
{ DSOR_1920_1200, "1920_1200" }, \ { DSOR_1920_1200, "1920_1200" }, \
{ DSOR_2560_1440, "2560_1440" }, \ { DSOR_2560_1440, "2560_1440" }, \
{ DSOR_2560_1600, "2560_1600" }, \ { DSOR_2560_1600, "2560_1600" }, \
{ DSOR_3840_2160, "3840_2160" }, \ { DSOR_3840_2160, "3840_2160" }, \
{ DSOR_4096_2160, "4096_2160" }, \ { DSOR_4096_2160, "4096_2160" }, \
{ DSOR_UNKNOWN, "UNKNOWN" } \ { (DFBScreenOutputResolution) DSOR_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenMixerCapabilitiesName { struct DFBScreenMixerCapabilitiesName {
DFBScreenMixerCapabilities capability; DFBScreenMixerCapabilities capability;
const char *name; const char *name;
}; };
#define DirectFBScreenMixerCapabilitiesNames(Identifier) struct DFBScreenMi xerCapabilitiesName Identifier[] = { \ #define DirectFBScreenMixerCapabilitiesNames(Identifier) struct DFBScreenMi xerCapabilitiesName Identifier[] = { \
{ DSMCAPS_FULL, "FULL" }, \ { DSMCAPS_FULL, "FULL" }, \
{ DSMCAPS_SUB_LEVEL, "SUB_LEVEL" }, \ { DSMCAPS_SUB_LEVEL, "SUB_LEVEL" }, \
{ DSMCAPS_SUB_LAYERS, "SUB_LAYERS" }, \ { DSMCAPS_SUB_LAYERS, "SUB_LAYERS" }, \
{ DSMCAPS_BACKGROUND, "BACKGROUND" }, \ { DSMCAPS_BACKGROUND, "BACKGROUND" }, \
{ DSMCAPS_NONE, "NONE" } \ { (DFBScreenMixerCapabilities) DSMCAPS_NONE, "NONE" } \
}; };
struct DFBScreenMixerTreeName { struct DFBScreenMixerTreeName {
DFBScreenMixerTree tree; DFBScreenMixerTree tree;
const char *name; const char *name;
}; };
#define DirectFBScreenMixerTreeNames(Identifier) struct DFBScreenMixerTreeN ame Identifier[] = { \ #define DirectFBScreenMixerTreeNames(Identifier) struct DFBScreenMixerTreeN ame Identifier[] = { \
{ DSMT_FULL, "FULL" }, \ { DSMT_FULL, "FULL" }, \
{ DSMT_SUB_LEVEL, "SUB_LEVEL" }, \ { DSMT_SUB_LEVEL, "SUB_LEVEL" }, \
{ DSMT_SUB_LAYERS, "SUB_LAYERS" }, \ { DSMT_SUB_LAYERS, "SUB_LAYERS" }, \
{ DSMT_UNKNOWN, "UNKNOWN" } \ { (DFBScreenMixerTree) DSMT_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenEncoderTestPictureName { struct DFBScreenEncoderTestPictureName {
DFBScreenEncoderTestPicture test_picture; DFBScreenEncoderTestPicture test_picture;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderTestPictureNames(Identifier) struct DFBScreenE ncoderTestPictureName Identifier[] = { \ #define DirectFBScreenEncoderTestPictureNames(Identifier) struct DFBScreenE ncoderTestPictureName Identifier[] = { \
{ DSETP_MULTI, "MULTI" }, \ { DSETP_MULTI, "MULTI" }, \
{ DSETP_SINGLE, "SINGLE" }, \ { DSETP_SINGLE, "SINGLE" }, \
{ DSETP_WHITE, "WHITE" }, \ { DSETP_WHITE, "WHITE" }, \
{ DSETP_YELLOW, "YELLOW" }, \ { DSETP_YELLOW, "YELLOW" }, \
{ DSETP_CYAN, "CYAN" }, \ { DSETP_CYAN, "CYAN" }, \
{ DSETP_GREEN, "GREEN" }, \ { DSETP_GREEN, "GREEN" }, \
{ DSETP_MAGENTA, "MAGENTA" }, \ { DSETP_MAGENTA, "MAGENTA" }, \
{ DSETP_RED, "RED" }, \ { DSETP_RED, "RED" }, \
{ DSETP_BLUE, "BLUE" }, \ { DSETP_BLUE, "BLUE" }, \
{ DSETP_BLACK, "BLACK" }, \ { DSETP_BLACK, "BLACK" }, \
{ DSETP_OFF, "OFF" } \ { (DFBScreenEncoderTestPicture) DSETP_OFF, "OFF" } \
}; };
struct DFBScreenEncoderScanModeName { struct DFBScreenEncoderScanModeName {
DFBScreenEncoderScanMode scan_mode; DFBScreenEncoderScanMode scan_mode;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderScanModeNames(Identifier) struct DFBScreenEnco derScanModeName Identifier[] = { \ #define DirectFBScreenEncoderScanModeNames(Identifier) struct DFBScreenEnco derScanModeName Identifier[] = { \
{ DSESM_INTERLACED, "INTERLACED" }, \ { DSESM_INTERLACED, "INTERLACED" }, \
{ DSESM_PROGRESSIVE, "PROGRESSIVE" }, \ { DSESM_PROGRESSIVE, "PROGRESSIVE" }, \
{ DSESM_UNKNOWN, "UNKNOWN" } \ { (DFBScreenEncoderScanMode) DSESM_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenEncoderConfigFlagsName { struct DFBScreenEncoderConfigFlagsName {
DFBScreenEncoderConfigFlags config_flags; DFBScreenEncoderConfigFlags config_flags;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderConfigFlagsNames(Identifier) struct DFBScreenE ncoderConfigFlagsName Identifier[] = { \ #define DirectFBScreenEncoderConfigFlagsNames(Identifier) struct DFBScreenE ncoderConfigFlagsName Identifier[] = { \
{ DSECONF_NONE, "NONE" }, \ { DSECONF_NONE, "NONE" }, \
{ DSECONF_TV_STANDARD, "TV_STANDARD" }, \ { DSECONF_TV_STANDARD, "TV_STANDARD" }, \
skipping to change at line 592 skipping to change at line 592
{ DSECONF_OUT_SIGNALS, "OUT_SIGNALS" }, \ { DSECONF_OUT_SIGNALS, "OUT_SIGNALS" }, \
{ DSECONF_SCANMODE, "SCANMODE" }, \ { DSECONF_SCANMODE, "SCANMODE" }, \
{ DSECONF_TEST_COLOR, "TEST_COLOR" }, \ { DSECONF_TEST_COLOR, "TEST_COLOR" }, \
{ DSECONF_ADJUSTMENT, "ADJUSTMENT" }, \ { DSECONF_ADJUSTMENT, "ADJUSTMENT" }, \
{ DSECONF_FREQUENCY, "FREQUENCY" }, \ { DSECONF_FREQUENCY, "FREQUENCY" }, \
{ DSECONF_CONNECTORS, "CONNECTORS" }, \ { DSECONF_CONNECTORS, "CONNECTORS" }, \
{ DSECONF_SLOW_BLANKING, "SLOW_BLANKING" }, \ { DSECONF_SLOW_BLANKING, "SLOW_BLANKING" }, \
{ DSECONF_RESOLUTION, "RESOLUTION" }, \ { DSECONF_RESOLUTION, "RESOLUTION" }, \
{ DSECONF_FRAMING, "FRAMING" }, \ { DSECONF_FRAMING, "FRAMING" }, \
{ DSECONF_ASPECT_RATIO, "ASPECT_RATIO" }, \ { DSECONF_ASPECT_RATIO, "ASPECT_RATIO" }, \
{ DSECONF_UNKNOWN, "UNKNOWN" } \ { (DFBScreenEncoderConfigFlags) DSECONF_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenEncoderFrequencyName { struct DFBScreenEncoderFrequencyName {
DFBScreenEncoderFrequency frequency; DFBScreenEncoderFrequency frequency;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderFrequencyNames(Identifier) struct DFBScreenEnc oderFrequencyName Identifier[] = { \ #define DirectFBScreenEncoderFrequencyNames(Identifier) struct DFBScreenEnc oderFrequencyName Identifier[] = { \
{ DSEF_25HZ, "25HZ" }, \ { DSEF_25HZ, "25HZ" }, \
{ DSEF_29_97HZ, "29_97HZ" }, \ { DSEF_29_97HZ, "29_97HZ" }, \
{ DSEF_50HZ, "50HZ" }, \ { DSEF_50HZ, "50HZ" }, \
{ DSEF_59_94HZ, "59_94HZ" }, \ { DSEF_59_94HZ, "59_94HZ" }, \
{ DSEF_60HZ, "60HZ" }, \ { DSEF_60HZ, "60HZ" }, \
{ DSEF_75HZ, "75HZ" }, \ { DSEF_75HZ, "75HZ" }, \
{ DSEF_30HZ, "30HZ" }, \ { DSEF_30HZ, "30HZ" }, \
{ DSEF_24HZ, "24HZ" }, \ { DSEF_24HZ, "24HZ" }, \
{ DSEF_23_976HZ, "23_976HZ" }, \ { DSEF_23_976HZ, "23_976HZ" }, \
{ DSEF_UNKNOWN, "UNKNOWN" } \ { (DFBScreenEncoderFrequency) DSEF_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBScreenEncoderPictureFramingName { struct DFBScreenEncoderPictureFramingName {
DFBScreenEncoderPictureFraming framing; DFBScreenEncoderPictureFraming framing;
const char *name; const char *name;
}; };
#define DirectFBScreenEncoderPictureFramingNames(Identifier) struct DFBScre enEncoderPictureFramingName Identifier[] = { \ #define DirectFBScreenEncoderPictureFramingNames(Identifier) struct DFBScre enEncoderPictureFramingName Identifier[] = { \
{ DSEPF_MONO, "MONO" }, \ { DSEPF_MONO, "MONO" }, \
{ DSEPF_STEREO_SIDE_BY_SIDE_HALF, "STEREO_SIDE_BY_SIDE_HALF" }, \ { DSEPF_STEREO_SIDE_BY_SIDE_HALF, "STEREO_SIDE_BY_SIDE_HALF" }, \
{ DSEPF_STEREO_TOP_AND_BOTTOM, "STEREO_TOP_AND_BOTTOM" }, \ { DSEPF_STEREO_TOP_AND_BOTTOM, "STEREO_TOP_AND_BOTTOM" }, \
{ DSEPF_STEREO_FRAME_PACKING, "STEREO_FRAME_PACKING" }, \ { DSEPF_STEREO_FRAME_PACKING, "STEREO_FRAME_PACKING" }, \
{ DSEPF_STEREO_SIDE_BY_SIDE_FULL, "STEREO_SIDE_BY_SIDE_FULL" }, \ { DSEPF_STEREO_SIDE_BY_SIDE_FULL, "STEREO_SIDE_BY_SIDE_FULL" }, \
{ DSEPF_UNKNOWN, "UNKNOWN" } \ { (DFBScreenEncoderPictureFraming) DSEPF_UNKNOWN, "UNKNOWN" } \
}; };
struct DFBAccelerationMaskName { struct DFBAccelerationMaskName {
DFBAccelerationMask mask; DFBAccelerationMask mask;
const char *name; const char *name;
}; };
#define DirectFBAccelerationMaskNames(Identifier) struct DFBAccelerationMas kName Identifier[] = { \ #define DirectFBAccelerationMaskNames(Identifier) struct DFBAccelerationMas kName Identifier[] = { \
{ DFXL_FILLRECTANGLE, "FILLRECTANGLE" }, \ { DFXL_FILLRECTANGLE, "FILLRECTANGLE" }, \
{ DFXL_DRAWRECTANGLE, "DRAWRECTANGLE" }, \ { DFXL_DRAWRECTANGLE, "DRAWRECTANGLE" }, \
skipping to change at line 647 skipping to change at line 647
{ DFXL_FILLTRAPEZOID, "FILLTRAPEZOID" }, \ { DFXL_FILLTRAPEZOID, "FILLTRAPEZOID" }, \
{ DFXL_FILLQUADRANGLE, "FILLQUADRANGLE" }, \ { DFXL_FILLQUADRANGLE, "FILLQUADRANGLE" }, \
{ DFXL_FILLSPAN, "FILLSPAN" }, \ { DFXL_FILLSPAN, "FILLSPAN" }, \
{ DFXL_DRAWMONOGLYPH, "DRAWMONOGLYPH" }, \ { DFXL_DRAWMONOGLYPH, "DRAWMONOGLYPH" }, \
{ DFXL_BLIT, "BLIT" }, \ { DFXL_BLIT, "BLIT" }, \
{ DFXL_STRETCHBLIT, "STRETCHBLIT" }, \ { DFXL_STRETCHBLIT, "STRETCHBLIT" }, \
{ DFXL_TEXTRIANGLES, "TEXTRIANGLES" }, \ { DFXL_TEXTRIANGLES, "TEXTRIANGLES" }, \
{ DFXL_BLIT2, "BLIT2" }, \ { DFXL_BLIT2, "BLIT2" }, \
{ DFXL_TILEBLIT, "TILEBLIT" }, \ { DFXL_TILEBLIT, "TILEBLIT" }, \
{ DFXL_DRAWSTRING, "DRAWSTRING" }, \ { DFXL_DRAWSTRING, "DRAWSTRING" }, \
{ DFXL_NONE, "NONE" } \ { (DFBAccelerationMask) DFXL_NONE, "NONE" } \
}; };
#endif #endif
 End of changes. 33 change blocks. 
33 lines changed or deleted 33 lines changed or added


 directfb_version.h   directfb_version.h 
skipping to change at line 34 skipping to change at line 34
License along with this library; if not, write to the License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330, Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
*/ */
#ifndef __DIRECTFB_VERSION_H__ #ifndef __DIRECTFB_VERSION_H__
#define __DIRECTFB_VERSION_H__ #define __DIRECTFB_VERSION_H__
#define DIRECTFB_MAJOR_VERSION (1) #define DIRECTFB_MAJOR_VERSION (1)
#define DIRECTFB_MINOR_VERSION (7) #define DIRECTFB_MINOR_VERSION (7)
#define DIRECTFB_MICRO_VERSION (6) #define DIRECTFB_MICRO_VERSION (7)
#define DIRECTFB_BINARY_AGE (0) #define DIRECTFB_BINARY_AGE (0)
#define DIRECTFB_INTERFACE_AGE (0) #define DIRECTFB_INTERFACE_AGE (0)
#endif /* __DIRECTFB_VERSION_H__ */ #endif /* __DIRECTFB_VERSION_H__ */
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 directfb_water_strings.h   directfb_water_strings.h 
skipping to change at line 35 skipping to change at line 35
{ WET_QUADRANGLE_STRIP, "QUADRANGLE_STRIP" }, \ { WET_QUADRANGLE_STRIP, "QUADRANGLE_STRIP" }, \
{ WET_POLYGON, "POLYGON" }, \ { WET_POLYGON, "POLYGON" }, \
{ WET_CIRCLE, "CIRCLE" }, \ { WET_CIRCLE, "CIRCLE" }, \
{ WET_ELLIPSE, "ELLIPSE" }, \ { WET_ELLIPSE, "ELLIPSE" }, \
{ WET_ARC_CIRCLE, "ARC_CIRCLE" }, \ { WET_ARC_CIRCLE, "ARC_CIRCLE" }, \
{ WET_ARC_ELLIPSE, "ARC_ELLIPSE" }, \ { WET_ARC_ELLIPSE, "ARC_ELLIPSE" }, \
{ WET_QUAD_CURVE, "QUAD_CURVE" }, \ { WET_QUAD_CURVE, "QUAD_CURVE" }, \
{ WET_QUAD_CURVE_STRIP, "QUAD_CURVE_STRIP" }, \ { WET_QUAD_CURVE_STRIP, "QUAD_CURVE_STRIP" }, \
{ WET_CUBIC_CURVE, "CUBIC_CURVE" }, \ { WET_CUBIC_CURVE, "CUBIC_CURVE" }, \
{ WET_CUBIC_CURVE_STRIP, "CUBIC_CURVE_STRIP" }, \ { WET_CUBIC_CURVE_STRIP, "CUBIC_CURVE_STRIP" }, \
{ WET_UNKNOWN, "UNKNOWN" } \ { (WaterElementType) WET_UNKNOWN, "UNKNOWN" } \
}; };
#endif #endif
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 init.h   init.h 
skipping to change at line 31 skipping to change at line 31
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330, Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
*/ */
#ifndef __FUSION__INIT_H__ #ifndef __DIRECT__INIT_H__
#define __FUSION__INIT_H__ #define __DIRECT__INIT_H__
#include <fusion/types.h> #include <direct/types.h>
__constructor__ void __Fusion_init_all ( void ); __constructor__ void __D_init_all ( void );
__destructor__ void __Fusion_deinit_all( void ); __destructor__ void __D_deinit_all( void );
#endif #endif
 End of changes. 3 change blocks. 
5 lines changed or deleted 5 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/