winegstreamer: Create transforms from MFVIDEOFORMAT / WAVEFORMATEX.

rbernon · julliard · commit 9192b3b724d9 · 2024-07-01T14:16:34.000+02:00
Instead of going through a custom intermediate format.
diff --git a/dlls/winegstreamer/gst_private.h b/dlls/winegstreamer/gst_private.h
@@ -81,8 +81,6 @@ char *wg_parser_stream_get_tag(wg_parser_stream_t stream, enum wg_parser_tag tag
 void wg_parser_stream_seek(wg_parser_stream_t stream, double rate,
         uint64_t start_pos, uint64_t stop_pos, DWORD start_flags, DWORD stop_flags);
 
-wg_transform_t wg_transform_create(const struct wg_format *input_format,
-        const struct wg_format *output_format, const struct wg_transform_attrs *attrs);
 HRESULT wg_transform_create_mf(IMFMediaType *input_type, IMFMediaType *output_type,
         const struct wg_transform_attrs *attrs, wg_transform_t *transform);
 HRESULT wg_transform_create_quartz(const AM_MEDIA_TYPE *input_format, const AM_MEDIA_TYPE *output_format,
diff --git a/dlls/winegstreamer/main.c b/dlls/winegstreamer/main.c
@@ -435,55 +435,59 @@ void wg_parser_stream_seek(wg_parser_stream_t stream, double rate,
     WINE_UNIX_CALL(unix_wg_parser_stream_seek, &params);
 }
 
-wg_transform_t wg_transform_create(const struct wg_format *input_format,
-        const struct wg_format *output_format, const struct wg_transform_attrs *attrs)
+HRESULT wg_transform_create_mf(IMFMediaType *input_type, IMFMediaType *output_type,
+        const struct wg_transform_attrs *attrs, wg_transform_t *transform)
 {
     struct wg_transform_create_params params =
     {
-        .input_format = input_format,
-        .output_format = output_format,
-        .attrs = attrs,
+        .attrs = *attrs,
     };
+    NTSTATUS status;
+    HRESULT hr;
 
-    TRACE("input_format %p, output_format %p.\n", input_format, output_format);
-
-    if (WINE_UNIX_CALL(unix_wg_transform_create, &params))
-        return 0;
+    TRACE("input_type %p, output_type %p.\n", input_type, output_type);
 
-    TRACE("Returning transform %#I64x.\n", params.transform);
-    return params.transform;
-}
-
-HRESULT wg_transform_create_mf(IMFMediaType *input_type, IMFMediaType *output_type,
-        const struct wg_transform_attrs *attrs, wg_transform_t *transform)
-{
-    struct wg_format input_format, output_format;
+    if (FAILED(hr = wg_media_type_from_mf(input_type, &params.input_type)))
+        return hr;
+    if (FAILED(hr = wg_media_type_from_mf(output_type, &params.output_type)))
+    {
+        CoTaskMemFree(params.input_type.u.format);
+        return hr;
+    }
 
-    mf_media_type_to_wg_format(input_type, &input_format);
-    if (input_format.major_type == WG_MAJOR_TYPE_UNKNOWN)
-        return MF_E_INVALIDMEDIATYPE;
-    mf_media_type_to_wg_format(output_type, &output_format);
-    if (output_format.major_type == WG_MAJOR_TYPE_UNKNOWN)
-        return MF_E_INVALIDMEDIATYPE;
+    if ((status = WINE_UNIX_CALL(unix_wg_transform_create, &params)))
+    {
+        WARN("Failed to create transform, status %#lx\n", status);
+        hr = HRESULT_FROM_NT(status);
+    }
 
-    if (!(*transform = wg_transform_create(&input_format, &output_format, attrs)))
-        return E_FAIL;
-    return S_OK;
+    CoTaskMemFree(params.output_type.u.format);
+    CoTaskMemFree(params.input_type.u.format);
+    *transform = params.transform;
+    return hr;
 }
 
-HRESULT wg_transform_create_quartz(const AM_MEDIA_TYPE *input_type, const AM_MEDIA_TYPE *output_type,
+HRESULT wg_transform_create_quartz(const AM_MEDIA_TYPE *input_format, const AM_MEDIA_TYPE *output_format,
         const struct wg_transform_attrs *attrs, wg_transform_t *transform)
 {
-    struct wg_format input_format, output_format;
+    IMFMediaType *input_type, *output_type;
+    HRESULT hr;
 
-    if (!amt_to_wg_format(input_type, &input_format))
-        return E_FAIL;
-    if (!amt_to_wg_format(output_type, &output_format))
-        return E_FAIL;
+    TRACE("input_format %p, output_format %p.\n", input_format, output_format);
 
-    if (!(*transform = wg_transform_create(&input_format, &output_format, attrs)))
-        return E_FAIL;
-    return S_OK;
+    /* through IMFMediaType to normalize representation to MFVIDEOFORMAT / WAVEFORMATEX */
+    if (FAILED(hr = MFCreateMediaTypeFromRepresentation(AM_MEDIA_TYPE_REPRESENTATION, (void *)input_format, &input_type)))
+        return 0;
+    if (FAILED(hr = MFCreateMediaTypeFromRepresentation(AM_MEDIA_TYPE_REPRESENTATION, (void *)output_format, &output_type)))
+    {
+        IMFMediaType_Release(input_type);
+        return 0;
+    }
+
+    hr = wg_transform_create_mf(input_type, output_type, attrs, transform);
+    IMFMediaType_Release(output_type);
+    IMFMediaType_Release(input_type);
+    return hr;
 }
 
 void wg_transform_destroy(wg_transform_t transform)
@@ -773,54 +777,61 @@ HRESULT wg_muxer_finalize(wg_muxer_t muxer)
     return S_OK;
 }
 
-HRESULT check_audio_transform_support(const WAVEFORMATEX *input, const WAVEFORMATEX *output)
+static HRESULT check_transform_support(const struct wg_media_type *input, const struct wg_media_type *output)
 {
     IMFMediaType *input_type, *output_type;
     struct wg_transform_attrs attrs = {0};
     wg_transform_t transform;
     HRESULT hr;
 
-    if (FAILED(hr = MFCreateMediaType(&input_type)))
+    if (FAILED(hr = wg_media_type_to_mf(input, &input_type)))
         return hr;
-    if (FAILED(hr = MFCreateMediaType(&output_type)))
+    if (FAILED(hr = wg_media_type_to_mf(output, &output_type)))
     {
         IMFMediaType_Release(input_type);
         return hr;
     }
 
-    if (SUCCEEDED(hr = MFInitMediaTypeFromWaveFormatEx(input_type, input, sizeof(*input) + input->cbSize))
-            && SUCCEEDED(hr = MFInitMediaTypeFromWaveFormatEx(output_type, output, sizeof(*output) + output->cbSize))
-            && SUCCEEDED(hr = wg_transform_create_mf(input_type, output_type, &attrs, &transform)))
+    if (SUCCEEDED(hr = wg_transform_create_mf(input_type, output_type, &attrs, &transform)))
         wg_transform_destroy(transform);
 
     IMFMediaType_Release(output_type);
     IMFMediaType_Release(input_type);
     return hr;
 }
 
-HRESULT check_video_transform_support(const MFVIDEOFORMAT *input, const MFVIDEOFORMAT *output)
+HRESULT check_audio_transform_support(const WAVEFORMATEX *input, const WAVEFORMATEX *output)
 {
-    IMFMediaType *input_type, *output_type;
-    struct wg_transform_attrs attrs = {0};
-    wg_transform_t transform;
-    HRESULT hr;
-
-    if (FAILED(hr = MFCreateMediaType(&input_type)))
-        return hr;
-    if (FAILED(hr = MFCreateMediaType(&output_type)))
+    const struct wg_media_type input_type =
     {
-        IMFMediaType_Release(input_type);
-        return hr;
-    }
-
-    if (SUCCEEDED(hr = MFInitMediaTypeFromMFVideoFormat(input_type, input, input->dwSize))
-            && SUCCEEDED(hr = MFInitMediaTypeFromMFVideoFormat(output_type, output, output->dwSize))
-            && SUCCEEDED(hr = wg_transform_create_mf(input_type, output_type, &attrs, &transform)))
-        wg_transform_destroy(transform);
+        .major = MFMediaType_Audio,
+        .format_size = sizeof(*input) + input->cbSize,
+        .u.audio = (WAVEFORMATEX *)input,
+    };
+    const struct wg_media_type output_type =
+    {
+        .major = MFMediaType_Audio,
+        .format_size = sizeof(*output) + output->cbSize,
+        .u.audio = (WAVEFORMATEX *)output,
+    };
+    return check_transform_support(&input_type, &output_type);
+}
 
-    IMFMediaType_Release(output_type);
-    IMFMediaType_Release(input_type);
-    return hr;
+HRESULT check_video_transform_support(const MFVIDEOFORMAT *input, const MFVIDEOFORMAT *output)
+{
+    const struct wg_media_type input_type =
+    {
+        .major = MFMediaType_Video,
+        .format_size = input->dwSize,
+        .u.video = (MFVIDEOFORMAT *)input,
+    };
+    const struct wg_media_type output_type =
+    {
+        .major = MFMediaType_Video,
+        .format_size = output->dwSize,
+        .u.video = (MFVIDEOFORMAT *)output,
+    };
+    return check_transform_support(&input_type, &output_type);
 }
 
 #define ALIGN(n, alignment) (((n) + (alignment) - 1) & ~((alignment) - 1))
diff --git a/dlls/winegstreamer/quartz_transform.c b/dlls/winegstreamer/quartz_transform.c
@@ -874,31 +874,26 @@ static const struct transform_ops mpeg_video_codec_transform_ops =
 
 HRESULT mpeg_video_codec_create(IUnknown *outer, IUnknown **out)
 {
-    static const struct wg_format output_format =
+    const MFVIDEOFORMAT output_format =
     {
-        .major_type = WG_MAJOR_TYPE_VIDEO,
-        .u.video = {
-            .format = WG_VIDEO_FORMAT_I420,
-            /* size doesn't matter, this one is only used to check if the GStreamer plugin exists */
-        },
+        .dwSize = sizeof(MFVIDEOFORMAT),
+        .videoInfo = {.dwWidth = 1920, .dwHeight = 1080},
+        .guidFormat = MEDIASUBTYPE_NV12,
     };
-    static const struct wg_format input_format =
+    const MFVIDEOFORMAT input_format =
     {
-        .major_type = WG_MAJOR_TYPE_VIDEO_MPEG1,
-        .u.video = {},
+        .dwSize = sizeof(MFVIDEOFORMAT),
+        .videoInfo = {.dwWidth = 1920, .dwHeight = 1080},
+        .guidFormat = MEDIASUBTYPE_MPEG1Payload,
     };
-    struct wg_transform_attrs attrs = {0};
-    wg_transform_t transform;
     struct transform *object;
     HRESULT hr;
 
-    transform = wg_transform_create(&input_format, &output_format, &attrs);
-    if (!transform)
+    if (FAILED(hr = check_video_transform_support(&input_format, &output_format)))
     {
         ERR_(winediag)("GStreamer doesn't support MPEG-1 video decoding, please install appropriate plugins.\n");
-        return E_FAIL;
+        return hr;
     }
-    wg_transform_destroy(transform);
 
     hr = transform_create(outer, &CLSID_CMpegVideoCodec, &mpeg_video_codec_transform_ops, &object);
     if (FAILED(hr))
diff --git a/dlls/winegstreamer/unixlib.h b/dlls/winegstreamer/unixlib.h
@@ -340,9 +340,9 @@ struct wg_transform_attrs
 struct wg_transform_create_params
 {
     wg_transform_t transform;
-    const struct wg_format *input_format;
-    const struct wg_format *output_format;
-    const struct wg_transform_attrs *attrs;
+    struct wg_media_type input_type;
+    struct wg_media_type output_type;
+    struct wg_transform_attrs attrs;
 };
 
 struct wg_transform_push_data_params
diff --git a/dlls/winegstreamer/wg_parser.c b/dlls/winegstreamer/wg_parser.c
@@ -2058,15 +2058,25 @@ NTSTATUS wow64_wg_transform_create(void *args)
     struct
     {
         wg_transform_t transform;
-        PTR32 input_format;
-        PTR32 output_format;
-        PTR32 attrs;
+        struct wg_media_type32 input_type;
+        struct wg_media_type32 output_type;
+        struct wg_transform_attrs attrs;
     } *params32 = args;
     struct wg_transform_create_params params =
     {
-        .input_format = ULongToPtr(params32->input_format),
-        .output_format = ULongToPtr(params32->output_format),
-        .attrs = ULongToPtr(params32->attrs),
+        .input_type =
+        {
+            .major = params32->input_type.major,
+            .format_size = params32->input_type.format_size,
+            .u.format = ULongToPtr(params32->input_type.format),
+        },
+        .output_type =
+        {
+            .major = params32->output_type.major,
+            .format_size = params32->output_type.format_size,
+            .u.format = ULongToPtr(params32->output_type.format),
+        },
+        .attrs = params32->attrs,
     };
     NTSTATUS ret;
 
diff --git a/dlls/winegstreamer/wg_transform.c b/dlls/winegstreamer/wg_transform.c
