dlls/winegstreamer/video_decoder.c

   1 /* Generic Video Decoder Transform
   2  *
   3  * Copyright 2022 Rémi Bernon for CodeWeavers
   4  * Copyright 2023 Shaun Ren for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "gst_private.h"
  22
  23 #include "mfapi.h"
  24 #include "mferror.h"
  25 #include "mfobjects.h"
  26 #include "mftransform.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  31
  32 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IV50, MAKEFOURCC('I','V','5','0'));
  33
  34 static const GUID *const input_types[] =
  35 {
  36     &MFVideoFormat_IV50,
  37 };
  38 static const GUID *const output_types[] =
  39 {
  40     &MFVideoFormat_YV12,
  41     &MFVideoFormat_YUY2,
  42     &MFVideoFormat_NV11,
  43     &MFVideoFormat_NV12,
  44     &MFVideoFormat_RGB32,
  45     &MFVideoFormat_RGB24,
  46     &MFVideoFormat_RGB565,
  47     &MFVideoFormat_RGB555,
  48     &MFVideoFormat_RGB8,
  49 };
  50
  51 struct video_decoder
  52 {
  53     IMFTransform IMFTransform_iface;
  54     LONG refcount;
  55
  56     IMFMediaType *input_type;
  57     IMFMediaType *output_type;
  58
  59     struct wg_format wg_format;
  60     struct wg_transform *wg_transform;
  61     struct wg_sample_queue *wg_sample_queue;
  62 };
  63
  64 static struct video_decoder *impl_from_IMFTransform(IMFTransform *iface)
  65 {
  66     return CONTAINING_RECORD(iface, struct video_decoder, IMFTransform_iface);
  67 }
  68
  69 static HRESULT try_create_wg_transform(struct video_decoder *decoder)
  70 {
  71     struct wg_transform_attrs attrs = {0};
  72     struct wg_format input_format;
  73     struct wg_format output_format;
  74
  75     if (decoder->wg_transform)
  76         wg_transform_destroy(decoder->wg_transform);
  77     decoder->wg_transform = NULL;
  78
  79     mf_media_type_to_wg_format(decoder->input_type, &input_format);
  80     if (input_format.major_type == WG_MAJOR_TYPE_UNKNOWN)
  81         return MF_E_INVALIDMEDIATYPE;
  82
  83     mf_media_type_to_wg_format(decoder->output_type, &output_format);
  84     if (output_format.major_type == WG_MAJOR_TYPE_UNKNOWN)
  85         return MF_E_INVALIDMEDIATYPE;
  86
  87     output_format.u.video.fps_d = 0;
  88     output_format.u.video.fps_n = 0;
  89
  90     if (!(decoder->wg_transform = wg_transform_create(&input_format, &output_format, &attrs)))
  91     {
  92         ERR("Failed to create transform with input major_type %u.\n", input_format.major_type);
  93         return E_FAIL;
  94     }
  95
  96     return S_OK;
  97 }
  98
  99 static HRESULT WINAPI transform_QueryInterface(IMFTransform *iface, REFIID iid, void **out)
 100 {
 101     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 102
 103     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 104
 105     if (IsEqualGUID(iid, &IID_IUnknown) ||
 106             IsEqualGUID(iid, &IID_IMFTransform))
 107         *out = &decoder->IMFTransform_iface;
 108     else
 109     {
 110         *out = NULL;
 111         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 112         return E_NOINTERFACE;
 113     }
 114
 115     IUnknown_AddRef((IUnknown *)*out);
 116     return S_OK;
 117 }
 118
 119 static ULONG WINAPI transform_AddRef(IMFTransform *iface)
 120 {
 121     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 122     ULONG refcount = InterlockedIncrement(&decoder->refcount);
 123
 124     TRACE("iface %p increasing refcount to %lu.\n", decoder, refcount);
 125
 126     return refcount;
 127 }
 128
 129 static ULONG WINAPI transform_Release(IMFTransform *iface)
 130 {
 131     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 132     ULONG refcount = InterlockedDecrement(&decoder->refcount);
 133
 134     TRACE("iface %p decreasing refcount to %lu.\n", decoder, refcount);
 135
 136     if (!refcount)
 137     {
 138         if (decoder->wg_transform)
 139             wg_transform_destroy(decoder->wg_transform);
 140         if (decoder->input_type)
 141             IMFMediaType_Release(decoder->input_type);
 142         if (decoder->output_type)
 143             IMFMediaType_Release(decoder->output_type);
 144
 145         wg_sample_queue_destroy(decoder->wg_sample_queue);
 146         free(decoder);
 147     }
 148
 149     return refcount;
 150 }
 151
 152 static HRESULT WINAPI transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
 153         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
 154 {
 155     FIXME("iface %p, input_minimum %p, input_maximum %p, output_minimum %p, output_maximum %p.\n",
 156             iface, input_minimum, input_maximum, output_minimum, output_maximum);
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 161 {
 162     FIXME("iface %p, inputs %p, outputs %p.\n", iface, inputs, outputs);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
 167         DWORD output_size, DWORD *outputs)
 168 {
 169     FIXME("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n",
 170             iface, input_size, inputs, output_size, outputs);
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 175 {
 176     FIXME("iface %p, id %#lx, info %p.\n", iface, id, info);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 181 {
 182     FIXME("iface %p, id %#lx, info %p.\n", iface, id, info);
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 187 {
 188     FIXME("iface %p, attributes %p semi-stub!\n", iface, attributes);
 189     return E_NOTIMPL;
 190 }
 191
 192 static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 193 {
 194     FIXME("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 199 {
 200     FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 205 {
 206     FIXME("iface %p, id %#lx.\n", iface, id);
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 211 {
 212     FIXME("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI transform_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 217         IMFMediaType **type)
 218 {
 219     FIXME("iface %p, id %#lx, index %#lx, type %p.\n", iface, id, index, type);
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI transform_GetOutputAvailableType(IMFTransform *iface, DWORD id,
 224         DWORD index, IMFMediaType **type)
 225 {
 226     FIXME("iface %p, id %#lx, index %#lx, type %p.\n", iface, id, index, type);
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 231 {
 232     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 233     GUID major, subtype;
 234     UINT64 frame_size;
 235     HRESULT hr;
 236     ULONG i;
 237
 238     TRACE("iface %p, id %#lx, type %p, flags %#lx.\n", iface, id, type, flags);
 239
 240     if (FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_MAJOR_TYPE, &major)) ||
 241             FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 242         return E_INVALIDARG;
 243
 244     if (!IsEqualGUID(&major, &MFMediaType_Video))
 245         return MF_E_INVALIDMEDIATYPE;
 246
 247     for (i = 0; i < ARRAY_SIZE(input_types); ++i)
 248         if (IsEqualGUID(&subtype, input_types[i]))
 249             break;
 250     if (i == ARRAY_SIZE(input_types))
 251         return MF_E_INVALIDMEDIATYPE;
 252
 253     if (FAILED(hr = IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)) ||
 254             (frame_size >> 32) == 0 || (UINT32)frame_size == 0)
 255         return MF_E_INVALIDMEDIATYPE;
 256
 257     if (flags & MFT_SET_TYPE_TEST_ONLY)
 258         return S_OK;
 259
 260     if (decoder->output_type)
 261     {
 262         IMFMediaType_Release(decoder->output_type);
 263         decoder->output_type = NULL;
 264     }
 265
 266     if (decoder->input_type)
 267         IMFMediaType_Release(decoder->input_type);
 268     IMFMediaType_AddRef((decoder->input_type = type));
 269
 270     return S_OK;
 271 }
 272
 273 static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 274 {
 275     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 276     GUID major, subtype;
 277     UINT64 frame_size;
 278     struct wg_format output_format;
 279     HRESULT hr;
 280     ULONG i;
 281
 282     TRACE("iface %p, id %#lx, type %p, flags %#lx.\n", iface, id, type, flags);
 283
 284     if (!decoder->input_type)
 285         return MF_E_TRANSFORM_TYPE_NOT_SET;
 286
 287     if (FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_MAJOR_TYPE, &major)) ||
 288             FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 289         return hr;
 290
 291     if (!IsEqualGUID(&major, &MFMediaType_Video))
 292         return MF_E_INVALIDMEDIATYPE;
 293
 294     for (i = 0; i < ARRAY_SIZE(output_types); ++i)
 295         if (IsEqualGUID(&subtype, output_types[i]))
 296             break;
 297     if (i == ARRAY_SIZE(output_types))
 298         return MF_E_INVALIDMEDIATYPE;
 299
 300     if (FAILED(hr = IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
 301         return hr;
 302
 303     if (flags & MFT_SET_TYPE_TEST_ONLY)
 304         return S_OK;
 305
 306     if (decoder->output_type)
 307         IMFMediaType_Release(decoder->output_type);
 308     IMFMediaType_AddRef((decoder->output_type = type));
 309
 310     if (decoder->wg_transform)
 311     {
 312         mf_media_type_to_wg_format(decoder->output_type, &output_format);
 313
 314         output_format.u.video.fps_d = 0;
 315         output_format.u.video.fps_n = 0;
 316
 317         if (output_format.major_type == WG_MAJOR_TYPE_UNKNOWN
 318             || !wg_transform_set_output_format(decoder->wg_transform, &output_format))
 319         {
 320             IMFMediaType_Release(decoder->output_type);
 321             decoder->output_type = NULL;
 322             return MF_E_INVALIDMEDIATYPE;
 323         }
 324     }
 325     else if (FAILED(hr = try_create_wg_transform(decoder)))
 326     {
 327         IMFMediaType_Release(decoder->output_type);
 328         decoder->output_type = NULL;
 329         return hr;
 330     }
 331
 332     decoder->wg_format.u.video.width = frame_size >> 32;
 333     decoder->wg_format.u.video.height = (UINT32)frame_size;
 334
 335     return hr;
 336 }
 337
 338 static HRESULT WINAPI transform_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 339 {
 340     FIXME("iface %p, id %#lx, type %p stub!\n", iface, id, type);
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI transform_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 345 {
 346     FIXME("iface %p, id %#lx, type %p stub!\n", iface, id, type);
 347     return E_NOTIMPL;
 348 }
 349
 350 static HRESULT WINAPI transform_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags)
 351 {
 352     FIXME("iface %p, id %#lx, flags %p stub!\n", iface, id, flags);
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI transform_GetOutputStatus(IMFTransform *iface, DWORD *flags)
 357 {
 358     FIXME("iface %p, flags %p stub!\n", iface, flags);
 359     return E_NOTIMPL;
 360 }
 361
 362 static HRESULT WINAPI transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 363 {
 364     TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI transform_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
 369 {
 370     FIXME("iface %p, id %#lx, event %p stub!\n", iface, id, event);
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT WINAPI transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
 375 {
 376     FIXME("iface %p, message %#x, param %Ix stub!\n", iface, message, param);
 377     return S_OK;
 378 }
 379
 380 static HRESULT WINAPI transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
 381 {
 382     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 383     HRESULT hr;
 384
 385     TRACE("iface %p, id %#lx, sample %p, flags %#lx.\n", iface, id, sample, flags);
 386
 387     if (!decoder->wg_transform)
 388         return MF_E_TRANSFORM_TYPE_NOT_SET;
 389
 390     hr = wg_transform_push_mf(decoder->wg_transform, sample, decoder->wg_sample_queue);
 391
 392     return hr;
 393 }
 394
 395 static HRESULT WINAPI transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
 396         MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status)
 397 {
 398     struct video_decoder *decoder = impl_from_IMFTransform(iface);
 399     struct wg_format wg_format;
 400     UINT32 sample_size;
 401     UINT64 frame_rate;
 402     GUID subtype;
 403     HRESULT hr;
 404
 405     TRACE("iface %p, flags %#lx, count %lu, samples %p, status %p.\n", iface, flags, count, samples, status);
 406
 407     if (count != 1)
 408         return E_INVALIDARG;
 409
 410     if (!decoder->wg_transform)
 411         return MF_E_TRANSFORM_TYPE_NOT_SET;
 412
 413     *status = samples->dwStatus = 0;
 414     if (!samples->pSample)
 415         return E_INVALIDARG;
 416
 417     if (FAILED(hr = IMFMediaType_GetGUID(decoder->output_type, &MF_MT_SUBTYPE, &subtype)))
 418         return hr;
 419     if (FAILED(hr = MFCalculateImageSize(&subtype, decoder->wg_format.u.video.width,
 420             decoder->wg_format.u.video.height, &sample_size)))
 421         return hr;
 422
 423     if (SUCCEEDED(hr = wg_transform_read_mf(decoder->wg_transform, samples->pSample,
 424             sample_size, &wg_format, &samples->dwStatus)))
 425         wg_sample_queue_flush(decoder->wg_sample_queue, false);
 426
 427     if (hr == MF_E_TRANSFORM_STREAM_CHANGE)
 428     {
 429         decoder->wg_format = wg_format;
 430
 431         if (FAILED(hr = MFCalculateImageSize(&subtype, decoder->wg_format.u.video.width,
 432             decoder->wg_format.u.video.height, &sample_size)))
 433             return hr;
 434
 435         /* keep the frame rate that was requested, GStreamer doesn't provide any */
 436         if (SUCCEEDED(IMFMediaType_GetUINT64(decoder->output_type, &MF_MT_FRAME_RATE, &frame_rate)))
 437         {
 438             decoder->wg_format.u.video.fps_n = frame_rate >> 32;
 439             decoder->wg_format.u.video.fps_d = (UINT32)frame_rate;
 440         }
 441
 442         samples[0].dwStatus |= MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE;
 443         *status |= MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE;
 444     }
 445
 446     return hr;
 447 }
 448
 449 static const IMFTransformVtbl transform_vtbl =
 450 {
 451     transform_QueryInterface,
 452     transform_AddRef,
 453     transform_Release,
 454     transform_GetStreamLimits,
 455     transform_GetStreamCount,
 456     transform_GetStreamIDs,
 457     transform_GetInputStreamInfo,
 458     transform_GetOutputStreamInfo,
 459     transform_GetAttributes,
 460     transform_GetInputStreamAttributes,
 461     transform_GetOutputStreamAttributes,
 462     transform_DeleteInputStream,
 463     transform_AddInputStreams,
 464     transform_GetInputAvailableType,
 465     transform_GetOutputAvailableType,
 466     transform_SetInputType,
 467     transform_SetOutputType,
 468     transform_GetInputCurrentType,
 469     transform_GetOutputCurrentType,
 470     transform_GetInputStatus,
 471     transform_GetOutputStatus,
 472     transform_SetOutputBounds,
 473     transform_ProcessEvent,
 474     transform_ProcessMessage,
 475     transform_ProcessInput,
 476     transform_ProcessOutput,
 477 };
 478
 479 HRESULT WINAPI winegstreamer_create_video_decoder(IMFTransform **out)
 480 {
 481     struct video_decoder *decoder;
 482     HRESULT hr;
 483
 484     TRACE("out %p.\n", out);
 485
 486     if (!init_gstreamer())
 487         return E_FAIL;
 488
 489     if (!(decoder = calloc(1, sizeof(*decoder))))
 490         return E_OUTOFMEMORY;
 491
 492     decoder->IMFTransform_iface.lpVtbl = &transform_vtbl;
 493     decoder->refcount = 1;
 494
 495     decoder->wg_format.u.video.fps_d = 1;
 496     decoder->wg_format.u.video.fps_n = 1;
 497
 498     if (FAILED(hr = wg_sample_queue_create(&decoder->wg_sample_queue)))
 499         goto failed;
 500
 501     *out = &decoder->IMFTransform_iface;
 502     TRACE("created decoder %p.\n", *out);
 503     return S_OK;
 504
 505 failed:
 506     free(decoder);
 507     return hr;
 508 }