Skip to content

V
vlc-gpu
Commit 4c1e4249 authored by Vincent Seguin's avatar Vincent Seguin
Browse files
Options

GGI fonctionnel. N'oubliez pas de d�finit GII_INPUT. 

Nettoyage de video_* et intf_*.
parent fa66a86a
Hide whitespace changes
Inline Side-by-side
Showing with 547 additions and 339 deletions
Makefile
View file @ 4c1e4249
......@@ -17,7 +17,7 @@
VIDEO=X11
#VIDEO=DGA (not yet supported)
#VIDEO=FB
#VIDEO=GGI (not yet supported)
#VIDEO=GGI
#VIDEO=BEOS (not yet supported)
# Target architecture and optimization
......@@ -69,7 +69,9 @@ ifeq ($(VIDEO),X11)
LIB += -L/usr/X11R6/lib
LIB += -lX11
LIB += -lXext
LIB += -lXpm
endif
ifeq ($(VIDEO),GGI)
LIB += -lggi
endif
# System dependant libraries
......@@ -265,7 +267,7 @@ vlc: $(C_OBJ) $(ASM_OBJ)
# Generic rules (see below)
#
$(dependancies): %.d: FORCE
@make -s --no-print-directory -f Makefile.dep $@
@$(MAKE) -s --no-print-directory -f Makefile.dep $@
$(C_OBJ): %.o: dep/%.d
......
include/config.h
View file @ 4c1e4249
......@@ -29,6 +29,8 @@
#define VIDEO_OPTIONS "X11"
#elif defined(VIDEO_FB)
#define VIDEO_OPTIONS "Framebuffer"
#elif defined(VIDEO_GGI)
#define VIDEO_OPTIONS "GGI"
#else
#define VIDEO_OPTIONS ""
#endif
......@@ -47,8 +49,6 @@
* General compilation options
*******************************************************************************/
#define FRAMEBUFFER
/* Define for DVB support - Note that some extensions or restrictions may be
* incompatible with native MPEG2 streams */
//#define DVB_EXTENSIONS
......
include/video_output.h
View file @ 4c1e4249
......@@ -5,20 +5,14 @@
* This module describes the programming interface for video output threads.
* It includes functions allowing to open a new thread, send pictures to a
* thread, and destroy a previously oppenned video output thread.
*******************************************************************************
* Requires:
* "config.h"
* "common.h"
* "mtime.h"
* "vlc_thread.h"
* "video.h"
*******************************************************************************/
/*******************************************************************************
* vout_thread_t: video output thread descriptor
*******************************************************************************
* Any independant video output device, such as an X11 window, is represented
* by a video output thread, and described using following structure.
* Any independant video output device, such as an X11 window or a GGI device,
* is represented by a video output thread, and described using following
* structure.
*******************************************************************************/
typedef struct vout_thread_s
{
......@@ -38,13 +32,6 @@ typedef struct vout_thread_s
float f_x_ratio; /* horizontal display ratio */
float f_y_ratio; /* vertical display ratio */
/* Output method */
p_vout_sys_t p_sys; /* system output method */
/* Video heap */
int i_pictures; /* current heap size */
picture_t p_picture[VOUT_MAX_PICTURES]; /* pictures */
#ifdef STATS
/* Statistics */
count_t c_loops; /* number of loops */
......@@ -52,6 +39,13 @@ typedef struct vout_thread_s
count_t c_pictures; /* number of pictures added to heap */
#endif
/* Output method */
p_vout_sys_t p_sys; /* system output method */
/* Video heap */
int i_pictures; /* current heap size */
picture_t p_picture[VOUT_MAX_PICTURES]; /* pictures */
/* YUV translation tables, for 15,16 and 24/32 bpp displays. 16 bits and 32
* bits pointers points on the same data.
* CAUTION: these tables are translated: their origin is -384 */
......@@ -61,37 +55,14 @@ typedef struct vout_thread_s
u32 * pi_trans32_red;
u32 * pi_trans32_green;
u32 * pi_trans32_blue;
/* Rendering functions - these functions are of vout_render_blank_t and
* vout_render_line_t, but are not declared here using these types since
* they require vout_thread_t to be defined */
/* void (* RenderRGBBlank) ( struct vout_thread_s *p_vout, pixel_t pixel,
int i_x, int i_y, int i_width, int i_height );
void (* RenderPixelBlank) ( struct vout_thread_s *p_vout, pixel_t pixel,
int i_x, int i_y, int i_width, int i_height );
void (* RenderRGBLine) ( struct vout_thread_s *p_vout, picture_t *p_pic,
int i_x, int i_y, int i_pic_x, int i_pic_y,
int i_width, int i_line_width, int i_ratio );
void (* RenderPixelLine) ( struct vout_thread_s *p_vout, picture_t *p_pic,
int i_x, int i_y, int i_pic_x, int i_pic_y,
int i_width, int i_line_width, int i_ratio );
void (* RenderRGBMaskLine) ( struct vout_thread_s *p_vout, picture_t *p_pic,
int i_x, int i_y, int i_pic_x, int i_pic_y,
int i_width, int i_line_width, int i_ratio );
void (* RenderPixelMaskLine) ( struct vout_thread_s *p_vout, picture_t *p_pic,
int i_x, int i_y, int i_pic_x, int i_pic_y,
int i_width, int i_line_width, int i_ratio );
*/ /* ?? add YUV types */
} vout_thread_t;
/*******************************************************************************
* Prototypes
*******************************************************************************/
vout_thread_t * vout_CreateThread (
#if defined(VIDEO_X11)
#ifdef VIDEO_X11
char *psz_display, Window root_window,
#elif defined(VIDEO_FB)
//??void
#endif
int i_width, int i_height, int *pi_status
);
......@@ -105,9 +76,6 @@ void vout_DisplayPicture ( vout_thread_t *p_vout, picture
void vout_LinkPicture ( vout_thread_t *p_vout, picture_t *p_pic );
void vout_UnlinkPicture ( vout_thread_t *p_vout, picture_t *p_pic );
#ifdef DEBUG
void vout_PrintHeap ( vout_thread_t *p_vout, char *psz_str );
#endif
......
include/video_sys.h
View file @ 4c1e4249
......@@ -6,11 +6,11 @@
/*******************************************************************************
* Prototypes
*******************************************************************************/
#if defined(VIDEO_X11)
int vout_SysCreate ( p_vout_thread_t p_vout, char *psz_display, Window root_window );
#elif defined(VIDEO_FB)
int vout_SysCreate ( p_vout_thread_t p_vout );
int vout_SysCreate ( p_vout_thread_t p_vout
#ifdef VIDEO_X11
, char *psz_display, Window root_window
#endif
);
int vout_SysInit ( p_vout_thread_t p_vout );
void vout_SysEnd ( p_vout_thread_t p_vout );
void vout_SysDestroy ( p_vout_thread_t p_vout );
......
include/vlc.h
View file @ 4c1e4249
......@@ -22,12 +22,13 @@
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <sys/shm.h>
#include <sys/soundcard.h>
......
src/audio_decoder/audio_decoder.c
View file @ 4c1e4249
......@@ -15,6 +15,8 @@
#include <stdio.h> /* "intf_msg.h" */
#include <stdlib.h> /* malloc(), free() */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> /* ntohl() */
#include <sys/soundcard.h> /* "audio_output.h" */
#include <sys/uio.h> /* "input.h" */
......
src/audio_decoder/audio_math.c
View file @ 4c1e4249
......@@ -8,6 +8,8 @@
#include <unistd.h>
#include <stdio.h> /* "intf_msg.h" */
#include <stdlib.h> /* malloc(), free() */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> /* ntohl() */
#include <sys/soundcard.h> /* "audio_output.h" */
#include <sys/uio.h>
......
src/input/input_file.c
View file @ 4c1e4249
......@@ -6,6 +6,7 @@
/*******************************************************************************
* Preamble
*******************************************************************************/
#include <sys/types.h>
#include <sys/uio.h>
#include "common.h"
......
src/input/input_netlist.c
View file @ 4c1e4249
......@@ -8,6 +8,7 @@
/*******************************************************************************
* Preamble
*******************************************************************************/
#include <sys/types.h>
#include <sys/uio.h>
#include <stdlib.h>
#include <stdio.h>
......
src/input/input_network.c
View file @ 4c1e4249
......@@ -8,6 +8,7 @@
/*******************************************************************************
* Preamble
*******************************************************************************/
#include <sys/types.h>
#include <sys/uio.h>
#include <string.h>
#include <stdio.h>
......@@ -17,7 +18,6 @@
#include <netinet/in.h> /* sockaddr_in, htons(), htonl() */
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include "common.h"
......
src/input/input_pcr.c
View file @ 4c1e4249
......@@ -9,8 +9,10 @@
* Preamble
*******************************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <sys/uio.h> /* iovec */
#include <stdlib.h> /* atoi(), malloc(), free() */
#include <sys/socket.h>
#include <netinet/in.h>
#include "config.h"
......
src/interface/interface.c
View file @ 4c1e4249
......@@ -12,6 +12,8 @@
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/uio.h> /* for input.h */
#include "config.h"
......@@ -42,32 +44,32 @@ intf_thread_t* intf_Create( void )
p_intf = malloc( sizeof( intf_thread_t ) );
if( !p_intf )
{
errno = ENOMEM;
intf_ErrMsg("error: %s\n", strerror( ENOMEM ) );
return( NULL );
}
p_intf->b_die = 0;
intf_DbgMsg( "0x%x\n", p_intf );
/* Initialize structure */
p_intf->p_vout = NULL;
p_intf->p_input = NULL;
p_intf->b_die = 0;
p_intf->p_vout = NULL;
p_intf->p_input = NULL;
/* Start interfaces */
p_intf->p_console = intf_ConsoleCreate();
if( p_intf->p_console == NULL )
{
intf_ErrMsg("intf error: can't create control console\n");
intf_ErrMsg("error: can't create control console\n");
free( p_intf );
return( NULL );
}
if( intf_SysCreate( p_intf ) )
{
intf_ErrMsg("intf error: can't create interface\n");
intf_ErrMsg("error: can't create interface\n");
intf_ConsoleDestroy( p_intf->p_console );
free( p_intf );
return( NULL );
}
intf_Msg("Interface initialized\n");
return( p_intf );
}
......@@ -78,13 +80,11 @@ intf_thread_t* intf_Create( void )
*******************************************************************************/
void intf_Run( intf_thread_t *p_intf )
{
intf_DbgMsg("0x%x begin\n", p_intf );
/* Execute the initialization script - if a positive number is returned,
* the script could be executed but failed */
if( intf_ExecScript( main_GetPszVariable( INTF_INIT_SCRIPT_VAR, INTF_INIT_SCRIPT_DEFAULT ) ) > 0 )
{
intf_ErrMsg("intf error: error during initialization script\n");
intf_ErrMsg("warning: error(s) during startup script\n");
}
/* Main loop */
......@@ -100,8 +100,6 @@ void intf_Run( intf_thread_t *p_intf )
* keyboard events, a 100ms delay is a good compromise */
msleep( INTF_IDLE_SLEEP );
}
intf_DbgMsg("0x%x end\n", p_intf );
}
/*******************************************************************************
......@@ -111,8 +109,6 @@ void intf_Run( intf_thread_t *p_intf )
*******************************************************************************/
void intf_Destroy( intf_thread_t *p_intf )
{
intf_DbgMsg("0x%x\n", p_intf );
/* Destroy interfaces */
intf_SysDestroy( p_intf );
intf_ConsoleDestroy( p_intf->p_console );
......
src/interface/intf_ctrl.c
View file @ 4c1e4249
......@@ -25,6 +25,7 @@
* Preamble
*******************************************************************************/
#include "vlc.h"
#include <sys/stat.h>
/*??#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
......@@ -33,7 +34,6 @@
#include <string.h>
#include <unistd.h>
#include <sys/soundcard.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <X11/Xlib.h>
#include <X11/extensions/XShm.h>
......
src/misc/netutils.c
View file @ 4c1e4249
......@@ -17,10 +17,11 @@
#include <errno.h>
#include <string.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/if.h>
#include "config.h"
#include "common.h"
......
src/video_output/video_ggi.c 0 → 100644
View file @ 4c1e4249
/*******************************************************************************
* vout_ggi.c: GGI video output display method
* (c)1998 VideoLAN
*******************************************************************************/
/*******************************************************************************
* Preamble
*******************************************************************************/
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <ggi/ggi.h>
#include "config.h"
#include "common.h"
#include "mtime.h"
#include "vlc_thread.h"
#include "video.h"
#include "video_output.h"
#include "video_sys.h"
#include "intf_msg.h"
/*******************************************************************************
* vout_sys_t: video output GGI method descriptor
*******************************************************************************
* This structure is part of the video output thread descriptor.
* It describes the GGI specific properties of an output thread.
*******************************************************************************/
typedef struct vout_sys_s
{
/* GGI system informations */
ggi_visual_t p_display; /* display device */
/* Buffer index */
int i_buffer_index;
} vout_sys_t;
/*******************************************************************************
* Local prototypes
*******************************************************************************/
static int GGIOpenDisplay ( vout_thread_t *p_vout );
static void GGICloseDisplay ( vout_thread_t *p_vout );
/*******************************************************************************
* vout_SysCreate: allocate GGI video thread output method
*******************************************************************************
* This function allocate and initialize a GGI vout method. It uses some of the
* vout properties to choose the correct mode, and change them according to the
* mode actually used.
*******************************************************************************/
int vout_SysCreate( vout_thread_t *p_vout )
{
/* Allocate structure */
p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
if( p_vout->p_sys == NULL )
{
intf_ErrMsg("error: %s\n", strerror(ENOMEM) );
return( 1 );
}
/* Open and initialize device */
if( GGIOpenDisplay( p_vout ) )
{
intf_ErrMsg("error: can't initialize GGI display\n");
free( p_vout->p_sys );
return( 1 );
}
return( 0 );
}
/*******************************************************************************
* vout_SysInit: initialize GGI video thread output method
*******************************************************************************
* This function initialize the GGI display device.
*******************************************************************************/
int vout_SysInit( vout_thread_t *p_vout )
{
p_vout->p_sys->i_buffer_index = 0;
return( 0 );
}
/*******************************************************************************
* vout_SysEnd: terminate Sys video thread output method
*******************************************************************************
* Terminate an output method created by vout_SysCreateOutputMethod
*******************************************************************************/
void vout_SysEnd( vout_thread_t *p_vout )
{
;
}
/*******************************************************************************
* vout_SysDestroy: destroy Sys video thread output method
*******************************************************************************
* Terminate an output method created by vout_SysCreateOutputMethod
*******************************************************************************/
void vout_SysDestroy( vout_thread_t *p_vout )
{
GGICloseDisplay( p_vout );
free( p_vout->p_sys );
}
/*******************************************************************************
* vout_SysManage: handle Sys events
*******************************************************************************
* This function should be called regularly by video output thread. It returns
* a negative value if something happened which does not allow the thread to
* continue, and a positive one if the thread can go on, but the images have
* been modified and therefore it is useless to display them.
*******************************************************************************/
int vout_SysManage( vout_thread_t *p_vout )
{
//??
return( 0 );
}
/*******************************************************************************
* vout_SysDisplay: displays previously rendered output
*******************************************************************************
* This function send the currently rendered image to the display, wait until
* it is displayed and switch the two rendering buffer, preparing next frame.
*******************************************************************************/
void vout_SysDisplay( vout_thread_t *p_vout )
{
/* Change display frame */
ggiFlush( p_vout->p_sys->p_display ); // ??
ggiSetDisplayFrame( p_vout->p_sys->p_display, p_vout->p_sys->i_buffer_index );
/* Swap buffers and change write frame */
p_vout->p_sys->i_buffer_index = ++p_vout->p_sys->i_buffer_index & 1;
ggiSetWriteFrame( p_vout->p_sys->p_display, p_vout->p_sys->i_buffer_index );
}
/*******************************************************************************
* vout_SysGetPicture: get current display buffer informations
*******************************************************************************
* This function returns the address of the current display buffer, and the
* number of samples per line. For 15, 16 and 32 bits displays, this value is
* the number of pixels in a line.
*******************************************************************************/
byte_t * vout_SysGetPicture( vout_thread_t *p_vout, int *pi_eol_offset )
{
*pi_eol_offset = p_vout->i_width;
//????
// return( p_vout->p_sys->p_ximage[ p_vout->p_sys->i_buffer_index ].data );
}
/* following functions are local */
/*******************************************************************************
* GGIOpenDisplay: open and initialize GGI device
*******************************************************************************
* Open and initialize display according to preferences specified in the vout
* thread fields.
*******************************************************************************/
static int GGIOpenDisplay( vout_thread_t *p_vout )
{
ggi_mode mode; /* mode descriptor */
/* Initialize library */
if( ggiInit() )
{
intf_ErrMsg("error: can't initialize GGI library\n");
return( 1 );
}
/* Open display */
p_vout->p_sys->p_display = ggiOpen( NULL );
if( p_vout->p_sys->p_display == NULL )
{
intf_ErrMsg("error: can't open GGI default display\n");
ggiExit();
return( 1 );
}
/* Find most appropriate mode */
mode.frames = 2; /* 2 buffers */
mode.visible.x = p_vout->i_width; /* minimum width */
mode.visible.y = p_vout->i_width; /* maximum width */
mode.virt.x = GGI_AUTO;
mode.virt.y = GGI_AUTO;
mode.size.x = GGI_AUTO;
mode.size.y = GGI_AUTO;
mode.graphtype = GT_15BIT; /* minimum usable screen depth */
mode.dpp.x = GGI_AUTO;
mode.dpp.y = GGI_AUTO;
ggiCheckMode( p_vout->p_sys->p_display, &mode );
/* Check that returned mode has some minimum properties */
//??
/* Set mode */
if( ggiSetMode( p_vout->p_sys->p_display, &mode ) )
{
intf_ErrMsg("error: can't set GGI mode\n");
ggiClose( p_vout->p_sys->p_display );
ggiExit();
return( 1 );
}
/* Set thread information */
p_vout->i_width = mode.visible.x;
p_vout->i_height = mode.visible.y;
switch( mode.graphtype )
{
case GT_15BIT:
p_vout->i_screen_depth = 15;
p_vout->i_bytes_per_pixel = 2;
break;
case GT_16BIT:
p_vout->i_screen_depth = 16;
p_vout->i_bytes_per_pixel = 2;
break;
case GT_24BIT:
p_vout->i_screen_depth = 24;
p_vout->i_bytes_per_pixel = 3;
break;
case GT_32BIT:
p_vout->i_screen_depth = 32;
p_vout->i_bytes_per_pixel = 4;
break;
default:
intf_ErrMsg("error: unsupported screen depth\n");
ggiClose( p_vout->p_sys->p_display );
ggiExit();
return( 1 );
break;
}
return( 0 );
}
/*******************************************************************************
* GGICloseDisplay: close and reset GGI device
*******************************************************************************
* This function returns all resources allocated by GGIOpenDisplay and restore
* the original state of the device.
*******************************************************************************/
static void GGICloseDisplay( vout_thread_t *p_vout )
{
// Restore original mode and close display
ggiClose( p_vout->p_sys->p_display );
// Exit library
ggiExit();
}
src/video_output/video_output.c
View file @ 4c1e4249
......@@ -36,12 +36,12 @@
* (0 or 255) */
#define CLIP_BYTE( i_val ) ( (i_val < 0) ? 0 : ((i_val > 255) ? 255 : i_val) )
/* YUV_TRANSFORM_16: parametric macro. Due to the high performance need of this
* loop, all possible conditions evaluations are made outside the transformation
* loop. However, the code does not change much for two different loops. This
* macro allows to change slightly the content of the loop without having to
* copy and paste code. It is used in RenderYUVPicture function.
*/
/* YUV_TRANSFORM: parametric macro for YUV transformation.
* Due to the high performance need of this loop, all possible conditions
* evaluations are made outside the transformation loop. However, the code does
* not change much for two different loops. This macro allows to change slightly
* the content of the loop without having to copy and paste code. It is used in
* RenderYUVPicture function. */
#define YUV_TRANSFORM( CHROMA, TRANS_RED, TRANS_GREEN, TRANS_BLUE, P_PIC ) \
/* Main loop */ \
for (i_pic_y=0; i_pic_y < p_pic->i_height ; i_pic_y++) \
......@@ -97,11 +97,10 @@ int matrix_coefficients_table[8][4] =
/*******************************************************************************
* Local prototypes
*******************************************************************************/
static int InitThread ( vout_thread_t *p_vout );
static void RunThread ( vout_thread_t *p_vout );
static void ErrorThread ( vout_thread_t *p_vout );
static void EndThread ( vout_thread_t *p_vout );
static int InitThread ( vout_thread_t *p_vout );
static void RunThread ( vout_thread_t *p_vout );
static void ErrorThread ( vout_thread_t *p_vout );
static void EndThread ( vout_thread_t *p_vout );
static void RenderPicture ( vout_thread_t *p_vout, picture_t *p_pic );
static void RenderYUVPicture( vout_thread_t *p_vout, picture_t *p_pic );
......@@ -110,22 +109,12 @@ static void RenderYUVPicture( vout_thread_t *p_vout, picture_t *p_pic );
*******************************************************************************
* This function creates a new video output thread, and returns a pointer
* to its description. On error, it returns NULL.
* Following configuration properties are used:
* VIDEO_CFG_SIZE video heap maximal size
* VIDEO_CFG_WIDTH window width
* VIDEO_CFG_HEIGHT window height
* Using X11 display method (the only one supported yet):
* VIDEO_CFG_DISPLAY display used
* VIDEO_CFG_TITLE window title
* VIDEO_CFG_SHM_EXT try to use XShm extension
* If pi_status is NULL, then the function will block until the thread is ready.
* If not, pi_error will be updated using one of the THREAD_* constants.
* If not, it will be updated using one of the THREAD_* constants.
*******************************************************************************/
vout_thread_t * vout_CreateThread (
#if defined(VIDEO_X11)
#ifdef VIDEO_X11
char *psz_display, Window root_window,
#elif defined(VIDEO_FB)
//??
#endif
int i_width, int i_height, int *pi_status
)
......@@ -133,45 +122,67 @@ vout_thread_t * vout_CreateThread (
vout_thread_t * p_vout; /* thread descriptor */
int i_status; /* thread status */
/* Allocate descriptor and create method */
/* Allocate descriptor */
p_vout = (vout_thread_t *) malloc( sizeof(vout_thread_t) );
if( p_vout == NULL ) /* error */
if( p_vout == NULL )
{
intf_ErrMsg("error: %s\n", strerror(ENOMEM));
return( NULL );
}
intf_DbgMsg( "%p\n", p_vout );
/* Initialize some fields used by the system-dependant method - these fields will
* probably be modified by the method */
p_vout->i_width = i_width;
p_vout->i_height = i_height;
p_vout->i_screen_depth = 15;
p_vout->i_bytes_per_pixel = 2;
p_vout->f_x_ratio = 1;
p_vout->f_y_ratio = 1;
intf_DbgMsg("wished configuration: %dx%dx%d (%d bytes per pixel), ratio %f:%f\n",
p_vout->i_width, p_vout->i_height, p_vout->i_screen_depth,
p_vout->i_bytes_per_pixel, p_vout->f_x_ratio, p_vout->f_y_ratio );
/* Create and initialize system-dependant method - this function issues its
* own error messages */
if( vout_SysCreate( p_vout
#if defined(VIDEO_X11)
, psz_display, root_window
#elif defined(VIDEO_FB)
//??
#endif
) )
{
free( p_vout );
return( NULL );
}
intf_DbgMsg("actual configuration: %dx%dx%d (%d bytes per pixel), ratio %f:%f\n",
p_vout->i_width, p_vout->i_height, p_vout->i_screen_depth,
p_vout->i_bytes_per_pixel, p_vout->f_x_ratio, p_vout->f_y_ratio );
/* Initialize */
p_vout->i_width = i_width;
p_vout->i_height = i_height;
p_vout->pi_status = (pi_status != NULL) ? pi_status : &i_status;
*p_vout->pi_status = THREAD_CREATE;
p_vout->b_die = 0;
p_vout->b_error = 0;
p_vout->b_active = 0;
/* Terminate the initialization */
p_vout->b_die = 0;
p_vout->b_error = 0;
p_vout->b_active = 0;
p_vout->pi_status = (pi_status != NULL) ? pi_status : &i_status;
*p_vout->pi_status = THREAD_CREATE;
#ifdef STATS
p_vout->c_loops = 0;
p_vout->c_idle_loops = 0;
p_vout->c_pictures = 0;
#endif
/* Create thread and set locks */
vlc_mutex_init( &p_vout->lock );
if( vlc_thread_create( &p_vout->thread_id, "video output",
(void *) RunThread, (void *) p_vout) )
{
intf_ErrMsg("vout error: %s\n", strerror(ENOMEM));
intf_ErrMsg("error: %s\n", strerror(ENOMEM));
vout_SysDestroy( p_vout );
free( p_vout );
return( NULL );
}
intf_Msg("Video: display initialized (%dx%d, %d bpp)\n",
p_vout->i_width, p_vout->i_height, p_vout->i_screen_depth );
/* If status is NULL, wait until the thread is created */
if( pi_status == NULL )
{
......@@ -185,7 +196,6 @@ vout_thread_t * vout_CreateThread (
return( NULL );
}
}
return( p_vout );
}
......@@ -201,8 +211,6 @@ void vout_DestroyThread( vout_thread_t *p_vout, int *pi_status )
{
int i_status; /* thread status */
intf_DbgMsg( "%p\n", p_vout );
/* Set status */
p_vout->pi_status = (pi_status != NULL) ? pi_status : &i_status;
*p_vout->pi_status = THREAD_DESTROY;
......@@ -313,7 +321,7 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, int i_type,
/* Allocate memory */
switch( i_type )
{
case YUV_420_PICTURE: /* YUV picture: 3*16 ?? bits per pixel */
case YUV_420_PICTURE: /* YUV picture: bits per pixel */
case YUV_422_PICTURE:
case YUV_444_PICTURE:
p_free_picture->p_data = malloc( 3 * i_height * i_bytes_per_line );
......@@ -323,8 +331,9 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, int i_type,
break;
#ifdef DEBUG
default:
intf_DbgMsg("%p error: unknown picture type %d\n", p_vout, i_type );
p_free_picture->p_data = NULL;
intf_DbgMsg("unknown picture type %d\n", i_type );
p_free_picture->p_data = NULL;
break;
#endif
}
......@@ -342,10 +351,10 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, int i_type,
else
{
/* Memory allocation failed : set picture as empty */
p_free_picture->i_type = EMPTY_PICTURE;
p_free_picture->i_status = FREE_PICTURE;
p_free_picture = NULL;
intf_DbgMsg("%p malloc for new picture failed\n", p_vout );
p_free_picture->i_type = EMPTY_PICTURE;
p_free_picture->i_status = FREE_PICTURE;
p_free_picture = NULL;
intf_ErrMsg("warning: %s\n", strerror( ENOMEM ) );
}
vlc_mutex_unlock( &p_vout->lock );
......@@ -353,7 +362,7 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, int i_type,
}
// No free or destroyed picture could be found
intf_DbgMsg("%p no picture available\n", p_vout );
intf_DbgMsg( "heap is full\n" );
vlc_mutex_unlock( &p_vout->lock );
return( NULL );
}
......@@ -368,11 +377,7 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, int i_type,
void vout_DestroyPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
vlc_mutex_lock( &p_vout->lock );
/* Mark picture for destruction */
p_pic->i_status = DESTROYED_PICTURE;
intf_DbgMsg("%p picture %p destroyed\n", p_vout, p_pic );
vlc_mutex_unlock( &p_vout->lock );
}
......@@ -423,24 +428,15 @@ static int InitThread( vout_thread_t *p_vout )
*p_vout->pi_status = THREAD_START;
/* Initialize pictures */
p_vout->i_pictures = 0;
for( i_index = 0; i_index < VOUT_MAX_PICTURES; i_index++)
{
p_vout->p_picture[i_index].i_type = EMPTY_PICTURE;
p_vout->p_picture[i_index].i_status= FREE_PICTURE;
}
/* Initialize other properties */
p_vout->i_pictures = 0;
#ifdef STATS
p_vout->c_loops = 0;
p_vout->c_idle_loops = 0;
p_vout->c_pictures = 0;
p_vout->c_rendered_pictures = 0;
#endif
/* Initialize output method - width, height, screen depth and bytes per
* pixel are initialized by this call. */
if( vout_SysInit( p_vout ) ) /* error */
/* Initialize output method - this function issues its own error messages */
if( vout_SysInit( p_vout ) )
{
*p_vout->pi_status = THREAD_ERROR;
return( 1 );
......@@ -454,9 +450,17 @@ static int InitThread( vout_thread_t *p_vout )
break;
case 3: /* 24 or 32 bpp, use 32 bits translations tables */
case 4:
#ifndef DEBUG
default:
#endif
i_pixel_size = sizeof( u32 );
break;
break;
#ifdef DEBUG
default:
intf_DbgMsg("invalid bytes_per_pixel %d\n", p_vout->i_bytes_per_pixel );
i_pixel_size = sizeof( u32 );
break;
#endif
}
p_vout->pi_trans32_red = (u32 *)p_vout->pi_trans16_red =
(u16 *)malloc( 1024 * i_pixel_size );
......@@ -468,7 +472,7 @@ static int InitThread( vout_thread_t *p_vout )
(p_vout->pi_trans16_green == NULL ) ||
(p_vout->pi_trans16_blue == NULL ) )
{
intf_ErrMsg("vout error: %s\n", strerror(ENOMEM) );
intf_ErrMsg("error: %s\n", strerror(ENOMEM) );
*p_vout->pi_status = THREAD_ERROR;
if( p_vout->pi_trans16_red != NULL )
{
......@@ -521,11 +525,17 @@ static int InitThread( vout_thread_t *p_vout )
p_vout->pi_trans32_blue[i_index] = CLIP_BYTE( i_index ) ;
}
break;
#ifdef DEBUG
default:
intf_DbgMsg("invalid screen depth %d\n", p_vout->i_screen_depth );
break;
#endif
}
/* Mark thread as running and return */
*p_vout->pi_status = THREAD_READY;
intf_DbgMsg("%p -> succeeded\n", p_vout);
p_vout->b_active = 1;
*p_vout->pi_status = THREAD_READY;
intf_DbgMsg("thread ready");
return(0);
}
......@@ -541,15 +551,11 @@ static void RunThread( vout_thread_t *p_vout)
int i_picture; /* picture index */
int i_err; /* error code */
mtime_t current_date; /* current date */
picture_t * p_pic = NULL;
#ifdef VOUT_DEBUG
char sz_date[MSTRTIME_MAX_SIZE]; /* date buffer */
#endif
picture_t * p_pic = NULL; /* picture pointer */
/*
* Initialize thread and free configuration
*/
intf_DbgMsg( "%p begin\n", p_vout );
p_vout->b_error = InitThread( p_vout );
if( p_vout->b_error )
{
......@@ -603,7 +609,7 @@ static void RunThread( vout_thread_t *p_vout)
p_pic->i_status = DESTROYED_PICTURE;
}
vlc_mutex_unlock( &p_vout->lock );
intf_ErrMsg( "vout error: picture %p was late - skipped\n", p_pic );
intf_ErrMsg( "warning: late picture skipped\n" );
p_pic = NULL;
}
else if( p_pic->date > current_date + VOUT_DISPLAY_DELAY )
......@@ -683,7 +689,7 @@ static void RunThread( vout_thread_t *p_vout)
/* End of thread */
EndThread( p_vout );
intf_DbgMsg( "%p end\n", p_vout );
intf_DbgMsg( "thread end\n" );
}
/*******************************************************************************
......@@ -734,12 +740,11 @@ static void EndThread( vout_thread_t *p_vout )
/* Destroy thread structures allocated by InitThread */
vout_SysEnd( p_vout );
vout_SysDestroy( p_vout ); /* destroy output method */
vout_SysDestroy( p_vout );
free( p_vout );
/* Update status */
*pi_status = THREAD_OVER;
intf_DbgMsg("%p\n", p_vout);
}
/*******************************************************************************
......@@ -759,18 +764,19 @@ static void RenderPicture( vout_thread_t *p_vout, picture_t *p_pic )
case YUV_444_PICTURE:
RenderYUVPicture( p_vout, p_pic );
break;
}
intf_DbgMsg("%p Picture %p type=%d, %dx%d\n",
p_vout, p_pic, p_pic->i_type, p_pic->i_width, p_pic->i_height );
/*???*/
#ifdef DEBUG
default:
intf_DbgMsg("unknown picture type %d\n", p_pic->i_type );
break;
#endif
}
}
/*******************************************************************************
* RenderYUVPicture: render a YUV picture
*******************************************************************************
* Performs the YUV convertion.
* Performs the YUV convertion. The picture sent to this function should only
* have YUV_420, YUV_422 or YUV_444 types.
*******************************************************************************/
static void RenderYUVPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
......@@ -893,6 +899,11 @@ static void RenderYUVPicture( vout_thread_t *p_vout, picture_t *p_pic )
break;
}
break;
#ifdef DEBUG
default:
intf_DbgMsg("invalid screen depth %d\n", p_vout->i_screen_depth );
break;
#endif
}
}
src/video_output/video_x11.c
View file @ 4c1e4249
/*******************************************************************************
* vout_x11.c: X11 video output display method
* (c)1998 VideoLAN
*******************************************************************************
* The X11 method for video output thread. It's properties (and the vout_x11_t
* type) are defined in vout.h. The functions declared here should not be
* needed by any other module than vout.c.
*******************************************************************************/
/*******************************************************************************
......@@ -14,6 +10,8 @@
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
......@@ -23,6 +21,7 @@
#include "common.h"
#include "mtime.h"
#include "vlc_thread.h"
#include "video.h"
#include "video_output.h"
#include "video_sys.h"
......@@ -48,12 +47,6 @@ typedef struct vout_sys_s
Window window; /* window instance handler */
GC gc; /* graphic context instance handler */
/* Color maps and translation tables - some of those tables are shifted,
* see x11.c for more informations. */
u8 * trans_16bpp_red; /* red (16 bpp) (SHIFTED !) */
u8 * trans_16bpp_green; /* green (16 bpp) (SHIFTED !) */
u8 * trans_16bpp_blue; /* blue (16 bpp) (SHIFTED !) */
/* Display buffers and shared memory information */
int i_buffer_index; /* buffer index */
XImage * p_ximage[2]; /* XImage pointer */
......@@ -63,83 +56,127 @@ typedef struct vout_sys_s
/*******************************************************************************
* Local prototypes
*******************************************************************************/
static int X11GetProperties ( vout_thread_t *p_vout );
static int X11CreateWindow ( vout_thread_t *p_vout );
static int X11CreateImages ( vout_thread_t *p_vout );
static void X11DestroyImages ( vout_thread_t *p_vout );
static void X11DestroyWindow ( vout_thread_t *p_vout );
static int X11CreateImage ( vout_thread_t *p_vout, XImage **pp_ximage );
static void X11DestroyImage ( XImage *p_ximage );
static int X11CreateShmImage ( vout_thread_t *p_vout, XImage **pp_ximage,
XShmSegmentInfo *p_shm_info );
static void X11DestroyShmImage ( vout_thread_t *p_vout, XImage *p_ximage,
XShmSegmentInfo *p_shm_info );
static int X11OpenDisplay ( vout_thread_t *p_vout, char *psz_display, Window root_window );
static void X11CloseDisplay ( vout_thread_t *p_vout );
static int X11CreateWindow ( vout_thread_t *p_vout );
static void X11DestroyWindow ( vout_thread_t *p_vout );
static int X11CreateImage ( vout_thread_t *p_vout, XImage **pp_ximage );
static void X11DestroyImage ( XImage *p_ximage );
static int X11CreateShmImage ( vout_thread_t *p_vout, XImage **pp_ximage,
XShmSegmentInfo *p_shm_info );
static void X11DestroyShmImage ( vout_thread_t *p_vout, XImage *p_ximage,
XShmSegmentInfo *p_shm_info );
/*******************************************************************************
* vout_SysCreate: allocate X11 video thread output method
*******************************************************************************
* This function allocate and initialize a X11 vout method.
* This function allocate and initialize a X11 vout method. It uses some of the
* vout properties to choose the window size, and change them according to the
* actual properties of the display.
*******************************************************************************/
int vout_SysCreate( vout_thread_t *p_vout, char *psz_display, Window root_window )
{
/* Allocate structure */
p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
if( p_vout->p_sys == NULL )
{
intf_ErrMsg("vout error: %s\n", strerror(ENOMEM) );
intf_ErrMsg("error: %s\n", strerror(ENOMEM) );
return( 1 );
}
/* Since XLib is usually not thread-safe, we can't use the same display
* pointer than the interface or another thread. However, the window
* id is still valid */
p_vout->p_sys->p_display = XOpenDisplay( psz_display );
if( !p_vout->p_sys->p_display ) /* error */
/* Open and initialize device. This function issues its own error messages.
* Since XLib is usually not thread-safe, we can't use the same display
* pointer than the interface or another thread. However, the root window
* id is still valid. */
if( X11OpenDisplay( p_vout, psz_display, root_window ) )
{
intf_ErrMsg("vout error: can't open display %s\n", psz_display );
intf_ErrMsg("error: can't initialize X11 display\n" );
free( p_vout->p_sys );
return( 1 );
}
p_vout->p_sys->root_window = root_window;
return( 0 );
}
/*******************************************************************************
* vout_SysInit: initialize X11 video thread output method
*******************************************************************************
* This function create a X11 window according to the user configuration.
* This function create the XImages needed by the output thread.
*******************************************************************************/
int vout_SysInit( vout_thread_t *p_vout )
{
if( X11GetProperties( p_vout ) ) /* get display properties */
{
return( 1 );
}
if( X11CreateWindow( p_vout ) ) /* create window */
{
int i_err;
/* Create XImages using XShm extension - on failure, fall back to regular
* way (and destroy the first image if it was created successfully) */
if( p_vout->p_sys->b_shm )
{
return( 1 );
/* Create first image */
i_err = X11CreateShmImage( p_vout, &p_vout->p_sys->p_ximage[0],
&p_vout->p_sys->shm_info[0] );
if( !i_err ) /* first image has been created */
{
/* Create second image */
if( X11CreateShmImage( p_vout, &p_vout->p_sys->p_ximage[1],
&p_vout->p_sys->shm_info[1] ) )
{ /* error creating the second image */
X11DestroyShmImage( p_vout, p_vout->p_sys->p_ximage[0],
&p_vout->p_sys->shm_info[0] );
i_err = 1;
}
}
if( i_err ) /* an error occured */
{
intf_Msg("warning: XShm video extension desactivated\n" );
p_vout->p_sys->b_shm = 0;
}
}
if( X11CreateImages( p_vout ) ) /* create images */
/* Create XImages without XShm extension */
if( !p_vout->p_sys->b_shm )
{
X11DestroyWindow( p_vout );
return( 1 );
if( X11CreateImage( p_vout, &p_vout->p_sys->p_ximage[0] ) )
{
intf_Msg("error: can't create images\n");
p_vout->p_sys->p_ximage[0] = NULL;
p_vout->p_sys->p_ximage[1] = NULL;
return( 1 );
}
if( X11CreateImage( p_vout, &p_vout->p_sys->p_ximage[1] ) )
{
intf_Msg("error: can't create images\n");
X11DestroyImage( p_vout->p_sys->p_ximage[0] );
p_vout->p_sys->p_ximage[0] = NULL;
p_vout->p_sys->p_ximage[1] = NULL;
return( 1 );
}
}
intf_Msg("vout: X11 display initialized, depth=%d bpp, Shm=%d\n",
p_vout->i_screen_depth, p_vout->p_sys->b_shm );
/* Set buffer index to 0 */
p_vout->p_sys->i_buffer_index = 0;
return( 0 );
}
/*******************************************************************************
* vout_SysEnd: terminate X11 video thread output method
*******************************************************************************
* Terminate an output method created by vout_X11CreateOutputMethod
* Destroy the X11 XImages created by vout_SysInit.
*******************************************************************************/
void vout_SysEnd( vout_thread_t *p_vout )
{
X11DestroyImages( p_vout );
X11DestroyWindow( p_vout );
intf_DbgMsg("%p\n", p_vout );
if( p_vout->p_sys->b_shm ) /* Shm XImages... */
{
X11DestroyShmImage( p_vout, p_vout->p_sys->p_ximage[0],
&p_vout->p_sys->shm_info[0] );
X11DestroyShmImage( p_vout, p_vout->p_sys->p_ximage[1],
&p_vout->p_sys->shm_info[1] );
}
else /* ...or regular XImages */
{
X11DestroyImage( p_vout->p_sys->p_ximage[0] );
X11DestroyImage( p_vout->p_sys->p_ximage[1] );
}
}
/*******************************************************************************
......@@ -149,7 +186,7 @@ void vout_SysEnd( vout_thread_t *p_vout )
*******************************************************************************/
void vout_SysDestroy( vout_thread_t *p_vout )
{
XCloseDisplay( p_vout->p_sys->p_display );
X11CloseDisplay( p_vout );
free( p_vout->p_sys );
}
......@@ -161,8 +198,6 @@ void vout_SysDestroy( vout_thread_t *p_vout )
* something happened which does not allow the thread to continue, and a
* positive one if the thread can go on, but the images have been modified and
* therefore it is useless to display them.
*******************************************************************************
* Messages type: vout, major code: 103
*******************************************************************************/
int vout_SysManage( vout_thread_t *p_vout )
{
......@@ -175,19 +210,19 @@ int vout_SysManage( vout_thread_t *p_vout )
/* If window has been resized, re-create images */
if( b_resized )
/* ?? if( b_resized )
{
intf_DbgMsg("%p -> resizing window\n", p_vout);
X11DestroyImages( p_vout );
if( X11CreateImages( p_vout ) )
{
{ */
/* A fatal error occured: images could not be re-created. Note
* that in this case, the images pointers will be NULL, so the
* image destructor will know it does not need to destroy them. */
return( -1 );
/* return( -1 );
}
return( 1 );
}
}*/
return( 0 );
}
......@@ -200,7 +235,7 @@ int vout_SysManage( vout_thread_t *p_vout )
*******************************************************************************/
void vout_SysDisplay( vout_thread_t *p_vout )
{
if( p_vout->p_sys->b_shm) /* XShm is used */
if( p_vout->p_sys->b_shm) /* XShm is used */
{
/* Display rendered image using shared memory extension */
XShmPutImage(p_vout->p_sys->p_display, p_vout->p_sys->window, p_vout->p_sys->gc,
......@@ -249,20 +284,28 @@ byte_t * vout_SysGetPicture( vout_thread_t *p_vout, int *pi_eol_offset )
/* following functions are local */
/*******************************************************************************
* X11GetProperties: get properties of a given display
* X11OpenDisplay: open and initialize X11 device
*******************************************************************************
* Opens an X11 display and try to detect usable X extensions.
* Create a window according to video output given size, and set other
* properties according to the display properties.
*******************************************************************************/
static int X11GetProperties( vout_thread_t *p_vout )
static int X11OpenDisplay( vout_thread_t *p_vout, char *psz_display, Window root_window )
{
/* Check if extensions are supported */
p_vout->p_sys->b_shm = VOUT_XSHM && (XShmQueryExtension(p_vout->p_sys->p_display) == True);
/* Get the screen number and depth (bpp) - select functions depending
* of this value. i_bytes_per_pixel is required since on some hardware,
* depth as 15bpp are used, which can cause problems with later memory
* allocation. */
p_vout->p_sys->i_screen = DefaultScreen( p_vout->p_sys->p_display );
/* Open display */
p_vout->p_sys->p_display = XOpenDisplay( psz_display );
if( p_vout->p_sys->p_display == NULL )
{
intf_ErrMsg("error: can't open display %s\n", psz_display );
return( 1 );
}
/* Initialize structure */
p_vout->p_sys->root_window = root_window;
p_vout->p_sys->b_shm = VOUT_XSHM &&
(XShmQueryExtension(p_vout->p_sys->p_display) == True);
p_vout->p_sys->i_screen = DefaultScreen( p_vout->p_sys->p_display );
/* Get the screen depth */
p_vout->i_screen_depth = DefaultDepth( p_vout->p_sys->p_display,
p_vout->p_sys->i_screen );
switch( p_vout->i_screen_depth )
......@@ -271,22 +314,41 @@ static int X11GetProperties( vout_thread_t *p_vout )
case 16: /* 16 bpp (65536 colors) */
p_vout->i_bytes_per_pixel = 2;
break;
case 24: /* 24 bpp (millions of colors) */
p_vout->i_bytes_per_pixel = 3;
break;
case 32: /* 32 bpp (millions of colors) */
p_vout->i_bytes_per_pixel = 4;
break;
default: /* unsupported screen depth */
intf_ErrMsg("vout error: screen depth %i is not supported\n",
p_vout->i_screen_depth);
intf_ErrMsg("error: screen depth %d is not supported\n",
p_vout->i_screen_depth);
XCloseDisplay( p_vout->p_sys->p_display );
return( 1 );
break;
}
return( 0 );
/* Create a window */
if( X11CreateWindow( p_vout ) ) /* create window */
{
intf_ErrMsg("error: can't open a window\n");
XCloseDisplay( p_vout->p_sys->p_display );
return( 1 );
}
return( 0 );
}
/*******************************************************************************
* X11CloseDisplay: close X11 device
*******************************************************************************
* Returns all resources allocated by X11OpenDisplay and restore the original
* state of the display.
*******************************************************************************/
static void X11CloseDisplay( vout_thread_t *p_vout )
{
X11DestroyWindow( p_vout );
XCloseDisplay( p_vout->p_sys->p_display );
}
/*******************************************************************************
......@@ -306,10 +368,9 @@ static int X11CreateWindow( vout_thread_t *p_vout )
boolean_t b_map_notify;
/* Prepare window attributes */
xwindow_attributes.backing_store = Always; /* save the hidden part */
xwindow_attributes.backing_store = Always; /* save the hidden part */
/* Create the window and set hints - the window must receive ConfigureNotify
* events, and, until it is displayed, Expose and MapNotify events. */
/* Create the window and set hints */
p_vout->p_sys->window = XCreateSimpleWindow( p_vout->p_sys->p_display,
p_vout->p_sys->root_window,
0, 0,
......@@ -349,94 +410,11 @@ static int X11CreateWindow( vout_thread_t *p_vout )
while( !( b_expose && b_map_notify ) );
XSelectInput( p_vout->p_sys->p_display, p_vout->p_sys->window, 0 );
/* At this stage, the window is openned, displayed, and ready to receive data */
p_vout->b_active = 1;
return( 0 );
}
/*******************************************************************************
* X11CreateImages: create X11 rendering buffers
*******************************************************************************
* Create two XImages which will be used as rendering buffers. On error, non 0
* will be returned and the images pointer will be set to NULL (see
* vout_X11ManageOutputMethod()).
*******************************************************************************/
static int X11CreateImages( vout_thread_t *p_vout )
{
int i_err;
/* Create XImages using XShm extension - on failure, fall back to regular
* way (and destroy the first image if it was created successfully) */
if( p_vout->p_sys->b_shm )
{
/* Create first image */
i_err = X11CreateShmImage( p_vout, &p_vout->p_sys->p_ximage[0],
&p_vout->p_sys->shm_info[0] );
if( !i_err ) /* first image has been created */
{
/* Create second image */
if( X11CreateShmImage( p_vout, &p_vout->p_sys->p_ximage[1],
&p_vout->p_sys->shm_info[1] ) )
{ /* error creating the second image */
X11DestroyShmImage( p_vout, p_vout->p_sys->p_ximage[0],
&p_vout->p_sys->shm_info[0] );
i_err = 1;
}
}
if( i_err ) /* an error occured */
{
intf_Msg("vout: XShm extension desactivated\n" );
p_vout->p_sys->b_shm = 0;
}
}
/* Create XImages without XShm extension */
if( !p_vout->p_sys->b_shm )
{
if( X11CreateImage( p_vout, &p_vout->p_sys->p_ximage[0] ) )
{
intf_Msg("vout error: can't create images\n");
p_vout->p_sys->p_ximage[0] = NULL;
p_vout->p_sys->p_ximage[1] = NULL;
return( -1 );
}
if( X11CreateImage( p_vout, &p_vout->p_sys->p_ximage[1] ) )
{
intf_Msg("vout error: can't create images\n");
X11DestroyImage( p_vout->p_sys->p_ximage[0] );
p_vout->p_sys->p_ximage[0] = NULL;
p_vout->p_sys->p_ximage[1] = NULL;
return( -1 );
}
}
/* Set buffer index to 0 */
p_vout->p_sys->i_buffer_index = 0;
/* At this stage, the window is openned, displayed, and ready to receive
* data */
return( 0 );
}
/*******************************************************************************
* X11DestroyImages: destroy X11 rendering buffers
*******************************************************************************
* Destroy buffers created by vout_X11CreateImages().
*******************************************************************************/
static void X11DestroyImages( vout_thread_t *p_vout )
{
if( p_vout->p_sys->b_shm ) /* Shm XImages... */
{
X11DestroyShmImage( p_vout, p_vout->p_sys->p_ximage[0],
&p_vout->p_sys->shm_info[0] );
X11DestroyShmImage( p_vout, p_vout->p_sys->p_ximage[1],
&p_vout->p_sys->shm_info[1] );
}
else /* ...or regular XImages */
{
X11DestroyImage( p_vout->p_sys->p_ximage[0] );
X11DestroyImage( p_vout->p_sys->p_ximage[1] );
}
}
/*******************************************************************************
* X11DestroyWindow: destroy X11 window
*******************************************************************************
......@@ -444,7 +422,6 @@ static void X11DestroyImages( vout_thread_t *p_vout )
*******************************************************************************/
static void X11DestroyWindow( vout_thread_t *p_vout )
{
intf_DbgMsg("vout window: 0x%x\n", p_vout->p_sys->window );
XUnmapWindow( p_vout->p_sys->p_display, p_vout->p_sys->window );
XFreeGC( p_vout->p_sys->p_display, p_vout->p_sys->gc );
XDestroyWindow( p_vout->p_sys->p_display, p_vout->p_sys->window );
......@@ -464,8 +441,8 @@ static int X11CreateImage( vout_thread_t *p_vout, XImage **pp_ximage )
* p_vout->i_height );
if( !pb_data ) /* error */
{
intf_ErrMsg("vout error: %s\n", strerror(ENOMEM));
return( -1 );
intf_ErrMsg("error: %s\n", strerror(ENOMEM));
return( 1 );
}
/* Optimize the quantum of a scanline regarding its size - the quantum is
......@@ -493,9 +470,9 @@ static int X11CreateImage( vout_thread_t *p_vout, XImage **pp_ximage )
p_vout->i_width, p_vout->i_height, i_quantum, 0);
if(! *pp_ximage ) /* error */
{
intf_ErrMsg( "vout error: can't create XImages\n" );
intf_ErrMsg( "error: XCreateImage() failed\n" );
free( pb_data );
return( -1 );
return( 1 );
}
return 0;
......@@ -525,8 +502,8 @@ static int X11CreateShmImage( vout_thread_t *p_vout, XImage **pp_ximage,
p_shm_info, p_vout->i_width, p_vout->i_height );
if(! *pp_ximage ) /* error */
{
intf_ErrMsg("vout error: can't create XImages with shared memory\n");
return( -1 );
intf_ErrMsg("error: XShmCreateImage() failed\n");
return( 1 );
}
/* Allocate shared memory segment - 0777 set the access permission
......@@ -536,21 +513,21 @@ static int X11CreateShmImage( vout_thread_t *p_vout, XImage **pp_ximage,
IPC_CREAT | 0777);
if( p_shm_info->shmid < 0) /* error */
{
intf_ErrMsg("vout error: can't allocate shared image data (%s)\n",
intf_ErrMsg("error: can't allocate shared image data (%s)\n",
strerror(errno));
XDestroyImage( *pp_ximage );
return( -1 );
return( 1 );
}
/* Attach shared memory segment to process (read/write) */
p_shm_info->shmaddr = (*pp_ximage)->data = shmat(p_shm_info->shmid, 0, 0);
if(! p_shm_info->shmaddr )
{ /* error */
intf_ErrMsg("vout error: can't attach shared memory (%s)\n",
intf_ErrMsg("error: can't attach shared memory (%s)\n",
strerror(errno));
shmctl( p_shm_info->shmid, IPC_RMID, 0 ); /* free shared memory */
XDestroyImage( *pp_ximage );
return( -1 );
return( 1 );
}
/* Mark the shm segment to be removed when there will be no more
......@@ -561,11 +538,11 @@ static int X11CreateShmImage( vout_thread_t *p_vout, XImage **pp_ximage,
p_shm_info->readOnly = True;
if( XShmAttach( p_vout->p_sys->p_display, p_shm_info ) == False ) /* error */
{
intf_ErrMsg("vout error: can't attach shared memory to X11 server\n");
intf_ErrMsg("error: can't attach shared memory to X11 server\n");
shmdt( p_shm_info->shmaddr ); /* detach shared memory from process
* and automatic free */
XDestroyImage( *pp_ximage );
return( -1 );
return( 1 );
}
return( 0 );
}
......@@ -575,8 +552,6 @@ static int X11CreateShmImage( vout_thread_t *p_vout, XImage **pp_ximage,
*******************************************************************************
* Destroy XImage AND associated data. If pointer is NULL, the image won't be
* destroyed (see vout_X11ManageOutputMethod())
*******************************************************************************
* Messages type: vout, major code 114
*******************************************************************************/
static void X11DestroyImage( XImage *p_ximage )
{
......@@ -592,8 +567,6 @@ static void X11DestroyImage( XImage *p_ximage )
* Destroy XImage AND associated data. Detach shared memory segment from
* server and process, then free it. If pointer is NULL, the image won't be
* destroyed (see vout_X11ManageOutputMethod())
*******************************************************************************
* Messages type: vout, major code 115
*******************************************************************************/
static void X11DestroyShmImage( vout_thread_t *p_vout, XImage *p_ximage,
XShmSegmentInfo *p_shm_info )
......@@ -608,10 +581,8 @@ static void X11DestroyShmImage( vout_thread_t *p_vout, XImage *p_ximage,
XDestroyImage( p_ximage );
if( shmdt( p_shm_info->shmaddr ) ) /* detach shared memory from process */
{ /* also automatic freeing... */
intf_ErrMsg("vout error: can't detach shared memory (%s)\n",
intf_ErrMsg("error: can't detach shared memory (%s)\n",
strerror(errno));
}
}
/* following functions are local rendering functions */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment