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(libAVPin, imemvtbl)
  26
  27 DECLARE_QUERYINTERFACE(libAVPin,
  28     { {&IID_IUnknown,0}, {&IID_IPin,0}, {&IID_IMemInputPin,imemoffset} })
  29 DECLARE_ADDREF(libAVPin)
  30 DECLARE_RELEASE(libAVPin)
  31
  32 long WINAPI
  33 libAVPin_Connect(libAVPin *this, IPin *pin, const AM_MEDIA_TYPE *type)
  34 {
  35     dshowdebug("libAVPin_Connect(%p, %p, %p)\n", this, pin, type);
  36     /* Input pins receive connections. */
  37     return S_FALSE;
  38 }
  39 long WINAPI
  40 libAVPin_ReceiveConnection(libAVPin *this, IPin *pin,
  41                            const AM_MEDIA_TYPE *type)
  42 {
  43     enum dshowDeviceType devtype = this->filter->type;
  44     dshowdebug("libAVPin_ReceiveConnection(%p)\n", this);
  45
  46     if (!pin)
  47         return E_POINTER;
  48     if (this->connectedto)
  49         return VFW_E_ALREADY_CONNECTED;
  50
  51     ff_print_AM_MEDIA_TYPE(type);
  52     if (devtype == VideoDevice) {
  53         if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Video))
  54             return VFW_E_TYPE_NOT_ACCEPTED;
  55     } else {
  56         if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
  57             return VFW_E_TYPE_NOT_ACCEPTED;
  58     }
  59
  60     IPin_AddRef(pin);
  61     this->connectedto = pin;
  62
  63     ff_copy_dshow_media_type(&this->type, type);
  64
  65     return S_OK;
  66 }
  67 long WINAPI
  68 libAVPin_Disconnect(libAVPin *this)
  69 {
  70     dshowdebug("libAVPin_Disconnect(%p)\n", this);
  71
  72     if (this->filter->state != State_Stopped)
  73         return VFW_E_NOT_STOPPED;
  74     if (!this->connectedto)
  75         return S_FALSE;
  76     IPin_Release(this->connectedto);
  77     this->connectedto = NULL;
  78
  79     return S_OK;
  80 }
  81 long WINAPI
  82 libAVPin_ConnectedTo(libAVPin *this, IPin **pin)
  83 {
  84     dshowdebug("libAVPin_ConnectedTo(%p)\n", this);
  85
  86     if (!pin)
  87         return E_POINTER;
  88     if (!this->connectedto)
  89         return VFW_E_NOT_CONNECTED;
  90     IPin_AddRef(this->connectedto);
  91     *pin = this->connectedto;
  92
  93     return S_OK;
  94 }
  95 long WINAPI
  96 libAVPin_ConnectionMediaType(libAVPin *this, AM_MEDIA_TYPE *type)
  97 {
  98     dshowdebug("libAVPin_ConnectionMediaType(%p)\n", this);
  99
 100     if (!type)
 101         return E_POINTER;
 102     if (!this->connectedto)
 103         return VFW_E_NOT_CONNECTED;
 104
 105     return ff_copy_dshow_media_type(type, &this->type);
 106 }
 107 long WINAPI
 108 libAVPin_QueryPinInfo(libAVPin *this, PIN_INFO *info)
 109 {
 110     dshowdebug("libAVPin_QueryPinInfo(%p)\n", this);
 111
 112     if (!info)
 113         return E_POINTER;
 114
 115     if (this->filter)
 116         libAVFilter_AddRef(this->filter);
 117
 118     info->pFilter = (IBaseFilter *) this->filter;
 119     info->dir     = PINDIR_INPUT;
 120     wcscpy(info->achName, L"Capture");
 121
 122     return S_OK;
 123 }
 124 long WINAPI
 125 libAVPin_QueryDirection(libAVPin *this, PIN_DIRECTION *dir)
 126 {
 127     dshowdebug("libAVPin_QueryDirection(%p)\n", this);
 128     if (!dir)
 129         return E_POINTER;
 130     *dir = PINDIR_INPUT;
 131     return S_OK;
 132 }
 133 long WINAPI
 134 libAVPin_QueryId(libAVPin *this, wchar_t **id)
 135 {
 136     dshowdebug("libAVPin_QueryId(%p)\n", this);
 137
 138     if (!id)
 139         return E_POINTER;
 140
 141     *id = wcsdup(L"libAV Pin");
 142
 143     return S_OK;
 144 }
 145 long WINAPI
 146 libAVPin_QueryAccept(libAVPin *this, const AM_MEDIA_TYPE *type)
 147 {
 148     dshowdebug("libAVPin_QueryAccept(%p)\n", this);
 149     return S_FALSE;
 150 }
 151 long WINAPI
 152 libAVPin_EnumMediaTypes(libAVPin *this, IEnumMediaTypes **enumtypes)
 153 {
 154     const AM_MEDIA_TYPE *type = NULL;
 155     libAVEnumMediaTypes *new;
 156     dshowdebug("libAVPin_EnumMediaTypes(%p)\n", this);
 157
 158     if (!enumtypes)
 159         return E_POINTER;
 160     new = libAVEnumMediaTypes_Create(type);
 161     if (!new)
 162         return E_OUTOFMEMORY;
 163
 164     *enumtypes = (IEnumMediaTypes *) new;
 165     return S_OK;
 166 }
 167 long WINAPI
 168 libAVPin_QueryInternalConnections(libAVPin *this, IPin **pin,
 169                                   unsigned long *npin)
 170 {
 171     dshowdebug("libAVPin_QueryInternalConnections(%p)\n", this);
 172     return E_NOTIMPL;
 173 }
 174 long WINAPI
 175 libAVPin_EndOfStream(libAVPin *this)
 176 {
 177     dshowdebug("libAVPin_EndOfStream(%p)\n", this);
 178     /* I don't care. */
 179     return S_OK;
 180 }
 181 long WINAPI
 182 libAVPin_BeginFlush(libAVPin *this)
 183 {
 184     dshowdebug("libAVPin_BeginFlush(%p)\n", this);
 185     /* I don't care. */
 186     return S_OK;
 187 }
 188 long WINAPI
 189 libAVPin_EndFlush(libAVPin *this)
 190 {
 191     dshowdebug("libAVPin_EndFlush(%p)\n", this);
 192     /* I don't care. */
 193     return S_OK;
 194 }
 195 long WINAPI
 196 libAVPin_NewSegment(libAVPin *this, REFERENCE_TIME start, REFERENCE_TIME stop,
 197                     double rate)
 198 {
 199     dshowdebug("libAVPin_NewSegment(%p)\n", this);
 200     /* I don't care. */
 201     return S_OK;
 202 }
 203
 204 static int
 205 libAVPin_Setup(libAVPin *this, libAVFilter *filter)
 206 {
 207     IPinVtbl *vtbl = this->vtbl;
 208     IMemInputPinVtbl *imemvtbl;
 209
 210     if (!filter)
 211         return 0;
 212
 213     imemvtbl = av_malloc(sizeof(IMemInputPinVtbl));
 214     if (!imemvtbl)
 215         return 0;
 216
 217     SETVTBL(imemvtbl, libAVMemInputPin, QueryInterface);
 218     SETVTBL(imemvtbl, libAVMemInputPin, AddRef);
 219     SETVTBL(imemvtbl, libAVMemInputPin, Release);
 220     SETVTBL(imemvtbl, libAVMemInputPin, GetAllocator);
 221     SETVTBL(imemvtbl, libAVMemInputPin, NotifyAllocator);
 222     SETVTBL(imemvtbl, libAVMemInputPin, GetAllocatorRequirements);
 223     SETVTBL(imemvtbl, libAVMemInputPin, Receive);
 224     SETVTBL(imemvtbl, libAVMemInputPin, ReceiveMultiple);
 225     SETVTBL(imemvtbl, libAVMemInputPin, ReceiveCanBlock);
 226
 227     this->imemvtbl = imemvtbl;
 228
 229     SETVTBL(vtbl, libAVPin, QueryInterface);
 230     SETVTBL(vtbl, libAVPin, AddRef);
 231     SETVTBL(vtbl, libAVPin, Release);
 232     SETVTBL(vtbl, libAVPin, Connect);
 233     SETVTBL(vtbl, libAVPin, ReceiveConnection);
 234     SETVTBL(vtbl, libAVPin, Disconnect);
 235     SETVTBL(vtbl, libAVPin, ConnectedTo);
 236     SETVTBL(vtbl, libAVPin, ConnectionMediaType);
 237     SETVTBL(vtbl, libAVPin, QueryPinInfo);
 238     SETVTBL(vtbl, libAVPin, QueryDirection);
 239     SETVTBL(vtbl, libAVPin, QueryId);
 240     SETVTBL(vtbl, libAVPin, QueryAccept);
 241     SETVTBL(vtbl, libAVPin, EnumMediaTypes);
 242     SETVTBL(vtbl, libAVPin, QueryInternalConnections);
 243     SETVTBL(vtbl, libAVPin, EndOfStream);
 244     SETVTBL(vtbl, libAVPin, BeginFlush);
 245     SETVTBL(vtbl, libAVPin, EndFlush);
 246     SETVTBL(vtbl, libAVPin, NewSegment);
 247
 248     this->filter = filter;
 249
 250     return 1;
 251 }
 252
 253 static void
 254 libAVPin_Free(libAVPin *this)
 255 {
 256     if (!this)
 257         return;
 258     av_freep(&this->imemvtbl);
 259     if (this->type.pbFormat) {
 260         CoTaskMemFree(this->type.pbFormat);
 261         this->type.pbFormat = NULL;
 262     }
 263 }
 264 DECLARE_CREATE(libAVPin, libAVPin_Setup(this, filter), libAVFilter *filter)
 265 DECLARE_DESTROY(libAVPin, libAVPin_Free)
 266
 267 /*****************************************************************************
 268  * libAVMemInputPin
 269  ****************************************************************************/
 270 long WINAPI
 271 libAVMemInputPin_QueryInterface(libAVMemInputPin *this, const GUID *riid,
 272                                 void **ppvObject)
 273 {
 274     libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset);
 275     dshowdebug("libAVMemInputPin_QueryInterface(%p)\n", this);
 276     return libAVPin_QueryInterface(pin, riid, ppvObject);
 277 }
 278 unsigned long WINAPI
 279 libAVMemInputPin_AddRef(libAVMemInputPin *this)
 280 {
 281     libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset);
 282     dshowdebug("libAVMemInputPin_AddRef(%p)\n", this);
 283     return libAVPin_AddRef(pin);
 284 }
 285 unsigned long WINAPI
 286 libAVMemInputPin_Release(libAVMemInputPin *this)
 287 {
 288     libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset);
 289     dshowdebug("libAVMemInputPin_Release(%p)\n", this);
 290     return libAVPin_Release(pin);
 291 }
 292 long WINAPI
 293 libAVMemInputPin_GetAllocator(libAVMemInputPin *this, IMemAllocator **alloc)
 294 {
 295     dshowdebug("libAVMemInputPin_GetAllocator(%p)\n", this);
 296     return VFW_E_NO_ALLOCATOR;
 297 }
 298 long WINAPI
 299 libAVMemInputPin_NotifyAllocator(libAVMemInputPin *this, IMemAllocator *alloc,
 300                                  BOOL rdwr)
 301 {
 302     dshowdebug("libAVMemInputPin_NotifyAllocator(%p)\n", this);
 303     return S_OK;
 304 }
 305 long WINAPI
 306 libAVMemInputPin_GetAllocatorRequirements(libAVMemInputPin *this,
 307                                           ALLOCATOR_PROPERTIES *props)
 308 {
 309     dshowdebug("libAVMemInputPin_GetAllocatorRequirements(%p)\n", this);
 310     return E_NOTIMPL;
 311 }
 312 long WINAPI
 313 libAVMemInputPin_Receive(libAVMemInputPin *this, IMediaSample *sample)
 314 {
 315     libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset);
 316     enum dshowDeviceType devtype = pin->filter->type;
 317     void *priv_data;
 318     AVFormatContext *s;
 319     uint8_t *buf;
 320     int buf_size; /* todo should be a long? */
 321     int index;
 322     int64_t curtime;
 323     int64_t orig_curtime;
 324     int64_t graphtime;
 325     const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
 326     IReferenceClock *clock = pin->filter->clock;
 327     int64_t dummy;
 328     struct dshow_ctx *ctx;
 329
 330
 331     dshowdebug("libAVMemInputPin_Receive(%p)\n", this);
 332
 333     if (!sample)
 334         return E_POINTER;
 335
 336     IMediaSample_GetTime(sample, &orig_curtime, &dummy);
 337     orig_curtime += pin->filter->start_time;
 338     IReferenceClock_GetTime(clock, &graphtime);
 339     if (devtype == VideoDevice) {
 340         /* PTS from video devices is unreliable. */
 341         IReferenceClock_GetTime(clock, &curtime);
 342     } else {
 343         IMediaSample_GetTime(sample, &curtime, &dummy);
 344         if(curtime > 400000000000000000LL) {
 345             /* initial frames sometimes start < 0 (shown as a very large number here,
 346                like 437650244077016960 which FFmpeg doesn't like.
 347                TODO figure out math. For now just drop them. */
 348             av_log(NULL, AV_LOG_DEBUG,
 349                 "dshow dropping initial (or ending) audio frame with odd PTS too high %"PRId64"\n", curtime);
 350             return S_OK;
 351         }
 352         curtime += pin->filter->start_time;
 353     }
 354
 355     buf_size = IMediaSample_GetActualDataLength(sample);
 356     IMediaSample_GetPointer(sample, &buf);
 357     priv_data = pin->filter->priv_data;
 358     s = priv_data;
 359     ctx = s->priv_data;
 360     index = pin->filter->stream_index;
 361
 362     av_log(NULL, AV_LOG_VERBOSE, "dshow passing through packet of type %s size %8d "
 363         "timestamp %"PRId64" orig timestamp %"PRId64" graph timestamp %"PRId64" diff %"PRId64" %s\n",
 364         devtypename, buf_size, curtime, orig_curtime, graphtime, graphtime - orig_curtime, ctx->device_name[devtype]);
 365     pin->filter->callback(priv_data, index, buf, buf_size, curtime, devtype);
 366
 367     return S_OK;
 368 }
 369 long WINAPI
 370 libAVMemInputPin_ReceiveMultiple(libAVMemInputPin *this,
 371                                  IMediaSample **samples, long n, long *nproc)
 372 {
 373     int i;
 374     dshowdebug("libAVMemInputPin_ReceiveMultiple(%p)\n", this);
 375
 376     for (i = 0; i < n; i++)
 377         libAVMemInputPin_Receive(this, samples[i]);
 378
 379     *nproc = n;
 380     return S_OK;
 381 }
 382 long WINAPI
 383 libAVMemInputPin_ReceiveCanBlock(libAVMemInputPin *this)
 384 {
 385     dshowdebug("libAVMemInputPin_ReceiveCanBlock(%p)\n", this);
 386     /* I swear I will not block. */
 387     return S_FALSE;
 388 }
 389
 390 void
 391 libAVMemInputPin_Destroy(libAVMemInputPin *this)
 392 {
 393     libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset);
 394     dshowdebug("libAVMemInputPin_Destroy(%p)\n", this);
 395     libAVPin_Destroy(pin);
 396 }