DirectShow过滤器开发-YV12压缩过滤器

已于 2024-07-01 12:06:23 修改
阅读量285 收藏 8
点赞数 5
文章标签： 音视频 c++ windows
于 2024-06-29 19:45:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h3974/article/details/140068905
版权

下载本过滤器DLL
本过滤器将RGB32视频流压缩为YV12视频流。

YV12压缩过滤器信息

过滤器名称：YV12压缩
过滤器GUID：{689F6AE8-33D1-4856-AC1B-17B56D4EC274}
DLL注册函数名：DllRegisterServer
删除注册函数名：DllUnregisterServer
过滤器有1个输入引脚和1个输出引脚。

输入引脚标识：In
输入引脚媒体类型：
主要类型：MEDIATYPE_Video
子类型：MEDIASUBTYPE_RGB32
格式类型：FORMAT_VideoInfo或FORMAT_VideoInfo2
样本为固定大小。
样本为32位。

输出引脚标识：Out
输出引脚媒体类型：
主要类型：MEDIATYPE_Video
子类型：MEDIASUBTYPE_YV12
格式类型：FORMAT_VideoInfo或FORMAT_VideoInfo2
样本为固定大小。
不使用时间压缩。
样本为12位。

YV12压缩过滤器开发信息

读取RGB32引脚样本颜色值，将其转换为YUV颜色值，按YV12引脚样本存储方式，创建YV12引脚样本。
YV12引脚样本颜色值存储方式为：首先存储该帧图像的Y值，每个Y值占1字节，Y值占用的内存大小为一幅图像的像素的总数，等于图像的宽度乘以高度。Y值后面是该图像的所有V值，其后是所有U值，每个U或V占1字节。
只在像素处于偶数行和偶数列时，获取其VU值，忽略了4分之3像素的VU值。故V值占用的内存大小是一幅图像的像素总数的4分之1，U值占用的内存也为像素总数的4分之1。
在显示YV12图像时，在水平方向每两个像素共用一组相同的UV值，在垂直方向每4个像素共用一组UV。故，UV值是使用一行，忽略一行。将有一半的UV值不用于还原图像。

YV12压缩过滤器DLL的全部代码

DLL.h


#ifndef  DLL_FILE
#define DLL_FILE

#include "strmbase10.h"//过滤器基础类定义文件

#if _DEBUG
#pragma comment(lib, "strmbasd10.lib")//过滤器基础类实现文件调试版本
#else
#pragma comment(lib, "strmbase10.lib")//过滤器基础类实现文件发布版本
#endif


// {689F6AE8-33D1-4856-AC1B-17B56D4EC274}
DEFINE_GUID(CLSID_YV12Filter,//过滤器GUID
	0x689f6ae8, 0x33d1, 0x4856, 0xac, 0x1b, 0x17, 0xb5, 0x6d, 0x4e, 0xc2, 0x74);


class COutPin;
class CFilter;

class CInPin : public CBaseInputPin
{
	friend class COutPin;
	friend class CFilter;
public:
	CInPin(CFilter *pFilter, HRESULT *phr, LPCWSTR pPinName);
	~CInPin();
	HRESULT CheckMediaType(const CMediaType *pmt);
	HRESULT SetMediaType(const CMediaType *pmt);
	STDMETHODIMP Receive(IMediaSample *pSample);
	STDMETHODIMP EndOfStream();
	STDMETHODIMP BeginFlush();
	STDMETHODIMP EndFlush();
	STDMETHODIMP NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
	CFilter *pCFilter;
};

class COutPin : public CBaseOutputPin
{
	friend class CInPin;
	friend class CFilter;
	IUnknown   *m_pPosition = NULL;
	COutputQueue *m_pOutputQueue = NULL;//样本队列
public:
	COutPin(CFilter *pFilter, HRESULT *phr, LPCWSTR pPinName);
	~COutPin();
	STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void **ppvoid);
	HRESULT GetMediaType(int iPosition, CMediaType *pMediaType);
	HRESULT CheckMediaType(const CMediaType *pmt);
	HRESULT DecideBufferSize(IMemAllocator *pMemAllocator, ALLOCATOR_PROPERTIES * ppropInputRequest);
	HRESULT Active();
	HRESULT Inactive();
	HRESULT Deliver(IMediaSample *pMediaSample);
	HRESULT DeliverEndOfStream();
	HRESULT DeliverBeginFlush();
	HRESULT DeliverEndFlush();
	HRESULT DeliverNewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
	STDMETHODIMP Notify(IBaseFilter *pSender, Quality q);
	CFilter *pCFilter = NULL;
};

class CFilter : public CCritSec, public CBaseFilter
{
	friend class CInPin;
	friend class COutPin;
public:
	CFilter(TCHAR* pName, LPUNKNOWN pUnk, HRESULT* hr);
	~CFilter();
	CBasePin* GetPin(int n);
	int GetPinCount();
	static CUnknown* WINAPI CreateInstance(LPUNKNOWN pUnk, HRESULT* phr);
	CInPin* pCInPin = NULL;
	COutPin* pCOutPin = NULL;
	int width;//图像的宽度，单位像素
	int height;//图像的高度，单位像素
	int nFrame;//每秒帧数
	LONGLONG AvgTimePerFrame;//帧持续时间，单位100纳秒
};

template <class T> void SafeRelease(T** ppT)
{
	if (*ppT)
	{
		(*ppT)->Release();
		*ppT = NULL;
	}
}

#endif //DLL_FILE

DLL.cpp

#include "DLL.h"

const AMOVIESETUP_MEDIATYPE InPinType[] =   //输入引脚媒体类型
{
	{
		&MEDIATYPE_Video,                //主要类型
		&MEDIASUBTYPE_RGB32              //子类型
	}
};

const AMOVIESETUP_MEDIATYPE OutPinType[] =   //输出引脚媒体类型
{
	{
		&MEDIATYPE_Video,               //主要类型
		&MEDIASUBTYPE_YV12              //子类型
	}
};

const AMOVIESETUP_PIN sudPins[] =  // 引脚信息
{
	{
		L"In",                     //引脚名称
		FALSE,                     //渲染引脚
	    FALSE,                     //输出引脚
	    FALSE,                     //具有该引脚的零个实例
	    FALSE,                     //可以创建一个以上引脚的实例
	    &CLSID_NULL,               //该引脚连接的过滤器的类标识
	    NULL,                      //该引脚连接的引脚名称
	    1,                         //引脚支持的媒体类型数
	    InPinType                  //媒体类型信息
	},
	{
		L"Out",                    //引脚名称
		FALSE,                     //渲染引脚
	    TRUE,                      //输出引脚
	    FALSE,                     //具有该引脚的零个实例
	    FALSE,                     //可以创建一个以上引脚的实例
	    &CLSID_NULL,               //该引脚连接的过滤器的类标识
	    NULL,                      //该引脚连接的引脚名称
	    1,                         //引脚支持的媒体类型数
	    OutPinType                 //媒体类型信息
	}
};

const AMOVIESETUP_FILTER YV12_FILTER =  //过滤器的注册信息
{
	&CLSID_YV12Filter,            //过滤器的类标识
	L"YV12压缩",                  //过滤器的名称
	MERIT_DO_NOT_USE,             //过滤器优先值
	2,                            //引脚数量
	sudPins                       //引脚信息
};

CFactoryTemplate g_Templates[] =   //类工厂模板数组
{
	{
		L"YV12压缩",               //过滤器名称
		&CLSID_YV12Filter,         //过滤器CLSID的指针
	    CFilter::CreateInstance,   //创建过滤器实例的函数的指针
	    NULL,                      //指向从DLL入口点调用的函数的指针
	    &YV12_FILTER               //指向AMOVIESETUP_FILTER结构的指针
	}
};

int g_cTemplates = 1;//模板数组大小

STDAPI DllRegisterServer()//注册DLL
{
	return AMovieDllRegisterServer2(TRUE);
}

STDAPI DllUnregisterServer()//删除DLL注册
{
	return AMovieDllRegisterServer2(FALSE);
}

extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);

