2010-10-20 20:55:16 +02:00
|
|
|
/*
|
|
|
|
* GStreamer splitter + decoder, adapted from parser.c
|
|
|
|
*
|
|
|
|
* Copyright 2010 Maarten Lankhorst for CodeWeavers
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 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
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __GST_PRIVATE_INCLUDED__
|
|
|
|
#define __GST_PRIVATE_INCLUDED__
|
|
|
|
|
2021-02-22 23:53:47 +01:00
|
|
|
#include <assert.h>
|
2021-09-16 01:00:08 +02:00
|
|
|
#include <limits.h>
|
2010-10-20 20:55:16 +02:00
|
|
|
#include <stdarg.h>
|
winegstreamer: Manage our own streaming thread.
This is a rather large and complex change. It comprises several parts:
(1) Instead of directly sending EOS, segment, and sample events to the
downstream DirectShow sink, first queue them in a local buffer (i.e.
"pin->event").
(2) Spawn a separate thread per source pin (i.e. "stream_thread") which consumes
said events and sends them downstream.
(3) When flushing or stopping, explicitly wait for this thread to pause or stop
(respectively).
There are a few reasons for this:
(1) It reduces the number of Unix -> PE callbacks we need to make, easing PE
conversion. This is not a great advantage *a priori*, and may not be worth a
similar dedicated "handler" thread for most modules, but winegstreamer is
different—we were already marshalling these calls onto another thread, and
now that marshalling can go away (almost).
(2) Because GStreamer can only do pad negotiation (and hence autoplugging) while
running (in contrast to DirectShow, which can do it while stopped), we
currently have to renegotiate every time the pipeline is started. Most
applications don't start the graph more than once, but even that requires
two negotiations, and startup time is demonstrably too high. It would be
nice to keep the graph in PAUSED state all of the time, but this is
difficult to do without more fine-grained control over the streaming thread.
[In particular, we cannot reliably wait for all samples to be delivered
except by stopping the GStreamer pipeline.]
Signed-off-by: Zebediah Figura <z.figura12@gmail.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2021-01-20 04:35:38 +01:00
|
|
|
#include <stdbool.h>
|
2021-01-22 00:22:52 +01:00
|
|
|
#include <stdint.h>
|
2020-03-08 20:05:09 +01:00
|
|
|
#include <stdio.h>
|
2010-10-20 20:55:16 +02:00
|
|
|
|
|
|
|
#define COBJMACROS
|
2020-03-08 20:05:09 +01:00
|
|
|
#define NONAMELESSSTRUCT
|
|
|
|
#define NONAMELESSUNION
|
2010-10-20 20:55:16 +02:00
|
|
|
#include "dshow.h"
|
2021-02-22 23:53:47 +01:00
|
|
|
#include "mfidl.h"
|
2020-10-22 18:10:17 +02:00
|
|
|
#include "wine/debug.h"
|
2010-10-20 20:55:16 +02:00
|
|
|
#include "wine/strmbase.h"
|
|
|
|
|
2021-02-11 23:18:56 +01:00
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
GST_AUTOPLUG_SELECT_TRY,
|
|
|
|
GST_AUTOPLUG_SELECT_EXPOSE,
|
|
|
|
GST_AUTOPLUG_SELECT_SKIP,
|
|
|
|
} GstAutoplugSelectResult;
|
|
|
|
|
2020-10-22 18:10:17 +02:00
|
|
|
static inline const char *debugstr_time(REFERENCE_TIME time)
|
|
|
|
{
|
|
|
|
ULONGLONG abstime = time >= 0 ? time : -time;
|
|
|
|
unsigned int i = 0, j = 0;
|
|
|
|
char buffer[23], rev[23];
|
|
|
|
|
|
|
|
while (abstime || i <= 8)
|
|
|
|
{
|
|
|
|
buffer[i++] = '0' + (abstime % 10);
|
|
|
|
abstime /= 10;
|
|
|
|
if (i == 7) buffer[i++] = '.';
|
|
|
|
}
|
|
|
|
if (time < 0) buffer[i++] = '-';
|
|
|
|
|
|
|
|
while (i--) rev[j++] = buffer[i];
|
|
|
|
while (rev[j-1] == '0' && rev[j-2] != '.') --j;
|
|
|
|
rev[j] = 0;
|
|
|
|
|
|
|
|
return wine_dbg_sprintf("%s", rev);
|
|
|
|
}
|
|
|
|
|
2010-10-26 18:39:15 +02:00
|
|
|
#define MEDIATIME_FROM_BYTES(x) ((LONGLONG)(x) * 10000000)
|
|
|
|
|
2021-02-08 22:06:59 +01:00
|
|
|
struct wg_format
|
|
|
|
{
|
|
|
|
enum wg_major_type
|
|
|
|
{
|
|
|
|
WG_MAJOR_TYPE_UNKNOWN,
|
|
|
|
WG_MAJOR_TYPE_VIDEO,
|
|
|
|
WG_MAJOR_TYPE_AUDIO,
|
|
|
|
} major_type;
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
enum wg_video_format
|
|
|
|
{
|
|
|
|
WG_VIDEO_FORMAT_UNKNOWN,
|
|
|
|
|
|
|
|
WG_VIDEO_FORMAT_BGRA,
|
|
|
|
WG_VIDEO_FORMAT_BGRx,
|
|
|
|
WG_VIDEO_FORMAT_BGR,
|
|
|
|
WG_VIDEO_FORMAT_RGB15,
|
|
|
|
WG_VIDEO_FORMAT_RGB16,
|
|
|
|
|
|
|
|
WG_VIDEO_FORMAT_AYUV,
|
|
|
|
WG_VIDEO_FORMAT_I420,
|
|
|
|
WG_VIDEO_FORMAT_NV12,
|
|
|
|
WG_VIDEO_FORMAT_UYVY,
|
|
|
|
WG_VIDEO_FORMAT_YUY2,
|
|
|
|
WG_VIDEO_FORMAT_YV12,
|
|
|
|
WG_VIDEO_FORMAT_YVYU,
|
|
|
|
|
|
|
|
WG_VIDEO_FORMAT_CINEPAK,
|
|
|
|
} format;
|
|
|
|
uint32_t width, height;
|
|
|
|
uint32_t fps_n, fps_d;
|
|
|
|
} video;
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
enum wg_audio_format
|
|
|
|
{
|
|
|
|
WG_AUDIO_FORMAT_UNKNOWN,
|
|
|
|
|
|
|
|
WG_AUDIO_FORMAT_U8,
|
|
|
|
WG_AUDIO_FORMAT_S16LE,
|
|
|
|
WG_AUDIO_FORMAT_S24LE,
|
|
|
|
WG_AUDIO_FORMAT_S32LE,
|
|
|
|
WG_AUDIO_FORMAT_F32LE,
|
|
|
|
WG_AUDIO_FORMAT_F64LE,
|
|
|
|
|
|
|
|
WG_AUDIO_FORMAT_MPEG1_LAYER1,
|
|
|
|
WG_AUDIO_FORMAT_MPEG1_LAYER2,
|
|
|
|
WG_AUDIO_FORMAT_MPEG1_LAYER3,
|
|
|
|
} format;
|
|
|
|
|
|
|
|
uint32_t channels;
|
2021-02-19 00:01:25 +01:00
|
|
|
uint32_t channel_mask; /* In WinMM format. */
|
2021-02-08 22:06:59 +01:00
|
|
|
uint32_t rate;
|
|
|
|
} audio;
|
|
|
|
} u;
|
|
|
|
};
|
|
|
|
|
2021-02-11 23:18:56 +01:00
|
|
|
enum wg_parser_event_type
|
|
|
|
{
|
|
|
|
WG_PARSER_EVENT_NONE = 0,
|
|
|
|
WG_PARSER_EVENT_BUFFER,
|
|
|
|
WG_PARSER_EVENT_EOS,
|
|
|
|
WG_PARSER_EVENT_SEGMENT,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wg_parser_event
|
|
|
|
{
|
|
|
|
enum wg_parser_event_type type;
|
|
|
|
union
|
|
|
|
{
|
2021-02-17 02:28:29 +01:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
/* pts and duration are in 100-nanosecond units. */
|
2021-02-20 03:34:58 +01:00
|
|
|
ULONGLONG pts, duration;
|
2021-02-17 02:28:29 +01:00
|
|
|
uint32_t size;
|
|
|
|
bool discontinuity, preroll, delta, has_pts, has_duration;
|
|
|
|
} buffer;
|
2021-02-11 23:18:56 +01:00
|
|
|
struct
|
|
|
|
{
|
2021-02-20 03:34:58 +01:00
|
|
|
ULONGLONG position, stop;
|
|
|
|
DOUBLE rate;
|
2021-02-11 23:18:56 +01:00
|
|
|
} segment;
|
|
|
|
} u;
|
|
|
|
};
|
2021-02-20 03:34:58 +01:00
|
|
|
C_ASSERT(sizeof(struct wg_parser_event) == 40);
|
2021-02-11 23:18:56 +01:00
|
|
|
|
|
|
|
struct unix_funcs
|
|
|
|
{
|
|
|
|
struct wg_parser *(CDECL *wg_decodebin_parser_create)(void);
|
|
|
|
struct wg_parser *(CDECL *wg_avi_parser_create)(void);
|
|
|
|
struct wg_parser *(CDECL *wg_mpeg_audio_parser_create)(void);
|
|
|
|
struct wg_parser *(CDECL *wg_wave_parser_create)(void);
|
2021-02-11 23:18:58 +01:00
|
|
|
void (CDECL *wg_parser_destroy)(struct wg_parser *parser);
|
2021-02-13 18:33:04 +01:00
|
|
|
|
|
|
|
HRESULT (CDECL *wg_parser_connect)(struct wg_parser *parser, uint64_t file_size);
|
2021-02-13 18:33:05 +01:00
|
|
|
void (CDECL *wg_parser_disconnect)(struct wg_parser *parser);
|
2021-02-13 18:33:06 +01:00
|
|
|
|
2021-02-16 00:01:53 +01:00
|
|
|
void (CDECL *wg_parser_begin_flush)(struct wg_parser *parser);
|
|
|
|
void (CDECL *wg_parser_end_flush)(struct wg_parser *parser);
|
|
|
|
|
2021-02-17 02:28:31 +01:00
|
|
|
bool (CDECL *wg_parser_get_read_request)(struct wg_parser *parser,
|
2021-02-18 00:30:34 +01:00
|
|
|
void **data, uint64_t *offset, uint32_t *size);
|
|
|
|
void (CDECL *wg_parser_complete_read_request)(struct wg_parser *parser, bool ret);
|
2021-02-17 02:28:31 +01:00
|
|
|
|
2021-02-19 00:01:27 +01:00
|
|
|
void (CDECL *wg_parser_set_unlimited_buffering)(struct wg_parser *parser);
|
|
|
|
|
2021-02-13 18:33:06 +01:00
|
|
|
uint32_t (CDECL *wg_parser_get_stream_count)(struct wg_parser *parser);
|
|
|
|
struct wg_parser_stream *(CDECL *wg_parser_get_stream)(struct wg_parser *parser, uint32_t index);
|
2021-02-16 00:01:50 +01:00
|
|
|
|
|
|
|
void (CDECL *wg_parser_stream_get_preferred_format)(struct wg_parser_stream *stream, struct wg_format *format);
|
2021-02-16 00:01:51 +01:00
|
|
|
void (CDECL *wg_parser_stream_enable)(struct wg_parser_stream *stream, const struct wg_format *format);
|
|
|
|
void (CDECL *wg_parser_stream_disable)(struct wg_parser_stream *stream);
|
2021-02-16 00:01:52 +01:00
|
|
|
|
|
|
|
bool (CDECL *wg_parser_stream_get_event)(struct wg_parser_stream *stream, struct wg_parser_event *event);
|
2021-02-17 02:28:29 +01:00
|
|
|
bool (CDECL *wg_parser_stream_copy_buffer)(struct wg_parser_stream *stream,
|
|
|
|
void *data, uint32_t offset, uint32_t size);
|
|
|
|
void (CDECL *wg_parser_stream_release_buffer)(struct wg_parser_stream *stream);
|
2021-02-16 00:01:54 +01:00
|
|
|
void (CDECL *wg_parser_stream_notify_qos)(struct wg_parser_stream *stream,
|
|
|
|
bool underflow, double proportion, int64_t diff, uint64_t timestamp);
|
2021-02-17 02:28:26 +01:00
|
|
|
|
2021-02-18 00:30:35 +01:00
|
|
|
/* Returns the duration in 100-nanosecond units. */
|
|
|
|
uint64_t (CDECL *wg_parser_stream_get_duration)(struct wg_parser_stream *stream);
|
2021-02-17 02:28:26 +01:00
|
|
|
/* start_pos and stop_pos are in 100-nanosecond units. */
|
|
|
|
bool (CDECL *wg_parser_stream_seek)(struct wg_parser_stream *stream, double rate,
|
|
|
|
uint64_t start_pos, uint64_t stop_pos, DWORD start_flags, DWORD stop_flags);
|
2021-02-11 23:18:56 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
extern const struct unix_funcs *unix_funcs;
|
|
|
|
|
2020-03-08 20:05:09 +01:00
|
|
|
HRESULT avi_splitter_create(IUnknown *outer, IUnknown **out) DECLSPEC_HIDDEN;
|
2021-01-16 00:59:17 +01:00
|
|
|
HRESULT decodebin_parser_create(IUnknown *outer, IUnknown **out) DECLSPEC_HIDDEN;
|
2020-03-08 20:05:09 +01:00
|
|
|
HRESULT mpeg_splitter_create(IUnknown *outer, IUnknown **out) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT wave_parser_create(IUnknown *outer, IUnknown **out) DECLSPEC_HIDDEN;
|
2010-10-26 18:39:15 +02:00
|
|
|
|
2019-03-26 06:57:33 +01:00
|
|
|
BOOL init_gstreamer(void) DECLSPEC_HIDDEN;
|
2016-01-12 20:35:04 +01:00
|
|
|
|
|
|
|
void start_dispatch_thread(void) DECLSPEC_HIDDEN;
|
|
|
|
|
2019-07-05 15:23:21 +02:00
|
|
|
extern HRESULT mfplat_get_class_object(REFCLSID rclsid, REFIID riid, void **obj) DECLSPEC_HIDDEN;
|
2020-12-03 17:42:19 +01:00
|
|
|
extern HRESULT mfplat_DllRegisterServer(void) DECLSPEC_HIDDEN;
|
2019-07-05 15:23:21 +02:00
|
|
|
|
2021-02-19 00:01:27 +01:00
|
|
|
IMFMediaType *mf_media_type_from_wg_format(const struct wg_format *format) DECLSPEC_HIDDEN;
|
|
|
|
void mf_media_type_to_wg_format(IMFMediaType *type, struct wg_format *format) DECLSPEC_HIDDEN;
|
2020-09-28 22:59:54 +02:00
|
|
|
|
2020-09-02 22:05:02 +02:00
|
|
|
HRESULT winegstreamer_stream_handler_create(REFIID riid, void **obj) DECLSPEC_HIDDEN;
|
|
|
|
|
2020-12-03 17:42:18 +01:00
|
|
|
HRESULT audio_converter_create(REFIID riid, void **ret) DECLSPEC_HIDDEN;
|
|
|
|
|
2010-10-20 20:55:16 +02:00
|
|
|
#endif /* __GST_PRIVATE_INCLUDED__ */
|