dlls/winegstreamer/color_convert.c

   1 /* Copyright 2022 Rémi Bernon for CodeWeavers
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  16  */
  17
  18 #include "gst_private.h"
  19
  20 #include "mfapi.h"
  21 #include "mferror.h"
  22 #include "mfobjects.h"
  23 #include "mftransform.h"
  24 #include "wmcodecdsp.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  29 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  30
  31 static const GUID *const input_types[] =
  32 {
  33     &MFVideoFormat_YV12,
  34     &MFVideoFormat_YUY2,
  35     &MFVideoFormat_UYVY,
  36     &MFVideoFormat_AYUV,
  37     &MFVideoFormat_NV12,
  38     &MFVideoFormat_RGB32,
  39     &MFVideoFormat_RGB565,
  40     &MFVideoFormat_I420,
  41     &MFVideoFormat_IYUV,
  42     &MFVideoFormat_YVYU,
  43     &MFVideoFormat_RGB24,
  44     &MFVideoFormat_RGB555,
  45     &MEDIASUBTYPE_RGB8,
  46     &MEDIASUBTYPE_V216,
  47     &MEDIASUBTYPE_V410,
  48     &MFVideoFormat_NV11,
  49     &MFVideoFormat_Y41P,
  50     &MFVideoFormat_Y41T,
  51     &MFVideoFormat_Y42T,
  52     &MFVideoFormat_YVU9,
  53 };
  54 static const GUID *const output_types[] =
  55 {
  56     &MFVideoFormat_YV12,
  57     &MFVideoFormat_YUY2,
  58     &MFVideoFormat_UYVY,
  59     &MFVideoFormat_AYUV,
  60     &MFVideoFormat_NV12,
  61     &MFVideoFormat_RGB32,
  62     &MFVideoFormat_RGB565,
  63     &MFVideoFormat_I420,
  64     &MFVideoFormat_IYUV,
  65     &MFVideoFormat_YVYU,
  66     &MFVideoFormat_RGB24,
  67     &MFVideoFormat_RGB555,
  68     &MEDIASUBTYPE_RGB8,
  69     &MEDIASUBTYPE_V216,
  70     &MEDIASUBTYPE_V410,
  71     &MFVideoFormat_NV11,
  72 };
  73
  74 struct color_convert
  75 {
  76     IUnknown IUnknown_inner;
  77     IMFTransform IMFTransform_iface;
  78     IMediaObject IMediaObject_iface;
  79     IPropertyBag IPropertyBag_iface;
  80     IPropertyStore IPropertyStore_iface;
  81     IUnknown *outer;
  82     LONG refcount;
  83
  84     IMFMediaType *input_type;
  85     MFT_INPUT_STREAM_INFO input_info;
  86     IMFMediaType *output_type;
  87     MFT_OUTPUT_STREAM_INFO output_info;
  88
  89     struct wg_transform *wg_transform;
  90     struct wg_sample_queue *wg_sample_queue;
  91 };
  92
  93 static inline struct color_convert *impl_from_IUnknown(IUnknown *iface)
  94 {
  95     return CONTAINING_RECORD(iface, struct color_convert, IUnknown_inner);
  96 }
  97
  98 static HRESULT try_create_wg_transform(struct color_convert *impl)
  99 {
 100     struct wg_format input_format, output_format;
 101
 102     if (impl->wg_transform)
 103         wg_transform_destroy(impl->wg_transform);
 104     impl->wg_transform = NULL;
 105
 106     mf_media_type_to_wg_format(impl->input_type, &input_format);
 107     if (input_format.major_type == WG_MAJOR_TYPE_UNKNOWN)
 108         return MF_E_INVALIDMEDIATYPE;
 109
 110     mf_media_type_to_wg_format(impl->output_type, &output_format);
 111     if (output_format.major_type == WG_MAJOR_TYPE_UNKNOWN)
 112         return MF_E_INVALIDMEDIATYPE;
 113
 114     if (!(impl->wg_transform = wg_transform_create(&input_format, &output_format)))
 115         return E_FAIL;
 116
 117     return S_OK;
 118 }
 119
 120 static HRESULT WINAPI unknown_QueryInterface(IUnknown *iface, REFIID iid, void **out)
 121 {
 122     struct color_convert *impl = impl_from_IUnknown(iface);
 123
 124     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 125
 126     if (IsEqualGUID(iid, &IID_IUnknown))
 127         *out = &impl->IUnknown_inner;
 128     else if (IsEqualGUID(iid, &IID_IMFTransform))
 129         *out = &impl->IMFTransform_iface;
 130     else if (IsEqualGUID(iid, &IID_IMediaObject))
 131         *out = &impl->IMediaObject_iface;
 132     else if (IsEqualIID(iid, &IID_IPropertyBag))
 133         *out = &impl->IPropertyBag_iface;
 134     else if (IsEqualIID(iid, &IID_IPropertyStore))
 135         *out = &impl->IPropertyStore_iface;
 136     else
 137     {
 138         *out = NULL;
 139         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 140         return E_NOINTERFACE;
 141     }
 142
 143     IUnknown_AddRef((IUnknown *)*out);
 144     return S_OK;
 145 }
 146
 147 static ULONG WINAPI unknown_AddRef(IUnknown *iface)
 148 {
 149     struct color_convert *impl = impl_from_IUnknown(iface);
 150     ULONG refcount = InterlockedIncrement(&impl->refcount);
 151
 152     TRACE("iface %p increasing refcount to %lu.\n", iface, refcount);
 153
 154     return refcount;
 155 }
 156
 157 static ULONG WINAPI unknown_Release(IUnknown *iface)
 158 {
 159     struct color_convert *impl = impl_from_IUnknown(iface);
 160     ULONG refcount = InterlockedDecrement(&impl->refcount);
 161
 162     TRACE("iface %p decreasing refcount to %lu.\n", iface, refcount);
 163
 164     if (!refcount)
 165     {
 166         if (impl->wg_transform)
 167             wg_transform_destroy(impl->wg_transform);
 168         if (impl->input_type)
 169             IMFMediaType_Release(impl->input_type);
 170         if (impl->output_type)
 171             IMFMediaType_Release(impl->output_type);
 172
 173         wg_sample_queue_destroy(impl->wg_sample_queue);
 174         free(impl);
 175     }
 176
 177     return refcount;
 178 }
 179
 180 static const IUnknownVtbl unknown_vtbl =
 181 {
 182     unknown_QueryInterface,
 183     unknown_AddRef,
 184     unknown_Release,
 185 };
 186
 187 static struct color_convert *impl_from_IMFTransform(IMFTransform *iface)
 188 {
 189     return CONTAINING_RECORD(iface, struct color_convert, IMFTransform_iface);
 190 }
 191
 192 static HRESULT WINAPI transform_QueryInterface(IMFTransform *iface, REFIID iid, void **out)
 193 {
 194     return IUnknown_QueryInterface(impl_from_IMFTransform(iface)->outer, iid, out);
 195 }
 196
 197 static ULONG WINAPI transform_AddRef(IMFTransform *iface)
 198 {
 199     return IUnknown_AddRef(impl_from_IMFTransform(iface)->outer);
 200 }
 201
 202 static ULONG WINAPI transform_Release(IMFTransform *iface)
 203 {
 204     return IUnknown_Release(impl_from_IMFTransform(iface)->outer);
 205 }
 206
 207 static HRESULT WINAPI transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
 208         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
 209 {
 210     TRACE("iface %p, input_minimum %p, input_maximum %p, output_minimum %p, output_maximum %p.\n",
 211             iface, input_minimum, input_maximum, output_minimum, output_maximum);
 212     *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
 213     return S_OK;
 214 }
 215
 216 static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 217 {
 218     TRACE("iface %p, inputs %p, outputs %p.\n", iface, inputs, outputs);
 219     *inputs = *outputs = 1;
 220     return S_OK;
 221 }
 222
 223 static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
 224         DWORD output_size, DWORD *outputs)
 225 {
 226     TRACE("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n", iface,
 227             input_size, inputs, output_size, outputs);
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 232 {
 233     struct color_convert *impl = impl_from_IMFTransform(iface);
 234
 235     TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);
 236
 237     if (!impl->input_type || !impl->output_type)
 238     {
 239         memset(info, 0, sizeof(*info));
 240         return MF_E_TRANSFORM_TYPE_NOT_SET;
 241     }
 242
 243     *info = impl->input_info;
 244     return S_OK;
 245 }
 246
 247 static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 248 {
 249     struct color_convert *impl = impl_from_IMFTransform(iface);
 250
 251     TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);
 252
 253     if (!impl->input_type || !impl->output_type)
 254     {
 255         memset(info, 0, sizeof(*info));
 256         return MF_E_TRANSFORM_TYPE_NOT_SET;
 257     }
 258
 259     *info = impl->output_info;
 260     return S_OK;
 261 }
 262
 263 static HRESULT WINAPI transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 264 {
 265     TRACE("iface %p, attributes %p.\n", iface, attributes);
 266     return E_NOTIMPL;
 267 }
 268
 269 static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 270 {
 271     TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 276 {
 277     TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 282 {
 283     TRACE("iface %p, id %#lx.\n", iface, id);
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 288 {
 289     TRACE("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
 290     return E_NOTIMPL;
 291 }
 292
 293 static HRESULT WINAPI transform_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 294         IMFMediaType **type)
 295 {
 296     IMFMediaType *media_type;
 297     const GUID *subtype;
 298     HRESULT hr;
 299
 300     TRACE("iface %p, id %#lx, index %#lx, type %p.\n", iface, id, index, type);
 301
 302     *type = NULL;
 303
 304     if (index >= ARRAY_SIZE(input_types))
 305         return MF_E_NO_MORE_TYPES;
 306     subtype = input_types[index];
 307
 308     if (FAILED(hr = MFCreateMediaType(&media_type)))
 309         return hr;
 310
 311     if (FAILED(hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video)))
 312         goto done;
 313     if (FAILED(hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, subtype)))
 314         goto done;
 315     if (FAILED(hr = IMFMediaType_SetUINT32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1)))
 316         goto done;
 317     if (FAILED(hr = IMFMediaType_SetUINT32(media_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1)))
 318         goto done;
 319
 320     IMFMediaType_AddRef((*type = media_type));
 321
 322 done:
 323     IMFMediaType_Release(media_type);
 324     return hr;
 325 }
 326
 327 static HRESULT WINAPI transform_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 328         IMFMediaType **type)
 329 {
 330     IMFMediaType *media_type;
 331     const GUID *subtype;
 332     HRESULT hr;
 333
 334     TRACE("iface %p, id %#lx, index %#lx, type %p.\n", iface, id, index, type);
 335
 336     *type = NULL;
 337
 338     if (index >= ARRAY_SIZE(output_types))
 339         return MF_E_NO_MORE_TYPES;
 340     subtype = output_types[index];
 341
 342     if (FAILED(hr = MFCreateMediaType(&media_type)))
 343         return hr;
 344
 345     if (FAILED(hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video)))
 346         goto done;
 347     if (FAILED(hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, subtype)))
 348         goto done;
 349     if (FAILED(hr = IMFMediaType_SetUINT32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1)))
 350         goto done;
 351     if (FAILED(hr = IMFMediaType_SetUINT32(media_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1)))
 352         goto done;
 353
 354     IMFMediaType_AddRef((*type = media_type));
 355
 356 done:
 357     IMFMediaType_Release(media_type);
 358     return hr;
 359 }
 360
 361 static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 362 {
 363     struct color_convert *impl = impl_from_IMFTransform(iface);
 364     GUID major, subtype;
 365     UINT64 frame_size;
 366     UINT32 stride;
 367     HRESULT hr;
 368     ULONG i;
 369
 370     TRACE("iface %p, id %#lx, type %p, flags %#lx.\n", iface, id, type, flags);
 371
 372     if (FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_MAJOR_TYPE, &major)) ||
 373             FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 374         return MF_E_ATTRIBUTENOTFOUND;
 375
 376     if (!IsEqualGUID(&major, &MFMediaType_Video)
 377             || IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size))
 378         return E_INVALIDARG;
 379
 380     for (i = 0; i < ARRAY_SIZE(input_types); ++i)
 381         if (IsEqualGUID(&subtype, input_types[i]))
 382             break;
 383     if (i == ARRAY_SIZE(input_types))
 384         return MF_E_INVALIDMEDIATYPE;
 385     if (flags & MFT_SET_TYPE_TEST_ONLY)
 386         return S_OK;
 387
 388     if (!impl->input_type && FAILED(hr = MFCreateMediaType(&impl->input_type)))
 389         return hr;
 390
 391     if (FAILED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)impl->input_type)))
 392     {
 393         IMFMediaType_Release(impl->input_type);
 394         impl->input_type = NULL;
 395     }
 396     if (FAILED(IMFMediaType_GetUINT32(impl->input_type, &MF_MT_DEFAULT_STRIDE, &stride)))
 397     {
 398         if (FAILED(hr = MFGetStrideForBitmapInfoHeader(subtype.Data1, frame_size >> 32, (LONG *)&stride)))
 399         {
 400             IMFMediaType_Release(impl->input_type);
 401             impl->input_type = NULL;
 402         }
 403         if (FAILED(hr = IMFMediaType_SetUINT32(impl->input_type, &MF_MT_DEFAULT_STRIDE, abs((INT32)stride))))
 404         {
 405             IMFMediaType_Release(impl->input_type);
 406             impl->input_type = NULL;
 407         }
 408     }
 409
 410     if (impl->output_type && FAILED(hr = try_create_wg_transform(impl)))
 411     {
 412         IMFMediaType_Release(impl->input_type);
 413         impl->input_type = NULL;
 414     }
 415
 416     if (FAILED(hr) || FAILED(MFCalculateImageSize(&subtype, frame_size >> 32, (UINT32)frame_size,
 417             (UINT32 *)&impl->input_info.cbSize)))
 418         impl->input_info.cbSize = 0;
 419
 420     return hr;
 421 }
 422
 423 static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 424 {
 425     struct color_convert *impl = impl_from_IMFTransform(iface);
 426     GUID major, subtype;
 427     UINT64 frame_size;
 428     UINT32 stride;
 429     HRESULT hr;
 430     ULONG i;
 431
 432     TRACE("iface %p, id %#lx, type %p, flags %#lx.\n", iface, id, type, flags);
 433
 434     if (FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_MAJOR_TYPE, &major)) ||
 435             FAILED(hr = IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 436         return MF_E_ATTRIBUTENOTFOUND;
 437
 438     if (!IsEqualGUID(&major, &MFMediaType_Video)
 439             || IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size))
 440         return E_INVALIDARG;
 441
 442     for (i = 0; i < ARRAY_SIZE(output_types); ++i)
 443         if (IsEqualGUID(&subtype, output_types[i]))
 444             break;
 445     if (i == ARRAY_SIZE(output_types))
 446         return MF_E_INVALIDMEDIATYPE;
 447     if (flags & MFT_SET_TYPE_TEST_ONLY)
 448         return S_OK;
 449
 450     if (!impl->output_type && FAILED(hr = MFCreateMediaType(&impl->output_type)))
 451         return hr;
 452
 453     if (FAILED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)impl->output_type)))
 454     {
 455         IMFMediaType_Release(impl->output_type);
 456         impl->output_type = NULL;
 457     }
 458     if (FAILED(IMFMediaType_GetUINT32(impl->output_type, &MF_MT_DEFAULT_STRIDE, &stride)))
 459     {
 460         if (FAILED(hr = MFGetStrideForBitmapInfoHeader(subtype.Data1, frame_size >> 32, (LONG *)&stride)))
 461         {
 462             IMFMediaType_Release(impl->output_type);
 463             impl->output_type = NULL;
 464         }
 465         if (FAILED(hr = IMFMediaType_SetUINT32(impl->output_type, &MF_MT_DEFAULT_STRIDE, abs((INT32)stride))))
 466         {
 467             IMFMediaType_Release(impl->output_type);
 468             impl->output_type = NULL;
 469         }
 470     }
 471
 472     if (impl->input_type && FAILED(hr = try_create_wg_transform(impl)))
 473     {
 474         IMFMediaType_Release(impl->output_type);
 475         impl->output_type = NULL;
 476     }
 477
 478     if (FAILED(hr) || FAILED(MFCalculateImageSize(&subtype, frame_size >> 32, (UINT32)frame_size,
 479             (UINT32 *)&impl->output_info.cbSize)))
 480         impl->output_info.cbSize = 0;
 481
 482     return hr;
 483 }
 484
 485 static HRESULT WINAPI transform_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 486 {
 487     struct color_convert *impl = impl_from_IMFTransform(iface);
 488     HRESULT hr;
 489
 490     TRACE("iface %p, id %#lx, type %p.\n", iface, id, type);
 491
 492     if (id != 0)
 493         return MF_E_INVALIDSTREAMNUMBER;
 494
 495     if (!impl->input_type)
 496         return MF_E_TRANSFORM_TYPE_NOT_SET;
 497
 498     if (FAILED(hr = MFCreateMediaType(type)))
 499         return hr;
 500
 501     if (FAILED(hr = IMFMediaType_CopyAllItems(impl->input_type, (IMFAttributes *)*type)))
 502         IMFMediaType_Release(*type);
 503
 504     return hr;
 505 }
 506
 507 static HRESULT WINAPI transform_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 508 {
 509     struct color_convert *impl = impl_from_IMFTransform(iface);
 510     HRESULT hr;
 511
 512     TRACE("iface %p, id %#lx, type %p.\n", iface, id, type);
 513
 514     if (id != 0)
 515         return MF_E_INVALIDSTREAMNUMBER;
 516
 517     if (!impl->output_type)
 518         return MF_E_TRANSFORM_TYPE_NOT_SET;
 519
 520     if (FAILED(hr = MFCreateMediaType(type)))
 521         return hr;
 522
 523     if (FAILED(hr = IMFMediaType_CopyAllItems(impl->output_type, (IMFAttributes *)*type)))
 524         IMFMediaType_Release(*type);
 525
 526     return hr;
 527 }
 528
 529 static HRESULT WINAPI transform_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags)
 530 {
 531     FIXME("iface %p, id %#lx, flags %p stub!\n", iface, id, flags);
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI transform_GetOutputStatus(IMFTransform *iface, DWORD *flags)
 536 {
 537     FIXME("iface %p, flags %p stub!\n", iface, flags);
 538     return E_NOTIMPL;
 539 }
 540
 541 static HRESULT WINAPI transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 542 {
 543     TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI transform_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
 548 {
 549     FIXME("iface %p, id %#lx, event %p stub!\n", iface, id, event);
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
 554 {
 555     FIXME("iface %p, message %#x, param %#Ix stub!\n", iface, message, param);
 556     return S_OK;
 557 }
 558
 559 static HRESULT WINAPI transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
 560 {
 561     struct color_convert *impl = impl_from_IMFTransform(iface);
 562
 563     TRACE("iface %p, id %#lx, sample %p, flags %#lx.\n", iface, id, sample, flags);
 564
 565     if (!impl->wg_transform)
 566         return MF_E_TRANSFORM_TYPE_NOT_SET;
 567
 568     return wg_transform_push_mf(impl->wg_transform, sample, impl->wg_sample_queue);
 569 }
 570
 571 static HRESULT WINAPI transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
 572         MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status)
 573 {
 574     struct color_convert *impl = impl_from_IMFTransform(iface);
 575     MFT_OUTPUT_STREAM_INFO info;
 576     HRESULT hr;
 577
 578     TRACE("iface %p, flags %#lx, count %lu, samples %p, status %p.\n", iface, flags, count, samples, status);
 579
 580     if (count != 1)
 581         return E_INVALIDARG;
 582
 583     if (!impl->wg_transform)
 584         return MF_E_TRANSFORM_TYPE_NOT_SET;
 585
 586     *status = samples->dwStatus = 0;
 587     if (!samples->pSample)
 588         return E_INVALIDARG;
 589
 590     if (FAILED(hr = IMFTransform_GetOutputStreamInfo(iface, 0, &info)))
 591         return hr;
 592
 593     if (SUCCEEDED(hr = wg_transform_read_mf(impl->wg_transform, samples->pSample,
 594             info.cbSize, NULL, &samples->dwStatus)))
 595         wg_sample_queue_flush(impl->wg_sample_queue, false);
 596
 597     return hr;
 598 }
 599
 600 static const IMFTransformVtbl transform_vtbl =
 601 {
 602     transform_QueryInterface,
 603     transform_AddRef,
 604     transform_Release,
 605     transform_GetStreamLimits,
 606     transform_GetStreamCount,
 607     transform_GetStreamIDs,
 608     transform_GetInputStreamInfo,
 609     transform_GetOutputStreamInfo,
 610     transform_GetAttributes,
 611     transform_GetInputStreamAttributes,
 612     transform_GetOutputStreamAttributes,
 613     transform_DeleteInputStream,
 614     transform_AddInputStreams,
 615     transform_GetInputAvailableType,
 616     transform_GetOutputAvailableType,
 617     transform_SetInputType,
 618     transform_SetOutputType,
 619     transform_GetInputCurrentType,
 620     transform_GetOutputCurrentType,
 621     transform_GetInputStatus,
 622     transform_GetOutputStatus,
 623     transform_SetOutputBounds,
 624     transform_ProcessEvent,
 625     transform_ProcessMessage,
 626     transform_ProcessInput,
 627     transform_ProcessOutput,
 628 };
 629
 630 static inline struct color_convert *impl_from_IMediaObject(IMediaObject *iface)
 631 {
 632     return CONTAINING_RECORD(iface, struct color_convert, IMediaObject_iface);
 633 }
 634
 635 static HRESULT WINAPI media_object_QueryInterface(IMediaObject *iface, REFIID iid, void **obj)
 636 {
 637     return IUnknown_QueryInterface(impl_from_IMediaObject(iface)->outer, iid, obj);
 638 }
 639
 640 static ULONG WINAPI media_object_AddRef(IMediaObject *iface)
 641 {
 642     return IUnknown_AddRef(impl_from_IMediaObject(iface)->outer);
 643 }
 644
 645 static ULONG WINAPI media_object_Release(IMediaObject *iface)
 646 {
 647     return IUnknown_Release(impl_from_IMediaObject(iface)->outer);
 648 }
 649
 650 static HRESULT WINAPI media_object_GetStreamCount(IMediaObject *iface, DWORD *input, DWORD *output)
 651 {
 652     FIXME("iface %p, input %p, output %p stub!\n", iface, input, output);
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI media_object_GetInputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
 657 {
 658     FIXME("iface %p, index %lu, flags %p stub!\n", iface, index, flags);
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI media_object_GetOutputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
 663 {
 664     FIXME("iface %p, index %lu, flags %p stub!\n", iface, index, flags);
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI media_object_GetInputType(IMediaObject *iface, DWORD index, DWORD type_index,
 669         DMO_MEDIA_TYPE *type)
 670 {
 671     FIXME("iface %p, index %lu, type_index %lu, type %p stub!\n", iface, index, type_index, type);
 672     return E_NOTIMPL;
 673 }
 674
 675 static HRESULT WINAPI media_object_GetOutputType(IMediaObject *iface, DWORD index, DWORD type_index,
 676         DMO_MEDIA_TYPE *type)
 677 {
 678     FIXME("iface %p, index %lu, type_index %lu, type %p stub!\n", iface, index, type_index, type);
 679     return E_NOTIMPL;
 680 }
 681
 682 static HRESULT WINAPI media_object_SetInputType(IMediaObject *iface, DWORD index,
 683         const DMO_MEDIA_TYPE *type, DWORD flags)
 684 {
 685     FIXME("iface %p, index %lu, type %p, flags %#lx stub!\n", iface, index, type, flags);
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI media_object_SetOutputType(IMediaObject *iface, DWORD index,
 690         const DMO_MEDIA_TYPE *type, DWORD flags)
 691 {
 692     FIXME("iface %p, index %lu, type %p, flags %#lx stub!\n", iface, index, type, flags);
 693     return E_NOTIMPL;
 694 }
 695
 696 static HRESULT WINAPI media_object_GetInputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
 697 {
 698     FIXME("iface %p, index %lu, type %p stub!\n", iface, index, type);
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI media_object_GetOutputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
 703 {
 704     FIXME("iface %p, index %lu, type %p stub!\n", iface, index, type);
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI media_object_GetInputSizeInfo(IMediaObject *iface, DWORD index, DWORD *size,
 709         DWORD *lookahead, DWORD *alignment)
 710 {
 711     FIXME("iface %p, index %lu, size %p, lookahead %p, alignment %p stub!\n", iface, index, size,
 712             lookahead, alignment);
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI media_object_GetOutputSizeInfo(IMediaObject *iface, DWORD index, DWORD *size, DWORD *alignment)
 717 {
 718     FIXME("iface %p, index %lu, size %p, alignment %p stub!\n", iface, index, size, alignment);
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI media_object_GetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME *latency)
 723 {
 724     FIXME("iface %p, index %lu, latency %p stub!\n", iface, index, latency);
 725     return E_NOTIMPL;
 726 }
 727
 728 static HRESULT WINAPI media_object_SetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME latency)
 729 {
 730     FIXME("iface %p, index %lu, latency %s stub!\n", iface, index, wine_dbgstr_longlong(latency));
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI media_object_Flush(IMediaObject *iface)
 735 {
 736     FIXME("iface %p stub!\n", iface);
 737     return E_NOTIMPL;
 738 }
 739
 740 static HRESULT WINAPI media_object_Discontinuity(IMediaObject *iface, DWORD index)
 741 {
 742     FIXME("iface %p, index %lu stub!\n", iface, index);
 743     return E_NOTIMPL;
 744 }
 745
 746 static HRESULT WINAPI media_object_AllocateStreamingResources(IMediaObject *iface)
 747 {
 748     FIXME("iface %p stub!\n", iface);
 749     return E_NOTIMPL;
 750 }
 751
 752 static HRESULT WINAPI media_object_FreeStreamingResources(IMediaObject *iface)
 753 {
 754     FIXME("iface %p stub!\n", iface);
 755     return E_NOTIMPL;
 756 }
 757
 758 static HRESULT WINAPI media_object_GetInputStatus(IMediaObject *iface, DWORD index, DWORD *flags)
 759 {
 760     FIXME("iface %p, index %lu, flags %p stub!\n", iface, index, flags);
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI media_object_ProcessInput(IMediaObject *iface, DWORD index,
 765         IMediaBuffer *buffer, DWORD flags, REFERENCE_TIME timestamp, REFERENCE_TIME timelength)
 766 {
 767     FIXME("iface %p, index %lu, buffer %p, flags %#lx, timestamp %s, timelength %s stub!\n", iface,
 768             index, buffer, flags, wine_dbgstr_longlong(timestamp), wine_dbgstr_longlong(timelength));
 769     return E_NOTIMPL;
 770 }
 771
 772 static HRESULT WINAPI media_object_ProcessOutput(IMediaObject *iface, DWORD flags, DWORD count,
 773         DMO_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
 774 {
 775     FIXME("iface %p, flags %#lx, count %lu, buffers %p, status %p stub!\n", iface, flags, count, buffers, status);
 776     return E_NOTIMPL;
 777 }
 778
 779 static HRESULT WINAPI media_object_Lock(IMediaObject *iface, LONG lock)
 780 {
 781     FIXME("iface %p, lock %ld stub!\n", iface, lock);
 782     return E_NOTIMPL;
 783 }
 784
 785 static const IMediaObjectVtbl media_object_vtbl =
 786 {
 787     media_object_QueryInterface,
 788     media_object_AddRef,
 789     media_object_Release,
 790     media_object_GetStreamCount,
 791     media_object_GetInputStreamInfo,
 792     media_object_GetOutputStreamInfo,
 793     media_object_GetInputType,
 794     media_object_GetOutputType,
 795     media_object_SetInputType,
 796     media_object_SetOutputType,
 797     media_object_GetInputCurrentType,
 798     media_object_GetOutputCurrentType,
 799     media_object_GetInputSizeInfo,
 800     media_object_GetOutputSizeInfo,
 801     media_object_GetInputMaxLatency,
 802     media_object_SetInputMaxLatency,
 803     media_object_Flush,
 804     media_object_Discontinuity,
 805     media_object_AllocateStreamingResources,
 806     media_object_FreeStreamingResources,
 807     media_object_GetInputStatus,
 808     media_object_ProcessInput,
 809     media_object_ProcessOutput,
 810     media_object_Lock,
 811 };
 812
 813 static inline struct color_convert *impl_from_IPropertyBag(IPropertyBag *iface)
 814 {
 815     return CONTAINING_RECORD(iface, struct color_convert, IPropertyBag_iface);
 816 }
 817
 818 static HRESULT WINAPI property_bag_QueryInterface(IPropertyBag *iface, REFIID iid, void **out)
 819 {
 820     return IUnknown_QueryInterface(impl_from_IPropertyBag(iface)->outer, iid, out);
 821 }
 822
 823 static ULONG WINAPI property_bag_AddRef(IPropertyBag *iface)
 824 {
 825     return IUnknown_AddRef(impl_from_IPropertyBag(iface)->outer);
 826 }
 827
 828 static ULONG WINAPI property_bag_Release(IPropertyBag *iface)
 829 {
 830     return IUnknown_Release(impl_from_IPropertyBag(iface)->outer);
 831 }
 832
 833 static HRESULT WINAPI property_bag_Read(IPropertyBag *iface, const WCHAR *prop_name, VARIANT *value,
 834         IErrorLog *error_log)
 835 {
 836     FIXME("iface %p, prop_name %s, value %p, error_log %p stub!\n", iface, debugstr_w(prop_name), value, error_log);
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI property_bag_Write(IPropertyBag *iface, const WCHAR *prop_name, VARIANT *value)
 841 {
 842     FIXME("iface %p, prop_name %s, value %p stub!\n", iface, debugstr_w(prop_name), value);
 843     return S_OK;
 844 }
 845
 846 static const IPropertyBagVtbl property_bag_vtbl =
 847 {
 848     property_bag_QueryInterface,
 849     property_bag_AddRef,
 850     property_bag_Release,
 851     property_bag_Read,
 852     property_bag_Write,
 853 };
 854
 855 static inline struct color_convert *impl_from_IPropertyStore(IPropertyStore *iface)
 856 {
 857     return CONTAINING_RECORD(iface, struct color_convert, IPropertyStore_iface);
 858 }
 859
 860 static HRESULT WINAPI property_store_QueryInterface(IPropertyStore *iface, REFIID iid, void **out)
 861 {
 862     return IUnknown_QueryInterface(impl_from_IPropertyStore(iface)->outer, iid, out);
 863 }
 864
 865 static ULONG WINAPI property_store_AddRef(IPropertyStore *iface)
 866 {
 867     return IUnknown_AddRef(impl_from_IPropertyStore(iface)->outer);
 868 }
 869
 870 static ULONG WINAPI property_store_Release(IPropertyStore *iface)
 871 {
 872     return IUnknown_Release(impl_from_IPropertyStore(iface)->outer);
 873 }
 874
 875 static HRESULT WINAPI property_store_GetCount(IPropertyStore *iface, DWORD *count)
 876 {
 877     FIXME("iface %p, count %p stub!\n", iface, count);
 878     return E_NOTIMPL;
 879 }
 880
 881 static HRESULT WINAPI property_store_GetAt(IPropertyStore *iface, DWORD index, PROPERTYKEY *key)
 882 {
 883     FIXME("iface %p, index %lu, key %p stub!\n", iface, index, key);
 884     return E_NOTIMPL;
 885 }
 886
 887 static HRESULT WINAPI property_store_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
 888 {
 889     FIXME("iface %p, key %p, value %p stub!\n", iface, key, value);
 890     return E_NOTIMPL;
 891 }
 892
 893 static HRESULT WINAPI property_store_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
 894 {
 895     FIXME("iface %p, key %p, value %p stub!\n", iface, key, value);
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI property_store_Commit(IPropertyStore *iface)
 900 {
 901     FIXME("iface %p stub!\n", iface);
 902     return E_NOTIMPL;
 903 }
 904
 905 static const IPropertyStoreVtbl property_store_vtbl =
 906 {
 907     property_store_QueryInterface,
 908     property_store_AddRef,
 909     property_store_Release,
 910     property_store_GetCount,
 911     property_store_GetAt,
 912     property_store_GetValue,
 913     property_store_SetValue,
 914     property_store_Commit,
 915 };
 916
 917 HRESULT color_convert_create(IUnknown *outer, IUnknown **out)
 918 {
 919     static const struct wg_format input_format =
 920     {
 921         .major_type = WG_MAJOR_TYPE_VIDEO,
 922         .u.video =
 923         {
 924             .format = WG_VIDEO_FORMAT_I420,
 925             .width = 1920,
 926             .height = 1080,
 927         },
 928     };
 929     static const struct wg_format output_format =
 930     {
 931         .major_type = WG_MAJOR_TYPE_VIDEO,
 932         .u.video =
 933         {
 934             .format = WG_VIDEO_FORMAT_NV12,
 935             .width = 1920,
 936             .height = 1080,
 937         },
 938     };
 939     struct wg_transform *transform;
 940     struct color_convert *impl;
 941     HRESULT hr;
 942
 943     TRACE("outer %p, out %p.\n", outer, out);
 944
 945     if (!(transform = wg_transform_create(&input_format, &output_format)))
 946     {
 947         ERR_(winediag)("GStreamer doesn't support video conversion, please install appropriate plugins.\n");
 948         return E_FAIL;
 949     }
 950     wg_transform_destroy(transform);
 951
 952     if (!(impl = calloc(1, sizeof(*impl))))
 953         return E_OUTOFMEMORY;
 954
 955     if (FAILED(hr = wg_sample_queue_create(&impl->wg_sample_queue)))
 956     {
 957         free(impl);
 958         return hr;
 959     }
 960
 961     impl->IUnknown_inner.lpVtbl = &unknown_vtbl;
 962     impl->IMFTransform_iface.lpVtbl = &transform_vtbl;
 963     impl->IMediaObject_iface.lpVtbl = &media_object_vtbl;
 964     impl->IPropertyBag_iface.lpVtbl = &property_bag_vtbl;
 965     impl->IPropertyStore_iface.lpVtbl = &property_store_vtbl;
 966     impl->refcount = 1;
 967     impl->outer = outer ? outer : &impl->IUnknown_inner;
 968
 969     impl->input_info.cbAlignment = 1;
 970     impl->output_info.cbAlignment = 1;
 971
 972     *out = &impl->IUnknown_inner;
 973     TRACE("Created %p\n", *out);
 974     return S_OK;
 975 }