BOOL APIENTRY DllMain(HANDLE hModule, DWORD  dwReason, LPVOID lpReserved)
{
	return DllEntryPoint((HINSTANCE)(hModule), dwReason, lpReserved);
}

CFilter.cpp

#include "DLL.h"

CFilter::CFilter(TCHAR *pName, LPUNKNOWN pUnk, HRESULT *phr) : CBaseFilter(NAME("YV12压缩"), pUnk, this, CLSID_YV12Filter)
{
	pCInPin = new CInPin(this, phr, L"In");//创建输入引脚
	pCOutPin = new COutPin(this, phr, L"Out");//创建输出引脚
}

CFilter::~CFilter()
{

}

CBasePin *CFilter::GetPin(int n)
{
	if (n == 0)return pCInPin;
	if (n == 1)return pCOutPin;
	return NULL;
}

int CFilter::GetPinCount()
{
	return 2;
}

CUnknown * WINAPI CFilter::CreateInstance(LPUNKNOWN pUnk, HRESULT *phr)
{
	return new CFilter(NAME("YV12压缩"), pUnk, phr);
}

CInPin.cpp

#include "DLL.h"
#include "dvdmedia.h"

CInPin::CInPin(CFilter *pFilter, HRESULT *phr, LPCWSTR pPinName) : CBaseInputPin(NAME("In"), pFilter, pFilter, phr, pPinName)
{
	pCFilter = pFilter;
}

CInPin::~CInPin()
{

}

HRESULT CInPin::CheckMediaType(const CMediaType *pmt)
{
	if (pmt->majortype == MEDIATYPE_Video && pmt->subtype == MEDIASUBTYPE_RGB32 && pmt->bFixedSizeSamples && 
		(pmt->formattype == FORMAT_VideoInfo || pmt->formattype == FORMAT_VideoInfo2))
	{
		if (pmt->formattype == FORMAT_VideoInfo)
		{
			VIDEOINFOHEADER* p = (VIDEOINFOHEADER*)pmt->pbFormat;
			if (p->bmiHeader.biBitCount != 32 || p->bmiHeader.biCompression != 0 || p->AvgTimePerFrame == 0)return S_FALSE;//要求每个像素32位，编码方式0，必须提供帧持续时间
		}
		if (pmt->formattype == FORMAT_VideoInfo2)
		{
			VIDEOINFOHEADER2* p = (VIDEOINFOHEADER2*)pmt->pbFormat;
			if (p->bmiHeader.biBitCount != 32 || p->bmiHeader.biCompression != 0 || p->AvgTimePerFrame == 0)return S_FALSE;//要求每个像素32位，编码方式0，必须提供帧持续时间
		}
		return S_OK;
	}
	return S_FALSE;
}

HRESULT CInPin::SetMediaType(const CMediaType *pmt)
{
	if (pmt->formattype == FORMAT_VideoInfo)
	{
		VIDEOINFOHEADER* p = (VIDEOINFOHEADER*)pmt->pbFormat;
		pCFilter->width = p->bmiHeader.biWidth; pCFilter->height = p->bmiHeader.biHeight;//获取图像宽高
		pCFilter->nFrame = (int)(10000000 / p->AvgTimePerFrame);//获取每秒帧数
		pCFilter->AvgTimePerFrame = p->AvgTimePerFrame;//获取帧持续时间，单位100纳秒
	}
	if (pmt->formattype == FORMAT_VideoInfo2)
	{
		VIDEOINFOHEADER2* p = (VIDEOINFOHEADER2*)pmt->pbFormat;
		pCFilter->width = p->bmiHeader.biWidth; pCFilter->height = p->bmiHeader.biHeight;//获取图像宽高
		pCFilter->nFrame = (int)(10000000 / p->AvgTimePerFrame);//获取每秒帧数
		pCFilter->AvgTimePerFrame = p->AvgTimePerFrame;//获取帧持续时间，单位100纳秒
	}
	return CBasePin::SetMediaType(pmt);
}

