git.sesse.net Git - ffmpeg/blob - libavdevice/dshow_pin.c

   1 /*
   2  * DirectShow capture interface
   3  * Copyright (c) 2010 Ramiro Polla
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "dshow_capture.h"
  23
  24 #include <stddef.h>
  25 #define imemoffset offsetof(DShowPin, imemvtbl)
  26
  27 DECLARE_QUERYINTERFACE(pin, DShowPin,
  28     { {&IID_IUnknown,0}, {&IID_IPin,0}, {&IID_IMemInputPin,imemoffset} })
  29 DECLARE_ADDREF(pin, DShowPin)
  30 DECLARE_RELEASE(pin, DShowPin)
  31
  32 long ff_dshow_pin_Connect(DShowPin *this, IPin *pin, const AM_MEDIA_TYPE *type)
  33 {
  34     dshowdebug("ff_dshow_pin_Connect(%p, %p, %p)\n", this, pin, type);
  35     /* Input pins receive connections. */
  36     return S_FALSE;
  37 }
  38 long ff_dshow_pin_ReceiveConnection(DShowPin *this, IPin *pin,
  39                            const AM_MEDIA_TYPE *type)
  40 {
  41     enum dshowDeviceType devtype = this->filter->type;
  42     dshowdebug("ff_dshow_pin_ReceiveConnection(%p)\n", this);
  43
  44     if (!pin)
  45         return E_POINTER;
  46     if (this->connectedto)
  47         return VFW_E_ALREADY_CONNECTED;
  48
  49     ff_print_AM_MEDIA_TYPE(type);
  50     if (devtype == VideoDevice) {
  51         if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Video))
  52             return VFW_E_TYPE_NOT_ACCEPTED;
  53     } else {
  54         if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
  55             return VFW_E_TYPE_NOT_ACCEPTED;
  56     }
  57
  58     IPin_AddRef(pin);
  59     this->connectedto = pin;
  60
  61     ff_copy_dshow_media_type(&this->type, type);
  62
  63     return S_OK;
  64 }
  65 long ff_dshow_pin_Disconnect(DShowPin *this)
  66 {
  67     dshowdebug("ff_dshow_pin_Disconnect(%p)\n", this);
  68
  69     if (this->filter->state != State_Stopped)
  70         return VFW_E_NOT_STOPPED;
  71     if (!this->connectedto)
  72         return S_FALSE;
  73     IPin_Release(this->connectedto);
  74     this->connectedto = NULL;
  75
  76     return S_OK;
  77 }
  78 long ff_dshow_pin_ConnectedTo(DShowPin *this, IPin **pin)
  79 {
  80     dshowdebug("ff_dshow_pin_ConnectedTo(%p)\n", this);
  81
  82     if (!pin)
  83         return E_POINTER;
  84     if (!this->connectedto)
  85         return VFW_E_NOT_CONNECTED;
  86     IPin_AddRef(this->connectedto);
  87     *pin = this->connectedto;
  88
  89     return S_OK;
  90 }
  91 long ff_dshow_pin_ConnectionMediaType(DShowPin *this, AM_MEDIA_TYPE *type)
  92 {
  93     dshowdebug("ff_dshow_pin_ConnectionMediaType(%p)\n", this);
  94
  95     if (!type)
  96         return E_POINTER;
  97     if (!this->connectedto)
  98         return VFW_E_NOT_CONNECTED;
  99
 100     return ff_copy_dshow_media_type(type, &this->type);
 101 }
 102 long ff_dshow_pin_QueryPinInfo(DShowPin *this, PIN_INFO *info)
 103 {
 104     dshowdebug("ff_dshow_pin_QueryPinInfo(%p)\n", this);
 105
 106     if (!info)
 107         return E_POINTER;
 108
 109     if (this->filter)
 110         ff_dshow_filter_AddRef(this->filter);
 111
 112     info->pFilter = (IBaseFilter *) this->filter;
 113     info->dir     = PINDIR_INPUT;
 114     wcscpy(info->achName, L"Capture");
 115
 116     return S_OK;
 117 }
 118 long ff_dshow_pin_QueryDirection(DShowPin *this, PIN_DIRECTION *dir)
 119 {
 120     dshowdebug("ff_dshow_pin_QueryDirection(%p)\n", this);
 121     if (!dir)
 122         return E_POINTER;
 123     *dir = PINDIR_INPUT;
 124     return S_OK;
 125 }
 126 long ff_dshow_pin_QueryId(DShowPin *this, wchar_t **id)
 127 {
 128     dshowdebug("ff_dshow_pin_QueryId(%p)\n", this);
 129
 130     if (!id)
 131         return E_POINTER;
 132
 133     *id = wcsdup(L"libAV Pin");
 134
 135     return S_OK;
 136 }
 137 long ff_dshow_pin_QueryAccept(DShowPin *this, const AM_MEDIA_TYPE *type)
 138 {
 139     dshowdebug("ff_dshow_pin_QueryAccept(%p)\n", this);
 140     return S_FALSE;
 141 }
 142 long ff_dshow_pin_EnumMediaTypes(DShowPin *this, IEnumMediaTypes **enumtypes)
 143 {
 144     const AM_MEDIA_TYPE *type = NULL;
 145     DShowEnumMediaTypes *new;
 146     dshowdebug("ff_dshow_pin_EnumMediaTypes(%p)\n", this);
 147
 148     if (!enumtypes)
 149         return E_POINTER;
 150     new = ff_dshow_enummediatypes_Create(type);
 151     if (!new)
 152         return E_OUTOFMEMORY;
 153
 154     *enumtypes = (IEnumMediaTypes *) new;
 155     return S_OK;
 156 }
 157 long ff_dshow_pin_QueryInternalConnections(DShowPin *this, IPin **pin,
 158                                   unsigned long *npin)
 159 {
 160     dshowdebug("ff_dshow_pin_QueryInternalConnections(%p)\n", this);
 161     return E_NOTIMPL;
 162 }
 163 long ff_dshow_pin_EndOfStream(DShowPin *this)
 164 {
 165     dshowdebug("ff_dshow_pin_EndOfStream(%p)\n", this);
 166     /* I don't care. */
 167     return S_OK;
 168 }
 169 long ff_dshow_pin_BeginFlush(DShowPin *this)
 170 {
 171     dshowdebug("ff_dshow_pin_BeginFlush(%p)\n", this);
 172     /* I don't care. */
 173     return S_OK;
 174 }
 175 long ff_dshow_pin_EndFlush(DShowPin *this)
 176 {
 177     dshowdebug("ff_dshow_pin_EndFlush(%p)\n", this);
 178     /* I don't care. */
 179     return S_OK;
 180 }
 181 long ff_dshow_pin_NewSegment(DShowPin *this, REFERENCE_TIME start, REFERENCE_TIME stop,
 182                     double rate)
 183 {
 184     dshowdebug("ff_dshow_pin_NewSegment(%p)\n", this);
 185     /* I don't care. */
 186     return S_OK;
 187 }
 188
 189 static int ff_dshow_pin_Setup(DShowPin *this, DShowFilter *filter)
 190 {
 191     IPinVtbl *vtbl = this->vtbl;
 192     IMemInputPinVtbl *imemvtbl;
 193
 194     if (!filter)
 195         return 0;
 196
 197     imemvtbl = av_malloc(sizeof(IMemInputPinVtbl));
 198     if (!imemvtbl)
 199         return 0;
 200
 201     SETVTBL(imemvtbl, meminputpin, QueryInterface);
 202     SETVTBL(imemvtbl, meminputpin, AddRef);
 203     SETVTBL(imemvtbl, meminputpin, Release);
 204     SETVTBL(imemvtbl, meminputpin, GetAllocator);
 205     SETVTBL(imemvtbl, meminputpin, NotifyAllocator);
 206     SETVTBL(imemvtbl, meminputpin, GetAllocatorRequirements);
 207     SETVTBL(imemvtbl, meminputpin, Receive);
 208     SETVTBL(imemvtbl, meminputpin, ReceiveMultiple);
 209     SETVTBL(imemvtbl, meminputpin, ReceiveCanBlock);
 210
 211     this->imemvtbl = imemvtbl;
 212
 213     SETVTBL(vtbl, pin, QueryInterface);
 214     SETVTBL(vtbl, pin, AddRef);
 215     SETVTBL(vtbl, pin, Release);
 216     SETVTBL(vtbl, pin, Connect);
 217     SETVTBL(vtbl, pin, ReceiveConnection);
 218     SETVTBL(vtbl, pin, Disconnect);
 219     SETVTBL(vtbl, pin, ConnectedTo);
 220     SETVTBL(vtbl, pin, ConnectionMediaType);
 221     SETVTBL(vtbl, pin, QueryPinInfo);
 222     SETVTBL(vtbl, pin, QueryDirection);
 223     SETVTBL(vtbl, pin, QueryId);
 224     SETVTBL(vtbl, pin, QueryAccept);
 225     SETVTBL(vtbl, pin, EnumMediaTypes);
 226     SETVTBL(vtbl, pin, QueryInternalConnections);
 227     SETVTBL(vtbl, pin, EndOfStream);
 228     SETVTBL(vtbl, pin, BeginFlush);
 229     SETVTBL(vtbl, pin, EndFlush);
 230     SETVTBL(vtbl, pin, NewSegment);
 231
 232     this->filter = filter;
 233
 234     return 1;
 235 }
 236
 237 static void ff_dshow_pin_Free(DShowPin *this)
 238 {
 239     if (!this)
 240         return;
 241     av_freep(&this->imemvtbl);
 242     if (this->type.pbFormat) {
 243         CoTaskMemFree(this->type.pbFormat);
 244         this->type.pbFormat = NULL;
 245     }
 246 }
 247 DECLARE_CREATE(pin, DShowPin, ff_dshow_pin_Setup(this, filter), DShowFilter *filter)
 248 DECLARE_DESTROY(pin, DShowPin, ff_dshow_pin_Free)
 249
 250 /*****************************************************************************
 251  * DShowMemInputPin
 252  ****************************************************************************/
 253 long ff_dshow_meminputpin_QueryInterface(DShowMemInputPin *this, const GUID *riid,
 254                                 void **ppvObject)
 255 {
 256     DShowPin *pin = (DShowPin *) ((uint8_t *) this - imemoffset);
 257     dshowdebug("ff_dshow_meminputpin_QueryInterface(%p)\n", this);
 258     return ff_dshow_pin_QueryInterface(pin, riid, ppvObject);
 259 }
 260 unsigned long ff_dshow_meminputpin_AddRef(DShowMemInputPin *this)
 261 {
 262     DShowPin *pin = (DShowPin *) ((uint8_t *) this - imemoffset);
 263     dshowdebug("ff_dshow_meminputpin_AddRef(%p)\n", this);
 264     return ff_dshow_pin_AddRef(pin);
 265 }
 266 unsigned long ff_dshow_meminputpin_Release(DShowMemInputPin *this)
 267 {
 268     DShowPin *pin = (DShowPin *) ((uint8_t *) this - imemoffset);
 269     dshowdebug("ff_dshow_meminputpin_Release(%p)\n", this);
 270     return ff_dshow_pin_Release(pin);
 271 }
 272 long ff_dshow_meminputpin_GetAllocator(DShowMemInputPin *this, IMemAllocator **alloc)
 273 {
 274     dshowdebug("ff_dshow_meminputpin_GetAllocator(%p)\n", this);
 275     return VFW_E_NO_ALLOCATOR;
 276 }
 277 long ff_dshow_meminputpin_NotifyAllocator(DShowMemInputPin *this, IMemAllocator *alloc,
 278                                  BOOL rdwr)
 279 {
 280     dshowdebug("ff_dshow_meminputpin_NotifyAllocator(%p)\n", this);
 281     return S_OK;
 282 }
 283 long ff_dshow_meminputpin_GetAllocatorRequirements(DShowMemInputPin *this,
 284                                           ALLOCATOR_PROPERTIES *props)
 285 {
 286     dshowdebug("ff_dshow_meminputpin_GetAllocatorRequirements(%p)\n", this);
 287     return E_NOTIMPL;
 288 }
 289 long ff_dshow_meminputpin_Receive(DShowMemInputPin *this, IMediaSample *sample)
 290 {
 291     DShowPin *pin = (DShowPin *) ((uint8_t *) this - imemoffset);
 292     enum dshowDeviceType devtype = pin->filter->type;
 293     void *priv_data;
 294     AVFormatContext *s;
 295     uint8_t *buf;
 296     int buf_size; /* todo should be a long? */
 297     int index;
 298     int64_t curtime;
 299     int64_t orig_curtime;
 300     int64_t graphtime;
 301     const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
 302     IReferenceClock *clock = pin->filter->clock;
 303     int64_t dummy;
 304     struct dshow_ctx *ctx;
 305
 306
 307     dshowdebug("ff_dshow_meminputpin_Receive(%p)\n", this);
 308
 309     if (!sample)
 310         return E_POINTER;
 311
 312     IMediaSample_GetTime(sample, &orig_curtime, &dummy);
 313     orig_curtime += pin->filter->start_time;
 314     IReferenceClock_GetTime(clock, &graphtime);
 315     if (devtype == VideoDevice) {
 316         /* PTS from video devices is unreliable. */
 317         IReferenceClock_GetTime(clock, &curtime);
 318     } else {
 319         IMediaSample_GetTime(sample, &curtime, &dummy);
 320         if(curtime > 400000000000000000LL) {
 321             /* initial frames sometimes start < 0 (shown as a very large number here,
 322                like 437650244077016960 which FFmpeg doesn't like.
 323                TODO figure out math. For now just drop them. */
 324             av_log(NULL, AV_LOG_DEBUG,
 325                 "dshow dropping initial (or ending) audio frame with odd PTS too high %"PRId64"\n", curtime);
 326             return S_OK;
 327         }
 328         curtime += pin->filter->start_time;
 329     }
 330
 331     buf_size = IMediaSample_GetActualDataLength(sample);
 332     IMediaSample_GetPointer(sample, &buf);
 333     priv_data = pin->filter->priv_data;
 334     s = priv_data;
 335     ctx = s->priv_data;
 336     index = pin->filter->stream_index;
 337
 338     av_log(NULL, AV_LOG_VERBOSE, "dshow passing through packet of type %s size %8d "
 339         "timestamp %"PRId64" orig timestamp %"PRId64" graph timestamp %"PRId64" diff %"PRId64" %s\n",
 340         devtypename, buf_size, curtime, orig_curtime, graphtime, graphtime - orig_curtime, ctx->device_name[devtype]);
 341     pin->filter->callback(priv_data, index, buf, buf_size, curtime, devtype);
 342
 343     return S_OK;
 344 }
 345 long ff_dshow_meminputpin_ReceiveMultiple(DShowMemInputPin *this,
 346                                  IMediaSample **samples, long n, long *nproc)
 347 {
 348     int i;
 349     dshowdebug("ff_dshow_meminputpin_ReceiveMultiple(%p)\n", this);
 350
 351     for (i = 0; i < n; i++)
 352         ff_dshow_meminputpin_Receive(this, samples[i]);
 353
 354     *nproc = n;
 355     return S_OK;
 356 }
 357 long ff_dshow_meminputpin_ReceiveCanBlock(DShowMemInputPin *this)
 358 {
 359     dshowdebug("ff_dshow_meminputpin_ReceiveCanBlock(%p)\n", this);
 360     /* I swear I will not block. */
 361     return S_FALSE;
 362 }
 363
 364 void ff_dshow_meminputpin_Destroy(DShowMemInputPin *this)
 365 {
 366     DShowPin *pin = (DShowPin *) ((uint8_t *) this - imemoffset);
 367     dshowdebug("ff_dshow_meminputpin_Destroy(%p)\n", this);
 368     ff_dshow_pin_Destroy(pin);
 369 }