dlls/winegstreamer/audioconvert.c

   1 /* GStreamer Audio Converter
   2  *
   3  * Copyright 2020 Derek Lesho
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "gst_private.h"
  21
  22 #include "mfapi.h"
  23 #include "mferror.h"
  24 #include "ks.h"
  25 #include "ksmedia.h"
  26
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  30
  31 struct audio_converter
  32 {
  33     IMFTransform IMFTransform_iface;
  34     LONG refcount;
  35     IMFMediaType *input_type;
  36     IMFMediaType *output_type;
  37     CRITICAL_SECTION cs;
  38 };
  39
  40 static struct audio_converter *impl_audio_converter_from_IMFTransform(IMFTransform *iface)
  41 {
  42     return CONTAINING_RECORD(iface, struct audio_converter, IMFTransform_iface);
  43 }
  44
  45 static HRESULT WINAPI audio_converter_QueryInterface(IMFTransform *iface, REFIID riid, void **obj)
  46 {
  47     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  48
  49     if (IsEqualIID(riid, &IID_IMFTransform) ||
  50             IsEqualIID(riid, &IID_IUnknown))
  51     {
  52         *obj = iface;
  53         IMFTransform_AddRef(iface);
  54         return S_OK;
  55     }
  56
  57     WARN("Unsupported %s.\n", debugstr_guid(riid));
  58     *obj = NULL;
  59     return E_NOINTERFACE;
  60 }
  61
  62 static ULONG WINAPI audio_converter_AddRef(IMFTransform *iface)
  63 {
  64     struct audio_converter *transform = impl_audio_converter_from_IMFTransform(iface);
  65     ULONG refcount = InterlockedIncrement(&transform->refcount);
  66
  67     TRACE("%p, refcount %u.\n", iface, refcount);
  68
  69     return refcount;
  70 }
  71
  72 static ULONG WINAPI audio_converter_Release(IMFTransform *iface)
  73 {
  74     struct audio_converter *transform = impl_audio_converter_from_IMFTransform(iface);
  75     ULONG refcount = InterlockedDecrement(&transform->refcount);
  76
  77     TRACE("%p, refcount %u.\n", iface, refcount);
  78
  79     if (!refcount)
  80     {
  81         transform->cs.DebugInfo->Spare[0] = 0;
  82         DeleteCriticalSection(&transform->cs);
  83         free(transform);
  84     }
  85
  86     return refcount;
  87 }
  88
  89 static HRESULT WINAPI audio_converter_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum, DWORD *input_maximum,
  90         DWORD *output_minimum, DWORD *output_maximum)
  91 {
  92     TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum);
  93
  94     *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
  95
  96     return S_OK;
  97 }
  98
  99 static HRESULT WINAPI audio_converter_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 100 {
 101     TRACE("%p, %p, %p.\n", iface, inputs, outputs);
 102
 103     *inputs = *outputs = 1;
 104
 105     return S_OK;
 106 }
 107
 108 static HRESULT WINAPI audio_converter_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
 109         DWORD output_size, DWORD *outputs)
 110 {
 111     TRACE("%p %u %p %u %p.\n", iface, input_size, inputs, output_size, outputs);
 112
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI audio_converter_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 117 {
 118     FIXME("%p %u %p.\n", iface, id, info);
 119
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI audio_converter_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 124 {
 125     FIXME("%p %u %p.\n", iface, id, info);
 126
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI audio_converter_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 131 {
 132     FIXME("%p, %p.\n", iface, attributes);
 133
 134     return E_NOTIMPL;
 135 }
 136
 137 static HRESULT WINAPI audio_converter_GetInputStreamAttributes(IMFTransform *iface, DWORD id,
 138         IMFAttributes **attributes)
 139 {
 140     FIXME("%p, %u, %p.\n", iface, id, attributes);
 141
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI audio_converter_GetOutputStreamAttributes(IMFTransform *iface, DWORD id,
 146         IMFAttributes **attributes)
 147 {
 148     FIXME("%p, %u, %p.\n", iface, id, attributes);
 149
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI audio_converter_DeleteInputStream(IMFTransform *iface, DWORD id)
 154 {
 155     TRACE("%p, %u.\n", iface, id);
 156
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI audio_converter_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 161 {
 162     TRACE("%p, %u, %p.\n", iface, streams, ids);
 163
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI audio_converter_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 168         IMFMediaType **type)
 169 {
 170     IMFMediaType *ret;
 171     HRESULT hr;
 172
 173     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
 174
 175     if (id != 0)
 176         return MF_E_INVALIDSTREAMNUMBER;
 177
 178     if (index >= 2)
 179         return MF_E_NO_MORE_TYPES;
 180
 181     if (FAILED(hr = MFCreateMediaType(&ret)))
 182         return hr;
 183
 184     if (FAILED(hr = IMFMediaType_SetGUID(ret, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio)))
 185     {
 186         IMFMediaType_Release(ret);
 187         return hr;
 188     }
 189
 190     if (FAILED(hr = IMFMediaType_SetGUID(ret, &MF_MT_SUBTYPE, index ? &MFAudioFormat_Float : &MFAudioFormat_PCM)))
 191     {
 192         IMFMediaType_Release(ret);
 193         return hr;
 194     }
 195
 196     *type = ret;
 197
 198     return S_OK;
 199 }
 200
 201 static HRESULT WINAPI audio_converter_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 202         IMFMediaType **type)
 203 {
 204     IMFMediaType *output_type;
 205     HRESULT hr;
 206
 207     static const struct
 208     {
 209         const GUID *subtype;
 210         DWORD depth;
 211     }
 212     formats[] =
 213     {
 214         {&MFAudioFormat_PCM, 16},
 215         {&MFAudioFormat_PCM, 24},
 216         {&MFAudioFormat_PCM, 32},
 217         {&MFAudioFormat_Float, 32},
 218     };
 219
 220     static const DWORD rates[] = {44100, 48000};
 221     static const DWORD channel_cnts[] = {1, 2, 6};
 222     const GUID *subtype;
 223     DWORD rate, channels, bps;
 224
 225     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
 226
 227     if (id != 0)
 228         return MF_E_INVALIDSTREAMNUMBER;
 229
 230     if (index >= ARRAY_SIZE(formats) * 2/*rates*/ * 3/*layouts*/)
 231         return MF_E_NO_MORE_TYPES;
 232
 233     if (FAILED(hr = MFCreateMediaType(&output_type)))
 234         return hr;
 235
 236     subtype = formats[index / 6].subtype;
 237     bps = formats[index / 6].depth;
 238     rate = rates[index % 2];
 239     channels = channel_cnts[(index / 2) % 3];
 240
 241     if (FAILED(hr = IMFMediaType_SetGUID(output_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio)))
 242         goto fail;
 243     if (FAILED(hr = IMFMediaType_SetGUID(output_type, &MF_MT_SUBTYPE, subtype)))
 244         goto fail;
 245     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, rate)))
 246         goto fail;
 247     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_AUDIO_NUM_CHANNELS, channels)))
 248         goto fail;
 249     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, bps)))
 250         goto fail;
 251
 252     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, channels * bps / 8)))
 253         goto fail;
 254     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, rate * channels * bps / 8)))
 255         goto fail;
 256     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_AUDIO_CHANNEL_MASK,
 257             channels == 1 ? KSAUDIO_SPEAKER_MONO :
 258             channels == 2 ? KSAUDIO_SPEAKER_STEREO :
 259           /*channels == 6*/ KSAUDIO_SPEAKER_5POINT1)))
 260         goto fail;
 261     if (FAILED(hr = IMFMediaType_SetUINT32(output_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE)))
 262         goto fail;
 263
 264     *type = output_type;
 265
 266     return S_OK;
 267 fail:
 268     IMFMediaType_Release(output_type);
 269     return hr;
 270 }
 271
 272 static HRESULT WINAPI audio_converter_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 273 {
 274     GUID major_type, subtype;
 275     DWORD unused;
 276     HRESULT hr;
 277
 278     struct audio_converter *converter = impl_audio_converter_from_IMFTransform(iface);
 279
 280     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
 281
 282     if (id != 0)
 283         return MF_E_INVALIDSTREAMNUMBER;
 284
 285     if (!type)
 286     {
 287         if (flags & MFT_SET_TYPE_TEST_ONLY)
 288             return S_OK;
 289
 290         EnterCriticalSection(&converter->cs);
 291
 292         if (converter->input_type)
 293         {
 294             IMFMediaType_Release(converter->input_type);
 295             converter->input_type = NULL;
 296         }
 297
 298         LeaveCriticalSection(&converter->cs);
 299
 300         return S_OK;
 301     }
 302
 303     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_MAJOR_TYPE, &major_type)))
 304         return MF_E_INVALIDTYPE;
 305     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 306         return MF_E_INVALIDTYPE;
 307     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &unused)))
 308         return MF_E_INVALIDTYPE;
 309     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &unused)))
 310         return MF_E_INVALIDTYPE;
 311     if (IsEqualGUID(&subtype, &MFAudioFormat_PCM) && FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &unused)))
 312         return MF_E_INVALIDTYPE;
 313
 314     if (!(IsEqualGUID(&major_type, &MFMediaType_Audio)))
 315         return MF_E_INVALIDTYPE;
 316
 317     if (!IsEqualGUID(&subtype, &MFAudioFormat_PCM) && !IsEqualGUID(&subtype, &MFAudioFormat_Float))
 318         return MF_E_INVALIDTYPE;
 319
 320     if (flags & MFT_SET_TYPE_TEST_ONLY)
 321         return S_OK;
 322
 323     EnterCriticalSection(&converter->cs);
 324
 325     hr = S_OK;
 326
 327     if (!converter->input_type)
 328         hr = MFCreateMediaType(&converter->input_type);
 329
 330     if (SUCCEEDED(hr))
 331         hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *) converter->input_type);
 332
 333     if (FAILED(hr))
 334     {
 335         IMFMediaType_Release(converter->input_type);
 336         converter->input_type = NULL;
 337     }
 338
 339     LeaveCriticalSection(&converter->cs);
 340
 341     return hr;
 342 }
 343
 344 static HRESULT WINAPI audio_converter_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 345 {
 346     struct audio_converter *converter = impl_audio_converter_from_IMFTransform(iface);
 347     GUID major_type, subtype;
 348     DWORD unused;
 349     HRESULT hr;
 350
 351     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
 352
 353     if (id != 0)
 354         return MF_E_INVALIDSTREAMNUMBER;
 355
 356     if (!converter->input_type)
 357         return MF_E_TRANSFORM_TYPE_NOT_SET;
 358
 359     if (!type)
 360     {
 361         if (flags & MFT_SET_TYPE_TEST_ONLY)
 362             return S_OK;
 363
 364         EnterCriticalSection(&converter->cs);
 365
 366         if (converter->output_type)
 367         {
 368             IMFMediaType_Release(converter->output_type);
 369             converter->output_type = NULL;
 370         }
 371
 372         LeaveCriticalSection(&converter->cs);
 373
 374         return S_OK;
 375     }
 376
 377     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_MAJOR_TYPE, &major_type)))
 378         return MF_E_INVALIDTYPE;
 379     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 380         return MF_E_INVALIDTYPE;
 381     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &unused)))
 382         return MF_E_INVALIDTYPE;
 383     if (IsEqualGUID(&subtype, &MFAudioFormat_PCM) && FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &unused)))
 384         return MF_E_INVALIDTYPE;
 385     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &unused)))
 386         return MF_E_INVALIDTYPE;
 387
 388     if (!(IsEqualGUID(&major_type, &MFMediaType_Audio)))
 389         return MF_E_INVALIDTYPE;
 390
 391     if (!IsEqualGUID(&subtype, &MFAudioFormat_PCM) && !IsEqualGUID(&subtype, &MFAudioFormat_Float))
 392         return MF_E_INVALIDTYPE;
 393
 394     if (flags & MFT_SET_TYPE_TEST_ONLY)
 395         return S_OK;
 396
 397     EnterCriticalSection(&converter->cs);
 398
 399     hr = S_OK;
 400
 401     if (!converter->output_type)
 402         hr = MFCreateMediaType(&converter->output_type);
 403
 404     if (SUCCEEDED(hr))
 405         hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *) converter->output_type);
 406
 407     if (FAILED(hr))
 408     {
 409         IMFMediaType_Release(converter->output_type);
 410         converter->output_type = NULL;
 411     }
 412
 413     LeaveCriticalSection(&converter->cs);
 414
 415     return hr;
 416 }
 417
 418 static HRESULT WINAPI audio_converter_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 419 {
 420     struct audio_converter *converter = impl_audio_converter_from_IMFTransform(iface);
 421     IMFMediaType *ret;
 422     HRESULT hr;
 423
 424     TRACE("%p, %u, %p.\n", converter, id, type);
 425
 426     if (id != 0)
 427         return MF_E_INVALIDSTREAMNUMBER;
 428
 429     if (FAILED(hr = MFCreateMediaType(&ret)))
 430         return hr;
 431
 432     EnterCriticalSection(&converter->cs);
 433
 434     if (converter->input_type)
 435         hr = IMFMediaType_CopyAllItems(converter->input_type, (IMFAttributes *)ret);
 436     else
 437         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 438
 439     LeaveCriticalSection(&converter->cs);
 440
 441     if (SUCCEEDED(hr))
 442         *type = ret;
 443     else
 444         IMFMediaType_Release(ret);
 445
 446     return hr;
 447 }
 448
 449 static HRESULT WINAPI audio_converter_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 450 {
 451     struct audio_converter *converter = impl_audio_converter_from_IMFTransform(iface);
 452     IMFMediaType *ret;
 453     HRESULT hr;
 454
 455     TRACE("%p, %u, %p.\n", converter, id, type);
 456
 457     if (id != 0)
 458         return MF_E_INVALIDSTREAMNUMBER;
 459
 460     if (FAILED(hr = MFCreateMediaType(&ret)))
 461         return hr;
 462
 463     EnterCriticalSection(&converter->cs);
 464
 465     if (converter->output_type)
 466         hr = IMFMediaType_CopyAllItems(converter->output_type, (IMFAttributes *)ret);
 467     else
 468         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 469
 470     LeaveCriticalSection(&converter->cs);
 471
 472     if (SUCCEEDED(hr))
 473         *type = ret;
 474     else
 475         IMFMediaType_Release(ret);
 476
 477     return hr;
 478 }
 479
 480 static HRESULT WINAPI audio_converter_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags)
 481 {
 482     FIXME("%p, %u, %p.\n", iface, id, flags);
 483
 484     return E_NOTIMPL;
 485 }
 486
 487 static HRESULT WINAPI audio_converter_GetOutputStatus(IMFTransform *iface, DWORD *flags)
 488 {
 489     FIXME("%p, %p.\n", iface, flags);
 490
 491     return E_NOTIMPL;
 492 }
 493
 494 static HRESULT WINAPI audio_converter_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 495 {
 496     FIXME("%p, %s, %s.\n", iface, wine_dbgstr_longlong(lower), wine_dbgstr_longlong(upper));
 497
 498     return E_NOTIMPL;
 499 }
 500
 501 static HRESULT WINAPI audio_converter_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
 502 {
 503     TRACE("%p, %u, %p.\n", iface, id, event);
 504
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI audio_converter_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
 509 {
 510     TRACE("%p, %u %lu.\n", iface, message, param);
 511
 512     switch(message)
 513     {
 514         case MFT_MESSAGE_NOTIFY_BEGIN_STREAMING:
 515             return S_OK;
 516         default:
 517             FIXME("Unhandled message type %x.\n", message);
 518             return E_NOTIMPL;
 519     }
 520 }
 521
 522 static HRESULT WINAPI audio_converter_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
 523 {
 524     FIXME("%p, %u, %p, %#x.\n", iface, id, sample, flags);
 525
 526     return E_NOTIMPL;
 527 }
 528
 529 static HRESULT WINAPI audio_converter_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
 530         MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status)
 531 {
 532     FIXME("%p, %#x, %u, %p, %p.\n", iface, flags, count, samples, status);
 533
 534     return E_NOTIMPL;
 535 }
 536
 537 static const IMFTransformVtbl audio_converter_vtbl =
 538 {
 539     audio_converter_QueryInterface,
 540     audio_converter_AddRef,
 541     audio_converter_Release,
 542     audio_converter_GetStreamLimits,
 543     audio_converter_GetStreamCount,
 544     audio_converter_GetStreamIDs,
 545     audio_converter_GetInputStreamInfo,
 546     audio_converter_GetOutputStreamInfo,
 547     audio_converter_GetAttributes,
 548     audio_converter_GetInputStreamAttributes,
 549     audio_converter_GetOutputStreamAttributes,
 550     audio_converter_DeleteInputStream,
 551     audio_converter_AddInputStreams,
 552     audio_converter_GetInputAvailableType,
 553     audio_converter_GetOutputAvailableType,
 554     audio_converter_SetInputType,
 555     audio_converter_SetOutputType,
 556     audio_converter_GetInputCurrentType,
 557     audio_converter_GetOutputCurrentType,
 558     audio_converter_GetInputStatus,
 559     audio_converter_GetOutputStatus,
 560     audio_converter_SetOutputBounds,
 561     audio_converter_ProcessEvent,
 562     audio_converter_ProcessMessage,
 563     audio_converter_ProcessInput,
 564     audio_converter_ProcessOutput,
 565 };
 566
 567 HRESULT audio_converter_create(REFIID riid, void **ret)
 568 {
 569     struct audio_converter *object;
 570
 571     TRACE("%s %p\n", debugstr_guid(riid), ret);
 572
 573     if (!(object = calloc(1, sizeof(*object))))
 574         return E_OUTOFMEMORY;
 575
 576     object->IMFTransform_iface.lpVtbl = &audio_converter_vtbl;
 577     object->refcount = 1;
 578
 579     InitializeCriticalSection(&object->cs);
 580     object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": audio_converter_lock");
 581
 582     *ret = &object->IMFTransform_iface;
 583     return S_OK;
 584 }