HRESULT CTMReceiverOutputPin::GetMediaType(CMediaType *pmt){
VIDEOINFO* pvih = (VIDEOINFO*)pmt->AllocFormatBuffer(sizeof(VIDEOINFO));
LPBITMAPINFOHEADER lpBitmapInfoHeader = &(pvih->bmiHeader);
lpBitmapInfoHeader->biSize = sizeof(BITMAPINFOHEADER);
lpBitmapInfoHeader->biBitCount = 32;
lpBitmapInfoHeader->biWidth = ((CTMReceiverSrc *)m_pFilter)->GetImageWidth()/4*4;
lpBitmapInfoHeader->biHeight = ((CTMReceiverSrc *)m_pFilter)->GetImageHeight();
lpBitmapInfoHeader->biPlanes = 1;
lpBitmapInfoHeader->biCompression = BI_RGB;
lpBitmapInfoHeader->biSizeImage = ((CTMReceiverSrc *)m_pFilter)->GetImageWidth() / 4 * 4 * ((CTMReceiverSrc *)m_pFilter)->GetImageHeight() * 4;
lpBitmapInfoHeader->biXPelsPerMeter = 0;
lpBitmapInfoHeader->biYPelsPerMeter =0;
lpBitmapInfoHeader->biClrUsed = 0;
lpBitmapInfoHeader->biClrImportant = 0;
pvih->AvgTimePerFrame = m_rtAvgTimePerFrame;
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
SetRectEmpty(&(pvih->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvih->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvih->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetSampleSize(pvih->bmiHeader.biSizeImage);
return S_OK;
}
// LJ version for one media type
//
// GetMediaType: This method tells the downstream pin what types we support.
//
// Here is how CSourceStream deals with media types:
//
// If you support exactly one type, override GetMediaType(CMediaType*). It will then be
// called when
// (a) our filter proposes a media type,
// (b) the other filter proposes a type and we have to check that type.
//
// If you support > 1 type, override GetMediaType(int,CMediaType*) AND CheckMediaType.
//
// In this case we support only one type, which we obtain from the bitmap.
//
// Can be called repeatedly
//
HRESULT CVCamStream::GetMediaType(CMediaType *pmt)
{
unsigned int width, height;
if(pmt == NULL) {
return E_POINTER;
}
DECLARE_PTR(VIDEOINFOHEADER, pvi, pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER)));
ZeroMemory(pvi, sizeof(VIDEOINFOHEADER));
// Allow for default as well as width and height of memory share image
if(g_Width == 0 || g_Height == 0) {
width = 320;
height = 240;
}
else {
// as per sending app
width = g_Width;
height = g_Height;
}
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = (LONG)width;
pvi->bmiHeader.biHeight = (LONG)height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biCompression = 0;
pvi->bmiHeader.biSizeImage = 0; // default
// pvi->bmiHeader.biXPelsPerMeter = 0; // default
// pvi->bmiHeader.biYPelsPerMeter = 0; // default
// pvi->bmiHeader.biClrUsed = 0;
pvi->bmiHeader.biClrImportant = 0;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
// The desired average display time of the video frames, in 100-nanosecond units.
// 60fps = 166667
// 30fps = 333333
pvi->AvgTimePerFrame = 166667; // 60fps
// pvi->AvgTimePerFrame = 200000; // 50fps
// pvi->AvgTimePerFrame = 333333; // 30fps
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(false);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetVariableSize(); // LJ - to be checked
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
return NOERROR;
}
// See Directshow help topic for IAMStreamConfig for details on this method
HRESULT CKCamStream::GetMediaType(int iPosition, CMediaType *pmt)
{
DbgLog((LOG_TRACE, 1, "GetMediaType (iPosition = %d)", iPosition));
if (!m_device)
return E_FAIL;
if (iPosition < 0) return E_INVALIDARG;
if (iPosition > m_device->video_resolution_count()) return VFW_S_NO_MORE_ITEMS;
if (iPosition == 0)
{
// return the default (preferred) resolution
*pmt = m_mt;
return S_OK; // exit !!!
}
// check the device for information of this resolution
auto f_devres = m_device->video_resolution(iPosition - 1);
// fill in the VIDEOINFO_HEADER
DECLARE_PTR(VIDEOINFOHEADER, pvi, pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER)));
ZeroMemory(pvi, sizeof(VIDEOINFOHEADER));
pvi->bmiHeader.biCompression = CompressionFromPixelFormat(f_devres.m_pixel_format);
pvi->bmiHeader.biBitCount = f_devres.m_bits_per_pixel;
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = f_devres.m_width;
pvi->bmiHeader.biHeight = f_devres.m_height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
pvi->AvgTimePerFrame = FrameIntervalFromRate(f_devres.m_framerate);
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
DbgLog((LOG_TRACE, 1, "GetMediaType (iPosition = %d) <= %d x %d x %d", iPosition, pvi->bmiHeader.biWidth, pvi->bmiHeader.biHeight, pvi->bmiHeader.biBitCount));
return S_OK;
}
// See Directshow help topic for IAMStreamConfig for details on this method
HRESULT UVCamStream::GetMediaType(int iPosition, CMediaType *pmt)
{
CheckPointer(pmt,E_POINTER);
CAutoLock cAutoLock(m_pFilter->pStateLock());
if(iPosition < 0) return E_INVALIDARG;
if(iPosition > 8) return VFW_S_NO_MORE_ITEMS;
if(iPosition == 0)
{
*pmt = m_mt;
return S_OK;
}
DECLARE_PTR(VIDEOINFOHEADER, pvi, pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER)));
ZeroMemory(pvi, sizeof(VIDEOINFOHEADER));
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = 80 * iPosition;
pvi->bmiHeader.biHeight = 60 * iPosition;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
pvi->AvgTimePerFrame = 1000000;
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
return NOERROR;
} // GetMediaType
HRESULT CPushPinBitmapSet::GetMediaType(CMediaType *pMediaType)
{
CAutoLock cAutoLock(m_pFilter->pStateLock());
CheckPointer(pMediaType, E_POINTER);
// If the bitmap files were not loaded, just fail here.
if (!m_bFilesLoaded)
return E_FAIL;
// Allocate enough room for the VIDEOINFOHEADER and the color tables
VIDEOINFOHEADER *pvi =
(VIDEOINFOHEADER*)pMediaType->AllocFormatBuffer(SIZE_PREHEADER +
m_cbBitmapInfo[m_iCurrentBitmap]);
if (pvi == 0)
return(E_OUTOFMEMORY);
// Initialize the video info header
ZeroMemory(pvi, pMediaType->cbFormat);
pvi->AvgTimePerFrame = m_rtFrameLength;
// Copy the header info from the current bitmap
memcpy(&(pvi->bmiHeader), m_pBmi[m_iCurrentBitmap], m_cbBitmapInfo[m_iCurrentBitmap]);
// Set image size for use in FillBuffer
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
// Clear source and target rectangles
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pMediaType->SetType(&MEDIATYPE_Video);
pMediaType->SetFormatType(&FORMAT_VideoInfo);
pMediaType->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pMediaType->SetSubtype(&SubTypeGUID);
pMediaType->SetSampleSize(pvi->bmiHeader.biSizeImage);
return S_OK;
}
//
// GetMediaType
//
// Prefer 5 formats - 8, 16 (*2), 24 or 32 bits per pixel
//
// Prefered types should be ordered by quality, with zero as highest quality.
// Therefore, iPosition =
// 0 Return a 24bit mediatype "as the default" since I guessed it might be faster though who knows
// 1 Return a 24bit mediatype
// 2 Return 16bit RGB565
// 3 Return a 16bit mediatype (rgb555)
// 4 Return 8 bit palettised format
// >4 Invalid
// except that we changed the orderings a bit...
//
HRESULT CPushPinDesktop::GetMediaType(int iPosition, CMediaType *pmt) // AM_MEDIA_TYPE basically == CMediaType
{
CheckPointer(pmt, E_POINTER);
CAutoLock cAutoLock(m_pFilter->pStateLock());
if(m_bFormatAlreadySet) {
// you can only have one option, buddy, if setFormat already called. (see SetFormat's msdn)
if(iPosition != 0)
return E_INVALIDARG;
VIDEOINFO *pvi = (VIDEOINFO *) m_mt.Format();
// Set() copies these in for us pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader); // calculates the size for us, after we gave it the width and everything else we already chucked into it
// pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
// nobody uses sample size anyway :P
pmt->Set(m_mt);
VIDEOINFOHEADER *pVih1 = (VIDEOINFOHEADER*) m_mt.pbFormat;
VIDEOINFO *pviHere = (VIDEOINFO *) pmt->pbFormat;
return S_OK;
}
// do we ever even get past here? hmm
if(iPosition < 0)
return E_INVALIDARG;
// Have we run out of types?
if(iPosition > 6)
return VFW_S_NO_MORE_ITEMS;
VIDEOINFO *pvi = (VIDEOINFO *) pmt->AllocFormatBuffer(sizeof(VIDEOINFO));
if(NULL == pvi)
return(E_OUTOFMEMORY);
// Initialize the VideoInfo structure before configuring its members
ZeroMemory(pvi, sizeof(VIDEOINFO));
if(iPosition == 0) {
// pass it our "preferred" which is 16 bits...I guess...haven't really researched it, but do want it to have a consistent default.
iPosition = 3;
// 32 -> 24 (2): getdibits took 2.251ms
// 32 -> 32 (1): getdibits took 2.916ms
// except those numbers might be misleading in terms of total speed...hmm...
}
switch(iPosition)
{
case 1:
{
// 32bit format
// Since we use RGB888 (the default for 32 bit), there is
// no reason to use BI_BITFIELDS to specify the RGB
// masks [sometimes even if you don't have enough bits you don't need to anyway?]
// Also, not everything supports BI_BITFIELDS ...
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 32;
break;
}
case 2:
{ // Return our 24bit format, same as above comments
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
break;
}
case 3:
{
// 16 bit per pixel RGB565 BI_BITFIELDS
// Place the RGB masks as the first 3 doublewords in the palette area
for(int i = 0; i < 3; i++)
pvi->TrueColorInfo.dwBitMasks[i] = bits565[i];
pvi->bmiHeader.biCompression = BI_BITFIELDS;
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 16;
break;
}
case 4:
{ // 16 bits per pixel RGB555
// Place the RGB masks as the first 3 doublewords in the palette area
for(int i = 0; i < 3; i++)
pvi->TrueColorInfo.dwBitMasks[i] = bits555[i];
// LODO ??? need? not need? BI_BITFIELDS? Or is this the default so we don't need it? Or do we need a different type that doesn't specify BI_BITFIELDS?
pvi->bmiHeader.biCompression = BI_BITFIELDS;
pvi->bmiHeader.biBitCount = 16;
break;
}
case 5:
{ // 8 bit palettised
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 8;
pvi->bmiHeader.biClrUsed = iPALETTE_COLORS;
break;
}
case 6:
{ // the i420 freak-o
pvi->bmiHeader.biCompression = FOURCC_I420; // who knows if this is right LOL
pvi->bmiHeader.biBitCount = 12;
pvi->bmiHeader.biSizeImage = (getCaptureDesiredFinalWidth()*getCaptureDesiredFinalHeight()*3)/2;
pmt->SetSubtype(&WMMEDIASUBTYPE_I420);
break;
}
}
// Now adjust some parameters that are the same for all formats
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = getCaptureDesiredFinalWidth();
pvi->bmiHeader.biHeight = getCaptureDesiredFinalHeight();
pvi->bmiHeader.biPlanes = 1;
if(pvi->bmiHeader.biSizeImage == 0)
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader); // calculates the size for us, after we gave it the width and everything else we already chucked into it
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage); // use the above size
pvi->bmiHeader.biClrImportant = 0;
pvi->AvgTimePerFrame = m_rtFrameLength; // from our config or default
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
if(*pmt->Subtype() == GUID_NULL) {
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
}
return NOERROR;
} // GetMediaType
//
// GetMediaType
//
// Prefer 5 formats - 8, 16 (*2), 24 or 32 bits per pixel
//
// Prefered types should be ordered by quality, with zero as highest quality.
// Therefore, iPosition =
// 0 Return a 32bit mediatype
// 1 Return a 24bit mediatype
// 2 Return 16bit RGB565
// 3 Return a 16bit mediatype (rgb555)
// 4 Return 8 bit palettised format
// >4 Invalid
// except that we changed the orderings a bit...
//
HRESULT CPushPinDesktop::GetMediaType(int iPosition, CMediaType *pmt) // AM_MEDIA_TYPE basically == CMediaType
{
CheckPointer(pmt, E_POINTER);
CAutoLock cAutoLock(m_pFilter->pStateLock());
if(formatAlreadySet) {
if(iPosition != 0)
return E_INVALIDARG;
// you only have one option, buddy. (see SetFormat's msdn)
pmt->Set(m_mt);
VIDEOINFOHEADER *pVih1 = (VIDEOINFOHEADER*)m_mt.pbFormat; // right ...
VIDEOINFO *pviHere = (VIDEOINFO *) pmt->pbFormat;
return S_OK;
}
if(iPosition < 0)
return E_INVALIDARG;
// Have we run off the end of types?
if(iPosition > 5)
return VFW_S_NO_MORE_ITEMS;
VIDEOINFO *pvi = (VIDEOINFO *) pmt->AllocFormatBuffer(sizeof(VIDEOINFO));
if(NULL == pvi)
return(E_OUTOFMEMORY);
// Initialize the VideoInfo structure before configuring its members
ZeroMemory(pvi, sizeof(VIDEOINFO));
if(iPosition == 0) {
// pass it our "preferred" which is unchanged pixel format
switch(m_iScreenBitRate)
{
case 24:
iPosition = 2;
break;
case 16:
iPosition = 2;//1;// 3; both fail in ffmpeg <sigh>. //2 -> 24 bit
// iPosition = 1; // 32 bit possibly better...
// 32 -> 24: getdibits took 2.251000ms
// 32 -> 32: getdibits took 2.916480ms
// except those numbers might be misleading...
break;
case 15:
//iPosition = 4; //fear of crashing ffmpeg remains in my heart...
iPosition = 2;
break;
case 8:
iPosition = 5;
break;
case 32:
iPosition = 2; // 32 -> 24 bit, figure since I'm already doing a conversion, might as well lose a few unused bits...
break;
default: // our high quality 32-bit, but we really should never get to the default option now...
iPosition = 1;
break;
}
}
switch(iPosition)
{
case 1:
{
// Return our highest quality 32bit format
// Since we use RGB888 (the default for 32 bit), there is
// no reason to use BI_BITFIELDS to specify the RGB
// masks. Also, not everything supports BI_BITFIELDS
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 32;
break;
}
case 2:
{ // Return our 24bit format, same as above.
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
break;
}
case 3:
{
// 16 bit per pixel RGB565 BI_BITFIELDS
// Place the RGB masks as the first 3 doublewords in the palette area
for(int i = 0; i < 3; i++)
pvi->TrueColorInfo.dwBitMasks[i] = bits565[i];
// LODO research this...does it come from the machine with...it set, or not?
// pvi->bmiHeader.biCompression = BI_BITFIELDS;
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 16;
break;
}
case 4:
{ // 16 bits per pixel RGB555
// Place the RGB masks as the first 3 doublewords in the palette area
for(int i = 0; i < 3; i++)
pvi->TrueColorInfo.dwBitMasks[i] = bits555[i];
// LODO
// pvi->bmiHeader.biCompression = BI_BITFIELDS;
pvi->bmiHeader.biBitCount = 16;
break;
}
case 5:
{ // 8 bit palettised
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 8;
pvi->bmiHeader.biClrUsed = iPALETTE_COLORS;
break;
}
}
// Adjust the parameters common to all formats
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = m_iImageWidth;
pvi->bmiHeader.biHeight = m_iImageHeight;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
pvi->AvgTimePerFrame = m_rtFrameLength; // hard set currently...
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
return NOERROR;
} // GetMediaType
//
// GetMediaType
//
// Prefer 5 formats - 8, 16 (*2), 24 or 32 bits per pixel
//
// Prefered types should be ordered by quality, with zero as highest quality.
// Therefore, iPosition =
// 0 Return a 32bit mediatype
// 1 Return a 24bit mediatype
// 2 Return 16bit RGB565
// 3 Return a 16bit mediatype (rgb555)
// 4 Return 8 bit palettised format
// >4 Invalid
//
HRESULT CVCamPin::GetMediaType(int iPosition, CMediaType *pmt)
{
CheckPointer(pmt,E_POINTER);
CAutoLock cAutoLock(m_pFilter->pStateLock());
if(iPosition < 0)
return E_INVALIDARG;
// Have we run off the end of types?
if(iPosition > 4)
return VFW_S_NO_MORE_ITEMS;
VIDEOINFO *pvi = (VIDEOINFO *) pmt->AllocFormatBuffer(sizeof(VIDEOINFO));
if(NULL == pvi)
return(E_OUTOFMEMORY);
// Initialize the VideoInfo structure before configuring its members
ZeroMemory(pvi, sizeof(VIDEOINFO));
switch(iPosition)
{
case 0:
{
// Return our highest quality 32bit format
// Since we use RGB888 (the default for 32 bit), there is
// no reason to use BI_BITFIELDS to specify the RGB
// masks. Also, not everything supports BI_BITFIELDS
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 32;
break;
}
case 1:
{ // Return our 24bit format
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
break;
}
case 2:
{
// 16 bit per pixel RGB565
// Place the RGB masks as the first 3 doublewords in the palette area
for(int i = 0; i < 3; i++)
pvi->TrueColorInfo.dwBitMasks[i] = bits565[i];
pvi->bmiHeader.biCompression = BI_BITFIELDS;
pvi->bmiHeader.biBitCount = 16;
break;
}
case 3:
{ // 16 bits per pixel RGB555
// Place the RGB masks as the first 3 doublewords in the palette area
for(int i = 0; i < 3; i++)
pvi->TrueColorInfo.dwBitMasks[i] = bits555[i];
pvi->bmiHeader.biCompression = BI_BITFIELDS;
pvi->bmiHeader.biBitCount = 16;
break;
}
case 4:
{ // 8 bit palettised
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 8;
pvi->bmiHeader.biClrUsed = iPALETTE_COLORS;
break;
}
}
// Adjust the parameters common to all formats
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = m_iImageWidth;
pvi->bmiHeader.biHeight = m_iImageHeight;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
return NOERROR;
} // GetMediaType
//返回这个Pin支持的媒体类型，框架会从iPosition为0递归调用进行检查，每次加1，直到返回错误(VFW_S_NO_MORE_ITEMS)
//本程序中支持以下几种媒体类型
// 0 -- 32bit mediatype
// 1 -- 24bit mediatype
HRESULT CScreenCaptureSourcePin::GetMediaType(int iPosition, CMediaType *pmt)
{
//FUNCTION_BLOCK_TRACE(1);
CheckPointer(pmt, E_POINTER);
if (iPosition < 0)
{
return E_INVALIDARG;
}
if (iPosition >= 2)
{
return VFW_S_NO_MORE_ITEMS;
}
CAutoLock(m_pFilter->pStateLock());
//VIDEO_STREAM_CONFIG_CAPS videoCaps = {0};
//GetDefaultCaps(0, &videoCaps);
//hr = m_pInput->ConnectionMediaType(pmt); //TransformFilter 时
//VIDEOINFO *pOldVideInfo = (VIDEOINFO *)pmt->Format();
VIDEOINFO *pvi = (VIDEOINFO*) pmt->AllocFormatBuffer(sizeof(VIDEOINFO));
if (NULL == pvi)
{
return (E_OUTOFMEMORY);
}
ZeroMemory(pvi, sizeof(VIDEOINFO));
switch(iPosition)
{
case 0:
{
// Return our highest quality 32bit format
// Since we use RGB888 (the default for 32 bit), there is
// no reason to use BI_BITFIELDS to specify the RGB
// masks. Also, not everything supports BI_BITFIELDS
//SetPaletteEntries(Yellow);
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 32;
break;
}
case 1:
{
// Return our 24bit format
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
break;
}
default:
FTLASSERT(FALSE);
break;
}
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = m_nWidth;
pvi->bmiHeader.biHeight = m_nHeight;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
pvi->AvgTimePerFrame = m_nAvgTimePerFrame;//
//pvi->rcSource = m_rcCapture;
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
return NOERROR;
}
HRESULT XnVideoStream::GetStreamCapability(int iIndex, CMediaType& mediaType, VIDEO_STREAM_CONFIG_CAPS& vscc)
{
// check bounds
if(iIndex < 0 || iIndex >= int(m_aSupportedModes.GetSize()))
{
xnLogVerbose(XN_MASK_FILTER, "GetStreamCapability() - Index %d is out of bounds!", iIndex);
return S_FALSE;
}
VIDEOINFO *pvi = (VIDEOINFO*)mediaType.AllocFormatBuffer(sizeof(VIDEOINFO));
if(NULL == pvi)
return(E_OUTOFMEMORY);
ZeroMemory(pvi, sizeof(VIDEOINFO));
int xRes = m_aSupportedModes[iIndex].OutputMode.nXRes;
int yRes = m_aSupportedModes[iIndex].OutputMode.nYRes;
XnUInt64 nFrameTime = 10000000 / m_aSupportedModes[iIndex].OutputMode.nFPS;
if (m_aSupportedModes[iIndex].Format == XN_PIXEL_FORMAT_RGB24)
{
pvi->bmiHeader.biCompression = BI_RGB;
}
else if (m_aSupportedModes[iIndex].Format == XN_PIXEL_FORMAT_MJPEG)
{
pvi->bmiHeader.biCompression = 'GPJM';
}
else
{
xnLogError(XN_MASK_FILTER, "Unknown format type!");
return E_UNEXPECTED;
}
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = xRes;
pvi->bmiHeader.biHeight = yRes;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pvi->dwBitRate =
GetBitmapSize(&pvi->bmiHeader) * // bytes per frame
m_aSupportedModes[iIndex].OutputMode.nFPS * // frames per second
8; // bits per byte
pvi->dwBitErrorRate = 0; // assume no errors
pvi->AvgTimePerFrame = nFrameTime;
mediaType.SetType(&MEDIATYPE_Video);
mediaType.SetFormatType(&FORMAT_VideoInfo);
mediaType.SetTemporalCompression(FALSE);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
mediaType.SetSubtype(&SubTypeGUID);
mediaType.SetSampleSize(pvi->bmiHeader.biSizeImage);
vscc.guid = FORMAT_VideoInfo;
vscc.VideoStandard = AnalogVideo_None;
vscc.InputSize.cx = xRes;
vscc.InputSize.cy = yRes;
vscc.MinCroppingSize.cx = xRes;
vscc.MinCroppingSize.cy = yRes;
vscc.MaxCroppingSize.cx = xRes;
vscc.MaxCroppingSize.cy = yRes;
vscc.CropGranularityX = 1;
vscc.CropGranularityY = 1;
vscc.CropAlignX = 1;
vscc.CropAlignY = 1;
vscc.MinOutputSize.cx = xRes;
vscc.MinOutputSize.cy = yRes;
vscc.MaxOutputSize.cx = xRes;
vscc.MaxOutputSize.cy = yRes;
vscc.OutputGranularityX = 1;
vscc.OutputGranularityY = 1;
vscc.StretchTapsX = 0;
vscc.StretchTapsY = 0;
vscc.ShrinkTapsX = 0;
vscc.ShrinkTapsY = 0;
// Frame interval is in 100 nanosecond units
vscc.MinFrameInterval = nFrameTime;
vscc.MaxFrameInterval = nFrameTime;
vscc.MinBitsPerSecond =
mediaType.GetSampleSize() * // bytes in frame
m_aSupportedModes[iIndex].OutputMode.nFPS * // frames per second
8; // bits per byte
vscc.MaxBitsPerSecond = vscc.MinBitsPerSecond;
return S_OK;
}
// See Directshow help topic for IAMStreamConfig for details on this method
HRESULT CVCamStream::GetMediaType(int iPosition, CMediaType *pmt)
{
unsigned int width, height;
if(iPosition < 0) {
return E_INVALIDARG;
}
if(iPosition > 8) { // TODO - needs work - only one position
return VFW_S_NO_MORE_ITEMS;
}
if(iPosition == 0) {
*pmt = m_mt;
return S_OK;
}
DECLARE_PTR(VIDEOINFOHEADER, pvi, pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER)));
ZeroMemory(pvi, sizeof(VIDEOINFOHEADER));
// Allow for default
if(g_Width == 0 || g_Height == 0) {
width = 640;
height = 480;
}
else {
// as per Spout sender received
width = g_Width;
height = g_Height;
}
// width = g_Width;
// height = g_Height;
// printf("GetMediaType [%d] (%dx%d)\n", iPosition, width, height);
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = (LONG)width;
pvi->bmiHeader.biHeight = (LONG)height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biCompression = 0; // defaults
pvi->bmiHeader.biSizeImage = 0;
pvi->bmiHeader.biClrImportant = 0;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
// The desired average display time of the video frames, in 100-nanosecond units.
// 60fps = 166667
// 30fps = 333333
pvi->AvgTimePerFrame = 166667; // 60fps
// pvi->AvgTimePerFrame = 200000; // 50fps
// pvi->AvgTimePerFrame = 333333; // 30fps
SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered.
SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
pmt->SetType(&MEDIATYPE_Video);
pmt->SetFormatType(&FORMAT_VideoInfo);
pmt->SetTemporalCompression(false);
// Work out the GUID for the subtype from the header info.
const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
pmt->SetSubtype(&SubTypeGUID);
pmt->SetVariableSize(); // LJ - to be checked
pmt->SetSampleSize(pvi->bmiHeader.biSizeImage);
return NOERROR;
} // GetMediaType
