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
  29 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  30
  31 struct sink_writer
  32 {
  33     IMFSinkWriter IMFSinkWriter_iface;
  34     LONG refcount;
  35 };
  36
  37 static struct sink_writer *impl_from_IMFSinkWriter(IMFSinkWriter *iface)
  38 {
  39     return CONTAINING_RECORD(iface, struct sink_writer, IMFSinkWriter_iface);
  40 }
  41
  42 static HRESULT WINAPI sink_writer_QueryInterface(IMFSinkWriter *iface, REFIID riid, void **out)
  43 {
  44     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
  45
  46     if (IsEqualIID(riid, &IID_IMFSinkWriter) ||
  47             IsEqualIID(riid, &IID_IUnknown))
  48     {
  49         *out = iface;
  50         IMFSinkWriter_AddRef(iface);
  51         return S_OK;
  52     }
  53
  54     WARN("Unsupported %s.\n", debugstr_guid(riid));
  55     *out = NULL;
  56     return E_NOINTERFACE;
  57 }
  58
  59 static ULONG WINAPI sink_writer_AddRef(IMFSinkWriter *iface)
  60 {
  61     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
  62     ULONG refcount = InterlockedIncrement(&writer->refcount);
  63
  64     TRACE("%p, %u.\n", iface, refcount);
  65
  66     return refcount;
  67 }
  68
  69 static ULONG WINAPI sink_writer_Release(IMFSinkWriter *iface)
  70 {
  71     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
  72     ULONG refcount = InterlockedDecrement(&writer->refcount);
  73
  74     TRACE("%p, %u.\n", iface, refcount);
  75
  76     if (!refcount)
  77     {
  78         free(writer);
  79     }
  80
  81     return refcount;
  82 }
  83
  84 static HRESULT WINAPI sink_writer_AddStream(IMFSinkWriter *iface, IMFMediaType *type, DWORD *index)
  85 {
  86     FIXME("%p, %p, %p.\n", iface, type, index);
  87
  88     return E_NOTIMPL;
  89 }
  90
  91 static HRESULT WINAPI sink_writer_SetInputMediaType(IMFSinkWriter *iface, DWORD index, IMFMediaType *type,
  92         IMFAttributes *parameters)
  93 {
  94     FIXME("%p, %u, %p, %p.\n", iface, index, type, parameters);
  95
  96     return E_NOTIMPL;
  97 }
  98
  99 static HRESULT WINAPI sink_writer_BeginWriting(IMFSinkWriter *iface)
 100 {
 101     FIXME("%p.\n", iface);
 102
 103     return E_NOTIMPL;
 104 }
 105
 106 static HRESULT WINAPI sink_writer_WriteSample(IMFSinkWriter *iface, DWORD index, IMFSample *sample)
 107 {
 108     FIXME("%p, %u, %p.\n", iface, index, sample);
 109
 110     return E_NOTIMPL;
 111 }
 112
 113 static HRESULT WINAPI sink_writer_SendStreamTick(IMFSinkWriter *iface, DWORD index, LONGLONG timestamp)
 114 {
 115     FIXME("%p, %u, %s.\n", iface, index, wine_dbgstr_longlong(timestamp));
 116
 117     return E_NOTIMPL;
 118 }
 119
 120 static HRESULT WINAPI sink_writer_PlaceMarker(IMFSinkWriter *iface, DWORD index, void *context)
 121 {
 122     FIXME("%p, %u, %p.\n", iface, index, context);
 123
 124     return E_NOTIMPL;
 125 }
 126
 127 static HRESULT WINAPI sink_writer_NotifyEndOfSegment(IMFSinkWriter *iface, DWORD index)
 128 {
 129     FIXME("%p, %u.\n", iface, index);
 130
 131     return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI sink_writer_Flush(IMFSinkWriter *iface, DWORD index)
 135 {
 136     FIXME("%p, %u.\n", iface, index);
 137
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI sink_writer_Finalize(IMFSinkWriter *iface)
 142 {
 143     FIXME("%p.\n", iface);
 144
 145     return E_NOTIMPL;
 146 }
 147
 148 static HRESULT WINAPI sink_writer_GetServiceForStream(IMFSinkWriter *iface, DWORD index, REFGUID service,
 149         REFIID riid, void **object)
 150 {
 151     FIXME("%p, %u, %s, %s, %p.\n", iface, index, debugstr_guid(service), debugstr_guid(riid), object);
 152
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI sink_writer_GetStatistics(IMFSinkWriter *iface, DWORD index, MF_SINK_WRITER_STATISTICS *stats)
 157 {
 158     FIXME("%p, %u, %p.\n", iface, index, stats);
 159
 160     return E_NOTIMPL;
 161 }
 162
 163 static const IMFSinkWriterVtbl sink_writer_vtbl =
 164 {
 165     sink_writer_QueryInterface,
 166     sink_writer_AddRef,
 167     sink_writer_Release,
 168     sink_writer_AddStream,
 169     sink_writer_SetInputMediaType,
 170     sink_writer_BeginWriting,
 171     sink_writer_WriteSample,
 172     sink_writer_SendStreamTick,
 173     sink_writer_PlaceMarker,
 174     sink_writer_NotifyEndOfSegment,
 175     sink_writer_Flush,
 176     sink_writer_Finalize,
 177     sink_writer_GetServiceForStream,
 178     sink_writer_GetStatistics,
 179 };
 180
 181 HRESULT create_sink_writer_from_sink(IMFMediaSink *sink, IMFAttributes *attributes,
 182         REFIID riid, void **out)
 183 {
 184     struct sink_writer *object;
 185     HRESULT hr;
 186
 187     object = malloc(sizeof(*object));
 188     if (!object)
 189         return E_OUTOFMEMORY;
 190
 191     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
 192     object->refcount = 1;
 193
 194     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
 195     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
 196     return hr;
 197 }
 198
 199 HRESULT create_sink_writer_from_stream(IMFByteStream *stream, IMFAttributes *attributes,
 200         REFIID riid, void **out)
 201 {
 202     struct sink_writer *object;
 203     HRESULT hr;
 204
 205     object = malloc(sizeof(*object));
 206     if (!object)
 207         return E_OUTOFMEMORY;
 208
 209     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
 210     object->refcount = 1;
 211
 212     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
 213     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
 214     return hr;
 215 }
 216
 217 /***********************************************************************
 218  *      MFCreateSinkWriterFromMediaSink (mfreadwrite.@)
 219  */
 220 HRESULT WINAPI MFCreateSinkWriterFromMediaSink(IMFMediaSink *sink, IMFAttributes *attributes, IMFSinkWriter **writer)
 221 {
 222     TRACE("%p, %p, %p.\n", sink, attributes, writer);
 223
 224     return create_sink_writer_from_sink(sink, attributes, &IID_IMFSinkWriter, (void **)writer);
 225 }
 226
 227 /***********************************************************************
 228  *      MFCreateSinkWriterFromURL (mfreadwrite.@)
 229  */
 230 HRESULT WINAPI MFCreateSinkWriterFromURL(const WCHAR *url, IMFByteStream *bytestream, IMFAttributes *attributes,
 231         IMFSinkWriter **writer)
 232 {
 233     FIXME("%s, %p, %p, %p.\n", debugstr_w(url), bytestream, attributes, writer);
 234
 235     return E_NOTIMPL;
 236 }