dlls/winegstreamer/wg_sample.c

   1 /*
   2  * Copyright 2022 Rémi Bernon 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 #include "gst_private.h"
  20
  21 #include "wmcodecdsp.h"
  22 #include "mfapi.h"
  23
  24 #include "wine/debug.h"
  25 #include "wine/list.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  28 WINE_DECLARE_DEBUG_CHANNEL(quartz);
  29
  30 struct wg_sample_queue
  31 {
  32     CRITICAL_SECTION cs;
  33     struct list samples;
  34 };
  35
  36 struct wg_sample_ops
  37 {
  38     void (*destroy)(struct wg_sample *sample);
  39 };
  40
  41 struct sample
  42 {
  43     struct wg_sample wg_sample;
  44
  45     const struct wg_sample_ops *ops;
  46     struct list entry;
  47
  48     union
  49     {
  50         struct
  51         {
  52             IMFSample *sample;
  53             IMFMediaBuffer *buffer;
  54         } mf;
  55         struct
  56         {
  57             IMediaSample *sample;
  58         } quartz;
  59     } u;
  60 };
  61
  62 static const struct wg_sample_ops mf_sample_ops;
  63
  64 static inline struct sample *unsafe_mf_from_wg_sample(struct wg_sample *wg_sample)
  65 {
  66     struct sample *sample = CONTAINING_RECORD(wg_sample, struct sample, wg_sample);
  67     if (sample->ops != &mf_sample_ops) return NULL;
  68     return sample;
  69 }
  70
  71 static void mf_sample_destroy(struct wg_sample *wg_sample)
  72 {
  73     struct sample *sample = unsafe_mf_from_wg_sample(wg_sample);
  74
  75     TRACE_(mfplat)("wg_sample %p.\n", wg_sample);
  76
  77     IMFMediaBuffer_Unlock(sample->u.mf.buffer);
  78     IMFMediaBuffer_Release(sample->u.mf.buffer);
  79     IMFSample_Release(sample->u.mf.sample);
  80 }
  81
  82 static const struct wg_sample_ops mf_sample_ops =
  83 {
  84     mf_sample_destroy,
  85 };
  86
  87 HRESULT wg_sample_create_mf(IMFSample *mf_sample, struct wg_sample **out)
  88 {
  89     DWORD current_length, max_length;
  90     struct sample *sample;
  91     BYTE *buffer;
  92     HRESULT hr;
  93
  94     if (!(sample = calloc(1, sizeof(*sample))))
  95         return E_OUTOFMEMORY;
  96     if (FAILED(hr = IMFSample_ConvertToContiguousBuffer(mf_sample, &sample->u.mf.buffer)))
  97         goto fail;
  98     if (FAILED(hr = IMFMediaBuffer_Lock(sample->u.mf.buffer, &buffer, &max_length, &current_length)))
  99         goto fail;
 100
 101     IMFSample_AddRef((sample->u.mf.sample = mf_sample));
 102     sample->wg_sample.data = buffer;
 103     sample->wg_sample.size = current_length;
 104     sample->wg_sample.max_size = max_length;
 105     sample->ops = &mf_sample_ops;
 106
 107     *out = &sample->wg_sample;
 108     TRACE_(mfplat)("Created wg_sample %p for IMFSample %p.\n", *out, mf_sample);
 109     return S_OK;
 110
 111 fail:
 112     if (sample->u.mf.buffer)
 113         IMFMediaBuffer_Release(sample->u.mf.buffer);
 114     free(sample);
 115     return hr;
 116 }
 117
 118 static const struct wg_sample_ops quartz_sample_ops;
 119
 120 static inline struct sample *unsafe_quartz_from_wg_sample(struct wg_sample *wg_sample)
 121 {
 122     struct sample *sample = CONTAINING_RECORD(wg_sample, struct sample, wg_sample);
 123     if (sample->ops != &quartz_sample_ops) return NULL;
 124     return sample;
 125 }
 126
 127 static void quartz_sample_destroy(struct wg_sample *wg_sample)
 128 {
 129     struct sample *sample = unsafe_quartz_from_wg_sample(wg_sample);
 130
 131     TRACE_(quartz)("wg_sample %p.\n", wg_sample);
 132
 133     IMediaSample_Release(sample->u.quartz.sample);
 134 }
 135
 136 static const struct wg_sample_ops quartz_sample_ops =
 137 {
 138     quartz_sample_destroy,
 139 };
 140
 141 HRESULT wg_sample_create_quartz(IMediaSample *media_sample, struct wg_sample **out)
 142 {
 143     DWORD current_length, max_length;
 144     struct sample *sample;
 145     BYTE *buffer;
 146     HRESULT hr;
 147
 148     if (FAILED(hr = IMediaSample_GetPointer(media_sample, &buffer)))
 149         return hr;
 150     current_length = IMediaSample_GetActualDataLength(media_sample);
 151     max_length = IMediaSample_GetSize(media_sample);
 152
 153     if (!(sample = calloc(1, sizeof(*sample))))
 154         return E_OUTOFMEMORY;
 155
 156     IMediaSample_AddRef((sample->u.quartz.sample = media_sample));
 157     sample->wg_sample.data = buffer;
 158     sample->wg_sample.size = current_length;
 159     sample->wg_sample.max_size = max_length;
 160     sample->ops = &quartz_sample_ops;
 161
 162     TRACE_(quartz)("Created wg_sample %p for IMediaSample %p.\n", &sample->wg_sample, media_sample);
 163     *out = &sample->wg_sample;
 164     return S_OK;
 165 }
 166
 167 void wg_sample_release(struct wg_sample *wg_sample)
 168 {
 169     struct sample *sample = CONTAINING_RECORD(wg_sample, struct sample, wg_sample);
 170
 171     if (InterlockedOr(&wg_sample->refcount, 0))
 172     {
 173         ERR("wg_sample %p is still in use, trouble ahead!\n", wg_sample);
 174         return;
 175     }
 176
 177     sample->ops->destroy(wg_sample);
 178
 179     free(sample);
 180 }
 181
 182 static void wg_sample_queue_begin_append(struct wg_sample_queue *queue, struct wg_sample *wg_sample)
 183 {
 184     struct sample *sample = CONTAINING_RECORD(wg_sample, struct sample, wg_sample);
 185
 186     /* make sure a concurrent wg_sample_queue_flush call won't release the sample until we're done */
 187     InterlockedIncrement(&wg_sample->refcount);
 188     sample->wg_sample.flags |= WG_SAMPLE_FLAG_HAS_REFCOUNT;
 189
 190     EnterCriticalSection(&queue->cs);
 191     list_add_tail(&queue->samples, &sample->entry);
 192     LeaveCriticalSection(&queue->cs);
 193 }
 194
 195 static void wg_sample_queue_end_append(struct wg_sample_queue *queue, struct wg_sample *wg_sample)
 196 {
 197     /* release temporary ref taken in wg_sample_queue_begin_append */
 198     InterlockedDecrement(&wg_sample->refcount);
 199
 200     wg_sample_queue_flush(queue, false);
 201 }
 202
 203 void wg_sample_queue_flush(struct wg_sample_queue *queue, bool all)
 204 {
 205     struct sample *sample, *next;
 206
 207     EnterCriticalSection(&queue->cs);
 208
 209     LIST_FOR_EACH_ENTRY_SAFE(sample, next, &queue->samples, struct sample, entry)
 210     {
 211         if (!InterlockedOr(&sample->wg_sample.refcount, 0) || all)
 212         {
 213             list_remove(&sample->entry);
 214             wg_sample_release(&sample->wg_sample);
 215         }
 216     }
 217
 218     LeaveCriticalSection(&queue->cs);
 219 }
 220
 221 HRESULT wg_sample_queue_create(struct wg_sample_queue **out)
 222 {
 223     struct wg_sample_queue *queue;
 224
 225     if (!(queue = calloc(1, sizeof(*queue))))
 226         return E_OUTOFMEMORY;
 227
 228     InitializeCriticalSection(&queue->cs);
 229     queue->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": cs");
 230     list_init(&queue->samples);
 231
 232     TRACE("Created wg_sample_queue %p.\n", queue);
 233     *out = queue;
 234
 235     return S_OK;
 236 }
 237
 238 void wg_sample_queue_destroy(struct wg_sample_queue *queue)
 239 {
 240     wg_sample_queue_flush(queue, true);
 241
 242     queue->cs.DebugInfo->Spare[0] = 0;
 243     InitializeCriticalSection(&queue->cs);
 244
 245     free(queue);
 246 }
 247
 248 HRESULT wg_transform_push_mf(struct wg_transform *transform, struct wg_sample *wg_sample,
 249         struct wg_sample_queue *queue)
 250 {
 251     struct sample *sample = unsafe_mf_from_wg_sample(wg_sample);
 252     LONGLONG time, duration;
 253     UINT32 value;
 254     HRESULT hr;
 255
 256     TRACE_(mfplat)("transform %p, wg_sample %p, queue %p.\n", transform, wg_sample, queue);
 257
 258     if (SUCCEEDED(IMFSample_GetSampleTime(sample->u.mf.sample, &time)))
 259     {
 260         sample->wg_sample.flags |= WG_SAMPLE_FLAG_HAS_PTS;
 261         sample->wg_sample.pts = time;
 262     }
 263     if (SUCCEEDED(IMFSample_GetSampleDuration(sample->u.mf.sample, &duration)))
 264     {
 265         sample->wg_sample.flags |= WG_SAMPLE_FLAG_HAS_DURATION;
 266         sample->wg_sample.duration = duration;
 267     }
 268     if (SUCCEEDED(IMFSample_GetUINT32(sample->u.mf.sample, &MFSampleExtension_CleanPoint, &value)) && value)
 269         sample->wg_sample.flags |= WG_SAMPLE_FLAG_SYNC_POINT;
 270
 271     wg_sample_queue_begin_append(queue, wg_sample);
 272     hr = wg_transform_push_data(transform, wg_sample);
 273     wg_sample_queue_end_append(queue, wg_sample);
 274
 275     return hr;
 276 }
 277
 278 HRESULT wg_transform_read_mf(struct wg_transform *transform, struct wg_sample *wg_sample,
 279         struct wg_format *format)
 280 {
 281     struct sample *sample = unsafe_mf_from_wg_sample(wg_sample);
 282     HRESULT hr;
 283
 284     TRACE_(mfplat)("transform %p, wg_sample %p, format %p.\n", transform, wg_sample, format);
 285
 286     if (FAILED(hr = wg_transform_read_data(transform, wg_sample, format)))
 287         return hr;
 288
 289     if (FAILED(hr = IMFMediaBuffer_SetCurrentLength(sample->u.mf.buffer, wg_sample->size)))
 290         return hr;
 291
 292     if (wg_sample->flags & WG_SAMPLE_FLAG_HAS_PTS)
 293         IMFSample_SetSampleTime(sample->u.mf.sample, wg_sample->pts);
 294     if (wg_sample->flags & WG_SAMPLE_FLAG_HAS_DURATION)
 295         IMFSample_SetSampleDuration(sample->u.mf.sample, wg_sample->duration);
 296     if (wg_sample->flags & WG_SAMPLE_FLAG_SYNC_POINT)
 297         IMFSample_SetUINT32(sample->u.mf.sample, &MFSampleExtension_CleanPoint, 1);
 298
 299     return S_OK;
 300 }