STDMETHODIMP CInPin::Receive(IMediaSample *pSample)
{
	HRESULT hr;
	BYTE* RGB32_data = NULL;
	hr = pSample->GetPointer(&RGB32_data);//获取引脚样本缓冲区指针
	REFERENCE_TIME star, end;
	hr = pSample->GetTime(&star, &end);//获取样本时间戳

	IMediaSample *pOutSample = NULL;
	hr = pCFilter->pCOutPin->GetDeliveryBuffer(&pOutSample, NULL, NULL, 0);//获取一个空的输出引脚样本
	if (hr == S_OK)
	{
		BYTE* pOutBuffer = NULL;
		hr = pOutSample->GetPointer(&pOutBuffer);//获取输出引脚样本缓冲区指针
		int iY = 0;
		int YSize = pCFilter->width * pCFilter->height;
		int iV = YSize;
		int iU = YSize + YSize / 4;
		BYTE Color32[4];
		for (int y = pCFilter->height - 1; y >= 0; y--)
		{
			for (int x = 0; x < pCFilter->width; x++)
			{
				memcpy(Color32, &RGB32_data[y * pCFilter->width * 4 + x * 4], 4);
				pOutBuffer[iY] = (BYTE)(0.299 * Color32[2] + 0.587 * Color32[1] + 0.114 * Color32[0]);//Y
				if ((x & 1) && (y & 1))
				{
					pOutBuffer[iV] = (BYTE)(0.5 * Color32[2] - 0.4187 * Color32[1] - 0.0813 * Color32[0] + 128);//V
					pOutBuffer[iU] = (BYTE)(-0.1687 * Color32[2] - 0.3313 * Color32[1] + 0.5 * Color32[0] + 128);//U
					iV++;iU++;
				}
				++iY;
			}
		}
		hr = pOutSample->SetTime(&star, &end);//设置输出引脚样本时间戳
		hr = pOutSample->SetActualDataLength((LONG)(pCFilter->width*pCFilter->height * 1.5));//设置输出引脚样本有效数据长度
		hr = pCFilter->pCOutPin->Deliver(pOutSample);//输出引脚向下游发送样本
		pOutSample->Release();//释放输出引脚样本
	}
	return S_OK;
}

STDMETHODIMP CInPin::EndOfStream()
{
	return pCFilter->pCOutPin->DeliverEndOfStream();
}

STDMETHODIMP CInPin::BeginFlush()
{
	HRESULT hr = S_OK;
	hr = pCFilter->pCOutPin->DeliverBeginFlush();
	if (FAILED(hr))
		return hr;
	return CBaseInputPin::BeginFlush();
}

STDMETHODIMP CInPin::EndFlush()
{
	HRESULT hr = S_OK;
	hr = pCFilter->pCOutPin->DeliverEndFlush();
	if (FAILED(hr))
		return hr;
	return CBaseInputPin::EndFlush();
}

STDMETHODIMP CInPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
{
	HRESULT hr = S_OK;
	hr = pCFilter->pCOutPin->DeliverNewSegment(tStart, tStop, dRate);
	if (FAILED(hr))
		return hr;
	return CBaseInputPin::NewSegment(tStart, tStop, dRate);
}

COutPin.cpp

#include "DLL.h"
#include "dvdmedia.h"

COutPin::COutPin(CFilter *pFilter, HRESULT *phr, LPCWSTR pPinName) : CBaseOutputPin(NAME("Out"), pFilter, pFilter, phr, pPinName)
{
	pCFilter = pFilter;
}

COutPin::~COutPin()
{
	SafeRelease(&m_pPosition);
}

STDMETHODIMP COutPin::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
	CheckPointer(ppv, E_POINTER);
	ASSERT(ppv);
	*ppv = NULL;
	HRESULT hr = NOERROR;
	if (riid == IID_IMediaPosition || riid == IID_IMediaSeeking)
	{
		if (m_pPosition == NULL)
		{
			hr = CreatePosPassThru(GetOwner(), FALSE, (IPin *)pCFilter->pCInPin, &m_pPosition);
			if (FAILED(hr)) return hr;
		}
		return m_pPosition->QueryInterface(riid, ppv);
	}
	return CBaseOutputPin::NonDelegatingQueryInterface(riid, ppv);
}

