diff options
Diffstat (limited to 'src/video_out')
25 files changed, 665 insertions, 81 deletions
diff --git a/src/video_out/Makefile.am b/src/video_out/Makefile.am index 062c7aa68..671e9f0ca 100644 --- a/src/video_out/Makefile.am +++ b/src/video_out/Makefile.am @@ -108,6 +108,7 @@ xineplug_LTLIBRARIES = $(xshm_module) $(xv_module) $(xvmc_module) \ $(xxmc_module) \ $(xcbshm_module) \ $(xcbxv_module) \ + xineplug_vo_out_raw.la \ xineplug_vo_out_none.la xineplug_vo_out_xcbshm_la_SOURCES = video_out_xcbshm.c $(XCBOSD) @@ -182,7 +183,7 @@ xineplug_vo_out_sdl_la_SOURCES = video_out_sdl.c xineplug_vo_out_sdl_la_LIBADD = $(XINE_LIB) $(SDL_LIBS) $(X_LIBS) $(PTHREAD_LIBS) $(LTLIBINTL) xineplug_vo_out_sdl_la_CFLAGS = $(AM_CFLAGS) $(X_CFLAGS) $(SDL_CFLAGS) -xineplug_vo_out_stk_la_SOURCES = video_out_stk.c +xineplug_vo_out_stk_la_SOURCES = video_out_stk.c xineplug_vo_out_stk_la_LIBADD = $(XINE_LIB) $(LIBSTK_LIBS) $(PTHREAD_LIBS) xineplug_vo_out_stk_la_CFLAGS = $(AM_CFLAGS) $(LIBSTK_CFLAGS) @@ -193,6 +194,10 @@ xineplug_vo_out_directx_la_CPPFLAGS = $(AM_CPPFLAGS) $(DIRECTX_CPPFLAGS) xineplug_vo_out_none_la_SOURCES = video_out_none.c xineplug_vo_out_none_la_LIBADD = $(XINE_LIB) $(PTHREAD_LIBS) $(LTLIBINTL) +xineplug_vo_out_raw_la_SOURCES = video_out_raw.c +xineplug_vo_out_raw_la_LIBADD = libyuv2rgb.la $(XINE_LIB) $(PTHREAD_LIBS) $(LTLIBINTL) $(AVUTIL_LIBS) +xineplug_vo_out_raw_la_CFLAGS = $(AM_CFLAGS) $(AVUTIL_CFLAGS) + xineplug_vo_out_macosx_la_SOURCES = video_out_macosx.m xineplug_vo_out_macosx_la_LIBADD = $(XINE_LIB) $(PTHREAD_LIBS) xineplug_vo_out_macosx_la_LDFLAGS = $(AM_LDFLAGS) -framework Cocoa -framework OpenGL diff --git a/src/video_out/video_out_aa.c b/src/video_out/video_out_aa.c index 3429e883f..7c021a090 100644 --- a/src/video_out/video_out_aa.c +++ b/src/video_out/video_out_aa.c @@ -104,7 +104,7 @@ static vo_frame_t *aa_alloc_frame(vo_driver_t *this_gen) { /* aa_driver_t *this = (aa_driver_t*) this_gen; */ aa_frame_t *frame; - frame = (aa_frame_t *) xine_xmalloc (sizeof (aa_frame_t)); + frame = calloc(1, sizeof (aa_frame_t)); if (!frame) return NULL; @@ -264,7 +264,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi aa_class_t *class = (aa_class_t *) class_gen; aa_driver_t *this; - this = (aa_driver_t*) xine_xmalloc (sizeof (aa_driver_t)); + this = (aa_driver_t*) calloc(1, sizeof(aa_driver_t)); this->context = (aa_context*) visual_gen; @@ -292,7 +292,7 @@ static void *init_class (xine_t *xine, void *visual_gen) { /* aa_context *context = (aa_context*) visual_gen; */ aa_class_t *this; - this = (aa_class_t *) xine_xmalloc(sizeof(aa_class_t)); + this = calloc(1, sizeof(aa_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "AA"; diff --git a/src/video_out/video_out_caca.c b/src/video_out/video_out_caca.c index 01aad0bc8..60552764f 100644 --- a/src/video_out/video_out_caca.c +++ b/src/video_out/video_out_caca.c @@ -117,7 +117,7 @@ static vo_frame_t *caca_alloc_frame(vo_driver_t *this_gen) { caca_driver_t *this = (caca_driver_t*) this_gen; caca_frame_t *frame; - frame = (caca_frame_t *) xine_xmalloc (sizeof (caca_frame_t)); + frame = calloc(1, sizeof (caca_frame_t)); if (!frame) return NULL; @@ -260,7 +260,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi caca_class_t *class = (caca_class_t *) class_gen; caca_driver_t *this; - this = (caca_driver_t*) xine_xmalloc (sizeof (caca_driver_t)); + this = calloc(1, sizeof (caca_driver_t)); this->config = class->config; this->xine = class->xine; @@ -292,7 +292,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi static void *init_class (xine_t *xine, void *visual_gen) { caca_class_t *this; - this = (caca_class_t *) xine_xmalloc(sizeof(caca_class_t)); + this = calloc(1, sizeof(caca_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "CACA"; diff --git a/src/video_out/video_out_directfb.c b/src/video_out/video_out_directfb.c index fecc2c5b0..18df07f76 100644 --- a/src/video_out/video_out_directfb.c +++ b/src/video_out/video_out_directfb.c @@ -168,10 +168,6 @@ typedef struct { "no-deinit-check" -#ifndef MAX -# define MAX( a, b ) (((a) > (b)) ? (a) : (b)) -#endif - #define YCBCR_TO_RGB( y, cb, cr, r, g, b ) \ do { \ int _y, _cb, _cr, _r, _g, _b; \ @@ -232,7 +228,7 @@ static vo_frame_t *directfb_alloc_frame (vo_driver_t *this_gen) { directfb_driver_t *this = (directfb_driver_t *) this_gen; directfb_frame_t *frame; - frame = (directfb_frame_t *) xine_xmalloc (sizeof (directfb_frame_t)); + frame = (directfb_frame_t *) calloc(1, sizeof(directfb_frame_t)); if (!frame) { xprintf (this->xine, XINE_VERBOSITY_DEBUG, "video_out_directfb: directfb_alloc_frame: out of memory\n"); @@ -1767,7 +1763,7 @@ static vo_driver_t *open_plugin_fb (video_driver_class_t *class_gen, const void DFBDisplayLayerID id; DFBResult ret; - this = xine_xmalloc (sizeof (directfb_driver_t)); + this = calloc(1, sizeof(directfb_driver_t)); if (!this) return NULL; @@ -1909,7 +1905,7 @@ static void *init_class_fb (xine_t *xine, void *visual_gen) { return NULL; } - this = (directfb_class_t *) xine_xmalloc (sizeof (directfb_class_t)); + this = (directfb_class_t *) calloc(1, sizeof(directfb_class_t)); this->driver_class.open_plugin = open_plugin_fb; this->driver_class.identifier = "DirectFB"; this->driver_class.description = N_("xine video output plugin using DirectFB."); @@ -1940,7 +1936,7 @@ static vo_driver_t *open_plugin_x11 (video_driver_class_t *class_gen, const void DFBDisplayLayerID id = DLID_PRIMARY; DFBResult ret; - this = xine_xmalloc (sizeof (directfb_driver_t)); + this = calloc(1, sizeof(directfb_driver_t)); if (!this) return NULL; @@ -2114,7 +2110,7 @@ static void *init_class_x11 (xine_t *xine, void *visual_gen) { if (strcmp (XServerVendor (visual->display), "Denis Oliver Kropp")) return NULL; - this = (directfb_class_t *) xine_xmalloc (sizeof (directfb_class_t)); + this = (directfb_class_t *) calloc(1, sizeof(directfb_class_t)); this->driver_class.open_plugin = open_plugin_x11; this->driver_class.identifier = "XDirectFB"; this->driver_class.description = N_("xine video output plugin using DirectFB under XDirectFB."); diff --git a/src/video_out/video_out_directx.c b/src/video_out/video_out_directx.c index c2b3aa101..7c63f93e9 100644 --- a/src/video_out/video_out_directx.c +++ b/src/video_out/video_out_directx.c @@ -863,7 +863,7 @@ static vo_frame_t * win32_alloc_frame( vo_driver_t * vo_driver ) { win32_frame_t *win32_frame; - win32_frame = ( win32_frame_t * ) xine_xmalloc( sizeof( win32_frame_t ) ); + win32_frame = calloc(1, sizeof(win32_frame_t)); if (!win32_frame) return NULL; @@ -1183,7 +1183,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *wi /*vo_driver_t *init_video_out_plugin( config_values_t * config, void * win32_visual )*/ { directx_class_t *class = (directx_class_t *)class_gen; - win32_driver_t *win32_driver = ( win32_driver_t * ) xine_xmalloc ( sizeof( win32_driver_t ) ); + win32_driver_t *win32_driver = calloc(1, sizeof(win32_driver_t)); _x_alphablend_init(&win32_driver->alphablend_extra_data, class->xine); @@ -1234,7 +1234,7 @@ static void *init_class (xine_t *xine, void *visual_gen) { /* * from this point on, nothing should go wrong anymore */ - directx = (directx_class_t *) xine_xmalloc (sizeof (directx_class_t)); + directx = calloc(1, sizeof (directx_class_t)); directx->driver_class.open_plugin = open_plugin; directx->driver_class.identifier = "DirectX"; diff --git a/src/video_out/video_out_fb.c b/src/video_out/video_out_fb.c index 1efc39459..107d2a133 100644 --- a/src/video_out/video_out_fb.c +++ b/src/video_out/video_out_fb.c @@ -221,7 +221,7 @@ static vo_frame_t *fb_alloc_frame(vo_driver_t *this_gen) this->total_num_native_buffers <= this->used_num_buffers) return 0; - frame = (fb_frame_t *)xine_xmalloc(sizeof(fb_frame_t)); + frame = calloc(1, sizeof(fb_frame_t)); if(!frame) return NULL; @@ -337,7 +337,7 @@ static void frame_reallocate(fb_driver_t *this, fb_frame_t *frame, else { free(frame->data); - frame->data = xine_xcalloc(frame->sc.output_width * + frame->data = calloc(frame->sc.output_width * frame->sc.output_height, this->bytes_per_pixel); } @@ -971,7 +971,7 @@ static vo_driver_t *fb_open_plugin(video_driver_class_t *class_gen, config = class->config; /* allocate plugin struct */ - this = (fb_driver_t *) xine_xmalloc(sizeof(fb_driver_t)); + this = calloc(1, sizeof(fb_driver_t)); if(!this) return NULL; @@ -1039,7 +1039,7 @@ error: static void *fb_init_class(xine_t *xine, void *visual_gen) { - fb_class_t *this = (fb_class_t *)xine_xmalloc(sizeof(fb_class_t)); + fb_class_t *this = calloc(1, sizeof(fb_class_t)); this->driver_class.open_plugin = fb_open_plugin; this->driver_class.identifier = "fb"; diff --git a/src/video_out/video_out_macosx.m b/src/video_out/video_out_macosx.m index 085387a44..3a87908df 100644 --- a/src/video_out/video_out_macosx.m +++ b/src/video_out/video_out_macosx.m @@ -97,7 +97,7 @@ static vo_frame_t *macosx_alloc_frame(vo_driver_t *vo_driver) { /* macosx_driver_t *this = (macosx_driver_t *) vo_driver; */ macosx_frame_t *frame; - frame = (macosx_frame_t *) xine_xmalloc(sizeof(macosx_frame_t)); + frame = calloc(1, sizeof(macosx_frame_t)); if(!frame) return NULL; @@ -320,7 +320,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *driver_class, const void * macosx_driver_t *driver; XineOpenGLView *view = (XineOpenGLView *) visual; - driver = (macosx_driver_t *) xine_xmalloc(sizeof(macosx_driver_t)); + driver = calloc(1, sizeof(macosx_driver_t)); driver->config = class->config; driver->xine = class->xine; @@ -353,7 +353,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *driver_class, const void * static void *init_class (xine_t *xine, void *visual) { macosx_class_t *this; - this = (macosx_class_t *) xine_xmalloc(sizeof(macosx_class_t)); + this = calloc(1, sizeof(macosx_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "MacOSX"; diff --git a/src/video_out/video_out_none.c b/src/video_out/video_out_none.c index c23c828a6..fc5d5d56e 100644 --- a/src/video_out/video_out_none.c +++ b/src/video_out/video_out_none.c @@ -88,7 +88,7 @@ static vo_frame_t *none_alloc_frame(vo_driver_t *vo_driver) { /* none_driver_t *this = (none_driver_t *) vo_driver; */ none_frame_t *frame; - frame = (none_frame_t *) xine_xmalloc(sizeof(none_frame_t)); + frame = calloc(1, sizeof(none_frame_t)); if(!frame) return NULL; @@ -243,7 +243,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *driver_class, const void * none_class_t *class = (none_class_t *) driver_class; none_driver_t *driver; - driver = (none_driver_t *) xine_xmalloc(sizeof(none_driver_t)); + driver = calloc(1, sizeof(none_driver_t)); driver->config = class->config; driver->xine = class->xine; @@ -272,7 +272,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *driver_class, const void * static void *init_class (xine_t *xine, void *visual) { none_class_t *this; - this = (none_class_t *) xine_xmalloc(sizeof(none_class_t)); + this = calloc(1, sizeof(none_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "none"; diff --git a/src/video_out/video_out_opengl.c b/src/video_out/video_out_opengl.c index 533b26a22..9656f9551 100644 --- a/src/video_out/video_out_opengl.c +++ b/src/video_out/video_out_opengl.c @@ -670,8 +670,8 @@ static int render_image_envtex (opengl_driver_t *this, opengl_frame_t *frame) { * Render setup functions */ static int render_help_verify_ext (opengl_driver_t *this, char *ext) { - int ret = 0; - int l = strlen (ext); + int ret = 0; + const size_t l = strlen (ext); const char *e; for (e = (char *) this->gl_exts; e && *e; e = strchr (e, ' ')) { while (isspace (*e)) @@ -695,10 +695,9 @@ static void *getdladdr (const GLubyte *_funcName) { return NULL; #elif defined(__APPLE__) - char *temp = xine_xmalloc (strlen (funcName) + 2); + char *temp; + asprintf(&temp, "_%s", funcName); void *res = NULL; - temp[0] = '_'; /* Mac OS X prepends an underscore on function names */ - strcpy (temp+1, funcName); if (NSIsSymbolNameDefined (temp)) { NSSymbol symbol = NSLookupAndBindSymbol (temp); res = NSAddressOfSymbol (symbol); @@ -1282,7 +1281,7 @@ static vo_frame_t *opengl_alloc_frame (vo_driver_t *this_gen) { opengl_frame_t *frame; opengl_driver_t *this = (opengl_driver_t *) this_gen; - frame = (opengl_frame_t *) xine_xmalloc (sizeof (opengl_frame_t)); + frame = (opengl_frame_t *) calloc(1, sizeof(opengl_frame_t)); if (!frame) return NULL; @@ -1818,7 +1817,7 @@ static vo_driver_t *opengl_open_plugin (video_driver_class_t *class_gen, const v char **render_fun_names; int i; - this = (opengl_driver_t *) xine_xmalloc (sizeof (opengl_driver_t)); + this = (opengl_driver_t *) calloc(1, sizeof(opengl_driver_t)); if (!this) return NULL; @@ -1874,8 +1873,7 @@ static vo_driver_t *opengl_open_plugin (video_driver_class_t *class_gen, const v this->drawable, X11OSD_SHAPED); XUnlockDisplay (this->display); - render_fun_names = xine_xmalloc ((sizeof(opengl_rb)/sizeof(opengl_render_t)+1) - * sizeof (const char *)); + render_fun_names = calloc((sizeof(opengl_rb)/sizeof(opengl_render_t)+1), sizeof(const char*)); for (i = 0; i < sizeof (opengl_rb) / sizeof (opengl_render_t); i++) render_fun_names[i] = opengl_rb[i].name; render_fun_names[i] = NULL; @@ -1953,7 +1951,7 @@ static vo_driver_t *opengl_open_plugin (video_driver_class_t *class_gen, const v * class functions */ static void *opengl_init_class (xine_t *xine, void *visual_gen) { - opengl_class_t *this = (opengl_class_t *) xine_xmalloc (sizeof (opengl_class_t)); + opengl_class_t *this = (opengl_class_t *) calloc(1, sizeof(opengl_class_t)); this->driver_class.open_plugin = opengl_open_plugin; this->driver_class.identifier = "opengl"; diff --git a/src/video_out/video_out_pgx32.c b/src/video_out/video_out_pgx32.c index 884f9939f..a69c26ee1 100644 --- a/src/video_out/video_out_pgx32.c +++ b/src/video_out/video_out_pgx32.c @@ -386,7 +386,7 @@ static vo_frame_t *pgx32_alloc_frame(vo_driver_t *this_gen) /*pgx32_driver_t *this = (pgx32_driver_t *)(void *)this_gen;*/ pgx32_frame_t *frame; - frame = (pgx32_frame_t *) xine_xmalloc(sizeof(pgx32_frame_t)); + frame = calloc(1, sizeof(pgx32_frame_t)); if (!frame) { return NULL; } @@ -793,7 +793,7 @@ static vo_driver_t *pgx32_init_driver(video_driver_class_t *class_gen, const voi pgx32_driver_class_t *class = (pgx32_driver_class_t *)(void *)class_gen; pgx32_driver_t *this; - this = (pgx32_driver_t *)xine_xmalloc(sizeof(pgx32_driver_t)); + this = calloc(1, sizeof(pgx32_driver_t)); if (!this) { return NULL; } @@ -852,7 +852,7 @@ static void *pgx32_init_class(xine_t *xine, void *visual_gen) { pgx32_driver_class_t *class; - class = (pgx32_driver_class_t *)xine_xmalloc(sizeof(pgx32_driver_class_t)); + class = calloc(1, sizeof(pgx32_driver_class_t)); if (!class) { return NULL; } diff --git a/src/video_out/video_out_pgx64.c b/src/video_out/video_out_pgx64.c index 0bdcc35fe..8482de06a 100644 --- a/src/video_out/video_out_pgx64.c +++ b/src/video_out/video_out_pgx64.c @@ -560,7 +560,7 @@ static vo_frame_t *pgx64_alloc_frame(vo_driver_t *this_gen) /*pgx64_driver_t *this = (pgx64_driver_t *)(void *)this_gen;*/ pgx64_frame_t *frame; - frame = (pgx64_frame_t *) xine_xmalloc(sizeof(pgx64_frame_t)); + frame = calloc(1, sizeof(pgx64_frame_t)); if (!frame) { return NULL; } @@ -1343,7 +1343,7 @@ static vo_driver_t *pgx64_init_driver(video_driver_class_t *class_gen, const voi struct fbgattr attr; long page_size; - this = (pgx64_driver_t *)xine_xmalloc(sizeof(pgx64_driver_t)); + this = calloc(1, sizeof(pgx64_driver_t)); if (!this) { return NULL; } @@ -1474,7 +1474,7 @@ static void *pgx64_init_class(xine_t *xine, void *visual_gen) { pgx64_driver_class_t *class; - class = (pgx64_driver_class_t *)xine_xmalloc(sizeof(pgx64_driver_class_t)); + class = calloc(1, sizeof(pgx64_driver_class_t)); if (!class) { return NULL; } diff --git a/src/video_out/video_out_raw.c b/src/video_out/video_out_raw.c new file mode 100644 index 000000000..227331f2f --- /dev/null +++ b/src/video_out/video_out_raw.c @@ -0,0 +1,586 @@ +/* + * Copyright (C) 2007 the xine project + * + * This file is part of xine, a free video player. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * + * video_out_raw.c, a video output plugin to pass raw data to frontend + * + * Written by Christophe Thommeret <hftom@free.fr>, + * based on others' video output plugins. + * + */ + +/* #define LOG */ +#define LOG_MODULE "video_out_raw" + +/* Allow frontend some time to render frames +* However, frontends are strongly advised to render synchronously */ +#define NUM_FRAMES_BACKLOG 4 +#define BYTES_PER_PIXEL 3 + + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <math.h> +#include <errno.h> +#include <ctype.h> +#include <pthread.h> + +#include <xine.h> +#include <xine/video_out.h> + +#include <xine/xine_internal.h> +#include "yuv2rgb.h" +#include <xine/xineutils.h> + +#include <mem.h> + +typedef struct { + vo_frame_t vo_frame; + + int width, height, format, flags; + double ratio; + uint8_t *rgb, *rgb_dst; + yuv2rgb_t *yuv2rgb; /* yuv2rgb converter set up for this frame */ + +} raw_frame_t; + +typedef struct { + vo_driver_t vo_driver; + + void *user_data; + + void (*raw_output_cb) (void *user_data, int format, + int frame_width, int frame_height, double frame_aspect, + void *data0, void *data1, void *data2); + + void (*raw_overlay_cb) (void *user_data, int num_ovl, + raw_overlay_t *overlays_p); + + int ovl_changed; + raw_overlay_t overlays[XINE_VORAW_MAX_OVL]; + yuv2rgb_t *ovl_yuv2rgb; + + int doYV12; + int doYUY2; + yuv2rgb_factory_t *yuv2rgb_factory; + /* Frame state */ + raw_frame_t *frame[NUM_FRAMES_BACKLOG]; + xine_t *xine; +} raw_driver_t; + + +typedef struct { + video_driver_class_t driver_class; + xine_t *xine; +} raw_class_t; + + + +static void raw_overlay_clut_yuv2rgb(raw_driver_t *this, vo_overlay_t *overlay, raw_frame_t *frame) +{ + int i; + clut_t* clut = (clut_t*) overlay->color; + + if (!overlay->rgb_clut) { + for ( i=0; i<sizeof(overlay->color)/sizeof(overlay->color[0]); i++ ) { + *((uint32_t *)&clut[i]) = this->ovl_yuv2rgb->yuv2rgb_single_pixel_fun(frame->yuv2rgb, clut[i].y, clut[i].cb, clut[i].cr); + } + overlay->rgb_clut++; + } + if (!overlay->hili_rgb_clut) { + clut = (clut_t*) overlay->hili_color; + for ( i=0; i<sizeof(overlay->color)/sizeof(overlay->color[0]); i++) { + *((uint32_t *)&clut[i]) = this->ovl_yuv2rgb->yuv2rgb_single_pixel_fun(frame->yuv2rgb, clut[i].y, clut[i].cb, clut[i].cr); + } + overlay->hili_rgb_clut++; + } +} + + +static int raw_process_ovl( raw_driver_t *this_gen, vo_overlay_t *overlay ) +{ + raw_overlay_t *ovl = &this_gen->overlays[this_gen->ovl_changed-1]; + + if ( overlay->width<=0 || overlay->height<=0 ) + return 0; + + if ( (overlay->width*overlay->height)!=(ovl->ovl_w*ovl->ovl_h) ) + ovl->ovl_rgba = (uint8_t*)realloc( ovl->ovl_rgba, overlay->width*overlay->height*4 ); + ovl->ovl_w = overlay->width; + ovl->ovl_h = overlay->height; + ovl->ovl_x = overlay->x; + ovl->ovl_y = overlay->y; + + int num_rle = overlay->num_rle; + rle_elem_t *rle = overlay->rle; + uint8_t *rgba = ovl->ovl_rgba; + clut_t *low_colors = (clut_t*)overlay->color; + clut_t *hili_colors = (clut_t*)overlay->hili_color; + uint8_t *low_trans = overlay->trans; + uint8_t *hili_trans = overlay->hili_trans; + clut_t *colors; + uint8_t *trans; + uint8_t alpha; + int rlelen = 0; + uint8_t clr = 0; + int i, pos=0, x, y; + + while ( num_rle>0 ) { + x = pos%ovl->ovl_w; + y = pos/ovl->ovl_w; + if ( (x>=overlay->hili_left && x<=overlay->hili_right) && (y>=overlay->hili_top && y<=overlay->hili_bottom) ) { + colors = hili_colors; + trans = hili_trans; + } + else { + colors = low_colors; + trans = low_trans; + } + rlelen = rle->len; + clr = rle->color; + alpha = trans[clr]; + for ( i=0; i<rlelen; ++i ) { + rgba[0] = colors[clr].y; + rgba[1] = colors[clr].cr; + rgba[2] = colors[clr].cb; + rgba[3] = alpha*255/15; + rgba+= 4; + ++pos; + } + ++rle; + --num_rle; + } + return 1; +} + + +static void raw_overlay_begin (vo_driver_t *this_gen, vo_frame_t *frame_gen, int changed) +{ + raw_driver_t *this = (raw_driver_t *) this_gen; + + if ( !changed ) + return; + + ++this->ovl_changed; +} + + +static void raw_overlay_blend (vo_driver_t *this_gen, vo_frame_t *frame_gen, vo_overlay_t *overlay) +{ + raw_driver_t *this = (raw_driver_t *) this_gen; + raw_frame_t *frame = (raw_frame_t *) frame_gen; + + if ( !this->ovl_changed || this->ovl_changed>XINE_VORAW_MAX_OVL ) + return; + + if (overlay->rle) { + if (!overlay->rgb_clut || !overlay->hili_rgb_clut) + raw_overlay_clut_yuv2rgb (this, overlay, frame); + if ( raw_process_ovl( this, overlay ) ) + ++this->ovl_changed; + } +} + + +static void raw_overlay_end (vo_driver_t *this_gen, vo_frame_t *vo_img) +{ + raw_driver_t *this = (raw_driver_t *) this_gen; + + if ( !this->ovl_changed ) + return; + + this->raw_overlay_cb( this->user_data, this->ovl_changed-1, &this->overlays ); + + this->ovl_changed = 0; +} + + +static void raw_frame_proc_slice (vo_frame_t *vo_img, uint8_t **src) +{ + raw_frame_t *frame = (raw_frame_t *) vo_img ; + + vo_img->proc_called = 1; + if (! frame->rgb_dst) + return; + + if( frame->vo_frame.crop_left || frame->vo_frame.crop_top || + frame->vo_frame.crop_right || frame->vo_frame.crop_bottom ) + { + /* TODO: ?!? */ + return; + } + + if (frame->format == XINE_IMGFMT_YV12) + frame->yuv2rgb->yuv2rgb_fun (frame->yuv2rgb, frame->rgb_dst, src[0], src[1], src[2]); + else + frame->yuv2rgb->yuy22rgb_fun (frame->yuv2rgb, frame->rgb_dst, src[0]); +} + + + +static void raw_frame_field (vo_frame_t *vo_img, int which_field) +{ + raw_frame_t *frame = (raw_frame_t *) vo_img ; + raw_driver_t *this = (raw_driver_t *) vo_img->driver; + + if ( frame->format==XINE_IMGFMT_YV12 && this->doYV12 ) { + frame->rgb_dst = 0; + return; + } + else if ( frame->format==XINE_IMGFMT_YUY2 && this->doYUY2 ) { + frame->rgb_dst = 0; + return; + } + + switch (which_field) { + case VO_TOP_FIELD: + frame->rgb_dst = (uint8_t *)frame->rgb; + break; + case VO_BOTTOM_FIELD: + frame->rgb_dst = (uint8_t *)frame->rgb + frame->width * BYTES_PER_PIXEL; + break; + case VO_BOTH_FIELDS: + frame->rgb_dst = (uint8_t *)frame->rgb; + break; + } + + frame->yuv2rgb->next_slice (frame->yuv2rgb, NULL); +} + + + +static void raw_frame_dispose (vo_frame_t *vo_img) +{ + raw_frame_t *frame = (raw_frame_t *) vo_img ; + + frame->yuv2rgb->dispose (frame->yuv2rgb); + + av_free (frame->vo_frame.base[0]); + av_free (frame->vo_frame.base[1]); + av_free (frame->vo_frame.base[2]); + av_free (frame->rgb); + free (frame); +} + + + +static vo_frame_t *raw_alloc_frame (vo_driver_t *this_gen) +{ + raw_frame_t *frame; + raw_driver_t *this = (raw_driver_t *) this_gen; + + frame = (raw_frame_t *) calloc(1, sizeof(raw_frame_t)); + + if (!frame) + return NULL; + + pthread_mutex_init (&frame->vo_frame.mutex, NULL); + + /* + * supply required functions/fields + */ + frame->vo_frame.proc_slice = raw_frame_proc_slice; + frame->vo_frame.proc_frame = NULL; + frame->vo_frame.field = raw_frame_field; + frame->vo_frame.dispose = raw_frame_dispose; + frame->vo_frame.driver = this_gen; + + /* + * colorspace converter for this frame + */ + frame->yuv2rgb = this->yuv2rgb_factory->create_converter (this->yuv2rgb_factory); + + return (vo_frame_t *) frame; +} + + + +static void raw_update_frame_format (vo_driver_t *this_gen, vo_frame_t *frame_gen, + uint32_t width, uint32_t height, double ratio, int format, int flags) +{ + raw_frame_t *frame = (raw_frame_t *) frame_gen; + + /* Check frame size and format and reallocate if necessary */ + if ((frame->width != width) + || (frame->height != height) + || (frame->format != format) + || (frame->flags != flags)) { +/* lprintf ("updating frame to %d x %d (ratio=%g, format=%08x)\n", width, height, ratio, format); */ + + flags &= VO_BOTH_FIELDS; + + /* (re-) allocate render space */ + av_free (frame->vo_frame.base[0]); + av_free (frame->vo_frame.base[1]); + av_free (frame->vo_frame.base[2]); + av_free (frame->rgb); + + if (format == XINE_IMGFMT_YV12) { + frame->vo_frame.pitches[0] = 8*((width + 7) / 8); + frame->vo_frame.pitches[1] = 8*((width + 15) / 16); + frame->vo_frame.pitches[2] = 8*((width + 15) / 16); + frame->vo_frame.base[0] = av_mallocz (frame->vo_frame.pitches[0] * height); + frame->vo_frame.base[1] = av_mallocz (frame->vo_frame.pitches[1] * ((height+1)/2)); + frame->vo_frame.base[2] = av_mallocz (frame->vo_frame.pitches[2] * ((height+1)/2)); + } else { + frame->vo_frame.pitches[0] = 8*((width + 3) / 4); + frame->vo_frame.base[0] = av_mallocz (frame->vo_frame.pitches[0] * height); + frame->vo_frame.base[1] = NULL; + frame->vo_frame.base[2] = NULL; + } + frame->rgb = av_mallocz (BYTES_PER_PIXEL*width*height); + + /* set up colorspace converter */ + switch (flags) { + case VO_TOP_FIELD: + case VO_BOTTOM_FIELD: + frame->yuv2rgb->configure (frame->yuv2rgb, + width, + height, + 2*frame->vo_frame.pitches[0], + 2*frame->vo_frame.pitches[1], + width, + height, + BYTES_PER_PIXEL*width * 2); + break; + case VO_BOTH_FIELDS: + frame->yuv2rgb->configure (frame->yuv2rgb, + width, + height, + frame->vo_frame.pitches[0], + frame->vo_frame.pitches[1], + width, + height, + BYTES_PER_PIXEL*width); + break; + } + + frame->width = width; + frame->height = height; + frame->format = format; + + raw_frame_field ((vo_frame_t *)frame, flags); + } + + frame->ratio = ratio; +} + + + +static int raw_redraw_needed (vo_driver_t *this_gen) +{ + return 0; +} + + + +static void raw_display_frame (vo_driver_t *this_gen, vo_frame_t *frame_gen) +{ + raw_driver_t *this = (raw_driver_t *) this_gen; + raw_frame_t *frame = (raw_frame_t *) frame_gen; + int i; + + if (this->frame[NUM_FRAMES_BACKLOG-1]) { + this->frame[NUM_FRAMES_BACKLOG-1]->vo_frame.free (&this->frame[NUM_FRAMES_BACKLOG-1]->vo_frame); + } + for (i = NUM_FRAMES_BACKLOG-1; i > 0; i--) + this->frame[i] = this->frame[i-1]; + this->frame[0] = frame; + + if ( frame->rgb_dst ) { + this->raw_output_cb( this->user_data, XINE_VORAW_RGB, frame->width, frame->height, frame->ratio, frame->rgb, 0, 0 ); + } + else if ( frame->format==XINE_IMGFMT_YV12 ) { + this->raw_output_cb( this->user_data, XINE_VORAW_YV12, frame->width, frame->height, frame->ratio, frame->vo_frame.base[0], + frame->vo_frame.base[1], frame->vo_frame.base[2] ); + } + else { + this->raw_output_cb( this->user_data, XINE_VORAW_YUY2, frame->width, frame->height, frame->ratio, frame->vo_frame.base[0], 0, 0 ); + } +} + + + +static int raw_get_property (vo_driver_t *this_gen, int property) +{ + switch (property) { + case VO_PROP_ASPECT_RATIO: + return XINE_VO_ASPECT_AUTO; + case VO_PROP_MAX_NUM_FRAMES: + return 15; + case VO_PROP_BRIGHTNESS: + return 0; + case VO_PROP_CONTRAST: + return 128; + case VO_PROP_SATURATION: + return 128; + case VO_PROP_WINDOW_WIDTH: + return 0; + case VO_PROP_WINDOW_HEIGHT: + return 0; + default: + return 0; + } +} + + + +static int raw_set_property (vo_driver_t *this_gen, int property, int value) +{ + return value; +} + + + +static void raw_get_property_min_max (vo_driver_t *this_gen, int property, int *min, int *max) +{ + *min = 0; + *max = 0; +} + + + +static int raw_gui_data_exchange (vo_driver_t *this_gen, int data_type, void *data) +{ + return 0; +} + + + +static uint32_t raw_get_capabilities (vo_driver_t *this_gen) +{ + uint32_t capabilities = VO_CAP_YV12 | VO_CAP_YUY2; + return capabilities; +} + + + +static void raw_dispose (vo_driver_t *this_gen) +{ + raw_driver_t *this = (raw_driver_t *) this_gen; + int i; + + for (i = 0; i < NUM_FRAMES_BACKLOG; i++) + if (this->frame[i]) + this->frame[i]->vo_frame.dispose (&this->frame[i]->vo_frame); + + this->yuv2rgb_factory->dispose (this->yuv2rgb_factory); + + for ( i=0; i<XINE_VORAW_MAX_OVL; ++i ) + free( this->overlays[i].ovl_rgba ); + + free (this); +} + + + +static vo_driver_t *raw_open_plugin (video_driver_class_t *class_gen, const void *visual_gen) +{ + raw_class_t *class = (raw_class_t *) class_gen; + raw_visual_t *visual = (raw_visual_t *) visual_gen; + raw_driver_t *this; + int i; + + this = (raw_driver_t *) calloc(1, sizeof(raw_driver_t)); + + if (!this) + return NULL; + + this->raw_output_cb = visual->raw_output_cb; + this->user_data = visual->user_data; + this->xine = class->xine; + this->raw_overlay_cb = visual->raw_overlay_cb; + this->doYV12 = visual->supported_formats&XINE_VORAW_YV12; + this->doYUY2 = visual->supported_formats&XINE_VORAW_YUY2; + + this->vo_driver.get_capabilities = raw_get_capabilities; + this->vo_driver.alloc_frame = raw_alloc_frame; + this->vo_driver.update_frame_format = raw_update_frame_format; + this->vo_driver.overlay_begin = raw_overlay_begin; + this->vo_driver.overlay_blend = raw_overlay_blend; + this->vo_driver.overlay_end = raw_overlay_end; + this->vo_driver.display_frame = raw_display_frame; + this->vo_driver.get_property = raw_get_property; + this->vo_driver.set_property = raw_set_property; + this->vo_driver.get_property_min_max = raw_get_property_min_max; + this->vo_driver.gui_data_exchange = raw_gui_data_exchange; + this->vo_driver.dispose = raw_dispose; + this->vo_driver.redraw_needed = raw_redraw_needed; + + this->yuv2rgb_factory = yuv2rgb_factory_init (MODE_24_BGR, 1, NULL); /* converts to rgb */ + + for (i = 0; i < NUM_FRAMES_BACKLOG; i++) + this->frame[i] = 0; + + for ( i=0; i<XINE_VORAW_MAX_OVL; ++i ) { + this->overlays[i].ovl_w = this->overlays[i].ovl_h = 2; + this->overlays[i].ovl_rgba = (uint8_t*)malloc(2*2*4); + this->overlays[i].ovl_x = this->overlays[i].ovl_y = 0; + } + this->ovl_changed = 0; + + /* we have to use a second converter for overlays + * because "MODE_24_BGR, 1 (swap)" breaks overlays conversion */ + yuv2rgb_factory_t *factory = yuv2rgb_factory_init (MODE_24_BGR, 0, NULL); + this->ovl_yuv2rgb = factory->create_converter( factory ); + factory->dispose( factory ); + + return &this->vo_driver; +} + +/* + * class functions + */ + +static void *raw_init_class (xine_t *xine, void *visual_gen) +{ + raw_class_t *this = (raw_class_t *) calloc(1, sizeof(raw_class_t)); + + this->driver_class.open_plugin = raw_open_plugin; + this->driver_class.identifier = "raw"; + this->driver_class.description = _("xine video output plugin passing raw data to supplied callback"); + this->driver_class.dispose = default_video_driver_class_dispose; + this->xine = xine; + + return this; +} + + + +static const vo_info_t vo_info_raw = { + 7, /* priority */ + XINE_VISUAL_TYPE_RAW /* visual type */ +}; + + +/* + * exported plugin catalog entry + */ + +const plugin_info_t xine_plugin_info[] EXPORTED = { + /* type, API, "name", version, special_info, init_function */ + { PLUGIN_VIDEO_OUT, 22, "raw", XINE_VERSION_CODE, &vo_info_raw, raw_init_class }, + { PLUGIN_NONE, 0, "", 0, NULL, NULL } +}; diff --git a/src/video_out/video_out_sdl.c b/src/video_out/video_out_sdl.c index 13a84475d..b96a4ba23 100644 --- a/src/video_out/video_out_sdl.c +++ b/src/video_out/video_out_sdl.c @@ -138,7 +138,7 @@ static vo_frame_t *sdl_alloc_frame (vo_driver_t *this_gen) { /* sdl_driver_t *this = (sdl_driver_t *) this_gen; */ sdl_frame_t *frame ; - frame = (sdl_frame_t *) xine_xmalloc (sizeof (sdl_frame_t)); + frame = (sdl_frame_t *) calloc(1, sizeof(sdl_frame_t)); if (!frame) return NULL; @@ -475,7 +475,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi XWindowAttributes window_attributes; #endif - this = (sdl_driver_t *) xine_xmalloc (sizeof (sdl_driver_t)); + this = (sdl_driver_t *) calloc(1, sizeof(sdl_driver_t)); if (!this) return NULL; @@ -583,7 +583,7 @@ static void *init_class (xine_t *xine, void *visual_gen) { } SDL_QuitSubSystem (SDL_INIT_VIDEO); - this = (sdl_class_t*) xine_xmalloc (sizeof (sdl_class_t)); + this = (sdl_class_t*) calloc(1, sizeof(sdl_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "SDL"; diff --git a/src/video_out/video_out_stk.c b/src/video_out/video_out_stk.c index e68efb30b..9e3a4ae30 100644 --- a/src/video_out/video_out_stk.c +++ b/src/video_out/video_out_stk.c @@ -133,7 +133,7 @@ static vo_frame_t *stk_alloc_frame(vo_driver_t *this_gen) { stk_frame_t* frame; //printf("video_out_stk: alloc_frame()\n"); - frame = (stk_frame_t *) xine_xmalloc(sizeof(stk_frame_t)); + frame = calloc(1, sizeof(stk_frame_t)); if (!frame) return NULL; @@ -389,7 +389,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *class_gen, const void *vis //printf("video_out_stk: open_plugin()\n"); - this = (stk_driver_t *) xine_xmalloc (sizeof (stk_driver_t)); + this = calloc(1, sizeof (stk_driver_t)); if (!this) return NULL; @@ -447,7 +447,7 @@ static void *init_class (xine_t *xine, void *visual_gen) { //printf("video_out_stk: init_class()\n"); - this = (stk_class_t *) xine_xmalloc(sizeof(stk_class_t)); + this = calloc(1, sizeof(stk_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "stk"; diff --git a/src/video_out/video_out_vidix.c b/src/video_out/video_out_vidix.c index 586268513..957d6ce1a 100644 --- a/src/video_out/video_out_vidix.c +++ b/src/video_out/video_out_vidix.c @@ -370,7 +370,7 @@ static vo_frame_t *vidix_alloc_frame (vo_driver_t *this_gen) { /* vidix_driver_t *this = (vidix_driver_t *) this_gen; */ vidix_frame_t *frame ; - frame = (vidix_frame_t *) xine_xmalloc (sizeof (vidix_frame_t)); + frame = (vidix_frame_t *) calloc(1, sizeof(vidix_frame_t)); if (!frame) return NULL; @@ -947,7 +947,7 @@ static vidix_driver_t *open_plugin (video_driver_class_t *class_gen) { vidix_driver_t *this; int err; - this = (vidix_driver_t *) xine_xmalloc (sizeof (vidix_driver_t)); + this = (vidix_driver_t *) calloc(1, sizeof(vidix_driver_t)); if (!this) return NULL; @@ -1093,7 +1093,7 @@ static void *init_class (xine_t *xine, void *visual_gen) { vidix_class_t *this; int err; - this = (vidix_class_t *) xine_xmalloc (sizeof (vidix_class_t)); + this = (vidix_class_t *) calloc(1, sizeof(vidix_class_t)); if (!this) return NULL; diff --git a/src/video_out/video_out_xcbshm.c b/src/video_out/video_out_xcbshm.c index 1b2e90be8..509412eb6 100644 --- a/src/video_out/video_out_xcbshm.c +++ b/src/video_out/video_out_xcbshm.c @@ -298,7 +298,7 @@ static vo_frame_t *xshm_alloc_frame (vo_driver_t *this_gen) { xshm_frame_t *frame; xshm_driver_t *this = (xshm_driver_t *) this_gen; - frame = (xshm_frame_t *) xine_xmalloc (sizeof (xshm_frame_t)); + frame = (xshm_frame_t *) calloc(1, sizeof(xshm_frame_t)); if (!frame) return NULL; @@ -1005,7 +1005,7 @@ static vo_driver_t *xshm_open_plugin(video_driver_class_t *class_gen, const void const xcb_query_extension_reply_t *query_extension_reply; - this = (xshm_driver_t *) xine_xmalloc (sizeof (xshm_driver_t)); + this = (xshm_driver_t *) calloc(1, sizeof(xshm_driver_t)); if (!this) return NULL; @@ -1225,7 +1225,7 @@ static vo_driver_t *xshm_open_plugin(video_driver_class_t *class_gen, const void * class functions */ static void *xshm_init_class (xine_t *xine, void *visual_gen) { - xshm_class_t *this = (xshm_class_t *) xine_xmalloc (sizeof (xshm_class_t)); + xshm_class_t *this = (xshm_class_t *) calloc(1, sizeof(xshm_class_t)); this->driver_class.open_plugin = xshm_open_plugin; this->driver_class.identifier = "XShm"; diff --git a/src/video_out/video_out_xcbxv.c b/src/video_out/video_out_xcbxv.c index e267f98fb..7b6ab6677 100644 --- a/src/video_out/video_out_xcbxv.c +++ b/src/video_out/video_out_xcbxv.c @@ -184,7 +184,7 @@ static vo_frame_t *xv_alloc_frame (vo_driver_t *this_gen) { /* xv_driver_t *this = (xv_driver_t *) this_gen; */ xv_frame_t *frame ; - frame = (xv_frame_t *) xine_xmalloc (sizeof (xv_frame_t)); + frame = (xv_frame_t *) calloc(1, sizeof(xv_frame_t)); if (!frame) return NULL; @@ -1189,7 +1189,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *class_gen, const void *vis xcb_xv_adaptor_info_iterator_t adaptor_it; xcb_xv_image_format_info_iterator_t format_it; - this = (xv_driver_t *) xine_xmalloc (sizeof (xv_driver_t)); + this = (xv_driver_t *) calloc(1, sizeof(xv_driver_t)); if (!this) return NULL; @@ -1460,7 +1460,7 @@ static vo_driver_t *open_plugin(video_driver_class_t *class_gen, const void *vis * class functions */ static void *init_class (xine_t *xine, void *visual_gen) { - xv_class_t *this = (xv_class_t *) xine_xmalloc (sizeof (xv_class_t)); + xv_class_t *this = (xv_class_t *) calloc(1, sizeof(xv_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "Xv"; diff --git a/src/video_out/video_out_xshm.c b/src/video_out/video_out_xshm.c index fba253b87..54cac9d46 100644 --- a/src/video_out/video_out_xshm.c +++ b/src/video_out/video_out_xshm.c @@ -280,7 +280,7 @@ static XImage *create_ximage (xshm_driver_t *this, XShmSegmentInfo *shminfo, this->bytes_per_pixel = this->bpp / 8; this->image_byte_order = myimage->byte_order; - myimage->data = xine_xcalloc (width * height, this->bytes_per_pixel); + myimage->data = calloc (width * height, this->bytes_per_pixel); } return myimage; @@ -391,7 +391,7 @@ static vo_frame_t *xshm_alloc_frame (vo_driver_t *this_gen) { xshm_frame_t *frame; xshm_driver_t *this = (xshm_driver_t *) this_gen; - frame = (xshm_frame_t *) xine_xmalloc (sizeof (xshm_frame_t)); + frame = (xshm_frame_t *) calloc(1, sizeof(xshm_frame_t)); if (!frame) return NULL; @@ -1074,7 +1074,7 @@ static vo_driver_t *xshm_open_plugin_2 (video_driver_class_t *class_gen, const v int cpu_byte_order; XColor dummy; - this = (xshm_driver_t *) xine_xmalloc (sizeof (xshm_driver_t)); + this = (xshm_driver_t *) calloc(1, sizeof(xshm_driver_t)); if (!this) return NULL; @@ -1286,7 +1286,7 @@ static vo_driver_t *xshm_open_plugin_old (video_driver_class_t *class_gen, const * class functions */ static void *xshm_init_class (xine_t *xine, void *visual_gen) { - xshm_class_t *this = (xshm_class_t *) xine_xmalloc (sizeof (xshm_class_t)); + xshm_class_t *this = (xshm_class_t *) calloc(1, sizeof(xshm_class_t)); this->driver_class.open_plugin = xshm_open_plugin_old; this->driver_class.identifier = "XShm"; diff --git a/src/video_out/video_out_xv.c b/src/video_out/video_out_xv.c index 0026bd8af..c78200077 100644 --- a/src/video_out/video_out_xv.c +++ b/src/video_out/video_out_xv.c @@ -206,7 +206,7 @@ static vo_frame_t *xv_alloc_frame (vo_driver_t *this_gen) { /* xv_driver_t *this = (xv_driver_t *) this_gen; */ xv_frame_t *frame ; - frame = (xv_frame_t *) xine_xmalloc (sizeof (xv_frame_t)); + frame = (xv_frame_t *) calloc(1, sizeof(xv_frame_t)); if (!frame) return NULL; @@ -720,8 +720,8 @@ static void xv_display_frame (vo_driver_t *this_gen, vo_frame_t *frame_gen) { if( factor > 1 ) { - lprintf( "%s PutImage %dX interval (%fs)\n", - log_line_prefix(), factor, elapse_time ); + lprintf( "%s PutImage %dX interval (%fs)\n", + LOG_MODULE, factor, elapse_time ); } } @@ -1220,7 +1220,7 @@ static vo_driver_t *open_plugin_2 (video_driver_class_t *class_gen, const void * unsigned int adaptor_num; xv_prefertype prefer_type; - this = (xv_driver_t *) xine_xmalloc (sizeof (xv_driver_t)); + this = (xv_driver_t *) calloc(1, sizeof(xv_driver_t)); if (!this) return NULL; @@ -1532,7 +1532,7 @@ static vo_driver_t *open_plugin_old (video_driver_class_t *class_gen, const void * class functions */ static void *init_class (xine_t *xine, void *visual_gen) { - xv_class_t *this = (xv_class_t *) xine_xmalloc (sizeof (xv_class_t)); + xv_class_t *this = (xv_class_t *) calloc(1, sizeof(xv_class_t)); this->driver_class.open_plugin = open_plugin_old; this->driver_class.identifier = "Xv"; diff --git a/src/video_out/video_out_xvmc.c b/src/video_out/video_out_xvmc.c index 7f282ee53..5caf58fae 100644 --- a/src/video_out/video_out_xvmc.c +++ b/src/video_out/video_out_xvmc.c @@ -547,7 +547,7 @@ static vo_frame_t *xvmc_alloc_frame (vo_driver_t *this_gen) { lprintf ("xvmc_alloc_frame\n"); - frame = (xvmc_frame_t *) xine_xmalloc (sizeof (xvmc_frame_t)); + frame = calloc(1, sizeof (xvmc_frame_t)); if (!frame) return NULL; @@ -587,8 +587,8 @@ static cxid_t *xvmc_set_context (xvmc_driver_t *this, /* initialize block & macro block pointers first time */ if(macroblocks->blocks == NULL || macroblocks->macro_blocks == NULL) { - macroblocks->blocks = xine_xmalloc(sizeof(XvMCBlockArray)); - macroblocks->macro_blocks = xine_xmalloc(sizeof(XvMCMacroBlockArray)); + macroblocks->blocks = calloc(1, sizeof(XvMCBlockArray)); + macroblocks->macro_blocks = calloc(1, sizeof(XvMCMacroBlockArray)); lprintf("macroblocks->blocks %lx ->macro_blocks %lx\n", macroblocks->blocks,macroblocks->macro_blocks); @@ -1309,7 +1309,8 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi lprintf ("open_plugin\n"); - this = (xvmc_driver_t *) xine_xmalloc (sizeof (xvmc_driver_t)); + /* TODO ??? */ + this = calloc(1, sizeof (xvmc_driver_t)); if (!this) return NULL; diff --git a/src/video_out/video_out_xxmc.c b/src/video_out/video_out_xxmc.c index bd8a76046..297d4ad49 100644 --- a/src/video_out/video_out_xxmc.c +++ b/src/video_out/video_out_xxmc.c @@ -548,7 +548,7 @@ static vo_frame_t *xxmc_alloc_frame (vo_driver_t *this_gen) { xxmc_driver_t *this = (xxmc_driver_t *) this_gen; xxmc_frame_t *frame ; - frame = (xxmc_frame_t *) xine_xmalloc (sizeof (xxmc_frame_t)); + frame = calloc(1, sizeof (xxmc_frame_t)); if (!frame) return NULL; @@ -2453,7 +2453,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi int use_more_frames; int use_unscaled; - this = (xxmc_driver_t *) xine_xmalloc (sizeof (xxmc_driver_t)); + this = calloc(1, sizeof (xxmc_driver_t)); if (!this) return NULL; @@ -2800,7 +2800,7 @@ static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *vi * class functions */ static void *init_class (xine_t *xine, void *visual_gen) { - xxmc_class_t *this = (xxmc_class_t *) xine_xmalloc (sizeof (xxmc_class_t)); + xxmc_class_t *this = calloc(1, sizeof (xxmc_class_t)); this->driver_class.open_plugin = open_plugin; this->driver_class.identifier = "XxMC"; diff --git a/src/video_out/x11osd.c b/src/video_out/x11osd.c index 450812f90..702fabda9 100644 --- a/src/video_out/x11osd.c +++ b/src/video_out/x11osd.c @@ -245,7 +245,7 @@ x11osd_create (xine_t *xine, Display *display, int screen, Window window, enum x XSetWindowAttributes attr; XWindowAttributes getattr; - osd = xine_xmalloc (sizeof (x11osd)); + osd = calloc(1, sizeof(x11osd)); if (!osd) return NULL; diff --git a/src/video_out/xcbosd.c b/src/video_out/xcbosd.c index 8bb96be1e..2da723011 100644 --- a/src/video_out/xcbosd.c +++ b/src/video_out/xcbosd.c @@ -238,7 +238,7 @@ xcbosd *xcbosd_create(xine_t *xine, xcb_connection_t *connection, xcb_screen_t * xcb_void_cookie_t generic_cookie; xcb_generic_error_t *generic_error; - osd = xine_xmalloc (sizeof (xcbosd)); + osd = calloc(1, sizeof(xcbosd)); if (!osd) return NULL; diff --git a/src/video_out/yuv2rgb.c b/src/video_out/yuv2rgb.c index 127338ee5..7def639a4 100644 --- a/src/video_out/yuv2rgb.c +++ b/src/video_out/yuv2rgb.c @@ -3146,7 +3146,7 @@ static void yuy22rgb_c_init (yuv2rgb_factory_t *this) static yuv2rgb_t *yuv2rgb_create_converter (yuv2rgb_factory_t *factory) { - yuv2rgb_t *this = xine_xmalloc (sizeof (yuv2rgb_t)); + yuv2rgb_t *this = calloc(1, sizeof(yuv2rgb_t)); this->swapped = factory->swapped; this->cmap = factory->cmap; diff --git a/src/video_out/yuv2rgb_mlib.c b/src/video_out/yuv2rgb_mlib.c index 794ce437e..b32817a90 100644 --- a/src/video_out/yuv2rgb_mlib.c +++ b/src/video_out/yuv2rgb_mlib.c @@ -38,8 +38,6 @@ #include <xine/xineutils.h> #include "yuv2rgb.h" -#define MIN(a, b) (((a) < (b)) ? (a) : (b)) - static void mlib_yuv420_rgb24(yuv2rgb_t *this, uint8_t * image, uint8_t * py, uint8_t * pu, uint8_t * pv) |