dlls/mfreadwrite/writer.c

   1 /*
   2  * Copyright 2020 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define NONAMELESSUNION
  21
  22 #include "mfapi.h"
  23 #include "mfidl.h"
  24 #include "mfreadwrite.h"
  25 #include "mf_private.h"
  26
  27 #include "wine/debug.h"
  28 #include "wine/heap.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  31
  32 struct sink_writer
  33 {
  34     IMFSinkWriter IMFSinkWriter_iface;
  35     LONG refcount;
  36 };
  37
  38 static struct sink_writer *impl_from_IMFSinkWriter(IMFSinkWriter *iface)
  39 {
  40     return CONTAINING_RECORD(iface, struct sink_writer, IMFSinkWriter_iface);
  41 }
  42
  43 static HRESULT WINAPI sink_writer_QueryInterface(IMFSinkWriter *iface, REFIID riid, void **out)
  44 {
  45     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
  46
  47     if (IsEqualIID(riid, &IID_IMFSinkWriter) ||
  48             IsEqualIID(riid, &IID_IUnknown))
  49     {
  50         *out = iface;
  51         IMFSinkWriter_AddRef(iface);
  52         return S_OK;
  53     }
  54
  55     WARN("Unsupported %s.\n", debugstr_guid(riid));
  56     *out = NULL;
  57     return E_NOINTERFACE;
  58 }
  59
  60 static ULONG WINAPI sink_writer_AddRef(IMFSinkWriter *iface)
  61 {
  62     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
  63     ULONG refcount = InterlockedIncrement(&writer->refcount);
  64
  65     TRACE("%p, %u.\n", iface, refcount);
  66
  67     return refcount;
  68 }
  69
  70 static ULONG WINAPI sink_writer_Release(IMFSinkWriter *iface)
  71 {
  72     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
  73     ULONG refcount = InterlockedDecrement(&writer->refcount);
  74
  75     TRACE("%p, %u.\n", iface, refcount);
  76
  77     if (!refcount)
  78     {
  79         heap_free(writer);
  80     }
  81
  82     return refcount;
  83 }
  84
  85 static HRESULT WINAPI sink_writer_AddStream(IMFSinkWriter *iface, IMFMediaType *type, DWORD *index)
  86 {
  87     FIXME("%p, %p, %p.\n", iface, type, index);
  88
  89     return E_NOTIMPL;
  90 }
  91
  92 static HRESULT WINAPI sink_writer_SetInputMediaType(IMFSinkWriter *iface, DWORD index, IMFMediaType *type,
  93         IMFAttributes *parameters)
  94 {
  95     FIXME("%p, %u, %p, %p.\n", iface, index, type, parameters);
  96
  97     return E_NOTIMPL;
  98 }
  99
 100 static HRESULT WINAPI sink_writer_BeginWriting(IMFSinkWriter *iface)
 101 {
 102     FIXME("%p.\n", iface);
 103
 104     return E_NOTIMPL;
 105 }
 106
 107 static HRESULT WINAPI sink_writer_WriteSample(IMFSinkWriter *iface, DWORD index, IMFSample *sample)
 108 {
 109     FIXME("%p, %u, %p.\n", iface, index, sample);
 110
 111     return E_NOTIMPL;
 112 }
 113
 114 static HRESULT WINAPI sink_writer_SendStreamTick(IMFSinkWriter *iface, DWORD index, LONGLONG timestamp)
 115 {
 116     FIXME("%p, %u, %s.\n", iface, index, wine_dbgstr_longlong(timestamp));
 117
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT WINAPI sink_writer_PlaceMarker(IMFSinkWriter *iface, DWORD index, void *context)
 122 {
 123     FIXME("%p, %u, %p.\n", iface, index, context);
 124
 125     return E_NOTIMPL;
 126 }
 127
 128 static HRESULT WINAPI sink_writer_NotifyEndOfSegment(IMFSinkWriter *iface, DWORD index)
 129 {
 130     FIXME("%p, %u.\n", iface, index);
 131
 132     return E_NOTIMPL;
 133 }
 134
 135 static HRESULT WINAPI sink_writer_Flush(IMFSinkWriter *iface, DWORD index)
 136 {
 137     FIXME("%p, %u.\n", iface, index);
 138
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI sink_writer_Finalize(IMFSinkWriter *iface)
 143 {
 144     FIXME("%p.\n", iface);
 145
 146     return E_NOTIMPL;
 147 }
 148
 149 static HRESULT WINAPI sink_writer_GetServiceForStream(IMFSinkWriter *iface, DWORD index, REFGUID service,
 150         REFIID riid, void **object)
 151 {
 152     FIXME("%p, %u, %s, %s, %p.\n", iface, index, debugstr_guid(service), debugstr_guid(riid), object);
 153
 154     return E_NOTIMPL;
 155 }
 156
 157 static HRESULT WINAPI sink_writer_GetStatistics(IMFSinkWriter *iface, DWORD index, MF_SINK_WRITER_STATISTICS *stats)
 158 {
 159     FIXME("%p, %u, %p.\n", iface, index, stats);
 160
 161     return E_NOTIMPL;
 162 }
 163
 164 static const IMFSinkWriterVtbl sink_writer_vtbl =
 165 {
 166     sink_writer_QueryInterface,
 167     sink_writer_AddRef,
 168     sink_writer_Release,
 169     sink_writer_AddStream,
 170     sink_writer_SetInputMediaType,
 171     sink_writer_BeginWriting,
 172     sink_writer_WriteSample,
 173     sink_writer_SendStreamTick,
 174     sink_writer_PlaceMarker,
 175     sink_writer_NotifyEndOfSegment,
 176     sink_writer_Flush,
 177     sink_writer_Finalize,
 178     sink_writer_GetServiceForStream,
 179     sink_writer_GetStatistics,
 180 };
 181
 182 HRESULT create_sink_writer_from_sink(IMFMediaSink *sink, IMFAttributes *attributes,
 183         REFIID riid, void **out)
 184 {
 185     struct sink_writer *object;
 186     HRESULT hr;
 187
 188     object = heap_alloc(sizeof(*object));
 189     if (!object)
 190         return E_OUTOFMEMORY;
 191
 192     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
 193     object->refcount = 1;
 194
 195     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
 196     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
 197     return hr;
 198 }
 199
 200 HRESULT create_sink_writer_from_stream(IMFByteStream *stream, IMFAttributes *attributes,
 201         REFIID riid, void **out)
 202 {
 203     struct sink_writer *object;
 204     HRESULT hr;
 205
 206     object = heap_alloc(sizeof(*object));
 207     if (!object)
 208         return E_OUTOFMEMORY;
 209
 210     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
 211     object->refcount = 1;
 212
 213     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
 214     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
 215     return hr;
 216 }
 217
 218 /***********************************************************************
 219  *      MFCreateSinkWriterFromMediaSink (mfreadwrite.@)
 220  */
 221 HRESULT WINAPI MFCreateSinkWriterFromMediaSink(IMFMediaSink *sink, IMFAttributes *attributes, IMFSinkWriter **writer)
 222 {
 223     TRACE("%p, %p, %p.\n", sink, attributes, writer);
 224
 225     return create_sink_writer_from_sink(sink, attributes, &IID_IMFSinkWriter, (void **)writer);
 226 }
 227
 228 /***********************************************************************
 229  *      MFCreateSinkWriterFromURL (mfreadwrite.@)
 230  */
 231 HRESULT WINAPI MFCreateSinkWriterFromURL(const WCHAR *url, IMFByteStream *bytestream, IMFAttributes *attributes,
 232         IMFSinkWriter **writer)
 233 {
 234     FIXME("%s, %p, %p, %p.\n", debugstr_w(url), bytestream, attributes, writer);
 235
 236     return E_NOTIMPL;
 237 }