HRESULT COutPin::GetMediaType(int iPosition, CMediaType *pMediaType)
{
	if (iPosition == 0)
	{
		pMediaType->SetType(&MEDIATYPE_Video);//设置主要类型
		pMediaType->SetSubtype(&MEDIASUBTYPE_YV12);//设置子类型
		pMediaType->SetFormatType(&FORMAT_VideoInfo);//设置格式类型
		pMediaType->SetTemporalCompression(FALSE);//不使用时间压缩
		pMediaType->SetSampleSize((ULONG)(pCFilter->width*pCFilter->height * 1.5));//设置样本大小
		VIDEOINFOHEADER* p = (VIDEOINFOHEADER*)pMediaType->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));//为格式块分配内存
		if (NULL == p)return(E_OUTOFMEMORY);
		ZeroMemory(p, sizeof(VIDEOINFOHEADER));
		p->rcSource.left = 0; p->rcSource.top = 0; p->rcSource.right = 0; p->rcSource.bottom = 0;//源矩形
		p->rcTarget.left = 0; p->rcTarget.top = 0; p->rcTarget.right = 0; p->rcTarget.bottom = 0;//目标矩形
		p->dwBitRate = (DWORD)(pCFilter->width*pCFilter->height * 1.5 * pCFilter->nFrame);//数据传输率
		p->dwBitErrorRate = 0;//数据错误率
		p->AvgTimePerFrame = pCFilter->AvgTimePerFrame;//帧持续时间
		p->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);//图像信息结构大小
		p->bmiHeader.biWidth = pCFilter->width;//图像宽度
		p->bmiHeader.biHeight = pCFilter->height;//图像高度
		p->bmiHeader.biPlanes = 1;//平面数
		p->bmiHeader.biBitCount = 12;//每个像素位数
		p->bmiHeader.biCompression = 842094169;//编码方式
		p->bmiHeader.biSizeImage = (DWORD)(pCFilter->width*pCFilter->height * 1.5);//图像的大小，单位字节
		p->bmiHeader.biXPelsPerMeter = 0;//水平分辨率
		p->bmiHeader.biYPelsPerMeter = 0;//垂直分辨率
		p->bmiHeader.biClrUsed = 0;//颜色表中颜色数量
		p->bmiHeader.biClrImportant = 0;//重要颜色数量
		return S_OK;
	}
	if (iPosition == 1)
	{
		pMediaType->SetType(&MEDIATYPE_Video);//设置主要类型
		pMediaType->SetSubtype(&MEDIASUBTYPE_YV12);//设置子类型
		pMediaType->SetFormatType(&FORMAT_VideoInfo2);//设置格式类型
		pMediaType->SetTemporalCompression(FALSE);//不使用时间压缩
		pMediaType->SetSampleSize((ULONG)(pCFilter->width*pCFilter->height * 1.5));//设置样本大小
		VIDEOINFOHEADER2* p = (VIDEOINFOHEADER2*)pMediaType->AllocFormatBuffer(sizeof(VIDEOINFOHEADER2));//为格式块分配内存
		if (NULL == p)return(E_OUTOFMEMORY);
		ZeroMemory(p, sizeof(VIDEOINFOHEADER2));
		p->rcSource.left = 0; p->rcSource.top = 0; p->rcSource.right = 0; p->rcSource.bottom = 0;//源矩形
		p->rcTarget.left = 0; p->rcTarget.top = 0; p->rcTarget.right = 0; p->rcTarget.bottom = 0;//目标矩形
		p->dwBitRate = (DWORD)(pCFilter->width*pCFilter->height * 1.5 * pCFilter->nFrame);//数据传输率
		p->dwBitErrorRate = 0;//数据错误率
		p->AvgTimePerFrame = pCFilter->AvgTimePerFrame;//帧持续时间
		p->dwInterlaceFlags = 0;
		p->dwCopyProtectFlags = 0;
		p->dwPictAspectRatioX = pCFilter->width;
		p->dwPictAspectRatioY = pCFilter->height;
		p->dwControlFlags = 0;
		p->dwReserved1 = 0;
		p->dwReserved2 = 0;
		p->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
		p->bmiHeader.biWidth = pCFilter->width;
		p->bmiHeader.biHeight = pCFilter->height;
		p->bmiHeader.biPlanes = 1;
		p->bmiHeader.biBitCount = 12;
		p->bmiHeader.biCompression = 842094169;//编码方式
		p->bmiHeader.biSizeImage = (DWORD)(pCFilter->width*pCFilter->height * 1.5);
		p->bmiHeader.biXPelsPerMeter = 0;
		p->bmiHeader.biYPelsPerMeter = 0;
		p->bmiHeader.biClrUsed = 0;
		p->bmiHeader.biClrImportant = 0;
		return S_OK;
	}
	return S_FALSE;
}

