VIDEOINFOHEADER m_VideoInfo; // Derived from the AMMediaType object
#endregion
#region Constructor
internal VideoCapability(AMMediaType mediaType, VIDEO_STREAM_CONFIG_CAPS caps)
{
if (null == mediaType)
throw new ArgumentNullException("mediaType");
m_MediaType = mediaType;
m_StreamConfigCaps = caps;
m_VideoInfo = (VIDEOINFOHEADER)Marshal.PtrToStructure(mediaType.formatPtr, typeof(VIDEOINFOHEADER));
}
void GetCaptureSize()
{
int hr = 0;
// After the filter is added to the graph, and before
// it is connected to anything, we need to set the format
// and size that we expect.
AMMediaType mt = new AMMediaType();
hr = sampleGrabber.GetConnectedMediaType(mt);
DsError.ThrowExceptionForHR(hr);
try
{
if ((mt.formatType != FormatType.VideoInfo) || (mt.formatPtr == IntPtr.Zero))
{
throw new NotSupportedException("Unknown Grabber Media Format");
}
// Get the struct
VIDEOINFOHEADER videoInfoHeader = new VIDEOINFOHEADER();
Marshal.PtrToStructure(mt.formatPtr, videoInfoHeader);
// Grab the size info
fGrabber.Width = videoInfoHeader.BmiHeader.biWidth;
fGrabber.Height = videoInfoHeader.BmiHeader.biHeight;
fGrabber.FrameBytes = (int)videoInfoHeader.BmiHeader.biSizeImage;
}
finally
{
mt.Dispose();
}
}
/// <summary>
/// Configure the capture filter once it is in the graph.
/// </summary>
/// <param name="streamConfig"></param>
/// <param name="iWidth">Desired width of video</param>
/// <param name="iHeight">Desired height of video</param>
/// <param name="bitsPerPixel">Number of bits per pixel</param>
/// <remarks>
/// We configure the source filter with the desired size, mediasubtype, and
/// bits per pixel. This must be done before the capture pin is connected
/// to other filters in the graph.
/// </remarks>
private void ConfigureSourceFilter(IAMStreamConfig streamConfig, int iWidth, int iHeight, short bitsPerPixel)
{
int hr;
AMMediaType mType = new AMMediaType();
VIDEOINFOHEADER v;
// First, we need to get the existing format block
// If there's an error, throw an exception.
hr = streamConfig.GetFormat(out mType);
DsError.ThrowExceptionForHR(hr);
// Return early if the media type is not what we expect
// First, the majorType must be 'Video'
// Second, the size of the format structure must be sizeof(VIDEOINFOHEADER)
if ((MediaType.Video != mType.majorType) ||
(mType.formatSize != Marshal.SizeOf(typeof(VIDEOINFOHEADER))))
return;
try
{
// The formatPtr member of the AMMediaType object points
// to a chunk of unmanaged memory that contains the data
// for the format structure. We need to copy this data
// into a structure object so we can manipulate it.
v = new VIDEOINFOHEADER();
Marshal.PtrToStructure(mType.formatPtr, v);
// In order to change the size and bits per pixel, we
// need to change the values of the VIDEOINFOHEADER object
// that we pulled out from the AMMediaType object.
if (iWidth > 0)
{
v.BmiHeader.biWidth = iWidth;
}
if (iHeight > 0)
{
v.BmiHeader.biHeight = iHeight;
}
if (bitsPerPixel > 0)
{
v.BmiHeader.biBitCount = (ushort)bitsPerPixel;
}
// Now we copy the VIDEOINFOHEADER structure back into
// a piece of unmanaged memory and give the pointer to
// the AMMediaType structure.
Marshal.StructureToPtr(v, mType.formatPtr, false);
// Finally, we set the new format on the pin
hr = streamConfig.SetFormat(mType);
DsError.ThrowExceptionForHR(hr);
}
finally
{
mType.Dispose();
}
}
void AddSampleGrabber()
{
int hr = 0;
// Add the sample grabber to the graph
hr = graphBuilder.AddFilter(grabberFilter, "NewTOAPIA Grabber");
DsError.ThrowExceptionForHR(hr);
// After the filter is added to the graph, and before
// it is connected to anything, we need to set the format
// and size that we expect.
AMMediaType mt = new AMMediaType();
// Set the media type to Video/RBG24
mt.majorType = MediaType.Video;
mt.subType = MediaSubType.RGB24;
mt.formatType = FormatType.VideoInfo; // What format do we want to use to describe the media
//VIDEOINFOHEADER vih = new VIDEOINFOHEADER();
//vih.BmiHeader.biBitCount = 24;
//vih.BmiHeader.biClrImportant = 0;
//vih.BmiHeader.biClrUsed = 0;
//vih.BmiHeader.biCompression = 0;
//vih.BmiHeader.biHeight = fDesiredHeight;
//vih.BmiHeader.biPlanes = 1;
//vih.BmiHeader.biSize = Marshal.SizeOf(vih);
//vih.BmiHeader.biSizeImage = (uint)(fDesiredWidth * fDesiredHeight * 3); // It's very important to set this one or things won't be right
//vih.BmiHeader.biWidth = fDesiredWidth;
//vih.BmiHeader.biXPelsPerMeter = 0;
//vih.BmiHeader.biYPelsPerMeter = 0;
//// turn the structure back into a pointer
//mt.formatPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(vih));
//mt.formatSize = Marshal.SizeOf(vih);
//mt.formatType = FormatType.VideoInfo;
//Marshal.StructureToPtr(vih, mt.formatPtr, false);
hr = sampleGrabber.SetMediaType(mt);
DsError.ThrowExceptionForHR(hr);
// Free the media type object because we're done with it
mt.Dispose();
mt = null;
// Final sample grabber configuration
hr = sampleGrabber.SetOneShot(false);
hr = sampleGrabber.SetBufferSamples(false);
hr = sampleGrabber.SetCallback(fGrabber, 1);
DsError.ThrowExceptionForHR(hr);
}
public static List<VideoCapability> GetAllVideoCapabilities(IAMStreamConfig videoStreamConfig)
{
if (videoStreamConfig == null)
throw new ArgumentNullException("videoStreamConfig");
UnmanagedMemory pCaps = null;
List<VideoCapability> capsList = new List<VideoCapability>();
try
{
// Ensure this device reports capabilities
int c, size;
int hr = videoStreamConfig.GetNumberOfCapabilities(out c, out size);
DsError.ThrowExceptionForHR(hr);
if (c <= 0)
throw new NotSupportedException("Video device does not report capabilities.");
if (size > Marshal.SizeOf(typeof(VIDEO_STREAM_CONFIG_CAPS)))
throw new NotSupportedException("Unable to retrieve video device capabilities. This video device requires a larger VideoStreamConfigCaps structure.");
// Alloc memory for structure
pCaps = new UnmanagedMemory(Marshal.SizeOf(typeof(VIDEO_STREAM_CONFIG_CAPS)));
VIDEO_STREAM_CONFIG_CAPS cap;
// Retrieve all capability structures
for (int i = 0; i < c; i++)
{
AMMediaType mediaType = new AMMediaType();
hr = videoStreamConfig.GetStreamCaps(i, out mediaType, pCaps.MemoryPointer);
DsError.ThrowExceptionForHR(hr);
if (MediaType.Video.Equals(mediaType.majorType))
{
cap = (VIDEO_STREAM_CONFIG_CAPS)Marshal.PtrToStructure(pCaps.MemoryPointer, typeof(VIDEO_STREAM_CONFIG_CAPS));
VideoCapability newCap = new VideoCapability(mediaType, cap);
capsList.Add(newCap);
} else if (MediaType.Audio.Equals(mediaType.majorType))
{
Console.WriteLine("Audio Configuration");
}
}
}
finally
{
if (pCaps != null)
pCaps.Dispose();
pCaps = null;
//if (mediaType != null)
// DsUtils.FreeAMMediaType(mediaType);
//mediaType = null;
}
return capsList;
}