0,0 → 1,362 |
/* |
* DirectShow capture interface |
* Copyright (c) 2010 Ramiro Polla |
* |
* This file is part of FFmpeg. |
* |
* FFmpeg is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* FFmpeg is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with FFmpeg; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
*/ |
|
#include "dshow_capture.h" |
|
#include <stddef.h> |
#define imemoffset offsetof(libAVPin, imemvtbl) |
|
DECLARE_QUERYINTERFACE(libAVPin, |
{ {&IID_IUnknown,0}, {&IID_IPin,0}, {&IID_IMemInputPin,imemoffset} }) |
DECLARE_ADDREF(libAVPin) |
DECLARE_RELEASE(libAVPin) |
|
long WINAPI |
libAVPin_Connect(libAVPin *this, IPin *pin, const AM_MEDIA_TYPE *type) |
{ |
dshowdebug("libAVPin_Connect(%p, %p, %p)\n", this, pin, type); |
/* Input pins receive connections. */ |
return S_FALSE; |
} |
long WINAPI |
libAVPin_ReceiveConnection(libAVPin *this, IPin *pin, |
const AM_MEDIA_TYPE *type) |
{ |
enum dshowDeviceType devtype = this->filter->type; |
dshowdebug("libAVPin_ReceiveConnection(%p)\n", this); |
|
if (!pin) |
return E_POINTER; |
if (this->connectedto) |
return VFW_E_ALREADY_CONNECTED; |
|
ff_print_AM_MEDIA_TYPE(type); |
if (devtype == VideoDevice) { |
if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Video)) |
return VFW_E_TYPE_NOT_ACCEPTED; |
} else { |
if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio)) |
return VFW_E_TYPE_NOT_ACCEPTED; |
} |
|
IPin_AddRef(pin); |
this->connectedto = pin; |
|
ff_copy_dshow_media_type(&this->type, type); |
|
return S_OK; |
} |
long WINAPI |
libAVPin_Disconnect(libAVPin *this) |
{ |
dshowdebug("libAVPin_Disconnect(%p)\n", this); |
|
if (this->filter->state != State_Stopped) |
return VFW_E_NOT_STOPPED; |
if (!this->connectedto) |
return S_FALSE; |
IPin_Release(this->connectedto); |
this->connectedto = NULL; |
|
return S_OK; |
} |
long WINAPI |
libAVPin_ConnectedTo(libAVPin *this, IPin **pin) |
{ |
dshowdebug("libAVPin_ConnectedTo(%p)\n", this); |
|
if (!pin) |
return E_POINTER; |
if (!this->connectedto) |
return VFW_E_NOT_CONNECTED; |
IPin_AddRef(this->connectedto); |
*pin = this->connectedto; |
|
return S_OK; |
} |
long WINAPI |
libAVPin_ConnectionMediaType(libAVPin *this, AM_MEDIA_TYPE *type) |
{ |
dshowdebug("libAVPin_ConnectionMediaType(%p)\n", this); |
|
if (!type) |
return E_POINTER; |
if (!this->connectedto) |
return VFW_E_NOT_CONNECTED; |
|
return ff_copy_dshow_media_type(type, &this->type); |
} |
long WINAPI |
libAVPin_QueryPinInfo(libAVPin *this, PIN_INFO *info) |
{ |
dshowdebug("libAVPin_QueryPinInfo(%p)\n", this); |
|
if (!info) |
return E_POINTER; |
|
if (this->filter) |
libAVFilter_AddRef(this->filter); |
|
info->pFilter = (IBaseFilter *) this->filter; |
info->dir = PINDIR_INPUT; |
wcscpy(info->achName, L"Capture"); |
|
return S_OK; |
} |
long WINAPI |
libAVPin_QueryDirection(libAVPin *this, PIN_DIRECTION *dir) |
{ |
dshowdebug("libAVPin_QueryDirection(%p)\n", this); |
if (!dir) |
return E_POINTER; |
*dir = PINDIR_INPUT; |
return S_OK; |
} |
long WINAPI |
libAVPin_QueryId(libAVPin *this, wchar_t **id) |
{ |
dshowdebug("libAVPin_QueryId(%p)\n", this); |
|
if (!id) |
return E_POINTER; |
|
*id = wcsdup(L"libAV Pin"); |
|
return S_OK; |
} |
long WINAPI |
libAVPin_QueryAccept(libAVPin *this, const AM_MEDIA_TYPE *type) |
{ |
dshowdebug("libAVPin_QueryAccept(%p)\n", this); |
return S_FALSE; |
} |
long WINAPI |
libAVPin_EnumMediaTypes(libAVPin *this, IEnumMediaTypes **enumtypes) |
{ |
const AM_MEDIA_TYPE *type = NULL; |
libAVEnumMediaTypes *new; |
dshowdebug("libAVPin_EnumMediaTypes(%p)\n", this); |
|
if (!enumtypes) |
return E_POINTER; |
new = libAVEnumMediaTypes_Create(type); |
if (!new) |
return E_OUTOFMEMORY; |
|
*enumtypes = (IEnumMediaTypes *) new; |
return S_OK; |
} |
long WINAPI |
libAVPin_QueryInternalConnections(libAVPin *this, IPin **pin, |
unsigned long *npin) |
{ |
dshowdebug("libAVPin_QueryInternalConnections(%p)\n", this); |
return E_NOTIMPL; |
} |
long WINAPI |
libAVPin_EndOfStream(libAVPin *this) |
{ |
dshowdebug("libAVPin_EndOfStream(%p)\n", this); |
/* I don't care. */ |
return S_OK; |
} |
long WINAPI |
libAVPin_BeginFlush(libAVPin *this) |
{ |
dshowdebug("libAVPin_BeginFlush(%p)\n", this); |
/* I don't care. */ |
return S_OK; |
} |
long WINAPI |
libAVPin_EndFlush(libAVPin *this) |
{ |
dshowdebug("libAVPin_EndFlush(%p)\n", this); |
/* I don't care. */ |
return S_OK; |
} |
long WINAPI |
libAVPin_NewSegment(libAVPin *this, REFERENCE_TIME start, REFERENCE_TIME stop, |
double rate) |
{ |
dshowdebug("libAVPin_NewSegment(%p)\n", this); |
/* I don't care. */ |
return S_OK; |
} |
|
static int |
libAVPin_Setup(libAVPin *this, libAVFilter *filter) |
{ |
IPinVtbl *vtbl = this->vtbl; |
IMemInputPinVtbl *imemvtbl; |
|
if (!filter) |
return 0; |
|
imemvtbl = av_malloc(sizeof(IMemInputPinVtbl)); |
if (!imemvtbl) |
return 0; |
|
SETVTBL(imemvtbl, libAVMemInputPin, QueryInterface); |
SETVTBL(imemvtbl, libAVMemInputPin, AddRef); |
SETVTBL(imemvtbl, libAVMemInputPin, Release); |
SETVTBL(imemvtbl, libAVMemInputPin, GetAllocator); |
SETVTBL(imemvtbl, libAVMemInputPin, NotifyAllocator); |
SETVTBL(imemvtbl, libAVMemInputPin, GetAllocatorRequirements); |
SETVTBL(imemvtbl, libAVMemInputPin, Receive); |
SETVTBL(imemvtbl, libAVMemInputPin, ReceiveMultiple); |
SETVTBL(imemvtbl, libAVMemInputPin, ReceiveCanBlock); |
|
this->imemvtbl = imemvtbl; |
|
SETVTBL(vtbl, libAVPin, QueryInterface); |
SETVTBL(vtbl, libAVPin, AddRef); |
SETVTBL(vtbl, libAVPin, Release); |
SETVTBL(vtbl, libAVPin, Connect); |
SETVTBL(vtbl, libAVPin, ReceiveConnection); |
SETVTBL(vtbl, libAVPin, Disconnect); |
SETVTBL(vtbl, libAVPin, ConnectedTo); |
SETVTBL(vtbl, libAVPin, ConnectionMediaType); |
SETVTBL(vtbl, libAVPin, QueryPinInfo); |
SETVTBL(vtbl, libAVPin, QueryDirection); |
SETVTBL(vtbl, libAVPin, QueryId); |
SETVTBL(vtbl, libAVPin, QueryAccept); |
SETVTBL(vtbl, libAVPin, EnumMediaTypes); |
SETVTBL(vtbl, libAVPin, QueryInternalConnections); |
SETVTBL(vtbl, libAVPin, EndOfStream); |
SETVTBL(vtbl, libAVPin, BeginFlush); |
SETVTBL(vtbl, libAVPin, EndFlush); |
SETVTBL(vtbl, libAVPin, NewSegment); |
|
this->filter = filter; |
|
return 1; |
} |
DECLARE_CREATE(libAVPin, libAVPin_Setup(this, filter), libAVFilter *filter) |
DECLARE_DESTROY(libAVPin, nothing) |
|
/***************************************************************************** |
* libAVMemInputPin |
****************************************************************************/ |
long WINAPI |
libAVMemInputPin_QueryInterface(libAVMemInputPin *this, const GUID *riid, |
void **ppvObject) |
{ |
libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset); |
dshowdebug("libAVMemInputPin_QueryInterface(%p)\n", this); |
return libAVPin_QueryInterface(pin, riid, ppvObject); |
} |
unsigned long WINAPI |
libAVMemInputPin_AddRef(libAVMemInputPin *this) |
{ |
libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset); |
dshowdebug("libAVMemInputPin_AddRef(%p)\n", this); |
return libAVPin_AddRef(pin); |
} |
unsigned long WINAPI |
libAVMemInputPin_Release(libAVMemInputPin *this) |
{ |
libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset); |
dshowdebug("libAVMemInputPin_Release(%p)\n", this); |
return libAVPin_Release(pin); |
} |
long WINAPI |
libAVMemInputPin_GetAllocator(libAVMemInputPin *this, IMemAllocator **alloc) |
{ |
dshowdebug("libAVMemInputPin_GetAllocator(%p)\n", this); |
return VFW_E_NO_ALLOCATOR; |
} |
long WINAPI |
libAVMemInputPin_NotifyAllocator(libAVMemInputPin *this, IMemAllocator *alloc, |
BOOL rdwr) |
{ |
dshowdebug("libAVMemInputPin_NotifyAllocator(%p)\n", this); |
return S_OK; |
} |
long WINAPI |
libAVMemInputPin_GetAllocatorRequirements(libAVMemInputPin *this, |
ALLOCATOR_PROPERTIES *props) |
{ |
dshowdebug("libAVMemInputPin_GetAllocatorRequirements(%p)\n", this); |
return E_NOTIMPL; |
} |
long WINAPI |
libAVMemInputPin_Receive(libAVMemInputPin *this, IMediaSample *sample) |
{ |
libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset); |
enum dshowDeviceType devtype = pin->filter->type; |
void *priv_data; |
uint8_t *buf; |
int buf_size; |
int index; |
int64_t curtime; |
|
dshowdebug("libAVMemInputPin_Receive(%p)\n", this); |
|
if (!sample) |
return E_POINTER; |
|
if (devtype == VideoDevice) { |
/* PTS from video devices is unreliable. */ |
IReferenceClock *clock = pin->filter->clock; |
IReferenceClock_GetTime(clock, &curtime); |
} else { |
int64_t dummy; |
IMediaSample_GetTime(sample, &curtime, &dummy); |
curtime += pin->filter->start_time; |
} |
|
buf_size = IMediaSample_GetActualDataLength(sample); |
IMediaSample_GetPointer(sample, &buf); |
priv_data = pin->filter->priv_data; |
index = pin->filter->stream_index; |
|
pin->filter->callback(priv_data, index, buf, buf_size, curtime); |
|
return S_OK; |
} |
long WINAPI |
libAVMemInputPin_ReceiveMultiple(libAVMemInputPin *this, |
IMediaSample **samples, long n, long *nproc) |
{ |
int i; |
dshowdebug("libAVMemInputPin_ReceiveMultiple(%p)\n", this); |
|
for (i = 0; i < n; i++) |
libAVMemInputPin_Receive(this, samples[i]); |
|
*nproc = n; |
return S_OK; |
} |
long WINAPI |
libAVMemInputPin_ReceiveCanBlock(libAVMemInputPin *this) |
{ |
dshowdebug("libAVMemInputPin_ReceiveCanBlock(%p)\n", this); |
/* I swear I will not block. */ |
return S_FALSE; |
} |
|
void |
libAVMemInputPin_Destroy(libAVMemInputPin *this) |
{ |
libAVPin *pin = (libAVPin *) ((uint8_t *) this - imemoffset); |
dshowdebug("libAVMemInputPin_Destroy(%p)\n", this); |
libAVPin_Destroy(pin); |
} |