HRESULT COutPin::CheckMediaType(const CMediaType *pmt)
{
	if (!pCFilter->pCInPin->IsConnected())
	{
		MessageBox(0, L"须先连接输入引脚", L"YV12压缩", MB_OK); return S_FALSE;
	}
	if (pmt->majortype == MEDIATYPE_Video && pmt->subtype == MEDIASUBTYPE_YV12 && (pmt->formattype == FORMAT_VideoInfo || pmt->formattype == FORMAT_VideoInfo2))return S_OK;
	return S_FALSE;
}

HRESULT COutPin::DecideBufferSize(IMemAllocator *pMemAllocator, ALLOCATOR_PROPERTIES * ppropInputRequest)//确定输出引脚样本缓冲区大小
{
	HRESULT hr = S_OK;
	ppropInputRequest->cBuffers = 1;//1个缓冲区
	ppropInputRequest->cbBuffer = (LONG)(pCFilter->width*pCFilter->height * 1.5);//缓冲区的大小
	ALLOCATOR_PROPERTIES Actual;
	hr = pMemAllocator->SetProperties(ppropInputRequest, &Actual);
	if (FAILED(hr))return hr;
	if (Actual.cbBuffer < ppropInputRequest->cbBuffer)// 这个分配器是否不合适
	{
		return E_FAIL;
	}
	ASSERT(Actual.cBuffers == 1);// 确保我们只有 1 个缓冲区
	return S_OK;
}

HRESULT COutPin::Active()
{
	HRESULT hr = NOERROR;
	if (m_Connected == NULL)
		return NOERROR;
	if (m_pOutputQueue == NULL)
	{
		m_pOutputQueue = new COutputQueue(m_Connected, &hr, TRUE, FALSE);
		if (m_pOutputQueue == NULL)
			return E_OUTOFMEMORY;
		if (FAILED(hr))
		{
			delete m_pOutputQueue;
			m_pOutputQueue = NULL;
			return hr;
		}
	}
	CBaseOutputPin::Active();
	return NOERROR;
}

HRESULT COutPin::Inactive()
{
	if (m_pOutputQueue)
	{
		delete m_pOutputQueue;
		m_pOutputQueue = NULL;
	}
	CBaseOutputPin::Inactive();
	return NOERROR;
}

HRESULT COutPin::Deliver(IMediaSample *pMediaSample)
{
	if (m_pOutputQueue == NULL)
		return NOERROR;
	pMediaSample->AddRef();
	return m_pOutputQueue->Receive(pMediaSample);
}

HRESULT COutPin::DeliverEndOfStream()
{
	if (m_pOutputQueue == NULL)
		return NOERROR;
	m_pOutputQueue->EOS();
	return NOERROR;
}

HRESULT COutPin::DeliverBeginFlush()
{
	if (m_pOutputQueue == NULL)
		return NOERROR;
	m_pOutputQueue->BeginFlush();
	return NOERROR;
}

HRESULT COutPin::DeliverEndFlush()
{
	if (m_pOutputQueue == NULL)
		return NOERROR;
	m_pOutputQueue->EndFlush();
	return NOERROR;
}

HRESULT COutPin::DeliverNewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
{
	if (m_pOutputQueue == NULL)
		return NOERROR;
	m_pOutputQueue->NewSegment(tStart, tStop, dRate);
	return NOERROR;
}

