diff options
Diffstat (limited to 'Source/DirectFB/tools/dfblayer.c')
| -rwxr-xr-x | Source/DirectFB/tools/dfblayer.c | 625 |
1 files changed, 625 insertions, 0 deletions
diff --git a/Source/DirectFB/tools/dfblayer.c b/Source/DirectFB/tools/dfblayer.c new file mode 100755 index 0000000..6519be1 --- /dev/null +++ b/Source/DirectFB/tools/dfblayer.c @@ -0,0 +1,625 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This file is subject to the terms and conditions of the MIT License: + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <directfb.h> +#include <directfb_strings.h> + +static DirectFBPixelFormatNames( format_names ); + +/*****************************************************************************/ + +static IDirectFB *dfb; +static IDirectFBDisplayLayer *layer; +static DFBDisplayLayerDescription desc; + +/*****************************************************************************/ + +static DFBDisplayLayerID id = DLID_PRIMARY; +static int width = 0; +static int height = 0; +static DFBSurfacePixelFormat format = DSPF_UNKNOWN; +static DFBDisplayLayerBufferMode buffermode = -1; +static int opacity = -1; +static int level = 0; +static DFBBoolean set_level = DFB_FALSE; +static int rotation = 0; +static DFBBoolean set_rotation = DFB_FALSE; +static DFBSurfaceLockFlags test_lock = 0; + +/*****************************************************************************/ + +static DFBBoolean parse_command_line( int argc, char *argv[] ); +static void set_configuration ( void ); + +/*****************************************************************************/ + +int +main( int argc, char *argv[] ) +{ + DFBResult ret; + + /* Initialize DirectFB including command line parsing. */ + ret = DirectFBInit( &argc, &argv ); + if (ret) { + DirectFBError( "DirectFBInit() failed", ret ); + return -1; + } + + /* Parse the command line. */ + if (!parse_command_line( argc, argv )) + return -2; + + /* Create the super interface. */ + ret = DirectFBCreate( &dfb ); + if (ret) { + DirectFBError( "DirectFBCreate() failed", ret ); + return -3; + } + + /* Get the primary display layer. */ + ret = dfb->GetDisplayLayer( dfb, id, &layer ); + if (ret) { + if (ret == DFB_IDNOTFOUND) + fprintf (stderr, "\nUnknown layer id, check 'dfbinfo' for valid values.\n\n"); + else + DirectFBError( "IDirectFB::GetDisplayLayer() failed", ret ); + dfb->Release( dfb ); + return -4; + } + + /* Get a description of the layer. */ + ret = layer->GetDescription( layer, &desc ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::GetDescription() failed", ret ); + layer->Release( layer ); + dfb->Release( dfb ); + return -5; + } + + /* Acquire administrative cooperative level. */ + ret = layer->SetCooperativeLevel( layer, DLSCL_ADMINISTRATIVE ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::SetCooperativeLevel() failed", ret ); + layer->Release( layer ); + dfb->Release( dfb ); + return -6; + } + + /* Show/change the configuration. */ + set_configuration(); + + /* Test Lock() on layer surface? */ + if (test_lock) { + IDirectFBSurface *surface; + + fprintf( stderr, "\nGetting layer surface...\n" ); + + ret = layer->GetSurface( layer, &surface ); + if (ret) + DirectFBError( "IDirectFBDisplayLayer::GetSurface() failed", ret ); + else { + void *data; + int pitch; + + fprintf( stderr, "\nTesting Lock( %s ) on layer surface...\n", + test_lock == DSLF_READ ? "read only" : test_lock == DSLF_WRITE ? "write only" : "read/write" ); + + ret = surface->Lock( surface, test_lock, &data, &pitch ); + if (ret) + DirectFBError( "IDirectFBSurface::Lock() failed", ret ); + else + fprintf( stderr, " => OK\n\n" ); + + surface->Release( surface ); + } + } + + /* Release the display layer. */ + layer->Release( layer ); + + /* Release the super interface. */ + dfb->Release( dfb ); + + return EXIT_SUCCESS; +} + +/*****************************************************************************/ + +static void +print_usage (const char *prg_name) +{ + int i = 0; + + fprintf (stderr, "\nDirectFB Layer Configuration (version %s)\n\n", DIRECTFB_VERSION); + fprintf (stderr, "Usage: %s [options]\n\n", prg_name); + fprintf (stderr, "Options:\n"); + fprintf (stderr, " -l, --layer <id> Use the specified layer, default is primary\n"); + fprintf (stderr, " -m, --mode <width>x<height> Change the resolution (pixels)\n"); + fprintf (stderr, " -f, --format <pixelformat> Change the pixel format\n"); + fprintf (stderr, " -b, --buffer <buffermode> Change the buffer mode (single/video/system)\n"); + fprintf (stderr, " -o, --opacity <opacity> Change the layer's opacity (0-255)\n"); + fprintf (stderr, " -L, --level <level> Change the layer's level\n"); + fprintf (stderr, " -R, --rotate <degree> Change the layer rotation\n"); + fprintf (stderr, " -t, --test-lock Get layer surface and Lock() it (read/write)\n"); + fprintf (stderr, " -tr, --test-lock-read Get layer surface and Lock() it (read only)\n"); + fprintf (stderr, " -tw, --test-lock-write Get layer surface and Lock() it (write only)\n"); + fprintf (stderr, " -h, --help Show this help message\n"); + fprintf (stderr, " -v, --version Print version information\n"); + fprintf (stderr, "\n"); + + fprintf (stderr, "Known pixel formats:\n"); + + while (format_names[i].format != DSPF_UNKNOWN) { + DFBSurfacePixelFormat format = format_names[i].format; + + fprintf (stderr, " %-10s %2d bits, %d bytes", + format_names[i].name, DFB_BITS_PER_PIXEL(format), + DFB_BYTES_PER_PIXEL(format)); + + if (DFB_PIXELFORMAT_HAS_ALPHA(format)) + fprintf (stderr, " ALPHA"); + + if (DFB_PIXELFORMAT_IS_INDEXED(format)) + fprintf (stderr, " INDEXED"); + + if (DFB_PLANAR_PIXELFORMAT(format)) { + int planes = DFB_PLANE_MULTIPLY(format, 1000); + + fprintf (stderr, " PLANAR (x%d.%03d)", + planes / 1000, planes % 1000); + } + + fprintf (stderr, "\n"); + + ++i; + } + fprintf (stderr, "\n"); + + fprintf (stderr, "Valid buffer modes:\n"); + fprintf (stderr, " FRONTONLY or 'single'\n"); + fprintf (stderr, " BACKVIDEO or 'video'\n"); + fprintf (stderr, " BACKSYSTEM or 'system'\n"); + fprintf (stderr, " TRIPLE\n"); + fprintf (stderr, " WINDOWS\n"); + + fprintf (stderr, "\n"); + fprintf (stderr, "Specifying neither mode nor format just displays the current configuration.\n"); + fprintf (stderr, "\n"); +} + +static DFBBoolean +parse_layer( const char *arg ) +{ + if (sscanf( arg, "%d", &id ) != 1 || id < 0) { + fprintf (stderr, "\n" + "Invalid layer id specified!\n" + "Check 'dfbinfo' for valid values.\n\n"); + + return DFB_FALSE; + } + + return DFB_TRUE; +} + +static DFBBoolean +parse_mode( const char *arg ) +{ + if (sscanf( arg, "%dx%d", &width, &height ) != 2 || + width < 1 || height < 1) + { + fprintf (stderr, "\nInvalid mode specified!\n\n" ); + return DFB_FALSE; + } + + return DFB_TRUE; +} + +static DFBBoolean +parse_format( const char *arg ) +{ + int i = 0; + + while (format_names[i].format != DSPF_UNKNOWN) { + if (!strcasecmp( arg, format_names[i].name )) { + format = format_names[i].format; + return DFB_TRUE; + } + + ++i; + } + + fprintf (stderr, "\nInvalid format specified!\n\n" ); + + return DFB_FALSE; +} + +static DFBBoolean +parse_buffermode( const char *arg ) +{ + if (!strcasecmp( arg, "single" ) || !strcasecmp( arg, "frontonly" )) + buffermode = DLBM_FRONTONLY; + else if (!strcasecmp( arg, "system" ) || !strcasecmp( arg, "backsystem" )) + buffermode = DLBM_BACKSYSTEM; + else if (!strcasecmp( arg, "video" ) || !strcasecmp( arg, "backvideo" )) + buffermode = DLBM_BACKVIDEO; + else if (!strcasecmp( arg, "triple" )) + buffermode = DLBM_TRIPLE; + else if (!strcasecmp( arg, "windows" )) + buffermode = DLBM_WINDOWS; + else { + fprintf (stderr, "\nInvalid buffer mode specified!\n\n" ); + return DFB_FALSE; + } + + return DFB_TRUE; +} + +static DFBBoolean +parse_opacity( const char *arg ) +{ + if (sscanf( arg, "%d", &opacity ) != 1 || opacity < 0 || opacity > 255) { + fprintf (stderr, "\nInvalid opacity value specified!\n\n"); + + return DFB_FALSE; + } + + return DFB_TRUE; +} + +static DFBBoolean +parse_level( const char *arg ) +{ + if (sscanf( arg, "%d", &level ) != 1) { + fprintf (stderr, "\nInvalid level specified!\n\n"); + + return DFB_FALSE; + } + + set_level = DFB_TRUE; + + return DFB_TRUE; +} + +static DFBBoolean +parse_rotation( const char *arg ) +{ + if (sscanf( arg, "%d", &rotation ) != 1) { + fprintf (stderr, "\nInvalid rotation specified!\n\n"); + + return DFB_FALSE; + } + + set_rotation = DFB_TRUE; + + return DFB_TRUE; +} + +static DFBBoolean +parse_command_line( int argc, char *argv[] ) +{ + int n; + + for (n = 1; n < argc; n++) { + const char *arg = argv[n]; + + if (strcmp (arg, "-h") == 0 || strcmp (arg, "--help") == 0) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) { + fprintf (stderr, "dfbg version %s\n", DIRECTFB_VERSION); + return DFB_FALSE; + } + + if (strcmp (arg, "-l") == 0 || strcmp (arg, "--layer") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_layer( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-m") == 0 || strcmp (arg, "--mode") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_mode( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-f") == 0 || strcmp (arg, "--format") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_format( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-b") == 0 || strcmp (arg, "--buffer") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_buffermode( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-o") == 0 || strcmp (arg, "--opacity") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_opacity( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-L") == 0 || strcmp (arg, "--level") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_level( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-R") == 0 || strcmp (arg, "--rotate") == 0) { + if (++n == argc) { + print_usage (argv[0]); + return DFB_FALSE; + } + + if (!parse_rotation( argv[n] )) + return DFB_FALSE; + + continue; + } + + if (strcmp (arg, "-t") == 0 || strcmp (arg, "--test-lock") == 0) { + test_lock = DSLF_READ | DSLF_WRITE; + + continue; + } + + if (strcmp (arg, "-tr") == 0 || strcmp (arg, "--test-lock-read") == 0) { + test_lock = DSLF_READ; + + continue; + } + + if (strcmp (arg, "-tw") == 0 || strcmp (arg, "--test-lock-write") == 0) { + test_lock = DSLF_WRITE; + + continue; + } + + print_usage (argv[0]); + + return DFB_FALSE; + } + + return DFB_TRUE; +} + +static void +set_configuration( void ) +{ + DFBResult ret; + DFBDisplayLayerConfig config; + + printf( "\n" ); + printf( "%s\n", desc.name ); + printf( "\n" ); + + config.flags = DLCONF_NONE; + + if (width) { + config.flags |= DLCONF_WIDTH; + config.width = width; + } + + if (height) { + config.flags |= DLCONF_HEIGHT; + config.height = height; + } + + if (format != DSPF_UNKNOWN) { + config.flags |= DLCONF_PIXELFORMAT; + config.pixelformat = format; + } + + if (buffermode != -1) { + config.flags |= DLCONF_BUFFERMODE; + config.buffermode = buffermode; + } + + /* Set the configuration if anything changed. */ + if (config.flags) { + ret = layer->TestConfiguration( layer, &config, NULL ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::TestConfiguration() failed", ret ); + return; + } + + ret = layer->SetConfiguration( layer, &config ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::SetConfiguration() failed", ret ); + return; + } + } + + /* Get and show the current (new) configuration. */ + ret = layer->GetConfiguration( layer, &config ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::GetConfiguration() failed", ret ); + return; + } + + /* Set the opacity if requested. */ + if (opacity != -1) { + ret = layer->SetOpacity( layer, opacity ); + if (ret == DFB_UNSUPPORTED) + fprintf( stderr, "Opacity value (%d) not supported!\n\n", opacity ); + else if (ret) + DirectFBError( "IDirectFBDisplayLayer::SetOpacity() failed", ret ); + } + + /* Set the level if requested. */ + if (set_level) { + ret = layer->SetLevel( layer, level ); + if (ret == DFB_UNSUPPORTED) + fprintf( stderr, "Level (%d) not supported!\n\n", level ); + else if (ret) + DirectFBError( "IDirectFBDisplayLayer::SetLevel() failed", ret ); + } + + /* Set the rotation if requested. */ + if (set_rotation) { + ret = layer->SetRotation( layer, rotation ); + if (ret == DFB_UNSUPPORTED) + fprintf( stderr, "Rotation (%d) not supported!\n\n", level ); + else if (ret) + DirectFBError( "IDirectFBDisplayLayer::SetRotation() failed", ret ); + } + + + if (config.flags & DLCONF_WIDTH) + printf( "Width %d\n", config.width ); + + if (config.flags & DLCONF_HEIGHT) + printf( "Height %d\n", config.height ); + + if (config.flags & DLCONF_PIXELFORMAT) + printf( "Format %s\n", + format_names[DFB_PIXELFORMAT_INDEX(config.pixelformat)].name ); + + if (config.flags & DLCONF_BUFFERMODE) { + printf( "Buffermode " ); + + switch (config.buffermode) { + case DLBM_FRONTONLY: + printf( "FRONTONLY\n" ); + break; + case DLBM_BACKVIDEO: + printf( "BACKVIDEO\n" ); + break; + case DLBM_BACKSYSTEM: + printf( "BACKSYSTEM\n" ); + break; + case DLBM_TRIPLE: + printf( "TRIPLE\n" ); + break; + case DLBM_WINDOWS: + printf( "WINDOWS\n" ); + break; + default: + printf( "unknown!\n" ); + break; + } + } + + if (config.flags & DLCONF_OPTIONS) { + printf( "Options " ); + + if (config.options == DLOP_NONE) { + printf( "none\n" ); + } + else { + if (config.options & DLOP_ALPHACHANNEL) + printf( "ALPHA CHANNEL " ); + + if (config.options & DLOP_DEINTERLACING) + printf( "DEINTERLACING " ); + + if (config.options & DLOP_DST_COLORKEY) + printf( "DST COLOR KEY " ); + + if (config.options & DLOP_FIELD_PARITY) + printf( "FIELD PARITY " ); + + if (config.options & DLOP_FLICKER_FILTERING) + printf( "FLICKER FILTERING " ); + + if (config.options & DLOP_OPACITY) + printf( "OPACITY " ); + + if (config.options & DLOP_SRC_COLORKEY) + printf( "SRC COLOR KEY " ); + + printf( "\n" ); + } + } + + /* Query current level. */ + if (desc.caps & DLCAPS_LEVELS) { + int l; + + ret = layer->GetLevel( layer, &l ); + if (ret) + DirectFBError( "IDirectFBDisplayLayer::GetLevel() failed", ret ); + else + printf( "Level %d\n", l ); + } + + printf( "\n" ); +} + |