diff options
Diffstat (limited to 'sys')
| -rw-r--r-- | sys/directdraw/gstdirectdrawplugin.c | 2 | ||||
| -rw-r--r-- | sys/directdraw/gstdirectdrawsink.c | 1485 | ||||
| -rw-r--r-- | sys/directdraw/gstdirectdrawsink.h | 13 | ||||
| -rw-r--r-- | sys/directsound/gstdirectsoundplugin.c | 2 | ||||
| -rw-r--r-- | sys/directsound/gstdirectsoundsink.c | 149 | ||||
| -rw-r--r-- | sys/directsound/gstdirectsoundsink.h | 4 |
6 files changed, 635 insertions, 1020 deletions
diff --git a/sys/directdraw/gstdirectdrawplugin.c b/sys/directdraw/gstdirectdrawplugin.c index 728551e0..14943020 100644 --- a/sys/directdraw/gstdirectdrawplugin.c +++ b/sys/directdraw/gstdirectdrawplugin.c @@ -38,5 +38,5 @@ plugin_init (GstPlugin * plugin) GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, "directdraw", - "DIRECTDRAW plugin library", + "Direct Draw plugin library", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/sys/directdraw/gstdirectdrawsink.c b/sys/directdraw/gstdirectdrawsink.c index 099be4e9..4dd0d834 100644 --- a/sys/directdraw/gstdirectdrawsink.c +++ b/sys/directdraw/gstdirectdrawsink.c @@ -27,10 +27,17 @@ * <para> * DirectdrawSink renders video frames to any win32 window. This element can receive * a window ID from the application through the XOverlay interface and will then render - * video frames in this drawable. + * video frames in this window. * If no Window ID was provided by the application, the element will create its * own internal window and render into it. * </para> + * <title>Examples</title> + * <para> + * Here is a simple pipeline to test the sink : + * <programlisting> + * gst-launch-0.10 -v videotestsrc ! directdrawsink + * </programlisting> + * </para> * </refsect2> */ @@ -40,103 +47,76 @@ #include "gstdirectdrawsink.h" -#include <fcntl.h> -#include <errno.h> -#ifdef HAVE_UNISTD_H -#include <unistd.h> -#endif -#include <string.h> - GST_DEBUG_CATEGORY_STATIC (directdrawsink_debug); #define GST_CAT_DEFAULT directdrawsink_debug /* elementfactory information */ -static const GstElementDetails gst_directdrawsink_details = -GST_ELEMENT_DETAILS ("Video Sink (DIRECTDRAW)", +static const GstElementDetails gst_directdraw_sink_details = +GST_ELEMENT_DETAILS ("Direct Draw Video Sink", "Sink/Video", - "Output to a video card via DIRECTDRAW", + "Output to a video card via Direct Draw", "Sebastien Moutte <sebastien@moutte.net>"); -static void gst_directdrawsink_init_interfaces (GType type); - -GST_BOILERPLATE_FULL (GstDirectDrawSink, gst_directdrawsink, GstVideoSink, - GST_TYPE_VIDEO_SINK, gst_directdrawsink_init_interfaces); +static void gst_directdraw_sink_init_interfaces (GType type); -static void gst_directdrawsink_finalize (GObject * object); +GST_BOILERPLATE_FULL (GstDirectDrawSink, gst_directdraw_sink, GstVideoSink, + GST_TYPE_VIDEO_SINK, gst_directdraw_sink_init_interfaces); -static void gst_directdrawsink_set_property (GObject * object, +static void gst_directdraw_sink_finalize (GObject * object); +static void gst_directdraw_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); -static void gst_directdrawsink_get_property (GObject * object, +static void gst_directdraw_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); - -static GstCaps *gst_directdrawsink_get_caps (GstBaseSink * bsink); -static gboolean gst_directdrawsink_set_caps (GstBaseSink * bsink, +static GstCaps *gst_directdraw_sink_get_caps (GstBaseSink * bsink); +static gboolean gst_directdraw_sink_set_caps (GstBaseSink * bsink, GstCaps * caps); - -static GstStateChangeReturn -gst_directdrawsink_change_state (GstElement * element, - GstStateChange transition); -static GstFlowReturn -gst_directdrawsink_buffer_alloc (GstBaseSink * bsink, guint64 offset, - guint size, GstCaps * caps, GstBuffer ** buf); -static void -gst_directdrawsink_get_times (GstBaseSink * bsink, GstBuffer * buf, +static GstStateChangeReturn gst_directdraw_sink_change_state (GstElement * + element, GstStateChange transition); +static GstFlowReturn gst_directdraw_sink_buffer_alloc (GstBaseSink * bsink, + guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf); +static void gst_directdraw_sink_get_times (GstBaseSink * bsink, GstBuffer * buf, GstClockTime * start, GstClockTime * end); -static GstFlowReturn -gst_directdrawsink_show_frame (GstBaseSink * bsink, GstBuffer * buf); +static GstFlowReturn gst_directdraw_sink_show_frame (GstBaseSink * bsink, + GstBuffer * buf); -static gboolean gst_directdrawsink_setup_ddraw (GstDirectDrawSink * ddrawsink); -static gboolean gst_directdrawsink_create_default_window (GstDirectDrawSink * +/* utils */ +static gboolean gst_directdraw_sink_setup_ddraw (GstDirectDrawSink * ddrawsink); +static gboolean gst_directdraw_sink_create_default_window (GstDirectDrawSink * ddrawsink); -static gboolean gst_directdrawsink_create_ddraw_surfaces (GstDirectDrawSink * +static gboolean gst_directdraw_sink_create_ddraw_surface (GstDirectDrawSink * ddrawsink); - -static GstCaps *gst_directdrawsink_get_ddrawcaps (GstDirectDrawSink * +static GstCaps *gst_directdraw_sink_get_ddrawcaps (GstDirectDrawSink * ddrawsink); - -static void gst_directdrawsink_cleanup (GstDirectDrawSink * ddrawsink); -static void gst_directdrawsink_bufferpool_clear (GstDirectDrawSink * ddrawsink); - -static void -gst_directdrawsink_ddraw_put (GstDirectDrawSink * ddrawsink, +static void gst_directdraw_sink_cleanup (GstDirectDrawSink * ddrawsink); +static void gst_directdraw_sink_bufferpool_clear (GstDirectDrawSink * + ddrawsink); +static void gst_directdraw_sink_ddraw_put (GstDirectDrawSink * ddrawsink, GstDDrawSurface * surface); - /* surfaces management functions */ -static void -gst_directdrawsink_surface_destroy (GstDirectDrawSink * ddrawsink, +static void gst_directdraw_sink_surface_destroy (GstDirectDrawSink * ddrawsink, GstDDrawSurface * surface); - -static GstDDrawSurface *gst_directdrawsink_surface_create (GstDirectDrawSink * +static GstDDrawSurface *gst_directdraw_sink_surface_create (GstDirectDrawSink * ddrawsink, GstCaps * caps, size_t size); static GstStaticPadTemplate directdrawsink_sink_factory = - GST_STATIC_PAD_TEMPLATE ("sink", +GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("video/x-raw-rgb, " "framerate = (fraction) [ 0, MAX ], " - "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]" -/* "; " - "video/x-raw-yuv, " - "framerate = (fraction) [ 0, MAX ], " - "width = (int) [ 1, MAX ], " - "height = (int) [ 1, MAX ], " - "format = (fourcc) YV12" -*/ - ) + "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]") ); enum { PROP_0, - PROP_SURFACE, PROP_KEEP_ASPECT_RATIO }; -/* interfaces stuff */ +/* XOverlay interface implementation */ static gboolean -gst_directdrawsink_interface_supported (GstImplementsInterface * iface, +gst_directdraw_sink_interface_supported (GstImplementsInterface * iface, GType type) { g_assert (type == GST_TYPE_X_OVERLAY); @@ -144,13 +124,13 @@ gst_directdrawsink_interface_supported (GstImplementsInterface * iface, } static void -gst_directdrawsink_interface_init (GstImplementsInterfaceClass * klass) +gst_directdraw_sink_interface_init (GstImplementsInterfaceClass * klass) { - klass->supported = gst_directdrawsink_interface_supported; + klass->supported = gst_directdraw_sink_interface_supported; } static void -gst_directdrawsink_set_window_id (GstXOverlay * overlay, ULONG window_id) +gst_directdraw_sink_set_window_id (GstXOverlay * overlay, ULONG window_id) { GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (overlay); @@ -163,7 +143,6 @@ gst_directdrawsink_set_window_id (GstXOverlay * overlay, ULONG window_id) ddrawsink->video_window = (HWND) window_id; ddrawsink->our_video_window = FALSE; - if (ddrawsink->setup) { /* update the clipper object with the new window */ hres = IDirectDrawClipper_SetHWnd (ddrawsink->clipper, 0, @@ -173,31 +152,31 @@ gst_directdrawsink_set_window_id (GstXOverlay * overlay, ULONG window_id) } static void -gst_directdrawsink_expose (GstXOverlay * overlay) +gst_directdraw_sink_expose (GstXOverlay * overlay) { GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (overlay); - gst_directdrawsink_show_frame (GST_BASE_SINK (ddrawsink), NULL); + gst_directdraw_sink_show_frame (GST_BASE_SINK (ddrawsink), NULL); } static void -gst_directdrawsink_xoverlay_interface_init (GstXOverlayClass * iface) +gst_directdraw_sink_xoverlay_interface_init (GstXOverlayClass * iface) { - iface->set_xwindow_id = gst_directdrawsink_set_window_id; - iface->expose = gst_directdrawsink_expose; + iface->set_xwindow_id = gst_directdraw_sink_set_window_id; + iface->expose = gst_directdraw_sink_expose; } static void -gst_directdrawsink_init_interfaces (GType type) +gst_directdraw_sink_init_interfaces (GType type) { static const GInterfaceInfo iface_info = { - (GInterfaceInitFunc) gst_directdrawsink_interface_init, + (GInterfaceInitFunc) gst_directdraw_sink_interface_init, NULL, NULL, }; static const GInterfaceInfo xoverlay_info = { - (GInterfaceInitFunc) gst_directdrawsink_xoverlay_interface_init, + (GInterfaceInitFunc) gst_directdraw_sink_xoverlay_interface_init, NULL, NULL, }; @@ -207,25 +186,26 @@ gst_directdrawsink_init_interfaces (GType type) g_type_add_interface_static (type, GST_TYPE_X_OVERLAY, &xoverlay_info); } - /* Utility functions */ + +/* this function fill a DDPIXELFORMAT using Gstreamer caps */ static gboolean -gst_ddrawvideosink_get_format_from_caps (GstCaps * caps, - DDPIXELFORMAT * pPixelFormat) +gst_ddrawvideosink_get_format_from_caps (GstDirectDrawSink * ddrawsink, + GstCaps * caps, DDPIXELFORMAT * pPixelFormat) { GstStructure *structure = NULL; gboolean ret = TRUE; - /*check params */ + /* check params */ g_return_val_if_fail (pPixelFormat, FALSE); g_return_val_if_fail (caps, FALSE); - /*init structure */ + /* init structure */ memset (pPixelFormat, 0, sizeof (DDPIXELFORMAT)); pPixelFormat->dwSize = sizeof (DDPIXELFORMAT); if (!(structure = gst_caps_get_structure (caps, 0))) { - GST_CAT_ERROR (directdrawsink_debug, + GST_CAT_ERROR_OBJECT (directdrawsink_debug, ddrawsink, "can't get structure pointer from caps"); return FALSE; } @@ -258,7 +238,7 @@ gst_ddrawvideosink_get_format_from_caps (GstCaps * caps, ret &= gst_structure_get_fourcc (structure, "format", &fourcc); pPixelFormat->dwFourCC = fourcc; } else { - GST_CAT_WARNING (directdrawsink_debug, + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, "unknown caps name received %" GST_PTR_FORMAT, caps); ret = FALSE; } @@ -266,46 +246,11 @@ gst_ddrawvideosink_get_format_from_caps (GstCaps * caps, return ret; } -/* -static GstCaps * -gst_ddrawvideosink_get_caps_from_format (DDPIXELFORMAT pixel_format) -{ - GstCaps *caps = NULL; - gint bpp, depth; - guint32 fourcc; - - if ((pixel_format.dwFlags & DDPF_RGB) == DDPF_RGB) { - bpp = pixel_format.dwRGBBitCount; - if (bpp != 32) - depth = bpp; - else { - if ((pixel_format.dwFlags & DDPF_ALPHAPREMULT) == DDPF_ALPHAPREMULT) - depth = 32; - else - depth = 24; - } - caps = gst_caps_new_simple ("video/x-raw-rgb", - "bpp", G_TYPE_INT, bpp, - "depth", G_TYPE_INT, depth, - "endianness", G_TYPE_INT, G_LITTLE_ENDIAN, - NULL); - } - - if ((pixel_format.dwFlags & DDPF_YUV) == DDPF_YUV) { - fourcc = pixel_format.dwFourCC; - caps = gst_caps_new_simple ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, fourcc, - NULL); - } - - g_assert (caps != NULL); - - return caps; -} -*/ - +/* This function centers the RECT of source surface to +a dest surface and set the result RECT into result */ static void -gst_directdrawsink_center_rect (RECT src, RECT dst, RECT * result) +gst_directdraw_sink_center_rect (GstDirectDrawSink * ddrawsink, RECT src, + RECT dst, RECT * result) { gdouble src_ratio, dst_ratio; long src_width = src.right; @@ -320,7 +265,7 @@ gst_directdrawsink_center_rect (RECT src, RECT dst, RECT * result) dst_ratio = (gdouble) dst_width / dst_heigth; if (src_ratio > dst_ratio) { - /*new height */ + /* new height */ result_height = (long) (dst_width / src_ratio); result->left = dst.left; @@ -329,7 +274,7 @@ gst_directdrawsink_center_rect (RECT src, RECT dst, RECT * result) result->bottom = result->top + result_height; } else if (src_ratio < dst_ratio) { - /*new width */ + /* new width */ result_width = (long) (dst_heigth * src_ratio); result->top = dst.top; @@ -338,62 +283,233 @@ gst_directdrawsink_center_rect (RECT src, RECT dst, RECT * result) result->right = result->left + result_width; } else { - /*same ratio */ + /* same ratio */ memcpy (result, &dst, sizeof (RECT)); } - GST_CAT_INFO (directdrawsink_debug, + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "source is %ldx%ld dest is %ldx%ld, result is %ldx%ld with x,y %ldx%ld", src_width, src_height, dst_width, dst_heigth, result->right - result->left, result->bottom - result->top, result->left, result->right); } -/************************************************************************/ -/* subclass of GstBuffer which manages surfaces lifetime */ -/* */ -/************************************************************************/ -static void -gst_ddrawsurface_finalize (GstDDrawSurface * surface) +/** + * Get DirectDraw error message. + * @hr: HRESULT code + * Returns: Text representation of the error. + */ +char * +DDErrorString (HRESULT hr) { - GstDirectDrawSink *ddrawsink = NULL; - - g_return_if_fail (surface != NULL); - - ddrawsink = surface->ddrawsink; - if (!ddrawsink) - goto no_sink; - - /* If our geometry changed we can't reuse that image. */ - if ((surface->width != ddrawsink->video_width) || - (surface->height != ddrawsink->video_height) || - (memcmp (&surface->dd_pixel_format, &ddrawsink->dd_pixel_format, - sizeof (DDPIXELFORMAT)) != 0) - ) { - GST_CAT_INFO (directdrawsink_debug, - "destroy image as its size changed %dx%d vs current %dx%d", - surface->width, surface->height, ddrawsink->video_width, - ddrawsink->video_height); - gst_directdrawsink_surface_destroy (ddrawsink, surface); - - } else { - /* In that case we can reuse the image and add it to our image pool. */ - GST_CAT_INFO (directdrawsink_debug, "recycling image in pool"); - - /* need to increment the refcount again to recycle */ - gst_buffer_ref (GST_BUFFER (surface)); - - g_mutex_lock (ddrawsink->pool_lock); - ddrawsink->buffer_pool = g_slist_prepend (ddrawsink->buffer_pool, surface); - g_mutex_unlock (ddrawsink->pool_lock); + switch (hr) { + case DDERR_ALREADYINITIALIZED: + return "DDERR_ALREADYINITIALIZED"; + case DDERR_CANNOTATTACHSURFACE: + return "DDERR_CANNOTATTACHSURFACE"; + case DDERR_CANNOTDETACHSURFACE: + return "DDERR_CANNOTDETACHSURFACE"; + case DDERR_CURRENTLYNOTAVAIL: + return "DDERR_CURRENTLYNOTAVAIL"; + case DDERR_EXCEPTION: + return "DDERR_EXCEPTION"; + case DDERR_GENERIC: + return "DDERR_GENERIC"; + case DDERR_HEIGHTALIGN: + return "DDERR_HEIGHTALIGN"; + case DDERR_INCOMPATIBLEPRIMARY: + return "DDERR_INCOMPATIBLEPRIMARY"; + case DDERR_INVALIDCAPS: + return "DDERR_INVALIDCAPS"; + case DDERR_INVALIDCLIPLIST: + return "DDERR_INVALIDCLIPLIST"; + case DDERR_INVALIDMODE: + return "DDERR_INVALIDMODE"; + case DDERR_INVALIDOBJECT: + return "DDERR_INVALIDOBJECT"; + case DDERR_INVALIDPARAMS: + return "DDERR_INVALIDPARAMS"; + case DDERR_INVALIDPIXELFORMAT: + return "DDERR_INVALIDPIXELFORMAT"; + case DDERR_INVALIDRECT: + return "DDERR_INVALIDRECT"; + case DDERR_LOCKEDSURFACES: + return "DDERR_LOCKEDSURFACES"; + case DDERR_NO3D: + return "DDERR_NO3D"; + case DDERR_NOALPHAHW: + return "DDERR_NOALPHAHW"; + case DDERR_NOCLIPLIST: + return "DDERR_NOCLIPLIST"; + case DDERR_NOCOLORCONVHW: + return "DDERR_NOCOLORCONVHW"; + case DDERR_NOCOOPERATIVELEVELSET: + return "DDERR_NOCOOPERATIVELEVELSET"; + case DDERR_NOCOLORKEY: + return "DDERR_NOCOLORKEY"; + case DDERR_NOCOLORKEYHW: + return "DDERR_NOCOLORKEYHW"; + case DDERR_NODIRECTDRAWSUPPORT: + return "DDERR_NODIRECTDRAWSUPPORT"; + case DDERR_NOEXCLUSIVEMODE: + return "DDERR_NOEXCLUSIVEMODE"; + case DDERR_NOFLIPHW: + return "DDERR_NOFLIPHW"; + case DDERR_NOGDI: + return "DDERR_NOGDI"; + case DDERR_NOMIRRORHW: + return "DDERR_NOMIRRORHW"; + case DDERR_NOTFOUND: + return "DDERR_NOTFOUND"; + case DDERR_NOOVERLAYHW: + return "DDERR_NOOVERLAYHW"; + case DDERR_NORASTEROPHW: + return "DDERR_NORASTEROPHW"; + case DDERR_NOROTATIONHW: + return "DDERR_NOROTATIONHW"; + case DDERR_NOSTRETCHHW: + return "DDERR_NOSTRETCHHW"; + case DDERR_NOT4BITCOLOR: + return "DDERR_NOT4BITCOLOR"; + case DDERR_NOT4BITCOLORINDEX: + return "DDERR_NOT4BITCOLORINDEX"; + case DDERR_NOT8BITCOLOR: + return "DDERR_NOT8BITCOLOR"; + case DDERR_NOTEXTUREHW: + return "DDERR_NOTEXTUREHW"; + case DDERR_NOVSYNCHW: + return "DDERR_NOVSYNCHW"; + case DDERR_NOZBUFFERHW: + return "DDERR_NOZBUFFERHW"; + case DDERR_NOZOVERLAYHW: + return "DDERR_NOZOVERLAYHW"; + case DDERR_OUTOFCAPS: + return "DDERR_OUTOFCAPS"; + case DDERR_OUTOFMEMORY: + return "DDERR_OUTOFMEMORY"; + case DDERR_OUTOFVIDEOMEMORY: + return "DDERR_OUTOFVIDEOMEMORY"; + case DDERR_OVERLAYCANTCLIP: + return "DDERR_OVERLAYCANTCLIP"; + case DDERR_OVERLAYCOLORKEYONLYONEACTIVE: + return "DDERR_OVERLAYCOLORKEYONLYONEACTIVE"; + case DDERR_PALETTEBUSY: + return "DDERR_PALETTEBUSY"; + case DDERR_COLORKEYNOTSET: + return "DDERR_COLORKEYNOTSET"; + case DDERR_SURFACEALREADYATTACHED: + return "DDERR_SURFACEALREADYATTACHED"; + case DDERR_SURFACEALREADYDEPENDENT: + return "DDERR_SURFACEALREADYDEPENDENT"; + case DDERR_SURFACEBUSY: + return "DDERR_SURFACEBUSY"; + case DDERR_CANTLOCKSURFACE: + return "DDERR_CANTLOCKSURFACE"; + case DDERR_SURFACEISOBSCURED: + return "DDERR_SURFACEISOBSCURED"; + case DDERR_SURFACELOST: + return "DDERR_SURFACELOST"; + case DDERR_SURFACENOTATTACHED: + return "DDERR_SURFACENOTATTACHED"; + case DDERR_TOOBIGHEIGHT: + return "DDERR_TOOBIGHEIGHT"; + case DDERR_TOOBIGSIZE: + return "DDERR_TOOBIGSIZE"; + case DDERR_TOOBIGWIDTH: + return "DDERR_TOOBIGWIDTH"; + case DDERR_UNSUPPORTED: + return "DDERR_UNSUPPORTED"; + case DDERR_UNSUPPORTEDFORMAT: + return "DDERR_UNSUPPORTEDFORMAT"; + case DDERR_UNSUPPORTEDMASK: + return "DDERR_UNSUPPORTEDMASK"; + case DDERR_VERTICALBLANKINPROGRESS: + return "DDERR_VERTICALBLANKINPROGRESS"; + case DDERR_WASSTILLDRAWING: + return "DDERR_WASSTILLDRAWING"; + case DDERR_XALIGN: + return "DDERR_XALIGN"; + case DDERR_INVALIDDIRECTDRAWGUID: + return "DDERR_INVALIDDIRECTDRAWGUID"; + case DDERR_DIRECTDRAWALREADYCREATED: + return "DDERR_DIRECTDRAWALREADYCREATED"; + case DDERR_NODIRECTDRAWHW: + return "DDERR_NODIRECTDRAWHW"; + case DDERR_PRIMARYSURFACEALREADYEXISTS: + return "DDERR_PRIMARYSURFACEALREADYEXISTS"; + case DDERR_NOEMULATION: + return "DDERR_NOEMULATION"; + case DDERR_REGIONTOOSMALL: + return "DDERR_REGIONTOOSMALL"; + case DDERR_CLIPPERISUSINGHWND: + return "DDERR_CLIPPERISUSINGHWND"; + case DDERR_NOCLIPPERATTACHED: + return "DDERR_NOCLIPPERATTACHED"; + case DDERR_NOHWND: + return "DDERR_NOHWND"; + case DDERR_HWNDSUBCLASSED: + return "DDERR_HWNDSUBCLASSED"; + case DDERR_HWNDALREADYSET: + return "DDERR_HWNDALREADYSET"; + case DDERR_NOPALETTEATTACHED: + return "DDERR_NOPALETTEATTACHED"; + case DDERR_NOPALETTEHW: + return "DDERR_NOPALETTEHW"; + case DDERR_BLTFASTCANTCLIP: + return "DDERR_BLTFASTCANTCLIP"; + case DDERR_NOBLTHW: + return "DDERR_NOBLTHW"; + case DDERR_NODDROPSHW: + return "DDERR_NODDROPSHW"; + case DDERR_OVERLAYNOTVISIBLE: + return "DDERR_OVERLAYNOTVISIBLE"; + case DDERR_NOOVERLAYDEST: + return "DDERR_NOOVERLAYDEST"; + case DDERR_INVALIDPOSITION: + return "DDERR_INVALIDPOSITION"; + case DDERR_NOTAOVERLAYSURFACE: + return "DDERR_NOTAOVERLAYSURFACE"; + case DDERR_EXCLUSIVEMODEALREADYSET: + return "DDERR_EXCLUSIVEMODEALREADYSET"; + case DDERR_NOTFLIPPABLE: + return "DDERR_NOTFLIPPABLE"; + case DDERR_CANTDUPLICATE: + return "DDERR_CANTDUPLICATE"; + case DDERR_NOTLOCKED: + return "DDERR_NOTLOCKED"; + case DDERR_CANTCREATEDC: + return "DDERR_CANTCREATEDC"; + case DDERR_NODC: + return "DDERR_NODC"; + case DDERR_WRONGMODE: + return "DDERR_WRONGMODE"; + case DDERR_IMPLICITLYCREATED: + return "DDERR_IMPLICITLYCREATED"; + case DDERR_NOTPALETTIZED: + return "DDERR_NOTPALETTIZED"; + case DDERR_UNSUPPORTEDMODE: + return "DDERR_UNSUPPORTEDMODE"; + case DDERR_NOMIPMAPHW: + return "DDERR_NOMIPMAPHW"; + case DDERR_INVALIDSURFACETYPE: + return "DDERR_INVALIDSURFACETYPE"; + case DDERR_DCALREADYCREATED: + return "DDERR_DCALREADYCREATED"; + case DDERR_CANTPAGELOCK: + return "DDERR_CANTPAGELOCK"; + case DDERR_CANTPAGEUNLOCK: + return "DDERR_CANTPAGEUNLOCK"; + case DDERR_NOTPAGELOCKED: + return "DDERR_NOTPAGELOCKED"; + case DDERR_NOTINITIALIZED: + return "DDERR_NOTINITIALIZED"; } - return; - -no_sink: - GST_CAT_WARNING (directdrawsink_debug, "no sink found"); - return; + return "Unknown Error"; } +/* Subclass of GstBuffer which manages buffer_pool surfaces lifetime */ +static void gst_ddrawsurface_finalize (GstDDrawSurface * surface); + static void gst_ddrawsurface_init (GstDDrawSurface * surface, gpointer g_class) { @@ -411,8 +527,7 @@ gst_ddrawsurface_class_init (gpointer g_class, gpointer class_data) { GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class); - mini_object_class->finalize = (GstMiniObjectFinalizeFunction) - gst_ddrawsurface_finalize; + mini_object_class->finalize = GST_DEBUG_FUNCPTR (gst_ddrawsurface_finalize); } GType @@ -439,21 +554,63 @@ gst_ddrawsurface_get_type (void) return _gst_ddrawsurface_type; } +static void +gst_ddrawsurface_finalize (GstDDrawSurface * surface) +{ + GstDirectDrawSink *ddrawsink = NULL; + + g_return_if_fail (surface != NULL); + + ddrawsink = surface->ddrawsink; + if (!ddrawsink) + goto no_sink; + + /* If our geometry changed we can't reuse that image. */ + if ((surface->width != ddrawsink->video_width) || + (surface->height != ddrawsink->video_height) || + (memcmp (&surface->dd_pixel_format, &ddrawsink->dd_pixel_format, + sizeof (DDPIXELFORMAT)) != 0) + ) { + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, + "destroy image as its size changed %dx%d vs current %dx%d", + surface->width, surface->height, ddrawsink->video_width, + ddrawsink->video_height); + gst_directdraw_sink_surface_destroy (ddrawsink, surface); + } else { + /* In that case we can reuse the image and add it to our image pool. */ + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, + "recycling image in pool"); + /* need to increment the refcount again to recycle */ + gst_buffer_ref (GST_BUFFER (surface)); + + g_mutex_lock (ddrawsink->pool_lock); + ddrawsink->buffer_pool = g_slist_prepend (ddrawsink->buffer_pool, surface); + g_mutex_unlock (ddrawsink->pool_lock); + } + return; + +no_sink: + GST_WARNING (directdrawsink_debug, "no sink found"); + return; +} + +/************************************************************************/ +/* Directdraw sink functions */ +/************************************************************************/ static void -gst_directdrawsink_base_init (gpointer g_class) +gst_directdraw_sink_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); - gst_element_class_set_details (element_class, &gst_directdrawsink_details); - + gst_element_class_set_details (element_class, &gst_directdraw_sink_details); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&directdrawsink_sink_factory)); } static void -gst_directdrawsink_class_init (GstDirectDrawSinkClass * klass) +gst_directdraw_sink_class_init (GstDirectDrawSinkClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; @@ -464,55 +621,43 @@ gst_directdrawsink_class_init (GstDirectDrawSinkClass * klass) gstelement_class = (GstElementClass *) klass; GST_DEBUG_CATEGORY_INIT (directdrawsink_debug, "directdrawsink", 0, - "Direct draw sink"); - - gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_directdrawsink_finalize); + "Directdraw sink"); + gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_directdraw_sink_finalize); gobject_class->get_property = - GST_DEBUG_FUNCPTR (gst_directdrawsink_get_property); + GST_DEBUG_FUNCPTR (gst_directdraw_sink_get_property); gobject_class->set_property = - GST_DEBUG_FUNCPTR (gst_directdrawsink_set_property); - + GST_DEBUG_FUNCPTR (gst_directdraw_sink_set_property); gstelement_class->change_state = - GST_DEBUG_FUNCPTR (gst_directdrawsink_change_state); - gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_directdrawsink_get_caps); - gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_directdrawsink_set_caps); + GST_DEBUG_FUNCPTR (gst_directdraw_sink_change_state); + gstbasesink_class->get_caps = + GST_DEBUG_FUNCPTR (gst_directdraw_sink_get_caps); + gstbasesink_class->set_caps = + GST_DEBUG_FUNCPTR (gst_directdraw_sink_set_caps); gstbasesink_class->preroll = - GST_DEBUG_FUNCPTR (gst_directdrawsink_show_frame); - gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_directdrawsink_show_frame); - + GST_DEBUG_FUNCPTR (gst_directdraw_sink_show_frame); + gstbasesink_class->render = + GST_DEBUG_FUNCPTR (gst_directdraw_sink_show_frame); gstbasesink_class->get_times = - GST_DEBUG_FUNCPTR (gst_directdrawsink_get_times); + GST_DEBUG_FUNCPTR (gst_directdraw_sink_get_times); gstbasesink_class->buffer_alloc = - GST_DEBUG_FUNCPTR (gst_directdrawsink_buffer_alloc); + GST_DEBUG_FUNCPTR (gst_directdraw_sink_buffer_alloc); - /*install properties */ - /*extern surface where we will blit the video */ - g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SURFACE, - g_param_spec_pointer ("surface", "Surface", - "The target surface for video", G_PARAM_WRITABLE)); - - /*setup aspect ratio mode */ + /* install properties */ + /* setup aspect ratio mode */ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_KEEP_ASPECT_RATIO, g_param_spec_boolean ("keep-aspect-ratio", - "keep-aspect-ratio", "boolean to video keep aspect ratio", FALSE, + "keep-aspect-ratio", "keep the aspect ratio or not", FALSE, G_PARAM_READWRITE)); - - /*should add a color_key property to permit applications to define the color used for overlays */ } static void -gst_directdrawsink_set_property (GObject * object, guint prop_id, +gst_directdraw_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { - GstDirectDrawSink *ddrawsink; - - ddrawsink = GST_DIRECTDRAW_SINK (object); + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (object); switch (prop_id) { - case PROP_SURFACE: - ddrawsink->extern_surface = g_value_get_pointer (value); - break; case PROP_KEEP_ASPECT_RATIO: ddrawsink->keep_aspect_ratio = g_value_get_boolean (value); break; @@ -523,12 +668,10 @@ gst_directdrawsink_set_property (GObject * object, guint prop_id, } static void -gst_directdrawsink_get_property (GObject * object, guint prop_id, +gst_directdraw_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { - GstDirectDrawSink *ddrawsink; - - ddrawsink = GST_DIRECTDRAW_SINK (object); + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (object); switch (prop_id) { case PROP_KEEP_ASPECT_RATIO: @@ -541,82 +684,63 @@ gst_directdrawsink_get_property (GObject * object, guint prop_id, } static void -gst_directdrawsink_finalize (GObject * object) +gst_directdraw_sink_finalize (GObject * object) { - GstDirectDrawSink *ddrawsink; - - ddrawsink = GST_DIRECTDRAW_SINK (object); + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (object); if (ddrawsink->pool_lock) { g_mutex_free (ddrawsink->pool_lock); ddrawsink->pool_lock = NULL; } + if (ddrawsink->caps) { + gst_caps_unref (ddrawsink->caps); + ddrawsink->caps = NULL; + } if (ddrawsink->setup) { - gst_directdrawsink_cleanup (ddrawsink); + gst_directdraw_sink_cleanup (ddrawsink); } } static void -gst_directdrawsink_init (GstDirectDrawSink * ddrawsink, +gst_directdraw_sink_init (GstDirectDrawSink * ddrawsink, GstDirectDrawSinkClass * g_class) { /*init members variables */ ddrawsink->ddraw_object = NULL; ddrawsink->primary_surface = NULL; - ddrawsink->overlays = NULL; + ddrawsink->offscreen_surface = NULL; ddrawsink->clipper = NULL; - ddrawsink->extern_surface = NULL; ddrawsink->video_window = NULL; ddrawsink->our_video_window = TRUE; ddrawsink->last_buffer = NULL; + ddrawsink->caps = NULL; + ddrawsink->window_thread = NULL; + ddrawsink->setup = FALSE; + ddrawsink->buffer_pool = NULL; + ddrawsink->keep_aspect_ratio = FALSE; + ddrawsink->pool_lock = g_mutex_new (); + memset (&ddrawsink->dd_pixel_format, 0, sizeof (DDPIXELFORMAT)); /*video default values */ ddrawsink->video_height = 0; ddrawsink->video_width = 0; ddrawsink->fps_n = 0; ddrawsink->fps_d = 0; - - memset (&ddrawsink->dd_pixel_format, 0, sizeof (DDPIXELFORMAT)); - - ddrawsink->caps = NULL; - ddrawsink->window_thread = NULL; - ddrawsink->bUseOverlay = FALSE; - ddrawsink->color_key = 0; /*need to be a public property and may be we can enable overlays when this property is set ... */ - - ddrawsink->setup = FALSE; - - ddrawsink->buffer_pool = NULL; - - - ddrawsink->pool_lock = g_mutex_new (); - ddrawsink->keep_aspect_ratio = FALSE; } static GstCaps * -gst_directdrawsink_get_caps (GstBaseSink * bsink) +gst_directdraw_sink_get_caps (GstBaseSink * bsink) { - GstDirectDrawSink *ddrawsink; + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (bsink); GstCaps *caps = NULL; - ddrawsink = GST_DIRECTDRAW_SINK (bsink); - if (!ddrawsink->setup) { caps = gst_caps_copy (gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (ddrawsink))); - - GST_CAT_INFO (directdrawsink_debug, + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "getcaps called and we are not setup yet, " "returning template %" GST_PTR_FORMAT, caps); } else { - /*if (ddrawsink->extern_surface) { - * We are not rendering to our own surface, returning this surface's - * pixel format * - GST_WARNING ("using extern surface"); - caps = gst_ddrawvideosink_get_caps_from_format (ddrawsink->dd_pixel_format); - } else */ - - /* i think we can't really use the format of the extern surface as the application owning the surface doesn't know - the format we will render. But we need to use overlays to overlay any format on the extern surface */ caps = gst_caps_ref (ddrawsink->caps); } @@ -624,17 +748,13 @@ gst_directdrawsink_get_caps (GstBaseSink * bsink) } static gboolean -gst_directdrawsink_set_caps (GstBaseSink * bsink, GstCaps * caps) +gst_directdraw_sink_set_caps (GstBaseSink * bsink, GstCaps * caps) { - GstDirectDrawSink *ddrawsink; + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (bsink); GstStructure *structure = NULL; gboolean ret; const GValue *fps; - ddrawsink = GST_DIRECTDRAW_SINK (bsink); - - GST_CAT_INFO (directdrawsink_debug, "set_caps"); - structure = gst_caps_get_structure (caps, 0); if (!structure) return FALSE; @@ -644,10 +764,13 @@ gst_directdrawsink_set_caps (GstBaseSink * bsink, GstCaps * caps) fps = gst_structure_get_value (structure, "framerate"); ret &= (fps != NULL); ret &= - gst_ddrawvideosink_get_format_from_caps (caps, + gst_ddrawvideosink_get_format_from_caps (ddrawsink, caps, &ddrawsink->dd_pixel_format); - if (!ret) + if (!ret) { + GST_ELEMENT_ERROR (ddrawsink, CORE, NEGOTIATION, + ("Failed to get caps properties from caps"), (NULL)); return FALSE; + } ddrawsink->fps_n = gst_value_get_fraction_numerator (fps); ddrawsink->fps_d = gst_value_get_fraction_denominator (fps); @@ -666,44 +789,32 @@ gst_directdrawsink_set_caps (GstBaseSink * bsink, GstCaps * caps) } /* create an offscreen surface with the caps */ - ret = gst_directdrawsink_create_ddraw_surfaces (ddrawsink); - if (!ret && ddrawsink->bUseOverlay) { - GST_CAT_WARNING (directdrawsink_debug, - "Can not create overlay surface, reverting to no overlay display"); - ddrawsink->bUseOverlay = FALSE; - ret = gst_directdrawsink_create_ddraw_surfaces (ddrawsink); - if (ret) { - return TRUE; - } - - /*could not create draw surfaces even with fallback, so leave everything as is */ - ddrawsink->bUseOverlay = TRUE; - } + ret = gst_directdraw_sink_create_ddraw_surface (ddrawsink); if (!ret) { - GST_CAT_ERROR (directdrawsink_debug, "Can not create ddraw surface"); + GST_ELEMENT_ERROR (ddrawsink, CORE, NEGOTIATION, + ("Can't create a directdraw offscreen surface with the input caps"), + (NULL)); } return ret; } static GstStateChangeReturn -gst_directdrawsink_change_state (GstElement * element, +gst_directdraw_sink_change_state (GstElement * element, GstStateChange transition) { - GstDirectDrawSink *ddrawsink; - - ddrawsink = GST_DIRECTDRAW_SINK (element); + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (element);; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: - if (ddrawsink->video_window == NULL && ddrawsink->extern_surface == NULL) - if (!gst_directdrawsink_create_default_window (ddrawsink)) + if (ddrawsink->video_window == NULL) + if (!gst_directdraw_sink_create_default_window (ddrawsink)) return GST_STATE_CHANGE_FAILURE; - if (!gst_directdrawsink_setup_ddraw (ddrawsink)) + if (!gst_directdraw_sink_setup_ddraw (ddrawsink)) return GST_STATE_CHANGE_FAILURE; - if (!(ddrawsink->caps = gst_directdrawsink_get_ddrawcaps (ddrawsink))) + if (!(ddrawsink->caps = gst_directdraw_sink_get_ddrawcaps (ddrawsink))) return GST_STATE_CHANGE_FAILURE; break; case GST_STATE_CHANGE_READY_TO_PAUSED: @@ -713,262 +824,40 @@ gst_directdrawsink_change_state (GstElement * element, case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: - ddrawsink->fps_n = 0; ddrawsink->fps_d = 1; ddrawsink->video_width = 0; ddrawsink->video_height = 0; - if (ddrawsink->buffer_pool) - gst_directdrawsink_bufferpool_clear (ddrawsink); - + gst_directdraw_sink_bufferpool_clear (ddrawsink); break; case GST_STATE_CHANGE_READY_TO_NULL: - if (ddrawsink->setup) - gst_directdrawsink_cleanup (ddrawsink); - + gst_directdraw_sink_cleanup (ddrawsink); break; } return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); } -/** - * Get DirectDraw error message. - * @hr: HRESULT code - * Returns: Text representation of the error. - */ -char * -DDErrorString (HRESULT hr) -{ - switch (hr) { - case DDERR_ALREADYINITIALIZED: - return "DDERR_ALREADYINITIALIZED"; - case DDERR_CANNOTATTACHSURFACE: - return "DDERR_CANNOTATTACHSURFACE"; - case DDERR_CANNOTDETACHSURFACE: - return "DDERR_CANNOTDETACHSURFACE"; - case DDERR_CURRENTLYNOTAVAIL: - return "DDERR_CURRENTLYNOTAVAIL"; - case DDERR_EXCEPTION: - return "DDERR_EXCEPTION"; - case DDERR_GENERIC: - return "DDERR_GENERIC"; - case DDERR_HEIGHTALIGN: - return "DDERR_HEIGHTALIGN"; - case DDERR_INCOMPATIBLEPRIMARY: - return "DDERR_INCOMPATIBLEPRIMARY"; - case DDERR_INVALIDCAPS: - return "DDERR_INVALIDCAPS"; - case DDERR_INVALIDCLIPLIST: - return "DDERR_INVALIDCLIPLIST"; - case DDERR_INVALIDMODE: - return "DDERR_INVALIDMODE"; - case DDERR_INVALIDOBJECT: - return "DDERR_INVALIDOBJECT"; - case DDERR_INVALIDPARAMS: - return "DDERR_INVALIDPARAMS"; - case DDERR_INVALIDPIXELFORMAT: - return "DDERR_INVALIDPIXELFORMAT"; - case DDERR_INVALIDRECT: - return "DDERR_INVALIDRECT"; - case DDERR_LOCKEDSURFACES: - return "DDERR_LOCKEDSURFACES"; - case DDERR_NO3D: - return "DDERR_NO3D"; - case DDERR_NOALPHAHW: - return "DDERR_NOALPHAHW"; - case DDERR_NOCLIPLIST: - return "DDERR_NOCLIPLIST"; - case DDERR_NOCOLORCONVHW: - return "DDERR_NOCOLORCONVHW"; - case DDERR_NOCOOPERATIVELEVELSET: - return "DDERR_NOCOOPERATIVELEVELSET"; - case DDERR_NOCOLORKEY: - return "DDERR_NOCOLORKEY"; - case DDERR_NOCOLORKEYHW: - return "DDERR_NOCOLORKEYHW"; - case DDERR_NODIRECTDRAWSUPPORT: - return "DDERR_NODIRECTDRAWSUPPORT"; - case DDERR_NOEXCLUSIVEMODE: - return "DDERR_NOEXCLUSIVEMODE"; - case DDERR_NOFLIPHW: - return "DDERR_NOFLIPHW"; - case DDERR_NOGDI: - return "DDERR_NOGDI"; - case DDERR_NOMIRRORHW: - return "DDERR_NOMIRRORHW"; - case DDERR_NOTFOUND: - return "DDERR_NOTFOUND"; - case DDERR_NOOVERLAYHW: - return "DDERR_NOOVERLAYHW"; - case DDERR_NORASTEROPHW: - return "DDERR_NORASTEROPHW"; - case DDERR_NOROTATIONHW: - return "DDERR_NOROTATIONHW"; - case DDERR_NOSTRETCHHW: - return "DDERR_NOSTRETCHHW"; - case DDERR_NOT4BITCOLOR: - return "DDERR_NOT4BITCOLOR"; - case DDERR_NOT4BITCOLORINDEX: - return "DDERR_NOT4BITCOLORINDEX"; - case DDERR_NOT8BITCOLOR: - return "DDERR_NOT8BITCOLOR"; - case DDERR_NOTEXTUREHW: - return "DDERR_NOTEXTUREHW"; - case DDERR_NOVSYNCHW: - return "DDERR_NOVSYNCHW"; - case DDERR_NOZBUFFERHW: - return "DDERR_NOZBUFFERHW"; - case DDERR_NOZOVERLAYHW: - return "DDERR_NOZOVERLAYHW"; - case DDERR_OUTOFCAPS: - return "DDERR_OUTOFCAPS"; - case DDERR_OUTOFMEMORY: - return "DDERR_OUTOFMEMORY"; - case DDERR_OUTOFVIDEOMEMORY: - return "DDERR_OUTOFVIDEOMEMORY"; - case DDERR_OVERLAYCANTCLIP: - return "DDERR_OVERLAYCANTCLIP"; - case DDERR_OVERLAYCOLORKEYONLYONEACTIVE: - return "DDERR_OVERLAYCOLORKEYONLYONEACTIVE"; - case DDERR_PALETTEBUSY: - return "DDERR_PALETTEBUSY"; - case DDERR_COLORKEYNOTSET: - return "DDERR_COLORKEYNOTSET"; - case DDERR_SURFACEALREADYATTACHED: - return "DDERR_SURFACEALREADYATTACHED"; - case DDERR_SURFACEALREADYDEPENDENT: - return "DDERR_SURFACEALREADYDEPENDENT"; - case DDERR_SURFACEBUSY: - return "DDERR_SURFACEBUSY"; - case DDERR_CANTLOCKSURFACE: - return "DDERR_CANTLOCKSURFACE"; - case DDERR_SURFACEISOBSCURED: - return "DDERR_SURFACEISOBSCURED"; - case DDERR_SURFACELOST: - return "DDERR_SURFACELOST"; - case DDERR_SURFACENOTATTACHED: - return "DDERR_SURFACENOTATTACHED"; - case DDERR_TOOBIGHEIGHT: - return "DDERR_TOOBIGHEIGHT"; - case DDERR_TOOBIGSIZE: - return "DDERR_TOOBIGSIZE"; - case DDERR_TOOBIGWIDTH: - return "DDERR_TOOBIGWIDTH"; - case DDERR_UNSUPPORTED: - return "DDERR_UNSUPPORTED"; - case DDERR_UNSUPPORTEDFORMAT: - return "DDERR_UNSUPPORTEDFORMAT"; - case DDERR_UNSUPPORTEDMASK: - return "DDERR_UNSUPPORTEDMASK"; - case DDERR_VERTICALBLANKINPROGRESS: - return "DDERR_VERTICALBLANKINPROGRESS"; - case DDERR_WASSTILLDRAWING: - return "DDERR_WASSTILLDRAWING"; - case DDERR_XALIGN: - return "DDERR_XALIGN"; - case DDERR_INVALIDDIRECTDRAWGUID: - return "DDERR_INVALIDDIRECTDRAWGUID"; - case DDERR_DIRECTDRAWALREADYCREATED: - return "DDERR_DIRECTDRAWALREADYCREATED"; - case DDERR_NODIRECTDRAWHW: - return "DDERR_NODIRECTDRAWHW"; - case DDERR_PRIMARYSURFACEALREADYEXISTS: - return "DDERR_PRIMARYSURFACEALREADYEXISTS"; - case DDERR_NOEMULATION: - return "DDERR_NOEMULATION"; - case DDERR_REGIONTOOSMALL: - return "DDERR_REGIONTOOSMALL"; - case DDERR_CLIPPERISUSINGHWND: - return "DDERR_CLIPPERISUSINGHWND"; - case DDERR_NOCLIPPERATTACHED: - return "DDERR_NOCLIPPERATTACHED"; - case DDERR_NOHWND: - return "DDERR_NOHWND"; - case DDERR_HWNDSUBCLASSED: - return "DDERR_HWNDSUBCLASSED"; - case DDERR_HWNDALREADYSET: - return "DDERR_HWNDALREADYSET"; - case DDERR_NOPALETTEATTACHED: - return "DDERR_NOPALETTEATTACHED"; - case DDERR_NOPALETTEHW: - return "DDERR_NOPALETTEHW"; - case DDERR_BLTFASTCANTCLIP: - return "DDERR_BLTFASTCANTCLIP"; - case DDERR_NOBLTHW: - return "DDERR_NOBLTHW"; - case DDERR_NODDROPSHW: - return "DDERR_NODDROPSHW"; - case DDERR_OVERLAYNOTVISIBLE: - return "DDERR_OVERLAYNOTVISIBLE"; - case DDERR_NOOVERLAYDEST: - return "DDERR_NOOVERLAYDEST"; - case DDERR_INVALIDPOSITION: - return "DDERR_INVALIDPOSITION"; - case DDERR_NOTAOVERLAYSURFACE: - return "DDERR_NOTAOVERLAYSURFACE"; - case DDERR_EXCLUSIVEMODEALREADYSET: - return "DDERR_EXCLUSIVEMODEALREADYSET"; - case DDERR_NOTFLIPPABLE: - return "DDERR_NOTFLIPPABLE"; - case DDERR_CANTDUPLICATE: - return "DDERR_CANTDUPLICATE"; - case DDERR_NOTLOCKED: - return "DDERR_NOTLOCKED"; - case DDERR_CANTCREATEDC: - return "DDERR_CANTCREATEDC"; - case DDERR_NODC: - return "DDERR_NODC"; - case DDERR_WRONGMODE: - return "DDERR_WRONGMODE"; - case DDERR_IMPLICITLYCREATED: - return "DDERR_IMPLICITLYCREATED"; - case DDERR_NOTPALETTIZED: - return "DDERR_NOTPALETTIZED"; - case DDERR_UNSUPPORTEDMODE: - return "DDERR_UNSUPPORTEDMODE"; - case DDERR_NOMIPMAPHW: - return "DDERR_NOMIPMAPHW"; - case DDERR_INVALIDSURFACETYPE: - return "DDERR_INVALIDSURFACETYPE"; - case DDERR_DCALREADYCREATED: - return "DDERR_DCALREADYCREATED"; - case DDERR_CANTPAGELOCK: - return "DDERR_CANTPAGELOCK"; - case DDERR_CANTPAGEUNLOCK: - return "DDERR_CANTPAGEUNLOCK"; - case DDERR_NOTPAGELOCKED: - return "DDERR_NOTPAGELOCKED"; - case DDERR_NOTINITIALIZED: - return "DDERR_NOTINITIALIZED"; - } - return "Unknown Error"; -} - - static GstFlowReturn -gst_directdrawsink_buffer_alloc (GstBaseSink * bsink, guint64 offset, +gst_directdraw_sink_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf) { - GstDirectDrawSink *ddrawsink = NULL; + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (bsink); GstDDrawSurface *surface = NULL; GstStructure *structure = NULL; GstFlowReturn ret = GST_FLOW_OK; - ddrawsink = GST_DIRECTDRAW_SINK (bsink); - GST_CAT_INFO (directdrawsink_debug, "a buffer of %d bytes was requested", - size); + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, + "a buffer of %d bytes was requested", size); structure = gst_caps_get_structure (caps, 0); - g_mutex_lock (ddrawsink->pool_lock); /* Inspect our buffer pool */ while (ddrawsink->buffer_pool) { surface = (GstDDrawSurface *) ddrawsink->buffer_pool->data; - if (surface) { /* Removing from the pool */ ddrawsink->buffer_pool = g_slist_delete_link (ddrawsink->buffer_pool, @@ -980,7 +869,7 @@ gst_directdrawsink_buffer_alloc (GstBaseSink * bsink, guint64 offset, (memcmp (&surface->dd_pixel_format, &ddrawsink->dd_pixel_format, sizeof (DDPIXELFORMAT))) ) { - gst_directdrawsink_surface_destroy (ddrawsink, surface); + gst_directdraw_sink_surface_destroy (ddrawsink, surface); surface = NULL; } else { /* We found a suitable surface */ @@ -991,7 +880,7 @@ gst_directdrawsink_buffer_alloc (GstBaseSink * bsink, guint64 offset, /* We haven't found anything, creating a new one */ if (!surface) { - surface = gst_directdrawsink_surface_create (ddrawsink, caps, size); + surface = gst_directdraw_sink_surface_create (ddrawsink, caps, size); } /* Now we should have a surface, set appropriate caps on it */ @@ -1006,119 +895,39 @@ gst_directdrawsink_buffer_alloc (GstBaseSink * bsink, guint64 offset, return ret; } -static gboolean -gst_directdrawsink_fill_colorkey (LPDIRECTDRAWSURFACE surface, DWORD dwColorKey) -{ - DDBLTFX ddbfx; - - if (!surface) - return FALSE; - - ddbfx.dwSize = sizeof (DDBLTFX); - ddbfx.dwFillColor = dwColorKey; - - if (IDirectDrawSurface7_Blt (surface, - NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbfx) == DD_OK) - return TRUE; - else - return FALSE; -} - -static void -gst_directdrawsink_show_overlay (GstDirectDrawSink * ddrawsink) -{ - HRESULT hRes; - RECT destsurf_rect, src_rect; - POINT dest_surf_point; - DDOVERLAYFX ddofx; - LPDIRECTDRAWSURFACE surface = NULL; - - if (!ddrawsink || !ddrawsink->overlays) - return; - - if (ddrawsink->extern_surface) - surface = ddrawsink->extern_surface; - else - surface = ddrawsink->primary_surface; - - if (ddrawsink->extern_surface) { - destsurf_rect.left = 0; - destsurf_rect.top = 0; - destsurf_rect.right = ddrawsink->out_width; - destsurf_rect.bottom = ddrawsink->out_height; - } else { - dest_surf_point.x = 0; - dest_surf_point.y = 0; - ClientToScreen (ddrawsink->video_window, &dest_surf_point); - GetClientRect (ddrawsink->video_window, &destsurf_rect); - OffsetRect (&destsurf_rect, dest_surf_point.x, dest_surf_point.y); - } - - if (ddrawsink->keep_aspect_ratio) { - src_rect.top = 0; - src_rect.left = 0; - src_rect.bottom = ddrawsink->video_height; - src_rect.right = ddrawsink->video_width; - gst_directdrawsink_center_rect (src_rect, destsurf_rect, &destsurf_rect); - } - - gst_directdrawsink_fill_colorkey (surface, ddrawsink->color_key); - - ddofx.dwSize = sizeof (DDOVERLAYFX); - ddofx.dckDestColorkey.dwColorSpaceLowValue = ddrawsink->color_key; - ddofx.dckDestColorkey.dwColorSpaceHighValue = ddrawsink->color_key; - - hRes = IDirectDrawSurface7_UpdateOverlay (ddrawsink->overlays, - NULL, surface, &destsurf_rect, DDOVER_KEYDESTOVERRIDE | DDOVER_SHOW, - &ddofx); -} - static GstFlowReturn -gst_directdrawsink_show_frame (GstBaseSink * bsink, GstBuffer * buf) +gst_directdraw_sink_show_frame (GstBaseSink * bsink, GstBuffer * buf) { - GstDirectDrawSink *ddrawsink; + GstDirectDrawSink *ddrawsink = GST_DIRECTDRAW_SINK (bsink); HRESULT hRes; - - DDSURFACEDESC2 surf_desc; RECT destsurf_rect, src_rect; POINT dest_surf_point; - LPDIRECTDRAWSURFACE lpSurface = NULL; - - ddrawsink = GST_DIRECTDRAW_SINK (bsink); - if (buf) { - /*save a reference to the input buffer */ + /* save a reference to the input buffer */ if (ddrawsink->last_buffer != buf) { if (ddrawsink->last_buffer) { - GST_LOG_OBJECT (ddrawsink, "unreffing %p", ddrawsink->last_buffer); + GST_CAT_LOG_OBJECT (directdrawsink_debug, ddrawsink, "unreffing %p", + ddrawsink->last_buffer); gst_buffer_unref (ddrawsink->last_buffer); } } - GST_LOG_OBJECT (ddrawsink, "reffing %p as our current buffer", buf); + GST_CAT_LOG_OBJECT (directdrawsink_debug, ddrawsink, + "reffing %p as our current buffer", buf); ddrawsink->last_buffer = gst_buffer_ref (buf); } else { - /*use last buffer */ + /* use last buffer */ buf = ddrawsink->last_buffer; } - if (buf == NULL) return GST_FLOW_ERROR; - - - if (ddrawsink->extern_surface) { - destsurf_rect.left = 0; - destsurf_rect.top = 0; - destsurf_rect.right = ddrawsink->out_width; - destsurf_rect.bottom = ddrawsink->out_height; - } else { - dest_surf_point.x = 0; - dest_surf_point.y = 0; - ClientToScreen (ddrawsink->video_window, &dest_surf_point); - GetClientRect (ddrawsink->video_window, &destsurf_rect); - OffsetRect (&destsurf_rect, dest_surf_point.x, dest_surf_point.y); - } + /* get the video window position */ + dest_surf_point.x = 0; + dest_surf_point.y = 0; + ClientToScreen (ddrawsink->video_window, &dest_surf_point); + GetClientRect (ddrawsink->video_window, &destsurf_rect); + OffsetRect (&destsurf_rect, dest_surf_point.x, dest_surf_point.y); if (ddrawsink->keep_aspect_ratio) { /* center image to dest image keeping aspect ratio */ @@ -1126,106 +935,67 @@ gst_directdrawsink_show_frame (GstBaseSink * bsink, GstBuffer * buf) src_rect.left = 0; src_rect.bottom = ddrawsink->video_height; src_rect.right = ddrawsink->video_width; - gst_directdrawsink_center_rect (src_rect, destsurf_rect, &destsurf_rect); - } - - if (ddrawsink->bUseOverlay) { - /*get the back buffer of the overlays flipping chain */ - DDSCAPS ddbackcaps; - - ddbackcaps.dwCaps = DDSCAPS_BACKBUFFER; - hRes = - IDirectDrawSurface7_GetAttachedSurface (ddrawsink->overlays, - &ddbackcaps, &lpSurface); - GST_CAT_WARNING (directdrawsink_debug, - "gst_directdrawsink_show_frame failed getting overlay backbuffer %s", - DDErrorString (hRes)); - } else { - /*use our offscreen surface */ - lpSurface = ddrawsink->offscreen_surface; + gst_directdraw_sink_center_rect (ddrawsink, src_rect, destsurf_rect, + &destsurf_rect); } - if (lpSurface == NULL) - return GST_FLOW_ERROR; - if (!GST_IS_DDRAWSURFACE (buf) || ((GST_IS_DDRAWSURFACE (buf)) && (GST_BUFFER (buf)->malloc_data))) { - + /* We are receiving a system memory buffer so we will copy + to the memory of our offscreen surface and next blit this surface + on the primary surface */ LPBYTE data = NULL; - guint src_pitch; - - /* Check for lost surface */ - if (IDirectDrawSurface7_IsLost (lpSurface) == DDERR_SURFACELOST) { - IDirectDrawSurface7_Restore (lpSurface); - } + guint src_pitch, line; + DDSURFACEDESC2 surf_desc; ZeroMemory (&surf_desc, sizeof (surf_desc)); surf_desc.dwSize = sizeof (surf_desc); + /* Check for lost surface */ + if (IDirectDrawSurface7_IsLost (ddrawsink->offscreen_surface) == + DDERR_SURFACELOST) { + IDirectDrawSurface7_Restore (ddrawsink->offscreen_surface); + } + /* Lock the surface */ hRes = - IDirectDrawSurface7_Lock (lpSurface, NULL, &surf_desc, DDLOCK_WAIT, - NULL); + IDirectDrawSurface7_Lock (ddrawsink->offscreen_surface, NULL, + &surf_desc, DDLOCK_WAIT, NULL); if (hRes != DD_OK) { - GST_CAT_WARNING (directdrawsink_debug, - "gst_directdrawsink_show_frame failed locking surface %s", + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "gst_directdraw_sink_show_frame failed locking surface %s", DDErrorString (hRes)); return GST_FLOW_ERROR; } - /* Write data */ + /* Write each line respecting the destination surface pitch */ data = surf_desc.lpSurface; - - /* Source video rowbytes */ src_pitch = GST_BUFFER_SIZE (buf) / ddrawsink->video_height; - - /* Write each line respecting dest surface pitch */ -/* for (line = 0; line < surf_desc.dwHeight; line++) { - memcpy (data, GST_BUFFER_DATA (buf) + (line * src_pitch), - src_pitch); + for (line = 0; line < surf_desc.dwHeight; line++) { + memcpy (data, GST_BUFFER_DATA (buf) + (line * src_pitch), src_pitch); data += surf_desc.lPitch; - }*/ - memcpy (data, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); + } /* Unlock the surface */ - hRes = IDirectDrawSurface7_Unlock (lpSurface, NULL); + hRes = IDirectDrawSurface7_Unlock (ddrawsink->offscreen_surface, NULL); if (hRes != DD_OK) { - GST_CAT_WARNING (directdrawsink_debug, - "gst_directdrawsink_show_frame failed unlocking surface %s", + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "gst_directdraw_sink_show_frame failed unlocking surface %s", DDErrorString (hRes)); return GST_FLOW_ERROR; } - if (ddrawsink->bUseOverlay) { - /*Flip to front overlay */ - hRes = - IDirectDrawSurface7_Flip (ddrawsink->overlays, lpSurface, - DDFLIP_WAIT); - IDirectDrawSurface7_Release (lpSurface); - lpSurface = NULL; - } else { - if (ddrawsink->extern_surface) { - if (ddrawsink->out_height == ddrawsink->video_height && - ddrawsink->out_width == ddrawsink->video_width) { - /*Fast blit to extern surface */ - hRes = IDirectDrawSurface7_BltFast (ddrawsink->extern_surface, 0, 0, - lpSurface, NULL, DDBLTFAST_WAIT); - - } else { - /*blit to extern surface (Blt will scale the video the dest rect surface if needed) */ - hRes = - IDirectDrawSurface7_Blt (ddrawsink->extern_surface, - &destsurf_rect, lpSurface, NULL, DDBLT_WAIT, NULL); - } - } else { - /*blit to primary surface ( Blt will scale the video the dest rect surface if needed */ - hRes = - IDirectDrawSurface7_Blt (ddrawsink->primary_surface, &destsurf_rect, - lpSurface, NULL, DDBLT_WAIT, NULL); - } - } - } else { + /* blit to primary surface ( Blt will scale the video the dest rect surface if needed */ + hRes = IDirectDrawSurface7_Blt (ddrawsink->primary_surface, &destsurf_rect, + ddrawsink->offscreen_surface, NULL, DDBLT_WAIT, NULL); + if (hRes != DD_OK) + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "IDirectDrawSurface7_Blt (object's offscreen surface) " "returned %s", + DDErrorString (hRes)); + } else { + /* We are receiving a directdraw surface (previously returned by our buffer pool + So we will simply blit it on the primary surface */ GstDDrawSurface *surface = NULL; surface = GST_DDRAWSURFACE (buf); @@ -1239,138 +1009,72 @@ gst_directdrawsink_show_frame (GstBaseSink * bsink, GstBuffer * buf) IDirectDrawSurface7_Restore (surface->surface); } - if (ddrawsink->bUseOverlay) { - /* blit to the overlays back buffer */ - hRes = IDirectDrawSurface7_Blt (lpSurface, NULL, - surface->surface, NULL, DDBLT_WAIT, NULL); - - hRes = IDirectDrawSurface7_Flip (ddrawsink->overlays, NULL, DDFLIP_WAIT); - if (hRes != DD_OK) - GST_CAT_WARNING (directdrawsink_debug, "error flipping"); - - } else { - if (ddrawsink->extern_surface) { - /*blit to the extern surface */ - if (ddrawsink->out_height == ddrawsink->video_height && - ddrawsink->out_width == ddrawsink->video_width) { - /*Fast blit to extern surface */ - hRes = IDirectDrawSurface7_BltFast (ddrawsink->extern_surface, 0, 0, - surface->surface, NULL, DDBLTFAST_WAIT); - - } else { - /*blit to extern surface (Blt will scale the video the dest rect surface if needed) */ - hRes = - IDirectDrawSurface7_Blt (ddrawsink->extern_surface, - &destsurf_rect, surface->surface, NULL, DDBLT_WAIT, NULL); - } - } else { - /*blit to our primary surface */ - hRes = - IDirectDrawSurface7_Blt (ddrawsink->primary_surface, &destsurf_rect, - surface->surface, NULL, DDBLT_WAIT, NULL); - if (hRes != DD_OK) - GST_CAT_WARNING (directdrawsink_debug, - "IDirectDrawSurface7_Blt returned %s", DDErrorString (hRes)); - else - GST_CAT_INFO (directdrawsink_debug, - "allocated surface was blit to our primary"); - } - } + /* blit to our primary surface */ + hRes = IDirectDrawSurface7_Blt (ddrawsink->primary_surface, &destsurf_rect, + surface->surface, NULL, DDBLT_WAIT, NULL); + if (hRes != DD_OK) + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "IDirectDrawSurface7_Blt (offscreen surface from buffer_alloc) " + "returned %s", DDErrorString (hRes)); } - if (ddrawsink->bUseOverlay) - gst_directdrawsink_show_overlay (ddrawsink); - return GST_FLOW_OK; } static gboolean -gst_directdrawsink_setup_ddraw (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_setup_ddraw (GstDirectDrawSink * ddrawsink) { gboolean bRet = TRUE; HRESULT hRes; DDSURFACEDESC2 dd_surface_desc; - //create an instance of the ddraw object + /* create an instance of the ddraw object use DDCREATE_EMULATIONONLY as first parameter to + force Directdraw to use the hardware emulation layer */ hRes = DirectDrawCreateEx ( /*DDCREATE_EMULATIONONLY */ 0, (void **) &ddrawsink->ddraw_object, &IID_IDirectDraw7, NULL); - if (hRes != DD_OK || ddrawsink->ddraw_object == NULL) { - GST_CAT_ERROR (directdrawsink_debug, "DirectDrawCreate failed with: %s", - DDErrorString (hRes)); + GST_ELEMENT_ERROR (ddrawsink, RESOURCE, WRITE, + ("Failed to create the DirectDraw object error=%s", + DDErrorString (hRes)), (NULL)); return FALSE; } /* set cooperative level */ hRes = IDirectDraw7_SetCooperativeLevel (ddrawsink->ddraw_object, ddrawsink->video_window, DDSCL_NORMAL); - if (hRes != DD_OK) { - GST_CAT_ERROR (directdrawsink_debug, "SetCooperativeLevel failed with: %s", - DDErrorString (hRes)); - bRet = FALSE; + GST_ELEMENT_ERROR (ddrawsink, RESOURCE, WRITE, + ("Failed to set the set the cooperative level error=%s", + DDErrorString (hRes)), (NULL)); + return FALSE; } - if (!ddrawsink->extern_surface) { - /*create our primary surface */ - memset (&dd_surface_desc, 0, sizeof (dd_surface_desc)); - dd_surface_desc.dwSize = sizeof (dd_surface_desc); - dd_surface_desc.dwFlags = DDSD_CAPS; - dd_surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; - - hRes = - IDirectDraw7_CreateSurface (ddrawsink->ddraw_object, &dd_surface_desc, - &ddrawsink->primary_surface, NULL); - if (hRes != DD_OK) { - GST_CAT_ERROR (directdrawsink_debug, - "CreateSurface (primary) failed with: %s", DDErrorString (hRes)); - IDirectDraw7_Release (ddrawsink->ddraw_object); - return FALSE; - } - - /* setup the clipper object */ - hRes = IDirectDraw7_CreateClipper (ddrawsink->ddraw_object, 0, - &ddrawsink->clipper, NULL); - if (hRes == DD_OK) { - hRes = IDirectDrawClipper_SetHWnd (ddrawsink->clipper, 0, - ddrawsink->video_window); - - hRes = IDirectDrawSurface7_SetClipper (ddrawsink->primary_surface, - ddrawsink->clipper); - } - - } else { - DDSURFACEDESC2 desc_surface; - - desc_surface.dwSize = sizeof (DDSURFACEDESC2); - - /*get extern surface size */ - hRes = IDirectDrawSurface7_GetSurfaceDesc (ddrawsink->extern_surface, - &desc_surface); - if (hRes != DD_OK) { - /*error while retrieving ext surface description */ - return FALSE; - } - - ddrawsink->out_width = desc_surface.dwWidth; - ddrawsink->out_height = desc_surface.dwHeight; - - /*get extern surface pixel format (FIXME not needed if we are using overlays) */ - ddrawsink->dd_pixel_format.dwSize = sizeof (DDPIXELFORMAT); - hRes = IDirectDrawSurface7_GetPixelFormat (ddrawsink->extern_surface, - &ddrawsink->dd_pixel_format); - if (hRes != DD_OK) { - /*error while retrieving ext surface pixel format */ - GST_CAT_WARNING (directdrawsink_debug, - "GetPixelFormat (ddrawsink->extern_surface) failed with: %s", - DDErrorString (hRes)); - return FALSE; - } + /*create our primary surface */ + memset (&dd_surface_desc, 0, sizeof (dd_surface_desc)); + dd_surface_desc.dwSize = sizeof (dd_surface_desc); + dd_surface_desc.dwFlags = DDSD_CAPS; + dd_surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; + hRes = IDirectDraw7_CreateSurface (ddrawsink->ddraw_object, &dd_surface_desc, + &ddrawsink->primary_surface, NULL); + if (hRes != DD_OK) { + GST_ELEMENT_ERROR (ddrawsink, RESOURCE, WRITE, + ("Failed to create our primary surface error=%s", DDErrorString (hRes)), + (NULL)); + return FALSE; + } - /*get specific caps if needed ... */ + /* setup the clipper object */ + hRes = IDirectDraw7_CreateClipper (ddrawsink->ddraw_object, 0, + &ddrawsink->clipper, NULL); + if (hRes == DD_OK) { + hRes = IDirectDrawClipper_SetHWnd (ddrawsink->clipper, 0, + ddrawsink->video_window); + hRes = IDirectDrawSurface7_SetClipper (ddrawsink->primary_surface, + ddrawsink->clipper); } + /* directdraw objects are setup */ ddrawsink->setup = TRUE; return bRet; @@ -1382,24 +1086,6 @@ WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) switch (message) { case WM_ERASEBKGND: return TRUE; -/* case WM_WINDOWPOSCHANGED: - case WM_MOVE: - case WM_SIZE: - if(global_ddrawsink && global_ddrawsink->bUseOverlay) - gst_directdrawsink_show_overlay(global_ddrawsink); - break; - case WM_PAINT: - if(global_ddrawsink && global_ddrawsink->bUseOverlay) - { - if(global_ddrawsink->extern_surface) - gst_directdrawsink_fill_colorkey(global_ddrawsink->extern_surface, - global_ddrawsink->color_key); - else - gst_directdrawsink_fill_colorkey(global_ddrawsink->primary_surface, - global_ddrawsink->color_key); - } - break; -*/ case WM_DESTROY: PostQuitMessage (0); break; @@ -1411,12 +1097,11 @@ WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) } static gpointer -gst_directdrawsink_window_thread (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_window_thread (GstDirectDrawSink * ddrawsink) { WNDCLASS WndClass; memset (&WndClass, 0, sizeof (WNDCLASS)); - WndClass.style = CS_HREDRAW | CS_VREDRAW; WndClass.hInstance = GetModuleHandle (NULL); WndClass.lpszClassName = "GStreamer-DirectDraw"; @@ -1425,24 +1110,22 @@ gst_directdrawsink_window_thread (GstDirectDrawSink * ddrawsink) WndClass.cbWndExtra = 0; WndClass.lpfnWndProc = WndProc; WndClass.hCursor = LoadCursor (NULL, IDC_ARROW); - RegisterClass (&WndClass); ddrawsink->video_window = CreateWindowEx (0, "GStreamer-DirectDraw", "GStreamer-DirectDraw sink default window", WS_OVERLAPPEDWINDOW | WS_SIZEBOX, 0, 0, 640, 480, NULL, NULL, WndClass.hInstance, NULL); - if (ddrawsink->video_window == NULL) return FALSE; /* signal application we create a window */ gst_x_overlay_got_xwindow_id (GST_X_OVERLAY (ddrawsink), - ddrawsink->video_window); + (gulong) ddrawsink->video_window); ReleaseSemaphore (ddrawsink->window_created_signal, 1, NULL); - /*start message loop processing our default window messages */ + /* start message loop processing our default window messages */ while (1) { MSG msg; @@ -1455,14 +1138,14 @@ gst_directdrawsink_window_thread (GstDirectDrawSink * ddrawsink) } static gboolean -gst_directdrawsink_create_default_window (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_create_default_window (GstDirectDrawSink * ddrawsink) { ddrawsink->window_created_signal = CreateSemaphore (NULL, 0, 1, NULL); if (ddrawsink->window_created_signal == NULL) return FALSE; ddrawsink->window_thread = g_thread_create ( - (GThreadFunc) gst_directdrawsink_window_thread, ddrawsink, TRUE, NULL); + (GThreadFunc) gst_directdraw_sink_window_thread, ddrawsink, TRUE, NULL); if (ddrawsink->window_thread == NULL) goto failed; @@ -1477,18 +1160,20 @@ gst_directdrawsink_create_default_window (GstDirectDrawSink * ddrawsink) failed: CloseHandle (ddrawsink->window_created_signal); + GST_ELEMENT_ERROR (ddrawsink, RESOURCE, WRITE, + ("Error creating our default window"), (NULL)); + return FALSE; } static gboolean -gst_directdrawsink_create_ddraw_surfaces (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_create_ddraw_surface (GstDirectDrawSink * ddrawsink) { DDSURFACEDESC2 dd_surface_desc; HRESULT hRes; memset (&dd_surface_desc, 0, sizeof (dd_surface_desc)); dd_surface_desc.dwSize = sizeof (dd_surface_desc); - dd_surface_desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; dd_surface_desc.dwHeight = ddrawsink->video_height; @@ -1496,45 +1181,22 @@ gst_directdrawsink_create_ddraw_surfaces (GstDirectDrawSink * ddrawsink) memcpy (&(dd_surface_desc.ddpfPixelFormat), &ddrawsink->dd_pixel_format, sizeof (DDPIXELFORMAT)); - if (ddrawsink->bUseOverlay) { - /*create overlays flipping chain */ - dd_surface_desc.ddsCaps.dwCaps = - DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY | DDSCAPS_FLIP | DDSCAPS_COMPLEX; - dd_surface_desc.dwFlags |= DDSD_BACKBUFFERCOUNT; - dd_surface_desc.dwBackBufferCount = 1; - - hRes = - IDirectDraw7_CreateSurface (ddrawsink->ddraw_object, &dd_surface_desc, - &ddrawsink->overlays, NULL); - - if (hRes != DD_OK) { - GST_CAT_WARNING (directdrawsink_debug, - "create_ddraw_surfaces:CreateSurface(overlays) failed %s", - DDErrorString (hRes)); - return FALSE; - } else { - GST_CAT_INFO (directdrawsink_debug, - "An overlay surfaces flipping chain was created"); - } - } else { - dd_surface_desc.ddsCaps.dwCaps = - DDSCAPS_OFFSCREENPLAIN /*|DDSCAPS_SYSTEMMEMORY */ ; - hRes = - IDirectDraw7_CreateSurface (ddrawsink->ddraw_object, &dd_surface_desc, - &ddrawsink->offscreen_surface, NULL); - if (hRes != DD_OK) { - GST_CAT_WARNING (directdrawsink_debug, - "create_ddraw_surfaces:CreateSurface(offscreen) failed %s", - DDErrorString (hRes)); - return FALSE; - } + dd_surface_desc.ddsCaps.dwCaps = + DDSCAPS_OFFSCREENPLAIN /*|DDSCAPS_SYSTEMMEMORY */ ; + hRes = + IDirectDraw7_CreateSurface (ddrawsink->ddraw_object, &dd_surface_desc, + &ddrawsink->offscreen_surface, NULL); + if (hRes != DD_OK) { + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "create_ddraw_surface:CreateSurface (offscreen surface for buffer_pool) failed %s", + DDErrorString (hRes)); + return FALSE; } - return TRUE; } static void -gst_directdrawsink_get_times (GstBaseSink * bsink, GstBuffer * buf, +gst_directdraw_sink_get_times (GstBaseSink * bsink, GstBuffer * buf, GstClockTime * start, GstClockTime * end) { GstDirectDrawSink *ddrawsink; @@ -1554,7 +1216,7 @@ gst_directdrawsink_get_times (GstBaseSink * bsink, GstBuffer * buf, } static int -gst_directdrawsink_get_depth (LPDDPIXELFORMAT lpddpfPixelFormat) +gst_directdraw_sink_get_depth (LPDDPIXELFORMAT lpddpfPixelFormat) { gint order = 0, binary; @@ -1580,7 +1242,7 @@ EnumModesCallback2 (LPDDSURFACEDESC2 lpDDSurfaceDesc, LPVOID lpContext) return DDENUMRET_CANCEL; if ((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) != DDSD_PIXELFORMAT) { - GST_CAT_INFO (directdrawsink_debug, + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "Display mode found with DDSD_PIXELFORMAT not set"); return DDENUMRET_OK; } @@ -1594,7 +1256,7 @@ EnumModesCallback2 (LPDDSURFACEDESC2 lpDDSurfaceDesc, LPVOID lpContext) "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, "bpp", G_TYPE_INT, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, "depth", G_TYPE_INT, - gst_directdrawsink_get_depth (&lpDDSurfaceDesc->ddpfPixelFormat), + gst_directdraw_sink_get_depth (&lpDDSurfaceDesc->ddpfPixelFormat), "endianness", G_TYPE_INT, G_LITTLE_ENDIAN, "red_mask", G_TYPE_INT, lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask, "green_mask", G_TYPE_INT, lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask, "blue_mask", G_TYPE_INT, @@ -1608,7 +1270,7 @@ EnumModesCallback2 (LPDDSURFACEDESC2 lpDDSurfaceDesc, LPVOID lpContext) } static GstCaps * -gst_directdrawsink_get_ddrawcaps (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_get_ddrawcaps (GstDirectDrawSink * ddrawsink) { HRESULT hRes = S_OK; DWORD dwFourccCodeIndex = 0; @@ -1629,26 +1291,25 @@ gst_directdrawsink_get_ddrawcaps (GstDirectDrawSink * ddrawsink) &ddcaps_emulation); /* we don't test for DDCAPS_BLTSTRETCH on the hardware as the directdraw emulation layer can do it */ - - if (!(ddcaps_hardware.dwCaps & DDCAPS_BLTFOURCC)) { DDSURFACEDESC2 surface_desc; gint endianness = G_LITTLE_ENDIAN; gint depth; - GST_CAT_INFO (directdrawsink_debug, + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "hardware doesn't support blit from one colorspace to another one. " "so we will create a caps with only the current display mode"); surface_desc.dwSize = sizeof (DDSURFACEDESC); hRes = IDirectDraw7_GetDisplayMode (ddrawsink->ddraw_object, &surface_desc); if (hRes != DD_OK) { - GST_CAT_ERROR (directdrawsink_debug, - "Error getting the current display mode (%s)", DDErrorString (hRes)); + GST_ELEMENT_ERROR (ddrawsink, CORE, NEGOTIATION, + ("Error getting the current display mode error=%s", + DDErrorString (hRes)), (NULL)); return NULL; } - depth = gst_directdrawsink_get_depth (&surface_desc.ddpfPixelFormat); + depth = gst_directdraw_sink_get_depth (&surface_desc.ddpfPixelFormat); if (surface_desc.ddpfPixelFormat.dwRGBBitCount == 24 || surface_desc.ddpfPixelFormat.dwRGBBitCount == 32) { @@ -1660,6 +1321,11 @@ gst_directdrawsink_get_ddrawcaps (GstDirectDrawSink * ddrawsink) GUINT32_TO_BE (surface_desc.ddpfPixelFormat.dwGBitMask); surface_desc.ddpfPixelFormat.dwBBitMask = GUINT32_TO_BE (surface_desc.ddpfPixelFormat.dwBBitMask); + if (surface_desc.ddpfPixelFormat.dwRGBBitCount == 24) { + surface_desc.ddpfPixelFormat.dwRBitMask >>= 8; + surface_desc.ddpfPixelFormat.dwGBitMask >>= 8; + surface_desc.ddpfPixelFormat.dwBBitMask >>= 8; + } } format_caps = gst_caps_new_simple ("video/x-raw-rgb", @@ -1677,88 +1343,48 @@ gst_directdrawsink_get_ddrawcaps (GstDirectDrawSink * ddrawsink) gst_caps_append (ddrawsink->caps, format_caps); } - GST_CAT_INFO (directdrawsink_debug, "returning caps %s", + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "returning caps %s", gst_caps_to_string (ddrawsink->caps)); - return ddrawsink->caps; } - GST_CAT_INFO (directdrawsink_debug, + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "the hardware can blit from one colorspace to another, " "then enumerate the colorspace supported by the hardware"); /* enumerate display modes exposed by directdraw object - to know supported RGB mode */ + to know supported RGB modes */ hRes = IDirectDraw7_EnumDisplayModes (ddrawsink->ddraw_object, DDEDM_REFRESHRATES, NULL, ddrawsink, EnumModesCallback2); if (hRes != DD_OK) { - GST_CAT_WARNING (directdrawsink_debug, "EnumDisplayModes returns: %s", - DDErrorString (hRes)); - return FALSE; - } + GST_ELEMENT_ERROR (ddrawsink, CORE, NEGOTIATION, + ("Error enumerating display modes error=%s", DDErrorString (hRes)), + (NULL)); - /* enumerate non-rgb modes exposed by directdraw object */ -/* IDirectDraw7_GetFourCCCodes(ddrawsink->ddraw_object, &dwNbFourccCodes, NULL); - if(dwNbFourccCodes != 0) - { - pdwFourccCodes = g_new0(DWORD, dwNbFourccCodes); - if(!pdwFourccCodes) - return FALSE; - - if (FAILED(IDirectDraw7_GetFourCCCodes(ddrawsink->ddraw_object, &dwNbFourccCodes, - pdwFourccCodes))) - { - g_free(pdwFourccCodes); - return FALSE; - } - - for(dwFourccCodeIndex = 0; dwFourccCodeIndex < dwNbFourccCodes; dwFourccCodeIndex++) - { - /*support only yuv formats YUY2, UYVY, YVU9, YV12, AYUV - if(/*pdwFourccCodes[dwFourccCodeIndex] == mmioFOURCC('Y','U','Y','2') || - pdwFourccCodes[dwFourccCodeIndex] == mmioFOURCC('U','Y','V','Y') || - pdwFourccCodes[dwFourccCodeIndex] == mmioFOURCC('Y','V','U','9') || - pdwFourccCodes[dwFourccCodeIndex] == mmioFOURCC('Y','V','1','2') /*|| - pdwFourccCodes[dwFourccCodeIndex] == mmioFOURCC('A','Y','U','V') - ) - { - format_caps = gst_caps_new_simple ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, pdwFourccCodes[dwFourccCodeIndex], - "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, - "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, - "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL); - - if(format_caps) - gst_caps_append (ddrawsink->caps, format_caps); - } - } - - g_free(pdwFourccCodes); + return NULL; } -*/ if (gst_caps_is_empty (ddrawsink->caps)) { gst_caps_unref (ddrawsink->caps); - - GST_ELEMENT_ERROR (ddrawsink, STREAM, WRONG_TYPE, (NULL), - ("No supported format found")); + ddrawsink->caps = NULL; + GST_ELEMENT_ERROR (ddrawsink, CORE, NEGOTIATION, + ("No supported caps found."), (NULL)); return NULL; } -// GST_CAT_INFO (directdrawsink_debug, "returning caps %s", gst_caps_to_string (ddrawsink->caps)); + //GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, "returning caps %s", gst_caps_to_string (ddrawsink->caps)); return ddrawsink->caps; } /* Creates miniobject and our internal surface */ static GstDDrawSurface * -gst_directdrawsink_surface_create (GstDirectDrawSink * ddrawsink, +gst_directdraw_sink_surface_create (GstDirectDrawSink * ddrawsink, GstCaps * caps, size_t size) { GstDDrawSurface *surface = NULL; GstStructure *structure = NULL; gint pitch; - HRESULT hRes; DDSURFACEDESC2 surf_desc, surf_lock_desc; @@ -1777,15 +1403,15 @@ gst_directdrawsink_surface_create (GstDirectDrawSink * ddrawsink, structure = gst_caps_get_structure (caps, 0); if (!gst_structure_get_int (structure, "width", &surface->width) || !gst_structure_get_int (structure, "height", &surface->height)) { - GST_WARNING ("failed getting geometry from caps %" GST_PTR_FORMAT, caps); + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "failed getting geometry from caps %" GST_PTR_FORMAT, caps); } pitch = GST_ROUND_UP_8 (size / surface->height); - - if (!gst_ddrawvideosink_get_format_from_caps (caps, + if (!gst_ddrawvideosink_get_format_from_caps (ddrawsink, caps, &surface->dd_pixel_format)) { - GST_WARNING ("failed getting pixel format from caps %" GST_PTR_FORMAT, - caps); + GST_CAT_WARNING_OBJECT (directdrawsink_debug, ddrawsink, + "failed getting pixel format from caps %" GST_PTR_FORMAT, caps); } if (ddrawsink->ddraw_object) { @@ -1798,16 +1424,12 @@ gst_directdrawsink_surface_create (GstDirectDrawSink * ddrawsink, DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH; surf_desc.dwHeight = surface->height; surf_desc.dwWidth = surface->width; - memcpy (&(surf_desc.ddpfPixelFormat), &surface->dd_pixel_format, sizeof (DDPIXELFORMAT)); hRes = IDirectDraw7_CreateSurface (ddrawsink->ddraw_object, &surf_desc, &surface->surface, NULL); if (hRes != DD_OK) { - /*gst_object_unref (surface); - surface = NULL; - goto beach; */ goto surface_pitch_bad; } @@ -1821,60 +1443,43 @@ gst_directdrawsink_surface_create (GstDirectDrawSink * ddrawsink, IDirectDrawSurface7_Restore (surface->surface); goto lock; } - surface->locked = TRUE; if (surf_lock_desc.lPitch != pitch) { - GST_CAT_INFO (directdrawsink_debug, - "DDraw stride/pitch %ld isn't as expected value %d, let's continue allocating buffer.", + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, + "DDraw stride/pitch %ld isn't as expected value %d, let's continue allocating a system memory buffer.", surf_lock_desc.lPitch, pitch); /*Unlock the surface as we will change it to use system memory with a GStreamer compatible pitch */ hRes = IDirectDrawSurface_Unlock (surface->surface, NULL); goto surface_pitch_bad; } - - GST_CAT_INFO (directdrawsink_debug, - "allocating a surface of %d bytes (stride=%ld)\n", size, - surf_lock_desc.lPitch); GST_BUFFER_DATA (surface) = surf_lock_desc.lpSurface; GST_BUFFER_SIZE (surface) = surf_lock_desc.lPitch * surface->height; + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, + "allocating a surface of %d bytes (stride=%ld)\n", size, + surf_lock_desc.lPitch); } else { surface_pitch_bad: GST_BUFFER (surface)->malloc_data = g_malloc (size); GST_BUFFER_DATA (surface) = GST_BUFFER (surface)->malloc_data; GST_BUFFER_SIZE (surface) = size; - -/* surf_desc.dwSize = sizeof(DDSURFACEDESC2); - surf_desc.dwFlags = DDSD_PITCH | DDSD_LPSURFACE | DDSD_HEIGHT | DDSD_WIDTH ||DDSD_PIXELFORMAT; - surf_desc.lpSurface = GST_BUFFER (surface)->malloc_data; - surf_desc.lPitch = pitch; - //surf_desc.dwHeight = surface->height; - surf_desc.dwWidth = surface->width; - hRes = IDirectDrawSurface7_SetSurfaceDesc(surface->surface, &surf_desc, 0); - printf("%\n", DDErrorString(hRes)); - - hRes = IDirectDrawSurface7_Lock (surface->surface, NULL, &surf_lock_desc, - DDLOCK_WAIT | DDLOCK_NOSYSLOCK, NULL); -*/ surface->surface = NULL; - /*printf ("allocating a buffer of %d bytes\n", size); */ + GST_CAT_INFO_OBJECT (directdrawsink_debug, ddrawsink, + "allocating a system memory buffer of %d bytes", size); } /* Keep a ref to our sink */ surface->ddrawsink = gst_object_ref (ddrawsink); - /* - beach: - */ return surface; } /* We are called from the finalize method of miniobject, the object will be * destroyed so we just have to clean our internal stuff */ static void -gst_directdrawsink_surface_destroy (GstDirectDrawSink * ddrawsink, +gst_directdraw_sink_surface_destroy (GstDirectDrawSink * ddrawsink, GstDDrawSurface * surface) { g_return_if_fail (GST_IS_DIRECTDRAW_SINK (ddrawsink)); @@ -1910,7 +1515,7 @@ no_sink: } static void -gst_directdrawsink_bufferpool_clear (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_bufferpool_clear (GstDirectDrawSink * ddrawsink) { g_mutex_lock (ddrawsink->pool_lock); while (ddrawsink->buffer_pool) { @@ -1918,15 +1523,14 @@ gst_directdrawsink_bufferpool_clear (GstDirectDrawSink * ddrawsink) ddrawsink->buffer_pool = g_slist_delete_link (ddrawsink->buffer_pool, ddrawsink->buffer_pool); - gst_directdrawsink_surface_destroy (ddrawsink, surface); + gst_directdraw_sink_surface_destroy (ddrawsink, surface); } g_mutex_unlock (ddrawsink->pool_lock); } static void -gst_directdrawsink_cleanup (GstDirectDrawSink * ddrawsink) +gst_directdraw_sink_cleanup (GstDirectDrawSink * ddrawsink) { - /* Post quit message and wait for our event window thread */ if (ddrawsink->video_window && ddrawsink->our_video_window) PostMessage (ddrawsink->video_window, WM_QUIT, 0, 0); @@ -1937,15 +1541,10 @@ gst_directdrawsink_cleanup (GstDirectDrawSink * ddrawsink) } if (ddrawsink->buffer_pool) { - gst_directdrawsink_bufferpool_clear (ddrawsink); + gst_directdraw_sink_bufferpool_clear (ddrawsink); ddrawsink->buffer_pool = NULL; } - if (ddrawsink->overlays) { - IDirectDrawSurface7_Release (ddrawsink->overlays); - ddrawsink->overlays = NULL; - } - if (ddrawsink->offscreen_surface) { IDirectDrawSurface7_Release (ddrawsink->offscreen_surface); ddrawsink->offscreen_surface = NULL; diff --git a/sys/directdraw/gstdirectdrawsink.h b/sys/directdraw/gstdirectdrawsink.h index 1a32c5a5..85ed0824 100644 --- a/sys/directdraw/gstdirectdrawsink.h +++ b/sys/directdraw/gstdirectdrawsink.h @@ -33,7 +33,7 @@ #include <ddraw.h> G_BEGIN_DECLS -#define GST_TYPE_DIRECTDRAW_SINK (gst_directdrawsink_get_type()) +#define GST_TYPE_DIRECTDRAW_SINK (gst_directdraw_sink_get_type()) #define GST_DIRECTDRAW_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DIRECTDRAW_SINK,GstDirectDrawSink)) #define GST_DIRECTDRAW_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DIRECTDRAW_SINK,GstDirectDrawSinkClass)) #define GST_IS_DIRECTDRAW_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DIRECTDRAW_SINK)) @@ -85,7 +85,6 @@ struct _GstDirectDrawSink LPDIRECTDRAW ddraw_object; LPDIRECTDRAWSURFACE primary_surface; LPDIRECTDRAWSURFACE offscreen_surface; - LPDIRECTDRAWSURFACE overlays; LPDIRECTDRAWCLIPPER clipper; /* last buffer displayed (used for XOverlay interface expose method) */ @@ -105,8 +104,7 @@ struct _GstDirectDrawSink gint fps_n; gint fps_d; - /*properties*/ - LPDIRECTDRAWSURFACE extern_surface; + /* properties */ gboolean keep_aspect_ratio; /*pixel format */ @@ -117,11 +115,6 @@ struct _GstDirectDrawSink /* TRUE when directdraw objects are setup */ gboolean setup; - - /* overlays */ - gboolean bUseOverlay; - gboolean bIsOverlayVisible; - guint color_key; }; struct _GstDirectDrawSinkClass @@ -129,7 +122,7 @@ struct _GstDirectDrawSinkClass GstVideoSinkClass parent_class; }; -GType gst_directdrawsink_get_type (void); +GType gst_direct_drawsink_get_type (void); G_END_DECLS #endif /* __GST_DIRECTDRAWSINK_H__ */ diff --git a/sys/directsound/gstdirectsoundplugin.c b/sys/directsound/gstdirectsoundplugin.c index e619f1a3..5a0ef205 100644 --- a/sys/directsound/gstdirectsoundplugin.c +++ b/sys/directsound/gstdirectsoundplugin.c @@ -39,5 +39,5 @@ plugin_init (GstPlugin * plugin) GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, "directsound", - "DIRECTSOUND plugin library", + "Direct Sound plugin library", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/sys/directsound/gstdirectsoundsink.c b/sys/directsound/gstdirectsoundsink.c index a159a9ee..46a57e8b 100644 --- a/sys/directsound/gstdirectsoundsink.c +++ b/sys/directsound/gstdirectsoundsink.c @@ -19,6 +19,37 @@ * Boston, MA 02111-1307, USA. */ +/** + * SECTION:element-directsound + * @short_description: output sound using Directsound API + * + * <refsect2> + * <para> + * This element lets you output sound using the DirectSound API. + * </para> + * <para> + * Note that you should almost always use generic audio conversion elements + * like audioconvert and audioresample in front of an audiosink to make sure + * your pipeline works under all circumstances (those conversion elements will + * act in passthrough-mode if no conversion is necessary). + * </para> + * <title>Example pipelines</title> + * <para> + * <programlisting> + * gst-launch-0.10 -v audiotestsrc ! audioconvert ! volume volume=0.1 ! directsoundsink + * </programlisting> + * will output a sine wave (continuous beep sound) to your sound card (with + * a very low volume as precaution). + * </para> + * <para> + * <programlisting> + * gst-launch-0.10 -v filesrc location=music.ogg ! decodebin ! audioconvert ! audioresample ! directsoundsink + * </programlisting> + * will play an Ogg/Vorbis audio file and output it. + * </para> + * </refsect2> + */ + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -35,35 +66,35 @@ GST_DEBUG_CATEGORY_STATIC (directsoundsink_debug); /* elementfactory information */ -static const GstElementDetails gst_directsoundsink_details = -GST_ELEMENT_DETAILS ("Audio Sink (DIRECTSOUND)", +static const GstElementDetails gst_directsound_sink_details = +GST_ELEMENT_DETAILS ("Direct Sound Audio Sink", "Sink/Audio", - "Output to a sound card via DIRECTSOUND", + "Output to a sound card via Direct Sound", "Sebastien Moutte <sebastien@moutte.net>"); -static void gst_directsoundsink_base_init (gpointer g_class); -static void gst_directsoundsink_class_init (GstDirectSoundSinkClass * klass); -static void gst_directsoundsink_init (GstDirectSoundSink * dsoundsink, +static void gst_directsound_sink_base_init (gpointer g_class); +static void gst_directsound_sink_class_init (GstDirectSoundSinkClass * klass); +static void gst_directsound_sink_init (GstDirectSoundSink * dsoundsink, GstDirectSoundSinkClass * g_class); -static void gst_directsoundsink_dispose (GObject * object); -static void gst_directsoundsink_finalise (GObject * object); -static void gst_directsoundsink_set_property (GObject * object, +static void gst_directsound_sink_dispose (GObject * object); +static void gst_directsound_sink_finalise (GObject * object); +static void gst_directsound_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); -static void gst_directsoundsink_get_property (GObject * object, +static void gst_directsound_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); -static GstCaps *gst_directsoundsink_getcaps (GstBaseSink * bsink); +static GstCaps *gst_directsound_sink_getcaps (GstBaseSink * bsink); -static gboolean gst_directsoundsink_prepare (GstAudioSink * asink, +static gboolean gst_directsound_sink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec); -static gboolean gst_directsoundsink_unprepare (GstAudioSink * asink); +static gboolean gst_directsound_sink_unprepare (GstAudioSink * asink); -static gboolean gst_directsoundsink_open (GstAudioSink * asink); -static gboolean gst_directsoundsink_close (GstAudioSink * asink); -static guint gst_directsoundsink_write (GstAudioSink * asink, gpointer data, +static gboolean gst_directsound_sink_open (GstAudioSink * asink); +static gboolean gst_directsound_sink_close (GstAudioSink * asink); +static guint gst_directsound_sink_write (GstAudioSink * asink, gpointer data, guint length); -static guint gst_directsoundsink_delay (GstAudioSink * asink); -static void gst_directsoundsink_reset (GstAudioSink * asink); +static guint gst_directsound_sink_delay (GstAudioSink * asink); +static void gst_directsound_sink_reset (GstAudioSink * asink); static GstStaticPadTemplate directsoundsink_sink_factory = @@ -71,7 +102,6 @@ static GstStaticPadTemplate directsoundsink_sink_factory = GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-int, " - "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, " "signed = (boolean) { TRUE, FALSE }, " "width = (int) 16, " "depth = (int) 16, " @@ -95,17 +125,17 @@ _do_init (GType directsoundsink_type) "DirectSound sink"); } -GST_BOILERPLATE_FULL (GstDirectSoundSink, gst_directsoundsink, GstAudioSink, +GST_BOILERPLATE_FULL (GstDirectSoundSink, gst_directsound_sink, GstAudioSink, GST_TYPE_AUDIO_SINK, _do_init); static void -gst_directsoundsink_dispose (GObject * object) +gst_directsound_sink_dispose (GObject * object) { G_OBJECT_CLASS (parent_class)->dispose (object); } static void -gst_directsoundsink_finalise (GObject * object) +gst_directsound_sink_finalise (GObject * object) { GstDirectSoundSink *dsoundsink = GST_DIRECTSOUND_SINK (object); @@ -115,18 +145,17 @@ gst_directsoundsink_finalise (GObject * object) } static void -gst_directsoundsink_base_init (gpointer g_class) +gst_directsound_sink_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); - gst_element_class_set_details (element_class, &gst_directsoundsink_details); - + gst_element_class_set_details (element_class, &gst_directsound_sink_details); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&directsoundsink_sink_factory)); } static void -gst_directsoundsink_class_init (GstDirectSoundSinkClass * klass) +gst_directsound_sink_class_init (GstDirectSoundSinkClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; @@ -142,34 +171,34 @@ gst_directsoundsink_class_init (GstDirectSoundSinkClass * klass) parent_class = g_type_class_peek_parent (klass); - gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_directsoundsink_dispose); - gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_directsoundsink_finalise); + gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_directsound_sink_dispose); + gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_directsound_sink_finalise); gobject_class->get_property = - GST_DEBUG_FUNCPTR (gst_directsoundsink_get_property); + GST_DEBUG_FUNCPTR (gst_directsound_sink_get_property); gobject_class->set_property = - GST_DEBUG_FUNCPTR (gst_directsoundsink_set_property); + GST_DEBUG_FUNCPTR (gst_directsound_sink_set_property); - gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_directsoundsink_getcaps); + gstbasesink_class->get_caps = + GST_DEBUG_FUNCPTR (gst_directsound_sink_getcaps); - gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_directsoundsink_prepare); + gstaudiosink_class->prepare = + GST_DEBUG_FUNCPTR (gst_directsound_sink_prepare); gstaudiosink_class->unprepare = - GST_DEBUG_FUNCPTR (gst_directsoundsink_unprepare); - gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_directsoundsink_open); - gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_directsoundsink_close); - gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_directsoundsink_write); - - gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_directsoundsink_delay); - gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_directsoundsink_reset); + GST_DEBUG_FUNCPTR (gst_directsound_sink_unprepare); + gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_directsound_sink_open); + gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_directsound_sink_close); + gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_directsound_sink_write); + gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_directsound_sink_delay); + gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_directsound_sink_reset); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ATTENUATION, g_param_spec_long ("attenuation", "Attenuation of the sound", "The attenuation for the directsound buffer (default is 0 so the directsound buffer will not be attenuated)", -10000, 0, 0, G_PARAM_READWRITE)); - } static void -gst_directsoundsink_set_property (GObject * object, guint prop_id, +gst_directsound_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDirectSoundSink *dsoundsink; @@ -198,7 +227,7 @@ gst_directsoundsink_set_property (GObject * object, guint prop_id, } static void -gst_directsoundsink_get_property (GObject * object, guint prop_id, +gst_directsound_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstDirectSoundSink *dsoundsink; @@ -216,7 +245,7 @@ gst_directsoundsink_get_property (GObject * object, guint prop_id, } static void -gst_directsoundsink_init (GstDirectSoundSink * dsoundsink, +gst_directsound_sink_init (GstDirectSoundSink * dsoundsink, GstDirectSoundSinkClass * g_class) { dsoundsink->pDS = NULL; @@ -229,7 +258,7 @@ gst_directsoundsink_init (GstDirectSoundSink * dsoundsink, } static GstCaps * -gst_directsoundsink_getcaps (GstBaseSink * bsink) +gst_directsound_sink_getcaps (GstBaseSink * bsink) { GstDirectSoundSink *dsoundsink; @@ -241,17 +270,15 @@ gst_directsoundsink_getcaps (GstBaseSink * bsink) } static gboolean -gst_directsoundsink_open (GstAudioSink * asink) +gst_directsound_sink_open (GstAudioSink * asink) { - GstDirectSoundSink *dsoundsink; + GstDirectSoundSink *dsoundsink = GST_DIRECTSOUND_SINK (asink); HRESULT hRes; - dsoundsink = GST_DIRECTSOUND_SINK (asink); - /* create and initialize a DirecSound object */ if (FAILED (hRes = DirectSoundCreate (NULL, &dsoundsink->pDS, NULL))) { GST_ELEMENT_ERROR (dsoundsink, RESOURCE, OPEN_READ, - ("gst_directsoundsink_open: DirectSoundCreate: %s", + ("gst_directsound_sink_open: DirectSoundCreate: %s", DXGetErrorString9 (hRes)), (NULL)); return FALSE; } @@ -259,7 +286,7 @@ gst_directsoundsink_open (GstAudioSink * asink) if (FAILED (hRes = IDirectSound_SetCooperativeLevel (dsoundsink->pDS, GetDesktopWindow (), DSSCL_PRIORITY))) { GST_ELEMENT_ERROR (dsoundsink, RESOURCE, OPEN_READ, - ("gst_directsoundsink_open: IDirectSound_SetCooperativeLevel: %s", + ("gst_directsound_sink_open: IDirectSound_SetCooperativeLevel: %s", DXGetErrorString9 (hRes)), (NULL)); return FALSE; } @@ -268,15 +295,13 @@ gst_directsoundsink_open (GstAudioSink * asink) } static gboolean -gst_directsoundsink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec) +gst_directsound_sink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec) { - GstDirectSoundSink *dsoundsink; + GstDirectSoundSink *dsoundsink = GST_DIRECTSOUND_SINK (asink); HRESULT hRes; DSBUFFERDESC descSecondary; WAVEFORMATEX wfx; - dsoundsink = GST_DIRECTSOUND_SINK (asink); - /*save number of bytes per sample */ dsoundsink->bytes_per_sample = spec->bytes_per_sample; @@ -293,7 +318,7 @@ gst_directsoundsink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec) /* directsound buffer size can handle 1/2 sec of the stream */ dsoundsink->buffer_size = wfx.nAvgBytesPerSec / 2; - GST_CAT_INFO (directsoundsink_debug, + GST_INFO_OBJECT (dsoundsink, "GstRingBufferSpec->channels: %d, GstRingBufferSpec->rate: %d, GstRingBufferSpec->bytes_per_sample: %d\n" "WAVEFORMATEX.nSamplesPerSec: %ld, WAVEFORMATEX.wBitsPerSample: %d, WAVEFORMATEX.nBlockAlign: %d, WAVEFORMATEX.nAvgBytesPerSec: %ld\n" "Size of dsound cirucular buffe=>%d\n", spec->channels, spec->rate, @@ -313,7 +338,7 @@ gst_directsoundsink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec) &dsoundsink->pDSBSecondary, NULL); if (FAILED (hRes)) { GST_ELEMENT_ERROR (dsoundsink, RESOURCE, OPEN_READ, - ("gst_directsoundsink_prepare: IDirectSound_CreateSoundBuffer: %s", + ("gst_directsound_sink_prepare: IDirectSound_CreateSoundBuffer: %s", DXGetErrorString9 (hRes)), (NULL)); return FALSE; } @@ -326,7 +351,7 @@ gst_directsoundsink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec) } static gboolean -gst_directsoundsink_unprepare (GstAudioSink * asink) +gst_directsound_sink_unprepare (GstAudioSink * asink) { GstDirectSoundSink *dsoundsink; @@ -340,7 +365,7 @@ gst_directsoundsink_unprepare (GstAudioSink * asink) } static gboolean -gst_directsoundsink_close (GstAudioSink * asink) +gst_directsound_sink_close (GstAudioSink * asink) { GstDirectSoundSink *dsoundsink = NULL; @@ -353,9 +378,8 @@ gst_directsoundsink_close (GstAudioSink * asink) return TRUE; } - static guint -gst_directsoundsink_write (GstAudioSink * asink, gpointer data, guint length) +gst_directsound_sink_write (GstAudioSink * asink, gpointer data, guint length) { GstDirectSoundSink *dsoundsink; DWORD dwStatus; @@ -445,7 +469,7 @@ gst_directsoundsink_write (GstAudioSink * asink, gpointer data, guint length) } static guint -gst_directsoundsink_delay (GstAudioSink * asink) +gst_directsound_sink_delay (GstAudioSink * asink) { GstDirectSoundSink *dsoundsink; HRESULT hRes; @@ -481,9 +505,8 @@ gst_directsoundsink_delay (GstAudioSink * asink) } static void -gst_directsoundsink_reset (GstAudioSink * asink) +gst_directsound_sink_reset (GstAudioSink * asink) { - /*not tested for seeking */ GstDirectSoundSink *dsoundsink; LPVOID pLockedBuffer = NULL; DWORD dwSizeBuffer = 0; diff --git a/sys/directsound/gstdirectsoundsink.h b/sys/directsound/gstdirectsoundsink.h index e4711cc9..d1a47aac 100644 --- a/sys/directsound/gstdirectsoundsink.h +++ b/sys/directsound/gstdirectsoundsink.h @@ -32,7 +32,7 @@ G_BEGIN_DECLS -#define GST_TYPE_DIRECTSOUND_SINK (gst_directsoundsink_get_type()) +#define GST_TYPE_DIRECTSOUND_SINK (gst_directsound_sink_get_type()) #define GST_DIRECTSOUND_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DIRECTSOUND_SINK,GstDirectSoundSink)) #define GST_DIRECTSOUND_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DIRECTSOUND_SINK,GstDirectSoundSinkClass)) #define GST_IS_DIRECTSOUND_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DIRECTSOUND_SINK)) @@ -71,7 +71,7 @@ struct _GstDirectSoundSinkClass GstAudioSinkClass parent_class; }; -GType gst_directsoundsink_get_type (void); +GType gst_directsound_sink_get_type (void); G_END_DECLS #endif /* __GST_DIRECTSOUNDSINK_H__ */ |