STDMETHODIMP COutPin::Notify(IBaseFilter *pSender, Quality q)
{
	if (pCFilter->pCInPin->m_pQSink != NULL)
	{
		return pCFilter->pCInPin->m_pQSink->Notify(pCFilter, q);
	}
	else
	{
		HRESULT hr;
		IQualityControl * pIQC;
		hr = VFW_E_NOT_FOUND;
		if (pCFilter->pCInPin->m_Connected)
		{
			pCFilter->pCInPin->m_Connected->QueryInterface(IID_IQualityControl, (void**)&pIQC);
			if (pIQC != NULL)
			{
				hr = pIQC->Notify(pCFilter, q);
				pIQC->Release();
			}
		}
		return hr;
	}
	return NOERROR;
}

下载本过滤器DLL

h3974
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
DirectShow过滤器开发-YV12解压缩过滤器
h3974的博客
06-29 314
介绍YV12解压缩过滤器的开发。
DirectShow过滤器开发-IYUV解压缩过滤器
h3974的博客
06-30 243
介绍IYUV解压缩过滤器的开发。
DirectShow过滤器开发-H264解码器
最新发布
h3974的博客
07-26 310
介绍H264视频解码过滤器的开发。
DirectShow中间过滤器需要注意的问题
lgs7907
02-27 270
李国帅 摘自工作日志 2012/7/10 13:57:45 在解码过滤器之后，渲染器之前，加入一个中间过滤器，就可以在这个过滤器中对媒体帧进行后处理，比如处理抓图，缩放，绘图等。 处理数据解码后非YUV420P的情况     我们将中间过滤器的inpin设定为接收YV12，但有些视频或解码器不能输出YV12格式，只可以输出I420格式，那么就需要将uv互换，变成YV12进行播放。 是否需要把yuv
DirectShow过滤器-YV12压缩过滤器
06-29
本过滤器将RGB32视频流压缩为YV12视频流。 参见介绍文章：...
DirectShow过滤器-YV12解压缩过滤器
06-29
本过滤器将YV12视频流解压缩为RGB32视频流。 参见介绍文章：...
dshow 过滤器编写和调用
07-27
在描述中提到的示例中，过滤器的功能是从摄像头捕获YUY2格式的数据，然后将其转换为YV12格式。这个过程涉及到了色彩空间转换，这是一个常见的图像处理任务，特别是在视频处理领域。之后，转换后的YV12数据被进一步...
YV12To422:aviynynth过滤器
05-10
YV12To422是一个avisynth过滤器插件，它基于由Kevin Stone（aka tritical）编写的YV12ToYUY2（ddcc.dll），并且是从头开始编写的。 ### Info：使用SSE2 / AVX2将YV12剪辑转换为YV16 / YUY2。 version 1.0.2 要求：...
avisynth_filter:DirectShow过滤器，可将AviSynth放入视频播放
03-04
通过加载AviSynth脚本并将生成的帧馈送到视频播放器的DirectShow过滤器，可将AviSynth放入视频播放。 该过滤器将“ AvsFilterSource（）”函数导出到AviSynth脚本，该脚本用作源插件。 此过滤器将DirectShow上游的...
政安晨【零基础玩转各类开源AI项目】基于Ubuntu系统部署MimicMotion ：利用可信度感知姿势指导生成高质量人体运动视频
政安晨——致力于AI人工智能数字互动领域
07-23 1973
本文目标：基于Ubuntu系统部署MimicMotion项目——利用可信度感知姿势指导生成高质量人体运动视频
.mp4格式的视频为何不能通过video标签在chrome浏览器中播放？
David_jiahuan的博客
07-23 387
ffmpeg查看视频编码格式；还可以通过ffmpeg对视频编码格式进行转换
pyaudio VAD通过声音音频值分贝大小检测没人说话自动停止录制
weixin_42357472的博客
07-24 1374
np.frombuffer(data, dtype=np.short)：将 data 转换为一个 NumPy 数组，数据类型为 np.short（通常是 16 位整数）。这个操作将音频数据块中的每个样本转换为一个数值。因此，temp_volume 是当前音频数据块中的最大音量值，以 16 位整数的形式表示。效果可能说话声音小可能不被监听到，需要更改QUIET_DB阈值，另外delay_time值是低于阈值多久就可以停止保存当前的语音。)：计算转换后的 NumPy 数组中的最大值。
linux C++ onnxruntime yolov8 视频检测Demo
.NET 人工智能实践
07-23 707
linux C++ onnxruntime yolov8 视频检测Demo
Android APP 音视频（01）MediaCodec解码H264码流
wangdsh的博客
07-23 1296
H.264，也被称为MPEG-4 AVC（Advanced Video Coding），是一种广泛使用的数字视频压缩标准，主要用于视频编码。H.264标准由ITU-T视频编码专家组（VCEG）和ISO/IEC动态图像专家组（MPEG）共同开发，旨在提供比之前的视频编码标准更高的数据压缩效率。H.264是一种基于块的编码技术，它将视频帧分为多个宏块（Macroblocks，MBs），每个宏块包含亮度信息和色度信息。帧类型，I帧（Intra-coded frames）
美摄科技企业级视频拍摄与编辑SDK解决方案
美摄科技
07-24 393
美摄科技的视频拍摄与编辑SDK，采用行业领先的非编架构，不仅支持高达8K的超高清视频录制与编辑，更率先融入HDR（高动态范围）技术，让每一帧画面都细腻入微，色彩层次丰富，为企业打造影院级的视觉享受。在视觉为王的时代，美摄科技以专业级的技术实力与前瞻性的创新理念，为企业视频创作提供了强有力的支持。让我们一起，用视觉的力量，讲述企业故事，传递品牌价值，共创美好未来！除了强大的特技与关键帧功能外，美摄SDK还提供了曲线编辑工具，让用户能够像专业调色师一样，对视频的亮度、对比度、饱和度等参数进行精细调节。
压缩视频在线免费 怎么免费压缩视频大小 哪个软件可以免费压缩视频
weixin_42560925的博客
07-22 394
在数字媒体时代，视频文件的体积越来越大，这就需要我们找到高效的方式来压缩视频，以节省存储空间和提升分享速度。视频压缩是处理大型视频文件的重要手段，选择合适的视频压缩软件可以让您的工作更加高效。以上推荐的软件都是免费的，您可以根据自己的需求进行选择。压缩完成后，你可以预览压缩后的视频效果。如果不满意，可以重新调整压缩参数，重新压缩。你可以根据需要调整压缩大小，也可以选择预设的压缩选项。打开浏览器，搜索“51视频处理官网”， 然后点击“上传视频”按钮。点击“添加文件”按钮，上传你想要压缩的视频。
【音视频之SDL2】Windows配置SDL2项目模板
m0_62599305的博客
07-24 672
在开发跨平台的音视频应用程序时，SDL2（Simple DirectMedia Layer 2）是一个备受欢迎的选择。SDL2 是一个开源库，旨在为图形、声音和输入设备提供一个简单的一致性 API。特别是在 Windows 环境下，SDL2 提供了强大的功能和广泛的支持，使开发者能够轻松创建高性能的多媒体应用程序。本篇文章将为您介绍如何在 Windows 平台上配置 SDL2 项目模板，并简要介绍 SDL2 的核心功能和使用方法。SDL2 是一个跨平台的多媒体库，广泛用于游戏开发和音视频处理。
使用Diffusion Models进行街景视频生成
沉迷单车的追风少年
07-22 1087
街景图生成相当有挑战性，目前的文本到视频的方法仅限于生成有限范围的场景的短视频，文本到3D的方法可以生成单独的对象但不是整个城市。除此之外街景图对一致性的要求相当高，这篇博客介绍如何用Diffusion Models执行街景图生成。
基于PLC的液体搅拌器控制系统设计
混合过程中，液体搅拌器按照以下规律循环工作：打开阀门 YV1，流入液体 A；当液面升至 M 位置，关闭阀门 YV1，打开阀门 YV2，流入液体 B；当液面升至 H 位置，关闭阀门 YV2，开始进行搅拌；搅拌 600s 以后，阀门 YV3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

h3974

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值