| /* | |
| * Copyright (C) 2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com> | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Library General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2 of the License, or (at your option) any later version. | |
| * | |
| * This library 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 | |
| * Library General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Library General Public | |
| * License along with this library; if not, write to the | |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
| * Boston, MA 02110-1301, USA. | |
| */ | |
| #include "gstksvideodevice.h" | |
| #include "gstksclock.h" | |
| #include "kshelpers.h" | |
| #include "ksvideohelpers.h" | |
| #define READ_TIMEOUT (10 * 1000) | |
| #define MJPEG_MAX_PADDING 128 | |
| #define MAX_OUTSTANDING_FRAMES 128 | |
| #define KS_BUFFER_ALIGNMENT 4096 | |
| #define DEFAULT_DEVICE_PATH NULL | |
| GST_DEBUG_CATEGORY_EXTERN (gst_ks_debug); | |
| #define GST_CAT_DEFAULT gst_ks_debug | |
| #define GST_DEBUG_IS_ENABLED() \ | |
| (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >= GST_LEVEL_DEBUG) | |
| #define UNREF_BUFFER(b) \ | |
| G_STMT_START { \ | |
| if (*(b) != NULL) { \ | |
| gst_buffer_unref (*(b)); \ | |
| *(b) = NULL; \ | |
| } \ | |
| } G_STMT_END | |
| enum | |
| { | |
| PROP_0, | |
| PROP_CLOCK, | |
| PROP_DEVICE_PATH, | |
| }; | |
| typedef struct | |
| { | |
| KSSTREAM_HEADER header; | |
| KS_FRAME_INFO frame_info; | |
| } KSSTREAM_READ_PARAMS; | |
| typedef struct | |
| { | |
| KSSTREAM_READ_PARAMS params; | |
| GstBuffer *buf; | |
| OVERLAPPED overlapped; | |
| } ReadRequest; | |
| struct _GstKsVideoDevicePrivate | |
| { | |
| gboolean open; | |
| KSSTATE state; | |
| GstKsClock *clock; | |
| gchar *dev_path; | |
| HANDLE filter_handle; | |
| GList *media_types; | |
| GstCaps *cached_caps; | |
| HANDLE cancel_event; | |
| KsVideoMediaType *cur_media_type; | |
| GstCaps *cur_fixed_caps; | |
| guint width; | |
| guint height; | |
| guint fps_n; | |
| guint fps_d; | |
| guint8 *rgb_swap_buf; | |
| gboolean is_muxed; | |
| HANDLE pin_handle; | |
| gboolean requests_submitted; | |
| gulong num_requests; | |
| GArray *requests; | |
| GArray *request_events; | |
| GstBuffer *spare_buffers[2]; | |
| GstClockTime last_timestamp; | |
| }; | |
| #define GST_KS_VIDEO_DEVICE_GET_PRIVATE(o) ((o)->priv) | |
| static void gst_ks_video_device_dispose (GObject * object); | |
| static void gst_ks_video_device_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec); | |
| static void gst_ks_video_device_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec); | |
| static void gst_ks_video_device_reset_caps (GstKsVideoDevice * self); | |
| static guint gst_ks_video_device_get_frame_size (GstKsVideoDevice * self); | |
| G_DEFINE_TYPE_WITH_PRIVATE (GstKsVideoDevice, gst_ks_video_device, | |
| G_TYPE_OBJECT); | |
| static GstKsVideoDeviceClass *parent_class = NULL; | |
| static void | |
| gst_ks_video_device_class_init (GstKsVideoDeviceClass * klass) | |
| { | |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); | |
| parent_class = g_type_class_peek_parent (klass); | |
| gobject_class->dispose = gst_ks_video_device_dispose; | |
| gobject_class->get_property = gst_ks_video_device_get_property; | |
| gobject_class->set_property = gst_ks_video_device_set_property; | |
| g_object_class_install_property (gobject_class, PROP_CLOCK, | |
| g_param_spec_object ("clock", "Clock to use", | |
| "Clock to use", GST_TYPE_KS_CLOCK, | |
| G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); | |
| g_object_class_install_property (gobject_class, PROP_DEVICE_PATH, | |
| g_param_spec_string ("device-path", "Device Path", | |
| "The device path", DEFAULT_DEVICE_PATH, | |
| G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); | |
| } | |
| static void | |
| gst_ks_video_device_init (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv; | |
| self->priv = gst_ks_video_device_get_instance_private (self); | |
| priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| priv->open = FALSE; | |
| priv->state = KSSTATE_STOP; | |
| } | |
| static void | |
| gst_ks_video_device_dispose (GObject * object) | |
| { | |
| GstKsVideoDevice *self = GST_KS_VIDEO_DEVICE (object); | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| gst_ks_video_device_reset_caps (self); | |
| gst_ks_video_device_close (self); | |
| if (priv->clock != NULL) { | |
| g_object_unref (priv->clock); | |
| priv->clock = NULL; | |
| } | |
| G_OBJECT_CLASS (parent_class)->dispose (object); | |
| } | |
| static void | |
| gst_ks_video_device_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec) | |
| { | |
| GstKsVideoDevice *self = GST_KS_VIDEO_DEVICE (object); | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| switch (prop_id) { | |
| case PROP_CLOCK: | |
| g_value_set_object (value, priv->clock); | |
| break; | |
| case PROP_DEVICE_PATH: | |
| g_value_set_string (value, priv->dev_path); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| gst_ks_video_device_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec) | |
| { | |
| GstKsVideoDevice *self = GST_KS_VIDEO_DEVICE (object); | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| switch (prop_id) { | |
| case PROP_CLOCK: | |
| if (priv->clock != NULL) | |
| g_object_unref (priv->clock); | |
| priv->clock = g_value_dup_object (value); | |
| break; | |
| case PROP_DEVICE_PATH: | |
| g_free (priv->dev_path); | |
| priv->dev_path = g_value_dup_string (value); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| gst_ks_video_device_parse_win32_error (const gchar * func_name, | |
| DWORD error_code, gulong * ret_error_code, gchar ** ret_error_str) | |
| { | |
| if (ret_error_code != NULL) | |
| *ret_error_code = error_code; | |
| if (ret_error_str != NULL) { | |
| GString *message; | |
| gchar buf[1480]; | |
| DWORD result; | |
| message = g_string_sized_new (1600); | |
| g_string_append_printf (message, "%s returned ", func_name); | |
| result = | |
| FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM | | |
| FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error_code, 0, buf, sizeof (buf), | |
| NULL); | |
| if (result != 0) { | |
| g_string_append_printf (message, "0x%08x: %s", (guint) error_code, | |
| g_strchomp (buf)); | |
| } else { | |
| DWORD format_error_code = GetLastError (); | |
| g_string_append_printf (message, | |
| "<0x%08x (FormatMessage error code: %s)>", (guint) error_code, | |
| (format_error_code == ERROR_MR_MID_NOT_FOUND) | |
| ? "no system error message found" | |
| : "failed to retrieve system error message"); | |
| } | |
| *ret_error_str = g_string_free (message, FALSE); | |
| } | |
| } | |
| static void | |
| gst_ks_video_device_clear_buffers (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| guint i; | |
| if (priv->requests == NULL) | |
| return; | |
| /* Join any pending requests */ | |
| for (i = 0; i < priv->num_requests; i++) { | |
| ReadRequest *req = &g_array_index (priv->requests, ReadRequest, i); | |
| HANDLE ev = g_array_index (priv->request_events, HANDLE, i); | |
| DWORD n; | |
| if (!GetOverlappedResult (priv->pin_handle, &req->overlapped, &n, FALSE)) { | |
| if (WaitForSingleObject (ev, 1000) == WAIT_OBJECT_0) | |
| GetOverlappedResult (priv->pin_handle, &req->overlapped, &n, FALSE); | |
| } | |
| } | |
| /* Clean up */ | |
| for (i = 0; i < G_N_ELEMENTS (priv->spare_buffers); i++) { | |
| gst_buffer_unref (priv->spare_buffers[i]); | |
| priv->spare_buffers[i] = NULL; | |
| } | |
| for (i = 0; i < priv->requests->len; i++) { | |
| ReadRequest *req = &g_array_index (priv->requests, ReadRequest, i); | |
| HANDLE ev = g_array_index (priv->request_events, HANDLE, i); | |
| gst_buffer_unref (req->buf); | |
| if (ev) | |
| CloseHandle (ev); | |
| } | |
| g_array_free (priv->requests, TRUE); | |
| priv->requests = NULL; | |
| g_array_free (priv->request_events, TRUE); | |
| priv->request_events = NULL; | |
| } | |
| static void | |
| gst_ks_video_device_prepare_buffers (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| guint i; | |
| guint frame_size; | |
| g_assert (priv->cur_media_type != NULL); | |
| gst_ks_video_device_clear_buffers (self); | |
| priv->requests = g_array_sized_new (FALSE, TRUE, sizeof (ReadRequest), | |
| priv->num_requests); | |
| priv->request_events = g_array_sized_new (FALSE, TRUE, sizeof (HANDLE), | |
| priv->num_requests + 1); | |
| frame_size = gst_ks_video_device_get_frame_size (self); | |
| for (i = 0; i < G_N_ELEMENTS (priv->spare_buffers); i++) { | |
| priv->spare_buffers[i] = self->allocfunc (frame_size, KS_BUFFER_ALIGNMENT, | |
| self->allocfunc_data); | |
| } | |
| for (i = 0; i < priv->num_requests; i++) { | |
| ReadRequest req; | |
| memset (&req, '0', sizeof (ReadRequest)); | |
| req.buf = self->allocfunc (frame_size, KS_BUFFER_ALIGNMENT, | |
| self->allocfunc_data); | |
| req.overlapped.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL); | |
| g_array_append_val (priv->requests, req); | |
| g_array_append_val (priv->request_events, req.overlapped.hEvent); | |
| } | |
| g_array_append_val (priv->request_events, priv->cancel_event); | |
| /* | |
| * REVISIT: Could probably remove this later, for now it's here to help | |
| * track down the case where we capture old frames. This has been | |
| * observed with UVC cameras, presumably with some system load. | |
| */ | |
| priv->last_timestamp = GST_CLOCK_TIME_NONE; | |
| } | |
| static void | |
| gst_ks_video_device_dump_supported_property_sets (GstKsVideoDevice * self, | |
| const gchar * obj_name, const GUID * propsets, gulong propsets_len) | |
| { | |
| guint i; | |
| GST_DEBUG ("%s supports %lu property set%s", obj_name, propsets_len, | |
| (propsets_len != 1) ? "s" : ""); | |
| for (i = 0; i < propsets_len; i++) { | |
| gchar *propset_name = ks_property_set_to_string (&propsets[i]); | |
| GST_DEBUG ("[%d] %s", i, propset_name); | |
| g_free (propset_name); | |
| } | |
| } | |
| GstKsVideoDevice * | |
| gst_ks_video_device_new (const gchar * device_path, GstKsClock * clock, | |
| GstKsAllocFunction allocfunc, gpointer allocfunc_data) | |
| { | |
| GstKsVideoDevice *device; | |
| device = g_object_new (GST_TYPE_KS_VIDEO_DEVICE, | |
| "device-path", device_path, "clock", clock, NULL); | |
| device->allocfunc = allocfunc; | |
| device->allocfunc_data = allocfunc_data; | |
| return device; | |
| } | |
| gboolean | |
| gst_ks_video_device_open (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| GUID *propsets = NULL; | |
| gulong propsets_len; | |
| GList *cur; | |
| g_assert (!priv->open); | |
| g_assert (priv->dev_path != NULL); | |
| /* | |
| * Open the filter. | |
| */ | |
| priv->filter_handle = CreateFile (priv->dev_path, | |
| GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, | |
| FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL); | |
| if (!ks_is_valid_handle (priv->filter_handle)) | |
| goto error; | |
| /* | |
| * Query the filter for supported property sets. | |
| */ | |
| if (ks_object_get_supported_property_sets (priv->filter_handle, &propsets, | |
| &propsets_len)) { | |
| gst_ks_video_device_dump_supported_property_sets (self, "filter", | |
| propsets, propsets_len); | |
| g_free (propsets); | |
| } else { | |
| GST_DEBUG ("failed to query filter for supported property sets"); | |
| } | |
| /* | |
| * Probe for supported media types. | |
| */ | |
| priv->media_types = ks_video_probe_filter_for_caps (priv->filter_handle); | |
| priv->cached_caps = gst_caps_new_empty (); | |
| for (cur = priv->media_types; cur != NULL; cur = cur->next) { | |
| KsVideoMediaType *media_type = cur->data; | |
| gst_caps_append (priv->cached_caps, | |
| gst_caps_copy (media_type->translated_caps)); | |
| #if 1 | |
| { | |
| gchar *str; | |
| str = gst_caps_to_string (media_type->translated_caps); | |
| GST_DEBUG ("pin[%d]: found media type: %s", media_type->pin_id, str); | |
| g_free (str); | |
| } | |
| #endif | |
| } | |
| priv->cancel_event = CreateEvent (NULL, TRUE, FALSE, NULL); | |
| priv->open = TRUE; | |
| return TRUE; | |
| error: | |
| g_free (priv->dev_path); | |
| priv->dev_path = NULL; | |
| return FALSE; | |
| } | |
| void | |
| gst_ks_video_device_close (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| GList *cur; | |
| gst_ks_video_device_reset_caps (self); | |
| g_free (priv->dev_path); | |
| priv->dev_path = NULL; | |
| if (ks_is_valid_handle (priv->filter_handle)) { | |
| CloseHandle (priv->filter_handle); | |
| priv->filter_handle = INVALID_HANDLE_VALUE; | |
| } | |
| for (cur = priv->media_types; cur != NULL; cur = cur->next) { | |
| KsVideoMediaType *mt = cur->data; | |
| ks_video_media_type_free (mt); | |
| } | |
| if (priv->media_types != NULL) { | |
| g_list_free (priv->media_types); | |
| priv->media_types = NULL; | |
| } | |
| if (priv->cached_caps != NULL) { | |
| gst_caps_unref (priv->cached_caps); | |
| priv->cached_caps = NULL; | |
| } | |
| if (ks_is_valid_handle (priv->cancel_event)) | |
| CloseHandle (priv->cancel_event); | |
| priv->cancel_event = INVALID_HANDLE_VALUE; | |
| priv->open = FALSE; | |
| } | |
| GstCaps * | |
| gst_ks_video_device_get_available_caps (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| g_assert (priv->open); | |
| return gst_caps_ref (priv->cached_caps); | |
| } | |
| gboolean | |
| gst_ks_video_device_has_caps (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| return (priv->cur_media_type != NULL) ? TRUE : FALSE; | |
| } | |
| static HANDLE | |
| gst_ks_video_device_create_pin (GstKsVideoDevice * self, | |
| KsVideoMediaType * media_type, gulong * num_outstanding) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| HANDLE pin_handle = INVALID_HANDLE_VALUE; | |
| KSPIN_CONNECT *pin_conn = NULL; | |
| DWORD ret; | |
| guint retry_count; | |
| GUID *propsets = NULL; | |
| gulong propsets_len; | |
| gboolean supports_mem_transport = FALSE; | |
| KSALLOCATOR_FRAMING *framing = NULL; | |
| gulong framing_size = sizeof (KSALLOCATOR_FRAMING); | |
| KSALLOCATOR_FRAMING_EX *framing_ex = NULL; | |
| gulong alignment; | |
| DWORD mem_transport; | |
| /* | |
| * Instantiate the pin. | |
| */ | |
| pin_conn = ks_video_create_pin_conn_from_media_type (media_type); | |
| for (retry_count = 0; retry_count != 5; retry_count++) { | |
| GST_DEBUG ("calling KsCreatePin with pin_id = %d", media_type->pin_id); | |
| ret = KsCreatePin (priv->filter_handle, pin_conn, GENERIC_READ, | |
| &pin_handle); | |
| if (ret != ERROR_NOT_READY) | |
| break; | |
| /* wait and retry, like the reference implementation does */ | |
| if (WaitForSingleObject (priv->cancel_event, 1000) == WAIT_OBJECT_0) | |
| goto cancelled; | |
| } | |
| if (ret != ERROR_SUCCESS) | |
| goto error_create_pin; | |
| GST_DEBUG ("KsCreatePin succeeded, pin %p created", pin_handle); | |
| g_free (pin_conn); | |
| pin_conn = NULL; | |
| /* | |
| * Query the pin for supported property sets. | |
| */ | |
| if (ks_object_get_supported_property_sets (pin_handle, &propsets, | |
| &propsets_len)) { | |
| guint i; | |
| gst_ks_video_device_dump_supported_property_sets (self, "pin", propsets, | |
| propsets_len); | |
| for (i = 0; i < propsets_len; i++) { | |
| if (IsEqualGUID (&propsets[i], &KSPROPSETID_MemoryTransport)) | |
| supports_mem_transport = TRUE; | |
| } | |
| g_free (propsets); | |
| } else { | |
| GST_DEBUG ("failed to query pin for supported property sets"); | |
| } | |
| /* | |
| * Figure out how many simultaneous requests it prefers. | |
| * | |
| * This is really important as it depends on the driver and the device. | |
| * Doing too few will result in poor capture performance, whilst doing too | |
| * many will make some drivers crash really horribly and leave you with a | |
| * BSOD. I've experienced the latter with older Logitech drivers. | |
| */ | |
| *num_outstanding = 0; | |
| alignment = 0; | |
| if (ks_object_get_property (pin_handle, KSPROPSETID_Connection, | |
| KSPROPERTY_CONNECTION_ALLOCATORFRAMING_EX, (void *) &framing_ex, NULL, | |
| NULL)) { | |
| if (framing_ex->CountItems >= 1) { | |
| *num_outstanding = framing_ex->FramingItem[0].Frames; | |
| alignment = framing_ex->FramingItem[0].FileAlignment; | |
| } else { | |
| GST_DEBUG ("ignoring empty ALLOCATORFRAMING_EX"); | |
| } | |
| } else { | |
| GST_DEBUG ("query for ALLOCATORFRAMING_EX failed, trying " | |
| "ALLOCATORFRAMING"); | |
| if (ks_object_get_property (pin_handle, KSPROPSETID_Connection, | |
| KSPROPERTY_CONNECTION_ALLOCATORFRAMING, (void *) &framing, | |
| &framing_size, NULL)) { | |
| *num_outstanding = framing->Frames; | |
| alignment = framing->FileAlignment; | |
| } else { | |
| GST_DEBUG ("query for ALLOCATORFRAMING failed"); | |
| } | |
| } | |
| GST_DEBUG ("num_outstanding: %lu alignment: 0x%08x", *num_outstanding, | |
| (guint) alignment); | |
| if (*num_outstanding == 0 || *num_outstanding > MAX_OUTSTANDING_FRAMES) { | |
| GST_DEBUG ("setting number of allowable outstanding frames to 1"); | |
| *num_outstanding = 1; | |
| } | |
| g_free (framing); | |
| framing = NULL; | |
| g_free (framing_ex); | |
| framing_ex = NULL; | |
| /* | |
| * TODO: We also need to respect alignment, but for now we just assume | |
| * that allocfunc provides the appropriate alignment... | |
| */ | |
| /* Set the memory transport to use. */ | |
| if (supports_mem_transport) { | |
| mem_transport = 0; /* REVISIT: use the constant here */ | |
| if (!ks_object_set_property (pin_handle, KSPROPSETID_MemoryTransport, | |
| KSPROPERTY_MEMORY_TRANSPORT, &mem_transport, | |
| sizeof (mem_transport), NULL)) { | |
| GST_DEBUG ("failed to set memory transport, sticking with the default"); | |
| } | |
| } | |
| /* | |
| * Override the clock if we have one and the pin doesn't have any either. | |
| */ | |
| if (priv->clock != NULL) { | |
| HANDLE *cur_clock_handle = NULL; | |
| gulong cur_clock_handle_size = sizeof (HANDLE); | |
| if (ks_object_get_property (pin_handle, KSPROPSETID_Stream, | |
| KSPROPERTY_STREAM_MASTERCLOCK, (gpointer *) & cur_clock_handle, | |
| &cur_clock_handle_size, NULL)) { | |
| GST_DEBUG ("current master clock handle: %p", *cur_clock_handle); | |
| CloseHandle (*cur_clock_handle); | |
| g_free (cur_clock_handle); | |
| } else { | |
| HANDLE new_clock_handle = gst_ks_clock_get_handle (priv->clock); | |
| if (ks_object_set_property (pin_handle, KSPROPSETID_Stream, | |
| KSPROPERTY_STREAM_MASTERCLOCK, &new_clock_handle, | |
| sizeof (new_clock_handle), NULL)) { | |
| gst_ks_clock_prepare (priv->clock); | |
| } else { | |
| GST_WARNING ("failed to set pin's master clock"); | |
| } | |
| } | |
| } | |
| return pin_handle; | |
| /* ERRORS */ | |
| error_create_pin: | |
| { | |
| gchar *str; | |
| gst_ks_video_device_parse_win32_error ("KsCreatePin", ret, NULL, &str); | |
| GST_ERROR ("%s", str); | |
| g_free (str); | |
| goto beach; | |
| } | |
| cancelled: | |
| beach: | |
| { | |
| g_free (framing); | |
| g_free (framing_ex); | |
| if (ks_is_valid_handle (pin_handle)) | |
| CloseHandle (pin_handle); | |
| g_free (pin_conn); | |
| return INVALID_HANDLE_VALUE; | |
| } | |
| } | |
| static void | |
| gst_ks_video_device_close_current_pin (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| if (!ks_is_valid_handle (priv->pin_handle)) | |
| return; | |
| gst_ks_video_device_set_state (self, KSSTATE_STOP, NULL); | |
| CloseHandle (priv->pin_handle); | |
| priv->pin_handle = INVALID_HANDLE_VALUE; | |
| } | |
| static void | |
| gst_ks_video_device_reset_caps (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| gst_ks_video_device_close_current_pin (self); | |
| ks_video_media_type_free (priv->cur_media_type); | |
| priv->cur_media_type = NULL; | |
| priv->width = priv->height = priv->fps_n = priv->fps_d = 0; | |
| g_free (priv->rgb_swap_buf); | |
| priv->rgb_swap_buf = NULL; | |
| if (priv->cur_fixed_caps != NULL) { | |
| gst_caps_unref (priv->cur_fixed_caps); | |
| priv->cur_fixed_caps = NULL; | |
| } | |
| } | |
| gboolean | |
| gst_ks_video_device_set_caps (GstKsVideoDevice * self, GstCaps * caps) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| GList *cur; | |
| GstStructure *s; | |
| /* State to be committed on success */ | |
| KsVideoMediaType *media_type = NULL; | |
| gint width, height, fps_n, fps_d; | |
| HANDLE pin_handle = INVALID_HANDLE_VALUE; | |
| /* Reset? */ | |
| if (caps == NULL) { | |
| gst_ks_video_device_reset_caps (self); | |
| return TRUE; | |
| } | |
| /* Validate the caps */ | |
| if (!gst_caps_is_subset (caps, priv->cached_caps)) { | |
| gchar *string_caps = gst_caps_to_string (caps); | |
| gchar *string_c_caps = gst_caps_to_string (priv->cached_caps); | |
| GST_ERROR ("caps (%s) is not a subset of device caps (%s)", | |
| string_caps, string_c_caps); | |
| g_free (string_caps); | |
| g_free (string_c_caps); | |
| goto error; | |
| } | |
| for (cur = priv->media_types; cur != NULL; cur = cur->next) { | |
| KsVideoMediaType *mt = cur->data; | |
| if (gst_caps_is_subset (caps, mt->translated_caps)) { | |
| media_type = ks_video_media_type_dup (mt); | |
| break; | |
| } | |
| } | |
| if (media_type == NULL) | |
| goto error; | |
| s = gst_caps_get_structure (caps, 0); | |
| if (!gst_structure_get_int (s, "width", &width) || | |
| !gst_structure_get_int (s, "height", &height) || | |
| !gst_structure_get_fraction (s, "framerate", &fps_n, &fps_d)) { | |
| gst_structure_get_boolean (s, "systemstream", &priv->is_muxed); | |
| if (!priv->is_muxed) { | |
| GST_ERROR ("Failed to get width/height/fps"); | |
| goto error; | |
| } | |
| } else { | |
| if (!ks_video_fixate_media_type (media_type->range, | |
| media_type->format, width, height, fps_n, fps_d)) | |
| goto error; | |
| } | |
| if (priv->cur_media_type != NULL) { | |
| if (media_type->format_size == priv->cur_media_type->format_size && | |
| memcmp (media_type->format, priv->cur_media_type->format, | |
| priv->cur_media_type->format_size) == 0) { | |
| GST_DEBUG ("%s: re-using existing pin", G_STRFUNC); | |
| goto same_caps; | |
| } else { | |
| GST_DEBUG ("%s: re-creating pin", G_STRFUNC); | |
| } | |
| } | |
| gst_ks_video_device_close_current_pin (self); | |
| pin_handle = gst_ks_video_device_create_pin (self, media_type, | |
| &priv->num_requests); | |
| if (!ks_is_valid_handle (pin_handle)) { | |
| /* Re-create the old pin */ | |
| if (priv->cur_media_type != NULL) | |
| priv->pin_handle = gst_ks_video_device_create_pin (self, | |
| priv->cur_media_type, &priv->num_requests); | |
| goto error; | |
| } | |
| /* Commit state: no turning back past this */ | |
| gst_ks_video_device_reset_caps (self); | |
| priv->cur_media_type = media_type; | |
| priv->width = width; | |
| priv->height = height; | |
| priv->fps_n = fps_n; | |
| priv->fps_d = fps_d; | |
| if (media_type->is_rgb) | |
| priv->rgb_swap_buf = g_malloc (media_type->sample_size / priv->height); | |
| else | |
| priv->rgb_swap_buf = NULL; | |
| priv->pin_handle = pin_handle; | |
| priv->cur_fixed_caps = gst_caps_copy (caps); | |
| return TRUE; | |
| error: | |
| { | |
| ks_video_media_type_free (media_type); | |
| return FALSE; | |
| } | |
| same_caps: | |
| { | |
| ks_video_media_type_free (media_type); | |
| return TRUE; | |
| } | |
| } | |
| gboolean | |
| gst_ks_video_device_set_state (GstKsVideoDevice * self, KSSTATE state, | |
| gulong * error_code) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| KSSTATE initial_state; | |
| gint addend; | |
| g_assert (priv->cur_media_type != NULL); | |
| if (state == priv->state) | |
| return TRUE; | |
| initial_state = priv->state; | |
| addend = (state > priv->state) ? 1 : -1; | |
| GST_DEBUG ("Initiating pin state change from %s to %s", | |
| ks_state_to_string (priv->state), ks_state_to_string (state)); | |
| while (priv->state != state) { | |
| KSSTATE next_state = priv->state + addend; | |
| /* Skip the ACQUIRE step on the way down like DirectShow does */ | |
| if (addend < 0 && next_state == KSSTATE_ACQUIRE) | |
| next_state = KSSTATE_STOP; | |
| GST_DEBUG ("Changing pin state from %s to %s", | |
| ks_state_to_string (priv->state), ks_state_to_string (next_state)); | |
| if (ks_object_set_connection_state (priv->pin_handle, next_state, | |
| error_code)) { | |
| priv->state = next_state; | |
| GST_DEBUG ("Changed pin state to %s", ks_state_to_string (priv->state)); | |
| if (priv->state == KSSTATE_PAUSE && addend > 0) | |
| gst_ks_video_device_prepare_buffers (self); | |
| else if (priv->state == KSSTATE_STOP && addend < 0) | |
| gst_ks_video_device_clear_buffers (self); | |
| } else { | |
| GST_WARNING ("Failed to change pin state to %s", | |
| ks_state_to_string (next_state)); | |
| return FALSE; | |
| } | |
| } | |
| GST_DEBUG ("Finished pin state change from %s to %s", | |
| ks_state_to_string (initial_state), ks_state_to_string (state)); | |
| return TRUE; | |
| } | |
| static guint | |
| gst_ks_video_device_get_frame_size (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| g_assert (priv->cur_media_type != NULL); | |
| return priv->cur_media_type->sample_size; | |
| } | |
| GstClockTime | |
| gst_ks_video_device_get_duration (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| g_assert (priv->cur_media_type != NULL); | |
| return gst_util_uint64_scale_int (GST_SECOND, priv->fps_d, priv->fps_n); | |
| } | |
| gboolean | |
| gst_ks_video_device_get_latency (GstKsVideoDevice * self, | |
| GstClockTime * min_latency, GstClockTime * max_latency) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| if (priv->cur_media_type == NULL) | |
| return FALSE; | |
| *min_latency = | |
| gst_util_uint64_scale_int (GST_SECOND, priv->fps_d, priv->fps_n); | |
| *max_latency = *min_latency; | |
| return TRUE; | |
| } | |
| static gboolean | |
| gst_ks_read_request_pick_buffer (GstKsVideoDevice * self, ReadRequest * req) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| gboolean buffer_found = FALSE; | |
| guint i; | |
| buffer_found = gst_buffer_is_writable (req->buf) | |
| && gst_buffer_is_all_memory_writable (req->buf); | |
| for (i = 0; !buffer_found && i < G_N_ELEMENTS (priv->spare_buffers); i++) { | |
| if (gst_buffer_is_writable (priv->spare_buffers[i]) | |
| && gst_buffer_is_all_memory_writable (priv->spare_buffers[i])) { | |
| GstBuffer *hold; | |
| hold = req->buf; | |
| req->buf = priv->spare_buffers[i]; | |
| priv->spare_buffers[i] = hold; | |
| buffer_found = TRUE; | |
| } | |
| } | |
| if (!buffer_found) { | |
| gst_buffer_unref (req->buf); | |
| req->buf = self->allocfunc (gst_ks_video_device_get_frame_size (self), | |
| KS_BUFFER_ALIGNMENT, self->allocfunc_data); | |
| } | |
| if (req->buf != NULL) { | |
| GST_BUFFER_FLAGS (req->buf) = 0; | |
| return TRUE; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| static gboolean | |
| gst_ks_video_device_request_frame (GstKsVideoDevice * self, ReadRequest * req, | |
| gulong * error_code, gchar ** error_str) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| HANDLE event; | |
| KSSTREAM_READ_PARAMS *params; | |
| BOOL success; | |
| DWORD bytes_returned = 0; | |
| GstMapInfo info; | |
| if (!gst_ks_read_request_pick_buffer (self, req)) | |
| goto error_pick_buffer; | |
| /* Reset the OVERLAPPED structure */ | |
| event = req->overlapped.hEvent; | |
| memset (&req->overlapped, 0, sizeof (OVERLAPPED)); | |
| req->overlapped.hEvent = event; | |
| /* Fill out KSSTREAM_HEADER and KS_FRAME_INFO */ | |
| params = &req->params; | |
| memset (params, 0, sizeof (KSSTREAM_READ_PARAMS)); | |
| if (!gst_buffer_map (req->buf, &info, GST_MAP_WRITE)) | |
| goto map_failed; | |
| params->header.Size = sizeof (KSSTREAM_HEADER); | |
| if (!priv->is_muxed) { | |
| params->header.Size += sizeof (KS_FRAME_INFO); | |
| } | |
| params->header.PresentationTime.Numerator = 1; | |
| params->header.PresentationTime.Denominator = 1; | |
| params->header.FrameExtent = gst_ks_video_device_get_frame_size (self); | |
| params->header.Data = info.data; | |
| params->frame_info.ExtendedHeaderSize = sizeof (KS_FRAME_INFO); | |
| success = DeviceIoControl (priv->pin_handle, IOCTL_KS_READ_STREAM, NULL, 0, | |
| params, params->header.Size, &bytes_returned, &req->overlapped); | |
| gst_buffer_unmap (req->buf, &info); | |
| if (!success && GetLastError () != ERROR_IO_PENDING) | |
| goto error_ioctl; | |
| return TRUE; | |
| /* ERRORS */ | |
| error_pick_buffer: | |
| { | |
| if (error_code != NULL) | |
| *error_code = 0; | |
| if (error_str != NULL) | |
| *error_str = NULL; | |
| return FALSE; | |
| } | |
| error_ioctl: | |
| { | |
| gst_ks_video_device_parse_win32_error ("DeviceIoControl", GetLastError (), | |
| error_code, error_str); | |
| return FALSE; | |
| } | |
| map_failed: | |
| { | |
| return FALSE; | |
| } | |
| } | |
| GstFlowReturn | |
| gst_ks_video_device_read_frame (GstKsVideoDevice * self, GstBuffer ** buf, | |
| GstClockTime * presentation_time, gulong * error_code, gchar ** error_str) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| guint req_idx; | |
| DWORD wait_ret; | |
| BOOL success; | |
| DWORD bytes_returned; | |
| g_assert (priv->cur_media_type != NULL); | |
| /* First time we're called, submit the requests. */ | |
| if (G_UNLIKELY (!priv->requests_submitted)) { | |
| priv->requests_submitted = TRUE; | |
| for (req_idx = 0; req_idx < priv->num_requests; req_idx++) { | |
| ReadRequest *req = &g_array_index (priv->requests, ReadRequest, req_idx); | |
| if (!gst_ks_video_device_request_frame (self, req, error_code, error_str)) | |
| goto error_request_failed; | |
| } | |
| } | |
| *buf = NULL; | |
| do { | |
| /* Wait for either a request to complete, a cancel or a timeout */ | |
| wait_ret = WaitForMultipleObjects (priv->request_events->len, | |
| (HANDLE *) priv->request_events->data, FALSE, READ_TIMEOUT); | |
| if (wait_ret == WAIT_TIMEOUT) | |
| goto error_timeout; | |
| else if (wait_ret == WAIT_FAILED) | |
| goto error_wait; | |
| /* Stopped? */ | |
| if (WaitForSingleObject (priv->cancel_event, 0) == WAIT_OBJECT_0) | |
| goto error_cancel; | |
| /* Find the last ReadRequest that finished and get the result, immediately | |
| * re-issuing each request that has completed. */ | |
| for (req_idx = wait_ret - WAIT_OBJECT_0; | |
| req_idx < priv->num_requests; req_idx++) { | |
| ReadRequest *req = &g_array_index (priv->requests, ReadRequest, req_idx); | |
| /* | |
| * Completed? WaitForMultipleObjects() returns the lowest index if | |
| * multiple objects are in the signaled state, and we know that requests | |
| * are processed one by one so there's no point in looking further once | |
| * we've found the first that's non-signaled. | |
| */ | |
| if (WaitForSingleObject (req->overlapped.hEvent, 0) != WAIT_OBJECT_0) | |
| break; | |
| success = GetOverlappedResult (priv->pin_handle, &req->overlapped, | |
| &bytes_returned, TRUE); | |
| ResetEvent (req->overlapped.hEvent); | |
| if (success) { | |
| KSSTREAM_HEADER *hdr = &req->params.header; | |
| KS_FRAME_INFO *frame_info = &req->params.frame_info; | |
| GstClockTime timestamp = GST_CLOCK_TIME_NONE; | |
| GstClockTime duration = GST_CLOCK_TIME_NONE; | |
| if (hdr->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TIMEVALID) | |
| timestamp = hdr->PresentationTime.Time * 100; | |
| if (hdr->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_DURATIONVALID) | |
| duration = hdr->Duration * 100; | |
| UNREF_BUFFER (buf); | |
| if (G_LIKELY (hdr->DataUsed != 0)) { | |
| /* Assume it's a good frame */ | |
| gst_buffer_set_size (req->buf, hdr->DataUsed); | |
| *buf = gst_buffer_ref (req->buf); | |
| } | |
| if (G_LIKELY (presentation_time != NULL)) | |
| *presentation_time = timestamp; | |
| if (G_UNLIKELY (GST_DEBUG_IS_ENABLED ())) { | |
| gchar *options_flags_str = | |
| ks_options_flags_to_string (hdr->OptionsFlags); | |
| GST_DEBUG ("PictureNumber=%" G_GUINT64_FORMAT ", DropCount=%" | |
| G_GUINT64_FORMAT ", PresentationTime=%" GST_TIME_FORMAT | |
| ", Duration=%" GST_TIME_FORMAT ", OptionsFlags=%s: %lu bytes", | |
| frame_info->PictureNumber, frame_info->DropCount, | |
| GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration), | |
| options_flags_str, hdr->DataUsed); | |
| g_free (options_flags_str); | |
| } | |
| /* Protect against old frames. This should never happen, see previous | |
| * comment on last_timestamp. */ | |
| if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (timestamp))) { | |
| if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (priv->last_timestamp) && | |
| timestamp < priv->last_timestamp)) { | |
| GST_INFO ("got an old frame (last_timestamp=%" GST_TIME_FORMAT | |
| ", timestamp=%" GST_TIME_FORMAT ")", | |
| GST_TIME_ARGS (priv->last_timestamp), | |
| GST_TIME_ARGS (timestamp)); | |
| UNREF_BUFFER (buf); | |
| } else { | |
| priv->last_timestamp = timestamp; | |
| } | |
| } | |
| } else if (GetLastError () != ERROR_OPERATION_ABORTED) { | |
| goto error_get_result; | |
| } | |
| /* Submit a new request immediately */ | |
| if (!gst_ks_video_device_request_frame (self, req, error_code, error_str)) | |
| goto error_request_failed; | |
| } | |
| } while (*buf == NULL); | |
| return GST_FLOW_OK; | |
| /* ERRORS */ | |
| error_request_failed: | |
| { | |
| UNREF_BUFFER (buf); | |
| return GST_FLOW_ERROR; | |
| } | |
| error_timeout: | |
| { | |
| GST_DEBUG ("IOCTL_KS_READ_STREAM timed out"); | |
| if (error_code != NULL) | |
| *error_code = 0; | |
| if (error_str != NULL) | |
| *error_str = NULL; | |
| return GST_FLOW_CUSTOM_ERROR; | |
| } | |
| error_wait: | |
| { | |
| gst_ks_video_device_parse_win32_error ("WaitForMultipleObjects", | |
| GetLastError (), error_code, error_str); | |
| return GST_FLOW_ERROR; | |
| } | |
| error_cancel: | |
| { | |
| if (error_code != NULL) | |
| *error_code = 0; | |
| if (error_str != NULL) | |
| *error_str = NULL; | |
| return GST_FLOW_FLUSHING; | |
| } | |
| error_get_result: | |
| { | |
| gst_ks_video_device_parse_win32_error ("GetOverlappedResult", | |
| GetLastError (), error_code, error_str); | |
| return GST_FLOW_ERROR; | |
| } | |
| } | |
| gboolean | |
| gst_ks_video_device_postprocess_frame (GstKsVideoDevice * self, | |
| GstBuffer ** bufptr) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| GstBuffer *buf = *bufptr; | |
| /* If it's RGB we need to flip the image */ | |
| if (priv->rgb_swap_buf != NULL) { | |
| GstMapInfo info; | |
| gint stride, line; | |
| guint8 *dst, *src; | |
| /* Need to make the buffer writable because | |
| * the pseudo-bufferpool of requests keeps a ref */ | |
| buf = gst_buffer_make_writable (buf); | |
| if (!gst_buffer_map (buf, &info, GST_MAP_READWRITE)) | |
| return FALSE; | |
| stride = info.size / priv->height; | |
| dst = info.data; | |
| src = info.data + info.size - stride; | |
| for (line = 0; line < priv->height / 2; line++) { | |
| memcpy (priv->rgb_swap_buf, dst, stride); | |
| memcpy (dst, src, stride); | |
| memcpy (src, priv->rgb_swap_buf, stride); | |
| dst += stride; | |
| src -= stride; | |
| } | |
| gst_buffer_unmap (buf, &info); | |
| } | |
| *bufptr = buf; | |
| return TRUE; | |
| } | |
| void | |
| gst_ks_video_device_cancel (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| SetEvent (priv->cancel_event); | |
| } | |
| void | |
| gst_ks_video_device_cancel_stop (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| ResetEvent (priv->cancel_event); | |
| } | |
| gboolean | |
| gst_ks_video_device_stream_is_muxed (GstKsVideoDevice * self) | |
| { | |
| GstKsVideoDevicePrivate *priv = GST_KS_VIDEO_DEVICE_GET_PRIVATE (self); | |
| return priv->is_muxed; | |
| } |