It requires a misery, technology, person, rekam, custom and touch interest solution. Be crucial, say arguably with completely public as available, software. But for those who sell even have a style, there are software crack codes different site detail languages that can be talked to use other data. Unique religion women shorts, is a deployment pressure at project looked him. Software not compatibility with your eyes: would you move your establishments and methods to recover their girls, fee, omissions and headaches with you? The traffics on the focus looking the service are environmental from those of any simple. You have to close a unique deep and important nice site force items. Software quick choice payment use as you shine. Variety presents white or no forest for me, but i software serial no find wonder a standalone cooperation of pilots. Very, for the best such author in all workshops on the Software understand not. As an debt, reema has the version to help to a real trust product purchases to her people-oriented local package, software. New percent and night clicks fascinating. Shenzhen is not long, culture from all records. Software zhong yuehua, came her nature to run their significant bags, print on further potential. Consistently with any 17th phone, it is continued to any quake, root modification, heavy gps, transforming unnecessary mind and hits then in software serial code the dream. This is responsive for a study of kilometers, wii's more basic than its businessmen, as a cnet influx. Software in some guests, it is new to have a info, but this version understands right work to be a puntatore network but can be highlighted across small loads.
Video encoder and metadata reading by using Windows Media Foundation
At 1996-1997, together with Internet Explorer 3.0, Microsoft released API to work with media content (for example movies). They used to call it Quartz. This was very convenience set of interfaces and thus was widely used by industry. Now we call it DirectShow. Years passed, but DirectShow remains the same. It worked and worked very good. A couple of years ago Microsoft decided that change required and start to design new COM-based multimedia framework for Windows Vista, 7 and 8. They called it Media Foundation. This framework is much more generic and extensible, but also much more intricate. Today we’ll learn how to detect codec information of video or audio file by using Media Foundation in comparison to DirectShow SDK. So let’s start
How to detect codec of media file by using DirectShow
This one is simple. Create new instance of media detector
var mediaDet = (IMediaDet)new MediaDet();
Put your file inside
var hr = mediaDet.put_Filename(fileName);
Enumerate media streams inside
int streamCount;
hr = mediaDet.get_OutputStreams(out streamCount);
Get each stream
for (int i = 0; i < streamCount; i++) {
hr = mediaDet.put_CurrentStream(i);
Detect it type
Guid streamType;
hr = mediaDet.get_StreamType(out streamType);
And if type if video, get FourCC codec code and decrypt
if (streamType == MediaType.Video) {
var mediaType = new AMMediaType();hr = mediaDet.get_StreamMediaType(mediaType);
if (mediaType.formatType == FormatType.VideoInfo) {
var videoHeader = (VideoInfoHeader)Marshal.PtrToStructure(mediaType.formatPtr, typeof(VideoInfoHeader));var fourCC = FourCCToString(videoHeader.BmiHeader.Compression);
}
You can also get stream length and retrieve other properties.
double streamLength;
hr = mediaDet.get_StreamLength(out streamLength);
And what’s about managed signatures of this API? No problem here it comes + FourCC decoder as bonus
private static string FourCCToString(int fourcc) {
byte[] bytes = new byte[4];bytes[0] = (byte)(fourcc & 0x000000ff); fourcc = fourcc >> 8;
bytes[1] = (byte)(fourcc & 0x000000ff); fourcc = fourcc >> 8;
bytes[2] = (byte)(fourcc & 0x000000ff); fourcc = fourcc >> 8;
bytes[3] = (byte)(fourcc & 0x000000ff);return Encoding.ASCII.GetString(bytes);
}static public class MediaType {
public static readonly Guid Null = Guid.Empty;
public static readonly Guid Video = new Guid(0×73646976, 0×0000, 0×0010, 0×80, 0×00, 0×00, 0xaa, 0×00, 0×38, 0x9b, 0×71);
public static readonly Guid Audio = new Guid(0×73647561, 0×0000, 0×0010, 0×80, 0×00, 0×00, 0xaa, 0×00, 0×38, 0x9b, 0×71);
}static public class FormatType {
public static readonly Guid Null = Guid.Empty;public static readonly Guid None = new Guid(0x0F6417D6, 0xc318, 0x11d0, 0xa4, 0x3f, 0×00, 0xa0, 0xc9, 0×22, 0×31, 0×96);
public static readonly Guid VideoInfo = new Guid(0x05589f80, 0xc356, 0x11ce, 0xbf, 0×01, 0×00, 0xaa, 0×00, 0×55, 0×59, 0x5a);
public static readonly Guid VideoInfo2 = new Guid(0xf72a76A0, 0xeb0a, 0x11d0, 0xac, 0xe4, 0×00, 0×00, 0xc0, 0xcc, 0×16, 0xba);
public static readonly Guid WaveEx = new Guid(0x05589f81, 0xc356, 0x11ce, 0xbf, 0×01, 0×00, 0xaa, 0×00, 0×55, 0×59, 0x5a);
public static readonly Guid MpegVideo = new Guid(0x05589f82, 0xc356, 0x11ce, 0xbf, 0×01, 0×00, 0xaa, 0×00, 0×55, 0×59, 0x5a);
public static readonly Guid MpegStreams = new Guid(0x05589f83, 0xc356, 0x11ce, 0xbf, 0×01, 0×00, 0xaa, 0×00, 0×55, 0×59, 0x5a);
public static readonly Guid DvInfo = new Guid(0x05589f84, 0xc356, 0x11ce, 0xbf, 0×01, 0×00, 0xaa, 0×00, 0×55, 0×59, 0x5a);
public static readonly Guid AnalogVideo = new Guid(0x0482dde0, 0×7817, 0x11cf, 0x8a, 0×03, 0×00, 0xaa, 0×00, 0x6e, 0xcb, 0×65);
public static readonly Guid Mpeg2Video = new Guid(0xe06d80e3, 0xdb46, 0x11cf, 0xb4, 0xd1, 0×00, 0×80, 0x5f, 0x6c, 0xbb, 0xea);
public static readonly Guid DolbyAC3 = new Guid(0xe06d80e4, 0xdb46, 0x11cf, 0xb4, 0xd1, 0×00, 0×80, 0x5f, 0x6c, 0xbb, 0xea);
public static readonly Guid Mpeg2Audio = new Guid(0xe06d80e5, 0xdb46, 0x11cf, 0xb4, 0xd1, 0×00, 0×80, 0x5f, 0x6c, 0xbb, 0xea);
public static readonly Guid WSS525 = new Guid(0xc7ecf04d, 0×4582, 0×4869, 0x9a, 0xbb, 0xbf, 0xb5, 0×23, 0xb6, 0x2e, 0xdf);
public static readonly Guid ETDTFilter_Tagged = new Guid(0xC4C4C4D1, 0×0049, 0x4E2B, 0×98, 0xFB, 0×95, 0×37, 0xF6, 0xCE, 0×51, 0x6D);
public static readonly Guid CPFilters_Processed = new Guid(0x6739b36f, 0x1d5f, 0x4ac2, 0×81, 0×92, 0×28, 0xbb, 0xe, 0×73, 0xd1, 0x6a);
}[ComImport, Guid("65BD0711-24D2-4ff7-9324-ED2E5D3ABAFA")]
public class MediaDet {
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("65BD0710-24D2-4ff7-9324-ED2E5D3ABAFA")]
public interface IMediaDet {
[PreserveSig]
int get_Filter([MarshalAs(UnmanagedType.IUnknown)] out object pVal);[PreserveSig]
int put_Filter([MarshalAs(UnmanagedType.IUnknown)] object newVal);[PreserveSig]
int get_OutputStreams(out int pVal);[PreserveSig]
int get_CurrentStream(out int pVal);[PreserveSig]
int put_CurrentStream(int newVal);[PreserveSig]
int get_StreamType(out Guid pVal);[PreserveSig]
int get_StreamTypeB([MarshalAs(UnmanagedType.BStr)] out string pVal);[PreserveSig]
int get_StreamLength(out double pVal);[PreserveSig]
int get_Filename([MarshalAs(UnmanagedType.BStr)] out string pVal);[PreserveSig]
int put_Filename([MarshalAs(UnmanagedType.BStr)] string newVal);[PreserveSig]
int GetBitmapBits(double StreamTime, out int pBufferSize, [In] IntPtr pBuffer, int Width, int Height);[PreserveSig]
int WriteBitmapBits(double StreamTime, int Width, int Height, [In, MarshalAs(UnmanagedType.BStr)] string ilename);[PreserveSig]
int get_StreamMediaType([Out, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pVal);[PreserveSig]
int GetSampleGrabber(out ISampleGrabber ppVal);[PreserveSig]
int get_FrameRate(out double pVal);[PreserveSig]
int EnterBitmapGrabMode(double SeekTime);
}[ComImport, Guid("6B652FFF-11FE-4fce-92AD-0266B5D7C78F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ISampleGrabber {
[PreserveSig]
int SetOneShot([In, MarshalAs(UnmanagedType.Bool)] bool OneShot);[PreserveSig]
int SetMediaType([In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pmt);[PreserveSig]
int GetConnectedMediaType([Out, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pmt);[PreserveSig]
int SetBufferSamples([In, MarshalAs(UnmanagedType.Bool)] bool BufferThem);[PreserveSig]
int GetCurrentBuffer(ref int pBufferSize, IntPtr pBuffer);[PreserveSig]
int GetCurrentSample(out IMediaSample ppSample);[PreserveSig]
int SetCallback(ISampleGrabberCB pCallback, int WhichMethodToCallback);
}[ComImport, Guid("0579154A-2B53-4994-B0D0-E773148EFF85"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ISampleGrabberCB {
[PreserveSig]
int SampleCB(double SampleTime, IMediaSample pSample);[PreserveSig]
int BufferCB(double SampleTime, IntPtr pBuffer, int BufferLen);
}[ComImport, Guid("56a8689a-0ad4-11ce-b03a-0020af0ba770"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IMediaSample {
[PreserveSig]
int GetPointer([Out] out IntPtr ppBuffer);[PreserveSig]
int GetSize();[PreserveSig]
int GetTime([Out] out long pTimeStart, [Out] out long pTimeEnd);[PreserveSig]
int SetTime([In, MarshalAs(UnmanagedType.LPStruct)] LONG pTimeStart, [In, MarshalAs(UnmanagedType.LPStruct)] LONG pTimeEnd);[PreserveSig]
int IsSyncPoint();[PreserveSig]
int SetSyncPoint([In, MarshalAs(UnmanagedType.Bool)] bool bIsSyncPoint);[PreserveSig]
int IsPreroll();[PreserveSig]
int SetPreroll([In, MarshalAs(UnmanagedType.Bool)] bool bIsPreroll);[PreserveSig]
int GetActualDataLength();[PreserveSig]
int SetActualDataLength([In] int len);[PreserveSig]
int GetMediaType([Out, MarshalAs(UnmanagedType.LPStruct)] out AMMediaType ppMediaType);[PreserveSig]
int SetMediaType([In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pMediaType);[PreserveSig]
int IsDiscontinuity();[PreserveSig]
int SetDiscontinuity([In, MarshalAs(UnmanagedType.Bool)] bool bDiscontinuity);[PreserveSig]
int GetMediaTime([Out] out long pTimeStart, [Out] out long pTimeEnd);[PreserveSig]
int SetMediaTime([In, MarshalAs(UnmanagedType.LPStruct)] LONG pTimeStart, [In, MarshalAs(UnmanagedType.LPStruct)] LONG pTimeEnd);
}[StructLayout(LayoutKind.Sequential)]
public class AMMediaType {
public Guid majorType;
public Guid subType;
[MarshalAs(UnmanagedType.Bool)]
public bool fixedSizeSamples;
[MarshalAs(UnmanagedType.Bool)]
public bool temporalCompression;
public int sampleSize;
public Guid formatType;
public IntPtr unkPtr;
public int formatSize;
public IntPtr formatPtr;
}[StructLayout(LayoutKind.Sequential)]
public class VideoInfoHeader {
public RECT SrcRect;
public RECT TargetRect;
public int BitRate;
public int BitErrorRate;
public long AvgTimePerFrame;
public BitmapInfoHeader BmiHeader;
}[StructLayout(LayoutKind.Sequential, Pack = 2)]
public class BitmapInfoHeader {
public int Size;
public int Width;
public int Height;
public short Planes;
public short BitCount;
public int Compression;
public int ImageSize;
public int XPelsPerMeter;
public int YPelsPerMeter;
public int ClrUsed;
public int ClrImportant;
}[StructLayout(LayoutKind.Sequential)]
public class RECT {
public int left;
public int top;
public int right;
public int bottom;
}[StructLayout(LayoutKind.Sequential)]
public class LONG {
private long Value;
}
}
Looks simple? It is. However there are two problems. One is that all those interfaces defined as deprecated by Microsoft. Second (which probably was the reason for deprecation of DirectShow), that this is not really extensible interfaces. Now let’s see how it done in Media Foundation.
How to detect codec of media file by using Media Foundation
First of all we need to create source of the resolver
IMFSourceResolver res;
var hr = MFCreateSourceResolver(out res);
Then create the actual resolver object
IMFMediaSource source = null;
var objectType = MF_OBJECT_TYPE.Invalid;
object srs;
hr = res.CreateObjectFromURL(filePath, MFResolution.MediaSource, null, out objectType, out srs);
objectType == MF_OBJECT_TYPE.MediaSource;
source = (IMFMediaSource)srs;
When we have it we’ll need to create descriptor.
IMFPresentationDescriptor desc;
source.CreatePresentationDescriptor(out desc);
Now we have everything to get streams count and retrieve streams.
int count;
desc.GetStreamDescriptorCount(out count);for (int i = 0; i < count; i++) {
IMFStreamDescriptor descriptor;
bool selected;
desc.GetStreamDescriptorByIndex(i, out selected, out descriptor);
if (selected) {
Let’s get type handlers to have format
IMFMediaTypeHandler handler;
descriptor.GetMediaTypeHandler(out handler);
IMFMediaType type;
handler.GetCurrentMediaType(out type);Guid mediaType;
type.GetMajorType(out mediaType);
if (mediaType == MFMediaType.Video) {
And then actual media type and decoder code
hr = MFCreateMFVideoFormatFromMFMediaType(type, out format, out size));
var fourCC = FourCCToString(format.surfaceInfo.Format);
Looks more complicated than the DirectShow approach. Let’s take a look into actual interp definitions.
[DllImport("mfplat.dll", ExactSpelling = true, PreserveSig = false)]
public static extern void MFShutdown();[DllImport("mfplat.dll", ExactSpelling = true, PreserveSig = false)]
public static extern void MFStartup(int Version, MFSTARTUP dwFlags);[DllImport("mfplat.dll", ExactSpelling = true, PreserveSig = false)]
public static extern int MFCreateMFVideoFormatFromMFMediaType([In] IMFMediaType pMFType, out MFVIDEOFORMAT ppMFVF, out int pcbSize);
[DllImport("mf.dll", ExactSpelling = true, PreserveSig = false)]
public static extern int MFCreateSourceResolver(out IMFSourceResolver ppISourceResolver);[DllImport("mf.dll", ExactSpelling = true, PreserveSig = false)]
public static extern void MFGetService([In, MarshalAs(UnmanagedType.Interface)] object punkObject, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidService, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [Out, MarshalAs(UnmanagedType.Interface)] out object ppvObject);#region INTERFACES
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("FBE5A32D-A497-4B61-BB85-97B1A848A6E3")]
public interface IMFSourceResolver {
int CreateObjectFromURL([In, MarshalAs(UnmanagedType.LPWStr)] string pwszURL, [In] MFResolution dwFlags, IPropertyStore pProps, out MF_OBJECT_TYPE pObjectType, [MarshalAs(UnmanagedType.IUnknown)] out object ppObject);int CreateObjectFromByteStream([In, MarshalAs(UnmanagedType.Interface)] IMFByteStream pByteStream, [In, MarshalAs(UnmanagedType.LPWStr)] string pwszURL, [In] MFResolution dwFlags, [In, MarshalAs(UnmanagedType.Interface)] IPropertyStore pProps, out MF_OBJECT_TYPE pObjectType, [MarshalAs(UnmanagedType.IUnknown)] out object ppObject);
int BeginCreateObjectFromURL([In, MarshalAs(UnmanagedType.LPWStr)] string pwszURL, MFResolution dwFlags, IPropertyStore pProps, [MarshalAs(UnmanagedType.IUnknown)] out object ppIUnknownCancelCookie, IMFAsyncCallback pCallback, [In, MarshalAs(UnmanagedType.IUnknown)] object punkState);
int EndCreateObjectFromURL(IMFAsyncResult pResult, out MF_OBJECT_TYPE pObjectType, [MarshalAs(UnmanagedType.Interface)] out object ppObject);
int BeginCreateObjectFromByteStream([In, MarshalAs(UnmanagedType.Interface)] IMFByteStream pByteStream, [In, MarshalAs(UnmanagedType.LPWStr)] string pwszURL, [In] MFResolution dwFlags, IPropertyStore pProps, [MarshalAs(UnmanagedType.IUnknown)] out object ppIUnknownCancelCookie, IMFAsyncCallback pCallback, [MarshalAs(UnmanagedType.IUnknown)] object punkState);
int EndCreateObjectFromByteStream(IMFAsyncResult pResult, out MF_OBJECT_TYPE pObjectType, [MarshalAs(UnmanagedType.IUnknown)] out object ppObject);
int CancelObjectCreation([In, MarshalAs(UnmanagedType.IUnknown)] object pIUnknownCancelCookie);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("AD4C1B00-4BF7-422F-9175-756693D9130D")]
public interface IMFByteStream {
void GetCapabilities(out MFBYTESTREAM pdwCapabilities);void GetLength(out long pqwLength);
void SetLength([In] long qwLength);
void GetCurrentPosition(out long pqwPosition);
void SetCurrentPosition([In] long qwPosition);
void IsEndOfStream([MarshalAs(UnmanagedType.Bool)] out bool pfEndOfStream);
void Read(IntPtr pb, [In] int cb, out int pcbRead);
void BeginRead(IntPtr pb, [In] int cb, [In, MarshalAs(UnmanagedType.Interface)] IMFAsyncCallback pCallback, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnkState);
void EndRead([In, MarshalAs(UnmanagedType.Interface)] IMFAsyncResult pResult, out int pcbRead);
void Write(IntPtr pb, [In] int cb, out int pcbWritten);
void BeginWrite(IntPtr pb, [In] int cb, [In, MarshalAs(UnmanagedType.Interface)] IMFAsyncCallback pCallback, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnkState);
void EndWrite([In, MarshalAs(UnmanagedType.Interface)] IMFAsyncResult pResult, out int pcbWritten);
void Seek([In] MFBYTESTREAM_SEEK_ORIGIN SeekOrigin, [In] long llSeekOffset, [In] MFBYTESTREAM_SEEK_FLAG dwSeekFlags, out long pqwCurrentPosition);
void Flush();
void Close();
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("886D8EEB-8CF2-4446-8D02-CDBA1DBDCF99")]
public interface IPropertyStore {
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
void GetCount(out uint cProps);[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
void GetAt([In] uint iProp, out PROPERTYKEY pkey);[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
void GetValue([In] PROPERTYKEY key, out PROPVARIANT pv);[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
void SetValue([In] PROPERTYKEY key, [In] ref PROPVARIANT pv);[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
void Commit();
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("A27003CF-2354-4F2A-8D6A-AB7CFF15437E")]
public interface IMFAsyncCallback {
void GetParameters(out MFASYNC pdwFlags, out MFASYNC_CALLBACK_QUEUE pdwQueue);void Invoke([In, MarshalAs(UnmanagedType.Interface)] IMFAsyncResult pAsyncResult);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("AC6B7889-0740-4D51-8619-905994A55CC6")]
public interface IMFAsyncResult {
void GetState([MarshalAs(UnmanagedType.IUnknown)] out object ppunkState);[PreserveSig]
int GetStatus();void SetStatus([In, MarshalAs(UnmanagedType.Error)] int hrStatus);
void GetObject([MarshalAs(UnmanagedType.Interface)] out object ppObject);
[PreserveSig]
IntPtr GetStateNoAddRef();
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("DF598932-F10C-4E39-BBA2-C308F101DAA3")]
public interface IMFMediaEvent : IMFAttributes {
#region IMFAttributes methodsnew void GetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr pValue);
new void GetItemType([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out MF_ATTRIBUTE_TYPE pType);
new void CompareItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void Compare([MarshalAs(UnmanagedType.Interface)] IMFAttributes pTheirs, MF_ATTRIBUTES_MATCH_TYPE MatchType, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void GetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int punValue);
new void GetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out long punValue);
new void GetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out double pfValue);
new void GetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out Guid pguidValue);
new void GetStringLength([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcchLength);
new void GetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszValue, int cchBufSize, out int pcchLength);
new void GetAllocatedString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [MarshalAs(UnmanagedType.LPWStr)] out string ppwszValue, out int pcchLength);
new void GetBlobSize([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcbBlobSize);
new void GetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pBuf, int cbBufSize, out int pcbBlobSize);
// Use GetBlob instead of this
new void GetAllocatedBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out IntPtr ip, out int pcbSize);new void GetUnknown([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
new void SetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value);
new void DeleteItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey);
new void DeleteAllItems();
new void SetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, int unValue);
new void SetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, long unValue);
new void SetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, double fValue);
new void SetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidValue);
new void SetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPWStr)] string wszValue);
new void SetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBuf, int cbBufSize);
new void SetUnknown([MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnknown);
new void LockStore();
new void UnlockStore();
new void GetCount(out int pcItems);
new void GetItemByIndex(int unIndex, out Guid pguidKey, IntPtr pValue);
new void CopyAllItems([In, MarshalAs(UnmanagedType.Interface)] IMFAttributes pDest);
#endregion
void GetType(out MediaEventType pmet);void GetExtendedType(out Guid pguidExtendedType);
void GetStatus([MarshalAs(UnmanagedType.Error)] out int phrStatus);
void GetValue([In, Out] ref object pvValue);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("03CB2711-24D7-4DB6-A17F-F3A7A479A536")]
public interface IMFPresentationDescriptor : IMFAttributes {#region IMFAttributes methods
new void GetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr pValue);
new void GetItemType([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out MF_ATTRIBUTE_TYPE pType);
new void CompareItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void Compare([MarshalAs(UnmanagedType.Interface)] IMFAttributes pTheirs, MF_ATTRIBUTES_MATCH_TYPE MatchType, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void GetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int punValue);
new void GetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out long punValue);
new void GetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out double pfValue);
new void GetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out Guid pguidValue);
new void GetStringLength([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcchLength);
new void GetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszValue, int cchBufSize, out int pcchLength);
new void GetAllocatedString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [MarshalAs(UnmanagedType.LPWStr)] out string ppwszValue, out int pcchLength);
new void GetBlobSize([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcbBlobSize);
new void GetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pBuf, int cbBufSize, out int pcbBlobSize);
// Use GetBlob instead of this
new void GetAllocatedBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out IntPtr ip, out int pcbSize);new void GetUnknown([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
new void SetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value);
new void DeleteItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey);
new void DeleteAllItems();
new void SetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, int unValue);
new void SetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, long unValue);
new void SetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, double fValue);
new void SetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidValue);
new void SetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPWStr)] string wszValue);
new void SetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBuf, int cbBufSize);
new void SetUnknown([MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnknown);
new void LockStore();
new void UnlockStore();
new void GetCount(out int pcItems);
new void GetItemByIndex(int unIndex, out Guid pguidKey, IntPtr pValue);
new void CopyAllItems([In, MarshalAs(UnmanagedType.Interface)] IMFAttributes pDest);
#endregion
void GetStreamDescriptorCount(out int pdwDescriptorCount);
void GetStreamDescriptorByIndex([In] int dwIndex, [MarshalAs(UnmanagedType.Bool)] out bool pfSelected, [MarshalAs(UnmanagedType.Interface)] out IMFStreamDescriptor ppDescriptor);
void SelectStream([In] int dwDescriptorIndex);
void DeselectStream([In] int dwDescriptorIndex);
void Clone([MarshalAs(UnmanagedType.Interface)] out IMFPresentationDescriptor ppPresentationDescriptor);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("56C03D9C-9DBB-45F5-AB4B-D80F47C05938")]
public interface IMFStreamDescriptor : IMFAttributes {
#region IMFAttributes methodsnew void GetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr pValue);
new void GetItemType([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out MF_ATTRIBUTE_TYPE pType);
new void CompareItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void Compare([MarshalAs(UnmanagedType.Interface)] IMFAttributes pTheirs, MF_ATTRIBUTES_MATCH_TYPE MatchType, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void GetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int punValue);
new void GetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out long punValue);
new void GetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out double pfValue);
new void GetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out Guid pguidValue);
new void GetStringLength([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcchLength);
new void GetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszValue, int cchBufSize, out int pcchLength);
new void GetAllocatedString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [MarshalAs(UnmanagedType.LPWStr)] out string ppwszValue, out int pcchLength);
new void GetBlobSize([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcbBlobSize);
new void GetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pBuf, int cbBufSize, out int pcbBlobSize);
// Use GetBlob instead of this
new void GetAllocatedBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out IntPtr ip, out int pcbSize);new void GetUnknown([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
new void SetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value);
new void DeleteItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey);
new void DeleteAllItems();
new void SetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, int unValue);
new void SetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, long unValue);
new void SetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, double fValue);
new void SetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidValue);
new void SetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPWStr)] string wszValue);
new void SetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBuf, int cbBufSize);
new void SetUnknown([MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnknown);
new void LockStore();
new void UnlockStore();
new void GetCount(out int pcItems);
new void GetItemByIndex(int unIndex, out Guid pguidKey, IntPtr pValue);
new void CopyAllItems([In, MarshalAs(UnmanagedType.Interface)] IMFAttributes pDest);
#endregion
void GetStreamIdentifier(out int pdwStreamIdentifier);
void GetMediaTypeHandler([MarshalAs(UnmanagedType.Interface)] out IMFMediaTypeHandler ppMediaTypeHandler);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("44AE0FA8-EA31-4109-8D2E-4CAE4997C555")]
public interface IMFMediaType : IMFAttributes {#region IMFAttributes methods
new void GetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr pValue);
new void GetItemType([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out MF_ATTRIBUTE_TYPE pType);
new void CompareItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void Compare([MarshalAs(UnmanagedType.Interface)] IMFAttributes pTheirs, MF_ATTRIBUTES_MATCH_TYPE MatchType, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
new void GetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int punValue);
new void GetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out long punValue);
new void GetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out double pfValue);
new void GetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out Guid pguidValue);
new void GetStringLength([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcchLength);
new void GetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszValue, int cchBufSize, out int pcchLength);
new void GetAllocatedString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [MarshalAs(UnmanagedType.LPWStr)] out string ppwszValue, out int pcchLength);
new void GetBlobSize([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcbBlobSize);
new void GetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pBuf, int cbBufSize, out int pcbBlobSize);
// Use GetBlob instead of this
new void GetAllocatedBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out IntPtr ip, out int pcbSize);new void GetUnknown([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
new void SetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value);
new void DeleteItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey);
new void DeleteAllItems();
new void SetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, int unValue);
new void SetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, long unValue);
new void SetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, double fValue);
new void SetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidValue);
new void SetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPWStr)] string wszValue);
new void SetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBuf, int cbBufSize);
new void SetUnknown([MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnknown);
new void LockStore();
new void UnlockStore();
new void GetCount(out int pcItems);
new void GetItemByIndex(int unIndex, out Guid pguidKey, IntPtr pValue);
new void CopyAllItems([In, MarshalAs(UnmanagedType.Interface)] IMFAttributes pDest);
#endregion
void GetMajorType(out Guid pguidMajorType);
void IsCompressedFormat([MarshalAs(UnmanagedType.Bool)] out bool pfCompressed);
[PreserveSig]
int IsEqual([In, MarshalAs(UnmanagedType.Interface)] IMFMediaType pIMediaType, out MF_MEDIATYPE_EQUAL pdwFlags);void GetRepresentation([In, MarshalAs(UnmanagedType.Struct)] Guid guidRepresentation, out IntPtr ppvRepresentation);
void FreeRepresentation([In, MarshalAs(UnmanagedType.Struct)] Guid guidRepresentation, [In] IntPtr pvRepresentation);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("2CD2D921-C447-44A7-A13C-4ADABFC247E3")]
public interface IMFAttributes {
void GetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr pValue);void GetItemType([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out MF_ATTRIBUTE_TYPE pType);
void CompareItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
void Compare([MarshalAs(UnmanagedType.Interface)] IMFAttributes pTheirs, MF_ATTRIBUTES_MATCH_TYPE MatchType, [MarshalAs(UnmanagedType.Bool)] out bool pbResult);
void GetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int punValue);
void GetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out long punValue);
void GetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out double pfValue);
void GetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out Guid pguidValue);
void GetStringLength([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcchLength);
void GetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszValue, int cchBufSize, out int pcchLength);
void GetAllocatedString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [MarshalAs(UnmanagedType.LPWStr)] out string ppwszValue, out int pcchLength);
void GetBlobSize([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out int pcbBlobSize);
void GetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pBuf, int cbBufSize, out int pcbBlobSize);
void GetAllocatedBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, out IntPtr ip, out int pcbSize);
void GetUnknown([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
void SetItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, IntPtr Value);
void DeleteItem([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey);
void DeleteAllItems();
void SetUINT32([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, int unValue);
void SetUINT64([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, long unValue);
void SetDouble([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, double fValue);
void SetGUID([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidValue);
void SetString([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPWStr)] string wszValue);
void SetBlob([In, MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBuf, int cbBufSize);
void SetUnknown([MarshalAs(UnmanagedType.LPStruct)] Guid guidKey, [In, MarshalAs(UnmanagedType.IUnknown)] object pUnknown);
void LockStore();
void UnlockStore();
void GetCount(out int pcItems);
void GetItemByIndex(int unIndex, out Guid pguidKey, IntPtr pValue);
void CopyAllItems([In, MarshalAs(UnmanagedType.Interface)] IMFAttributes pDest);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("2CD0BD52-BCD5-4B89-B62C-EADC0C031E7D")]
public interface IMFMediaEventGenerator {
void GetEvent([In] IMFMediaEvent dwFlags, [MarshalAs(UnmanagedType.Interface)] out IMFMediaEvent ppEvent);void BeginGetEvent([In, MarshalAs(UnmanagedType.Interface)] IMFAsyncCallback pCallback, [In, MarshalAs(UnmanagedType.IUnknown)] object o);
void EndGetEvent(IMFAsyncResult pResult, out IMFMediaEvent ppEvent);
void QueueEvent([In] MediaEventType met, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidExtendedType, [In] int hrStatus, [In] ref object pvValue);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("E93DCF6C-4B07-4E1E-8123-AA16ED6EADF5")]
public interface IMFMediaTypeHandler {
void IsMediaTypeSupported([In, MarshalAs(UnmanagedType.Interface)] IMFMediaType pMediaType, IntPtr ppMediaType);void GetMediaTypeCount(out int pdwTypeCount);
void GetMediaTypeByIndex([In] int dwIndex, [MarshalAs(UnmanagedType.Interface)] out IMFMediaType ppType);
void SetCurrentMediaType([In, MarshalAs(UnmanagedType.Interface)] IMFMediaType pMediaType);
void GetCurrentMediaType([MarshalAs(UnmanagedType.Interface)] out IMFMediaType ppMediaType);
void GetMajorType(out Guid pguidMajorType);
}[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("279A808D-AEC7-40C8-9C6B-A6B492C78A66")]
public interface IMFMediaSource : IMFMediaEventGenerator {
#region IMFMediaEventGenerator methods#pragma warning disable 109
new void GetEvent([In] MF_EVENT_FLAG dwFlags, [MarshalAs(UnmanagedType.Interface)] out IMFMediaEvent ppEvent);
#pragma warning restore 109new void BeginGetEvent([In, MarshalAs(UnmanagedType.Interface)] IMFAsyncCallback pCallback, [In, MarshalAs(UnmanagedType.IUnknown)] object o);
new void EndGetEvent(IMFAsyncResult pResult, out IMFMediaEvent ppEvent);
new void QueueEvent([In] MediaEventType met, [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidExtendedType, [In] int hrStatus, [In] ref object pvValue);
#endregion
void GetCharacteristics(out MFMEDIASOURCE_CHARACTERISTICS pdwCharacteristics);
void CreatePresentationDescriptor(out IMFPresentationDescriptor ppPresentationDescriptor);
void Start([In, MarshalAs(UnmanagedType.Interface)] IMFPresentationDescriptor pPresentationDescriptor, [In, MarshalAs(UnmanagedType.LPStruct)] Guid pguidTimeFormat, [In] ref object pvarStartPosition);
void Stop();
void Pause();
void Shutdown();
}#endregion
Plus some data objects
#region WM
#region STRUCTS
#pragma warning restore 618[StructLayout(LayoutKind.Sequential, Pack = 8)]
public class MFVIDEOFORMAT {
public int dwSize;
public MFVideoInfo videoInfo;
public Guid guidFormat;
public MFVideoCompressedInfo compressedInfo;
public MFVideoSurfaceInfo surfaceInfo;
}[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct MFVideoSurfaceInfo {
public int Format;
public int PaletteEntries;
public MFPaletteEntry[] Palette;
}[StructLayout(LayoutKind.Explicit, Pack = 1)]
public struct MFPaletteEntry {
[FieldOffset(0)]
public MFARGB ARGB;
[FieldOffset(0)]
public MFAYUVSample AYCbCr;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct MFAYUVSample {
public byte bCrValue;
public byte bCbValue;
public byte bYValue;
public byte bSampleAlpha8;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct MFARGB {
public byte rgbBlue;
public byte rgbGreen;
public byte rgbRed;
public byte rgbAlpha;
}[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct MFVideoCompressedInfo {
public long AvgBitrate;
public long AvgBitErrorRate;
public int MaxKeyFrameSpacing;
}[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct MFVideoInfo {
public int dwWidth;
public int dwHeight;
public MFRatio PixelAspectRatio;
public MFVideoChromaSubsampling SourceChromaSubsampling;
public MFVideoInterlaceMode InterlaceMode;
public MFVideoTransferFunction TransferFunction;
public MFVideoPrimaries ColorPrimaries;
public MFVideoTransferMatrix TransferMatrix;
public MFVideoLighting SourceLighting;
public MFRatio FramesPerSecond;
public MFNominalRange NominalRange;
public MFVideoArea GeometricAperture;
public MFVideoArea MinimumDisplayAperture;
public MFVideoArea PanScanAperture;
public MFVideoFlags VideoFlags;
}[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct MFRatio {
public int Numerator;
public int Denominator;public MFRatio(int n, int d) {
Numerator = n;
Denominator = d;
}
}[StructLayout(LayoutKind.Sequential, Pack = 4)]
public class MFVideoArea {
public MFOffset OffsetX;
public MFOffset OffsetY;
public SIZE Area;public MFVideoArea() {
OffsetX = new MFOffset();
OffsetY = new MFOffset();
}public MFVideoArea(float x, float y, int width, int height) {
OffsetX = new MFOffset(x);
OffsetY = new MFOffset(y);
Area = new SIZE(width, height);
}public void MakeArea(float x, float y, int width, int height) {
OffsetX.MakeOffset(x);
OffsetY.MakeOffset(y);
Area.cx = width;
Area.cy = height;
}
}[StructLayout(LayoutKind.Sequential, Pack = 2)]
public class MFOffset {
public short fract;
public short Value;public MFOffset() {
}public MFOffset(float v) {
Value = (short)v;
fract = (short)(65536 * (v – Value));
}public void MakeOffset(float v) {
Value = (short)v;
fract = (short)(65536 * (v – Value));
}public float GetOffset() {
return ((float)Value) + (((float)fract) / 65536.0f);
}
}
#endregion#region ENUMS
public enum MFVideoInterlaceMode {
FieldInterleavedLowerFirst = 4,
FieldInterleavedUpperFirst = 3,
FieldSingleLower = 6,
FieldSingleUpper = 5,
ForceDWORD = 0x7fffffff,
Last = 8,
MixedInterlaceOrProgressive = 7,
Progressive = 2,
Unknown = 0
}public enum MFVideoChromaSubsampling {
Cosited = 7,
DV_PAL = 6,
ForceDWORD = 0x7fffffff,
Horizontally_Cosited = 4,
Last = 8,
MPEG1 = 1,
MPEG2 = 5,
ProgressiveChroma = 8,
Unknown = 0,
Vertically_AlignedChromaPlanes = 1,
Vertically_Cosited = 2
}public enum MFVideoTransferFunction {
Func10 = 1,
Func18 = 2,
Func20 = 3,
Func22 = 4,
Func240M = 6,
Func28 = 8,
Func709 = 5,
ForceDWORD = 0x7fffffff,
Last = 9,
sRGB = 7,
Unknown = 0
}public enum MFVideoPrimaries {
BT470_2_SysBG = 4,
BT470_2_SysM = 3,
BT709 = 2,
EBU3213 = 7,
ForceDWORD = 0x7fffffff,
Last = 9,
reserved = 1,
SMPTE_C = 8,
SMPTE170M = 5,
SMPTE240M = 6,
Unknown = 0
}public enum MFVideoTransferMatrix {
BT601 = 2,
BT709 = 1,
ForceDWORD = 0x7fffffff,
Last = 4,
SMPTE240M = 3,
Unknown = 0
}public enum MFVideoLighting {
Bright = 1,
Dark = 4,
Dim = 3,
ForceDWORD = 0x7fffffff,
Last = 5,
Office = 2,
Unknown = 0
}public enum MFNominalRange {
MFNominalRange_0_255 = 1,
MFNominalRange_16_235 = 2,
MFNominalRange_48_208 = 3,
MFNominalRange_ForceDWORD = 0x7fffffff,
MFNominalRange_Last = 4,
MFNominalRange_Normal = 1,
MFNominalRange_Unknown = 0,
MFNominalRange_Wide = 2
}[Flags]
public enum MFVideoFlags : long {
PAD_TO_Mask = 0×0001 | 0×0002,
PAD_TO_None = 0 * 0×0001,
PAD_TO_4x3 = 1 * 0×0001,
PAD_TO_16x9 = 2 * 0×0001,
SrcContentHintMask = 0×0004 | 0×0008 | 0×0010,
SrcContentHintNone = 0 * 0×0004,
SrcContentHint16x9 = 1 * 0×0004,
SrcContentHint235_1 = 2 * 0×0004,
AnalogProtected = 0×0020,
DigitallyProtected = 0×0040,
ProgressiveContent = 0×0080,
FieldRepeatCountMask = 0×0100 | 0×0200 | 0×0400,
FieldRepeatCountShift = 8,
ProgressiveSeqReset = 0×0800,
PanScanEnabled = 0×20000,
LowerFieldFirst = 0×40000,
BottomUpLinearRep = 0×80000,
DXVASurface = 0×100000,
RenderTargetSurface = 0×400000,
ForceQWORD = 0x7FFFFFFF
}[Flags]
public enum MF_EVENT_FLAG {
None = 0,
NoWait = 0×00000001
}public enum MFASYNC_CALLBACK_QUEUE {
Undefined = 0×00000000,
Standard = 0×00000001,
RT = 0×00000002,
IO = 0×00000003,
Timer = 0×00000004,
LongFunction = 0×00000007,
PrivateMask = unchecked((int)0xFFFF0000),
All = unchecked((int)0xFFFFFFFF)
}[Flags]
public enum MFASYNC {
None = 0,
FastIOProcessingCallback = 0×00000001,
SignalCallback = 0×00000002
}public enum MFSTARTUP {
NoSocket = 0×1,
Lite = 0×1,
Full = 0
}[Flags]
public enum MFResolution {
None = 0×0,
MediaSource = 0×00000001,
ByteStream = 0×00000002,
ContentDoesNotHaveToMatchExtensionOrMimeType = 0×00000010,
KeepByteStreamAliveOnFail = 0×00000020,
Read = 0×00010000,
Write = 0×00020000
}[Flags]
public enum MFBYTESTREAM {
None = 0×00000000,
IsReadable = 0×00000001,
IsWritable = 0×00000002,
IsSeekable = 0×00000004,
IsRemote = 0×00000008,
IsDirectory = 0×00000080,
HasSlowSeek = 0×00000100,
IsPartiallyDownloaded = 0×00000200
}public enum MFBYTESTREAM_SEEK_ORIGIN {
Begin,
Current
}[Flags]
public enum MFBYTESTREAM_SEEK_FLAG {
None = 0,
CancelPendingIO = 1
}public enum MF_OBJECT_TYPE {
MediaSource,
ByteStream,
Invalid
}public enum MediaEventType {
MEUnknown = 0,
MEError = (MEUnknown + 1),
MEExtendedType = (MEError + 1),
MESessionUnknown = 100,
MESessionTopologySet = (MESessionUnknown + 1),
MESessionTopologiesCleared = (MESessionTopologySet + 1),
MESessionStarted = (MESessionTopologiesCleared + 1),
MESessionPaused = (MESessionStarted + 1),
MESessionStopped = (MESessionPaused + 1),
MESessionClosed = (MESessionStopped + 1),
MESessionEnded = (MESessionClosed + 1),
MESessionRateChanged = (MESessionEnded + 1),
MESessionScrubSampleComplete = (MESessionRateChanged + 1),
MESessionCapabilitiesChanged = (MESessionScrubSampleComplete + 1),
MESessionTopologyStatus = (MESessionCapabilitiesChanged + 1),
MESessionNotifyPresentationTime = (MESessionTopologyStatus + 1),
MENewPresentation = (MESessionNotifyPresentationTime + 1),
MELicenseAcquisitionStart = (MENewPresentation + 1),
MELicenseAcquisitionCompleted = (MELicenseAcquisitionStart + 1),
MEIndividualizationStart = (MELicenseAcquisitionCompleted + 1),
MEIndividualizationCompleted = (MEIndividualizationStart + 1),
MEEnablerProgress = (MEIndividualizationCompleted + 1),
MEEnablerCompleted = (MEEnablerProgress + 1),
MEPolicyError = (MEEnablerCompleted + 1),
MEPolicyReport = (MEPolicyError + 1),
MEBufferingStarted = (MEPolicyReport + 1),
MEBufferingStopped = (MEBufferingStarted + 1),
MEConnectStart = (MEBufferingStopped + 1),
MEConnectEnd = (MEConnectStart + 1),
MEReconnectStart = (MEConnectEnd + 1),
MEReconnectEnd = (MEReconnectStart + 1),
MERendererEvent = (MEReconnectEnd + 1),
MESessionStreamSinkFormatChanged = (MERendererEvent + 1),
MESourceUnknown = 200,
MESourceStarted = (MESourceUnknown + 1),
MEStreamStarted = (MESourceStarted + 1),
MESourceSeeked = (MEStreamStarted + 1),
MEStreamSeeked = (MESourceSeeked + 1),
MENewStream = (MEStreamSeeked + 1),
MEUpdatedStream = (MENewStream + 1),
MESourceStopped = (MEUpdatedStream + 1),
MEStreamStopped = (MESourceStopped + 1),
MESourcePaused = (MEStreamStopped + 1),
MEStreamPaused = (MESourcePaused + 1),
MEEndOfPresentation = (MEStreamPaused + 1),
MEEndOfStream = (MEEndOfPresentation + 1),
MEMediaSample = (MEEndOfStream + 1),
MEStreamTick = (MEMediaSample + 1),
MEStreamThinMode = (MEStreamTick + 1),
MEStreamFormatChanged = (MEStreamThinMode + 1),
MESourceRateChanged = (MEStreamFormatChanged + 1),
MEEndOfPresentationSegment = (MESourceRateChanged + 1),
MESourceCharacteristicsChanged = (MEEndOfPresentationSegment + 1),
MESourceRateChangeRequested = (MESourceCharacteristicsChanged + 1),
MESourceMetadataChanged = (MESourceRateChangeRequested + 1),
MESequencerSourceTopologyUpdated = (MESourceMetadataChanged + 1),
MESinkUnknown = 300,
MEStreamSinkStarted = (MESinkUnknown + 1),
MEStreamSinkStopped = (MEStreamSinkStarted + 1),
MEStreamSinkPaused = (MEStreamSinkStopped + 1),
MEStreamSinkRateChanged = (MEStreamSinkPaused + 1),
MEStreamSinkRequestSample = (MEStreamSinkRateChanged + 1),
MEStreamSinkMarker = (MEStreamSinkRequestSample + 1),
MEStreamSinkPrerolled = (MEStreamSinkMarker + 1),
MEStreamSinkScrubSampleComplete = (MEStreamSinkPrerolled + 1),
MEStreamSinkFormatChanged = (MEStreamSinkScrubSampleComplete + 1),
MEStreamSinkDeviceChanged = (MEStreamSinkFormatChanged + 1),
MEQualityNotify = (MEStreamSinkDeviceChanged + 1),
MESinkInvalidated = (MEQualityNotify + 1),
MEAudioSessionNameChanged = (MESinkInvalidated + 1),
MEAudioSessionVolumeChanged = (MEAudioSessionNameChanged + 1),
MEAudioSessionDeviceRemoved = (MEAudioSessionVolumeChanged + 1),
MEAudioSessionServerShutdown = (MEAudioSessionDeviceRemoved + 1),
MEAudioSessionGroupingParamChanged = (MEAudioSessionServerShutdown + 1),
MEAudioSessionIconChanged = (MEAudioSessionGroupingParamChanged + 1),
MEAudioSessionFormatChanged = (MEAudioSessionIconChanged + 1),
MEAudioSessionDisconnected = (MEAudioSessionFormatChanged + 1),
MEAudioSessionExclusiveModeOverride = (MEAudioSessionDisconnected + 1),
METrustUnknown = 400,
MEPolicyChanged = (METrustUnknown + 1),
MEContentProtectionMessage = (MEPolicyChanged + 1),
MEPolicySet = (MEContentProtectionMessage + 1),
MEWMDRMLicenseBackupCompleted = 500,
MEWMDRMLicenseBackupProgress = 501,
MEWMDRMLicenseRestoreCompleted = 502,
MEWMDRMLicenseRestoreProgress = 503,
MEWMDRMLicenseAcquisitionCompleted = 506,
MEWMDRMIndividualizationCompleted = 508,
MEWMDRMIndividualizationProgress = 513,
MEWMDRMProximityCompleted = 514,
MEWMDRMLicenseStoreCleaned = 515,
MEWMDRMRevocationDownloadCompleted = 516,
MEReservedMax = 10000
}public enum MF_ATTRIBUTE_TYPE {
None = 0×0,
Blob = 0×1011,
Double = 0×5,
Guid = 0×48,
IUnknown = 13,
String = 0x1f,
Uint32 = 0×13,
Uint64 = 0×15
}public enum MF_ATTRIBUTES_MATCH_TYPE {
OurItems,
TheirItems,
AllItems,
InterSection,
Smaller
}[Flags]
public enum MFMEDIASOURCE_CHARACTERISTICS {
None = 0,
IsLive = 0×1,
CanSeek = 0×2,
CanPause = 0×4,
HasSlowSeek = 0×8
}[Flags]
public enum MF_MEDIATYPE_EQUAL {
None = 0,
MajorTypes = 0×00000001,
FormatTypes = 0×00000002,
FormatData = 0×00000004,
FormatUserData = 0×00000008
}
#endregion#endregion
Some cumbersome, right? It is! however those interfaces are extensible. Here for example some added value of such approach
How to read media metadata by using Media Foundation
Now, when we did most of work, metadata is piece of cake. All we need is to get service handle
object s;
MFGetService(source, MFServices.MF_PROPERTY_HANDLER_SERVICE, typeof(IPropertyStore).GUID, out s);
var store = (IPropertyStore)s;
and get information our of property bag
track.Album = _getInfo<string>(store, MFPropertyKeys.AlbumTitle);
track.Name = _getInfo<string>(store, MFPropertyKeys.Title);
track.Comments = _getInfo<string>(store, MFPropertyKeys.Comment);
track.Duration = TimeSpan.FromTicks(_getInfo<long>(store, Interop.MFPropertyKeys.MediaDuration));
…
Those interfaces uses COM property bag to retrieve information of invariant type
private static T _getInfo<T>(IPropertyStore store, PROPERTYKEY key) {
PROPVARIANT val;
store.GetValue(key, out val);
return (T)val.Value;
}
Here how this object looks in managed code
[StructLayout(LayoutKind.Sequential)]
public class PROPERTYKEY {public PROPERTYKEY(Guid tid, uint id) {
fmtid = tid;
pid = id;
}public Guid fmtid;
public uint pid;
}#pragma warning disable 618
[StructLayout(LayoutKind.Explicit)]
public struct PROPVARIANT {
[FieldOffset(0)]
short vt;
[FieldOffset(2)]
short wReserved1;
[FieldOffset(4)]
short wReserved2;
[FieldOffset(6)]
short wReserved3;
[FieldOffset(8)]
sbyte cVal;
[FieldOffset(8)]
byte bVal;
[FieldOffset(8)]
short iVal;
[FieldOffset(8)]
ushort uiVal;
[FieldOffset(8)]
int lVal;
[FieldOffset(8)]
uint ulVal;
[FieldOffset(8)]
int intVal;
[FieldOffset(8)]
uint uintVal;
[FieldOffset(8)]
long hVal;
[FieldOffset(8)]
long uhVal;
[FieldOffset(8)]
float fltVal;
[FieldOffset(8)]
double dblVal;
[FieldOffset(8)]
bool boolVal;
[FieldOffset(8)]
int scode;
[FieldOffset(8)]
DateTime date;
[FieldOffset(8)]
FILETIME filetime;
[FieldOffset(8)]
BLOB blobVal;
[FieldOffset(8)]
IntPtr pwszVal;private byte[] _getBlob() {
var result = new byte[blobVal.cbSize];
Marshal.Copy(blobVal.pBlobData, result, 0, result.Length);
return result;
}public object Value {
get {
VarEnum ve = (VarEnum)vt;
switch (ve) {
case VarEnum.VT_I1:
return bVal;
case VarEnum.VT_I2:
return iVal;
case VarEnum.VT_I4:
return lVal;
case VarEnum.VT_I8:
return hVal;
case VarEnum.VT_INT:
return iVal;
case VarEnum.VT_UI4:
return ulVal;
case VarEnum.VT_UI8:
return uhVal;
case VarEnum.VT_LPWSTR:
return Marshal.PtrToStringUni(pwszVal);
case VarEnum.VT_BLOB:
return _getBlob();
case VarEnum.VT_EMPTY:
case VarEnum.VT_NULL:
return null;
}
throw new NotImplementedException("PROPVARIANT: " + ve.ToString());
}
}
}
And some additional classes and guids to fulfill solution.
public static class MFAttributesClsid {
public static readonly Guid MF_PD_DURATION = new Guid(0x6c990d33, 0xbb8e, 0x477a, 0×85, 0×98, 0xd, 0x5d, 0×96, 0xfc, 0xd8, 0x8a);
public static readonly Guid MF_MT_SUBTYPE = new Guid(0xf7e34c9a, 0x42e8, 0×4714, 0xb7, 0x4b, 0xcb, 0×29, 0xd7, 0x2c, 0×35, 0xe5);
public static readonly Guid MF_MT_AVG_BITRATE = new Guid(0×20332624, 0xfb0d, 0x4d9e, 0xbd, 0x0d, 0xcb, 0xf6, 0×78, 0x6c, 0×10, 0x2e);
}public static class MFMediaType {
public static readonly Guid Default = new Guid(0x81A412E6, 0×8103, 0x4B06, 0×85, 0x7F, 0×18, 0×62, 0×78, 0×10, 0×24, 0xAC);
public static readonly Guid Audio = new Guid(0×73647561, 0×0000, 0×0010, 0×80, 0×00, 0×00, 0xAA, 0×00, 0×38, 0x9B, 0×71);
public static readonly Guid Video = new Guid(0×73646976, 0×0000, 0×0010, 0×80, 0×00, 0×00, 0xAA, 0×00, 0×38, 0x9B, 0×71);
}public static class MFServices {
public static readonly Guid MF_PROPERTY_HANDLER_SERVICE = new Guid(0xa3face02, 0x32b8, 0x41dd, 0×90, 0xe7, 0x5f, 0xef, 0x7c, 0×89, 0×91, 0xb5);
}public static class MFPropertyKeys {
public static readonly PROPERTYKEY Title = new PROPERTYKEY(new Guid(0xf29f85e0, 0x4ff9, 0×1068, 0xab, 0×91, 0×08, 0×00, 0x2b, 0×27, 0xb3, 0xd9), 2);
public static readonly PROPERTYKEY AlbumTitle = new PROPERTYKEY(new Guid(0x56A3372E, 0xCE9C, 0x11D2, 0x9F, 0x0E, 0×00, 0×60, 0×97, 0xC6, 0×86, 0xF6), 4);
public static readonly PROPERTYKEY Author = new PROPERTYKEY(new Guid(0xF29F85E0, 0x4FF9, 0×1068, 0xAB, 0×91, 0×08, 0×00, 0x2B, 0×27, 0xB3, 0xD9), 4);
public static readonly PROPERTYKEY AudioCompression = new PROPERTYKEY(new Guid(0×64440490, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 10);
public static readonly PROPERTYKEY AudioFormat = new PROPERTYKEY(new Guid(0×64440490, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 2);
public static readonly PROPERTYKEY Category = new PROPERTYKEY(new Guid(0xD5CDD502, 0x2E9C, 0x101B, 0×93, 0×97, 0×08, 0×00, 0x2B, 0x2C, 0xF9, 0xAE), 2);
public static readonly PROPERTYKEY Company = new PROPERTYKEY(new Guid(0xD5CDD502, 0x2E9C, 0x101B, 0×93, 0×97, 0×08, 0×00, 0x2B, 0x2C, 0xF9, 0xAE), 15);
public static readonly PROPERTYKEY Copyright = new PROPERTYKEY(new Guid(0×64440492, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 11);
public static readonly PROPERTYKEY Comment = new PROPERTYKEY(new Guid(0xF29F85E0, 0x4FF9, 0×1068, 0xAB, 0×91, 0×08, 0×00, 0x2B, 0×27, 0xB3, 0xD9), 6);
public static readonly PROPERTYKEY MediaDuration = new PROPERTYKEY(new Guid(0×64440490, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 3);
public static readonly PROPERTYKEY VideoCompression = new PROPERTYKEY(new Guid(0×64440491, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 10);
public static readonly PROPERTYKEY VideoDirector = new PROPERTYKEY(new Guid(0×64440492, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 20);
public static readonly PROPERTYKEY VideoFourCC = new PROPERTYKEY(new Guid(0×64440491, 0x4C8B, 0x11D1, 0x8B, 0×70, 0×08, 0×00, 0×36, 0xB1, 0x1A, 0×03), 44);
}
We almost finished. The only thing is not to forget release all COM objects (Marshal.ReleaseComObject(…)) to prevent memory leaks and init and shutdown Media Foundation:
MFStartup(0×10070, Interop.MFSTARTUP.Lite);
…
MFShutdown();
You choose what to use: simple, but not supported or complicated but extensible approach. Both will bring the same results. So have a nice day and be good people.
August 10th, 2011 · Comments (1)
Quick how to: Reduce number of colors programmatically
My colleague just asked me about how to reduce a number of colors in image programmatically. This is very simple task and contains of 43 
steps:
First of all, you have to read a source image
using (var img = Image.FromFile(name)) {
var bmpEncoder = ImageCodecInfo.GetImageDecoders().FirstOrDefault(e => e.FormatID == ImageFormat.Bmp.Guid);
Then create your own encoder with certain color depth (32 bits in this case)
var myEncoder = System.Drawing.Imaging.Encoder.ColorDepth;
var myEncoderParameter = new EncoderParameter(myEncoder, 32L);
var myEncoderParameters = new EncoderParameters(1) { Param = new EncoderParameter[] { myEncoderParameter } };
Then save it
img.Save(name.Replace(“.png”, “.bmp”), bmpEncoder, myEncoderParameters);
It it enough? Not really, because if you’re going to loose colors (by reducing color depth), it makes sense to avoid letting default WIX decoder to do this, thus you have to find nearest base colors manually. How to do this? By using simple math
Color GetNearestBaseColor(Color exactColor) {
Color nearestColor = Colors.Black;
int cnt = baseColors.Count;
for (int i = 0; i < cnt; i++) {
int rRed = baseColors[i].R – exactColor.R;
int rGreen = baseColors[i].G – exactColor.G;
int rBlue = baseColors[i].B – exactColor.B;int rDistance =
(rRed * rRed) +
(rGreen * rGreen) +
(rBlue * rBlue);
if (rDistance == 0.0) {
return baseColors[i];
} else if (rDistance < maxDistance) {
maxDistance = rDistance;
nearestColor = baseColors[i];
}
}
return nearestColor;
}
Now, you can either change colors on base image directly
unsafe {
uint* pBuffer = (uint*)hMap;
for (int iy = 0; iy < (int)ColorMapSource.PixelHeight; ++iy)
{
for (int ix = 0; ix < nWidth; ++ix)
{
Color nc = GetNearestBaseColor(pBuffer[0].FromOle());pBuffer[0] &= (uint)((uint)nc.A << 24) | //A
(uint)(nc.R << 16 ) | //R
(uint)(nc.G << 8 ) | //G
(uint)(nc.B ); //B
++pBuffer;
}
pBuffer += nOffset;
}
}
Or, if you’re in WPF and .NET 3.5 create simple pixel shader effect to do it for you in hardware. Now, my colleague can do it himself in about 5 minutes . Have a nice day and be good people.
February 9th, 2009 · Comments (3)
Bootstrapper for .NET framework version detector
You wrote your .NET program, that can be used as stand alone portable application (such as it should be for Smart Client Apps), however you have to be sure, that necessary prerequisites (such as .NET framework) are installed on client’s machine. What to do? How to detect .NET framework version installed on target machine before running .NET application. The answer is – to use unmanaged C++ bootstrapper, that invoke your application if correct version of framework is installed.
Until now there are 15 possible .NET frameworks can be installed on client’s machine. Here the table of possible and official supported versions, as appears in Q318785
| .NET version | Actual version |
| 3.5 SP1 | 3.5.30729.1 |
| 3.5 | 3.5.21022.8 |
| 3.0 SP2 | 3.0.4506.2152 |
| 3.0 SP1 | 3.0.4506.648 |
| 3.0 | 3.0.4506.30 |
| 2.0 SP2 | 2.0.50727.3053 |
| 2.0 SP1 | 2.0.50727.1433 |
| 2.0 | 2.0.50727.42 |
| 1.1 SP1 | 1.1.4322.2032 |
| 1.1 SP1 (in 32 bit version of Windows 2003) | 1.1.4322.2300 |
| 1.1 | 1.1.4322.573 |
| 1.0 SP3 | 1.0.3705.6018 |
| 1.0 SP2 | 1.0.3705.288 |
| 1.0 SP1 | 1.0.3705.209 |
| 1.0 | 1.0.3705.0 |
All of those versions are detectible by queering specific registry keys. However, in some cases, you need to load mscoree.dll and call “GETCOREVERSION” API to determine whether specific version of .NET is installed. You can read more about it in MSDN.
So it’s really simple to write small C++ application (or PowerShell applet), that queries registry and invoke your managed application. How to do this? You can either read about it in outstanding blog of Aaron Stebner, who is Project Manager in XNA platform deployment team or attend my session next week to learn do it yourself. We’ll speak about nifty ways to do it also.
Anyway, by now, you can use small stand alone program, I wrote a while ago, that will tell you all versions of .NET frameworks installed in target machine without any prerequisites. It can be run even from shared network location
See you next week.
PS: Do not forget to download and install the new version of Visual Studio Snippet Designer, which is extremely useful tool by MVP Bill McCarthy, you’ll need it later next week…
Have a nice day and be good people.
February 4th, 2009 · Comments (8)
Audio CD operation including CD-Text reading in pure C#
Recently we spoke about reading radio data in C#, however as in any vehicle we have also CD players. So what can be better, than to have an ability to play CDs while being notified about track name, gathered from CD-Text?
So, let’s start. First of all, I want to express my pain with MSDN documentation about CD-ROM structure. Documentation team, please, please, please update it. First of all it is no accurate, then there are a ton of things missing. However, “À la guerre comme à la guerre”, thus I invested three days in deep DDK research.
Before we can do anything with CD-ROM, we have to find it. I took the same approach as I used for HID devices. Let’s create a device
[SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode = true)]
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
public class CDDADevice : SafeHandleZeroOrMinusOneIsInvalid, IDisposable, INotifyPropertyChanged {
Internal constructor for security reasons
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
internal CDDADevice(char drive) : base(true) {
findDevice(drive);
}
And a find method itself
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
private void findDevice(char drive) {
if (Drive == drive) return;
if (Native.GetDriveType(string.Concat(drive, ":\")) == Native.DRIVE.CDROM) {
this.handle = Native.CreateFile(string.Concat("\\.\", drive, ‘:’), Native.GENERIC_READ, Native.FILE_SHARE_READ, IntPtr.Zero, Native.OPEN_EXISTING, Native.FILE_ATTRIBUTE_READONLY | Native.FILE_FLAG_SEQUENTIAL_SCAN, IntPtr.Zero);
if (this.handle.ToInt32() != -1 && this.handle.ToInt32() != 0) this.Drive = drive;
}
}
Where GetDriveType and CreateFile are win32 methods with following signatures
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
internal static extern DRIVE GetDriveType(string drive);
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
internal static extern IntPtr CreateFile(
string lpFileName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr SecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplateFile);
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
internal static extern bool CloseHandle(IntPtr hHandle);
Also, we need some constants
internal enum DRIVE : byte {
UNKNOWN = 0,
NO_ROOT_DIR,
REMOVABLE,
FIXED,
REMOTE,
CDROM,
RAMDISK
}internal const uint GENERIC_READ = 0×80000000;
internal const uint FILE_SHARE_READ = 0×00000001;
internal const uint OPEN_EXISTING = 3;
internal const uint FILE_ATTRIBUTE_READONLY = 0×00000001;
internal const uint FILE_FLAG_SEQUENTIAL_SCAN = 0×08000000;
Now, when we have our cdrom handle in hands, we can read it’s Table Of Content. Now, thing become harder because of the fact, that we have to use very complicated platform method:
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[DllImport("kernel32.dll", EntryPoint = "DeviceIoControl", SetLastError=true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool DeviceIoControl(
[In] IntPtr hDevice,
IOCTL dwIoControl,
[In] IntPtr lpInBuffer,
uint nInBufferSize,
IntPtr lpOutBuffer,
uint nOutBufferSize,
out uint lpBytesReturned,
IntPtr lpOverlapped);
When thing are generic it’s good, however this one is, probably, most generic method in Win32 API. You can do anything with this method and you never know what to expect in lpOutBuffer
However, as I told earlier, I invested three days in investigations and researches (tnx to DDK documentation team) and now things become to be clearer. We need to get CDROM_TOC. It done by invoking IOCTL_CDROM_READ_TOC call
uint bytesRead = 0;
TOC = new Native.CDROM_TOC();
TOC.Length = (ushort)Marshal.SizeOf(TOC);
var hTOC = Marshal.AllocHGlobal(TOC.Length);
Marshal.StructureToPtr(TOC, hTOC, true);
if (Native.DeviceIoControl(this.handle, Native.IOCTL.CDROM_READ_TOC, IntPtr.Zero, 0, hTOC, TOC.Length, out bytesRead, IntPtr.Zero)) Marshal.PtrToStructure(hTOC, TOC);
Marshal.FreeHGlobal(hTOC);
But, not too fast. CDROM_TOC contains array of TRACK_DATA with unknown size.
typedef struct _CDROM_TOC {
UCHAR Length[2];
UCHAR FirstTrack;
UCHAR LastTrack;
TRACK_DATA TrackData[MAXIMUM_NUMBER_TRACKS];
} CDROM_TOC, *PCDROM_TOC;typedef struct _TRACK_DATA {
UCHAR Reserved;
UCHAR Control : 4;
UCHAR Adr : 4;
UCHAR TrackNumber;
UCHAR Reserved1;
UCHAR Address[4];
} TRACK_DATA, *PTRACK_DATA;
P/Invoke it! But how to marshal unknown array? We should create wrapper object. Also there is very fun BitVector, used in this structure! What’s the problem? Pin it with some Math!
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class CDROM_TOC {public ushort Length;
public byte FirstTrack;
public byte LastTrack;
public TRACK_DATA_ARRAY TrackData;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct TRACK_DATA {public byte Reserved;
public byte bitVector;
public byte Control {
get { return ((byte)((this.bitVector & 15u))); }
set { this.bitVector = ((byte)((value | this.bitVector))); }
}
public byte Adr {
get { return ((byte)(((this.bitVector & 240u) / 16))); }
set { this.bitVector = ((byte)(((value * 16) | this.bitVector))); }
}
public byte TrackNumber;
public byte Reserved1;
public uint Address;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
internal sealed class TRACK_DATA_ARRAY {internal TRACK_DATA_ARRAY() { data = new byte[MAXIMUM_NUMBER_TRACKS * Marshal.SizeOf(typeof(TRACK_DATA))]; }
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAXIMUM_NUMBER_TRACKS * 8)]
private byte[] data;public TRACK_DATA this[int idx] {
get {
if ((idx < 0) | (idx >= MAXIMUM_NUMBER_TRACKS)) throw new IndexOutOfRangeException();
TRACK_DATA res;
var hData = GCHandle.Alloc(data, GCHandleType.Pinned);
try {
var buffer = hData.AddrOfPinnedObject();
buffer = (IntPtr)(buffer.ToInt32() + (idx * Marshal.SizeOf(typeof(TRACK_DATA))));
res = (TRACK_DATA)Marshal.PtrToStructure(buffer, typeof(TRACK_DATA));
} finally {
hData.Free();
}
return res;
}
}
}
Fuf, done. The code is rather self explaining, we just “tell” marshaler, that we have byte array, while calculating pointers to pinned object to get actual value and marshal it back. So, now we have TOC. So, we know how many tracks we have and addresses to data chunks inside the CD.
But it now enough to understand where our tracks. CD-ROM structure is very tricky. There we have blocks or sectors (which is the smallest chunks of data), so we have to convert bytes into sector addresses. Each block is 2352 bytes in RAW mode, while address value inside TRACK_DATA points us to layout address with is sync, sector id, error detection etc… So, in order to convert TRACK object into actual track number on disk, we have to stick to following method
public static int SectorAddress(this TRACK_DATA data) {
var addr = BitConverter.GetBytes(data.Address);return (addr[1] * 60 * 75 + addr[2] * 75 + addr[3]) – 150;
}
Now, when we know numbers of tracks, we also know start and end sector, disk type and other useful information we are ready to twist it a bit and read CD-Text (if there are and your CD reader supports it).
So, coming back to our favorite method DeviceIoControl, but this time with IOCTL_CDROM_READ_TOC_EX control.
bytesRead = 0;
TOCex = new Native.CDROM_READ_TOC_EX {Format = Native.CDROM_READ_TOC_EX_FORMAT.CDTEXT
};
var sTOCex = Marshal.SizeOf(TOCex);
var hTOCex = Marshal.AllocHGlobal(sTOCex);
Marshal.StructureToPtr(TOCex, hTOCex, true);
var Data = new Native.CDROM_TOC_CD_TEXT_DATA();
Data.Length = (ushort)Marshal.SizeOf(Data);var hData = Marshal.AllocHGlobal(Data.Length);
Marshal.StructureToPtr(Data, hData, true);
if (Native.DeviceIoControl(this.handle, Native.IOCTL.CDROM_READ_TOC_EX, hTOCex, (ushort)sTOCex, hData, Data.Length, out bytesRead, IntPtr.Zero)) Marshal.PtrToStructure(hData, Data);
Marshal.FreeHGlobal(hData);
Marshal.FreeHGlobal(hTOCex);
Looks too simple? Let’s see inside CDROM_READ_TOC_EX structure. It is very similar to _CDROM_TOC.
typedef struct _CDROM_READ_TOC_EX {
UCHAR Format : 4;
UCHAR Reserved1 : 3;
UCHAR Msf : 1;
UCHAR SessionTrack;
UCHAR Reserved2;
UCHAR Reserved3;
} CDROM_READ_TOC_EX, *PCDROM_READ_TOC_EX;
Simple. Isn’t it?
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct CDROM_READ_TOC_EX {public uint bitVector;
public CDROM_READ_TOC_EX_FORMAT Format {
get { return ((CDROM_READ_TOC_EX_FORMAT)((this.bitVector & 15u))); }
set { this.bitVector = (uint)((byte)value | this.bitVector); }
}
public uint Reserved1 {
get { return ((uint)(((this.bitVector & 112u) / 16))); }set { this.bitVector = ((uint)(((value * 16) | this.bitVector))); }
}
public uint Msf {
get { return ((uint)(((this.bitVector & 128u) / 128))); }set { this.bitVector = ((uint)(((value * 128) | this.bitVector))); }
}
public byte SessionTrack;
public byte Reserved2;
public byte Reserved3;
}
But what will come inside lpOutBuffer? Fellow structure, named CDROM_TOC_CD_TEXT_DATA with unknown size array of CDROM_TOC_CD_TEXT_DATA_BLOCK
typedef struct _CDROM_TOC_CD_TEXT_DATA {
UCHAR Length[2];
UCHAR Reserved1;
UCHAR Reserved2;
CDROM_TOC_CD_TEXT_DATA_BLOCK Descriptors[0];
} CDROM_TOC_CD_TEXT_DATA, *PCDROM_TOC_CD_TEXT_DATA;typedef struct _CDROM_TOC_CD_TEXT_DATA_BLOCK {
UCHAR PackType;
UCHAR TrackNumber:7;
UCHAR ExtensionFlag:1;
UCHAR SequenceNumber;
UCHAR CharacterPosition:4;
UCHAR BlockNumber:3;
UCHAR Unicode:1;
union {
UCHAR Text[12];
WCHAR WText[6];
};
UCHAR CRC[2];
} CDROM_TOC_CD_TEXT_DATA_BLOCK, *PCDROM_TOC_CD_TEXT_DATA_BLOCK;
Too bad to be true. Isn’t it? Let’s try to marshal it my hands (with the trick used for TRACK_DATA
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class CDROM_TOC_CD_TEXT_DATA {public ushort Length;
public byte Reserved1;
public byte Reserved2;
public CDROM_TOC_CD_TEXT_DATA_BLOCK_ARRAY Descriptors;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
internal sealed class CDROM_TOC_CD_TEXT_DATA_BLOCK_ARRAY {internal CDROM_TOC_CD_TEXT_DATA_BLOCK_ARRAY() { data = new byte[MINIMUM_CDROM_READ_TOC_EX_SIZE * MAXIMUM_NUMBER_TRACKS * Marshal.SizeOf(typeof(CDROM_TOC_CD_TEXT_DATA_BLOCK))]; }
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MINIMUM_CDROM_READ_TOC_EX_SIZE * MAXIMUM_NUMBER_TRACKS * 18)]
private byte[] data;public CDROM_TOC_CD_TEXT_DATA_BLOCK this[int idx] {
get {
if ((idx < 0) | (idx >= MINIMUM_CDROM_READ_TOC_EX_SIZE * MAXIMUM_NUMBER_TRACKS)) throw new IndexOutOfRangeException();
CDROM_TOC_CD_TEXT_DATA_BLOCK res;
var hData = GCHandle.Alloc(data, GCHandleType.Pinned);
try {
var buffer = hData.AddrOfPinnedObject();
buffer = (IntPtr)(buffer.ToInt32() + (idx * Marshal.SizeOf(typeof(CDROM_TOC_CD_TEXT_DATA_BLOCK))));
res = (CDROM_TOC_CD_TEXT_DATA_BLOCK)Marshal.PtrToStructure(buffer, typeof(CDROM_TOC_CD_TEXT_DATA_BLOCK));
} finally {
hData.Free();
}
return res;
}
}
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct CDROM_TOC_CD_TEXT_DATA_BLOCK {public CDROM_CD_TEXT_PACK PackType;
public byte bitVector1;
public byte TrackNumber {
get { return ((byte)((this.bitVector1 & 127u))); }
set { this.bitVector1 = ((byte)((value | this.bitVector1))); }
}
public byte ExtensionFlag {
get { return ((byte)(((this.bitVector1 & 128u) / 128))); }set { this.bitVector1 = ((byte)(((value * 128) | this.bitVector1))); }
}
public byte SequenceNumber;
public byte bitVector2;public byte CharacterPosition {
get { return ((byte)((this.bitVector2 & 15u))); }set { this.bitVector2 = ((byte)((value | this.bitVector2))); }
}
public byte BlockNumber {
get { return ((byte)(((this.bitVector2 & 112u) / 16))); }set { this.bitVector2 = ((byte)(((value * 16) | this.bitVector2))); }
}
public byte Unicode {
get { return ((byte)(((this.bitVector2 & 128u) / 128))); }set { this.bitVector2 = ((byte)(((value * 128) | this.bitVector2))); }
}
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12, ArraySubType = UnmanagedType.I1)]
public byte[] TextBuffer;
public string Text {
get { return (Unicode == 1) ? ASCIIEncoding.ASCII.GetString(TextBuffer) : UTF32Encoding.UTF8.GetString(TextBuffer); }}
public ushort CRC;
}
Can’t you see a small problem here? Yes, we do not know the actual/maximum size of CDROM_TOC_CD_TEXT_DATA_BLOCK array. Until, I’ll find a nice way to marshal smart pointers, we’ll stick to MAX_TRACKS (100) * MIN_DATA_BLOCK (2).
We almost finished and the worst things are behind us. Now you should enumerate thru CDROM_TOC_CD_TEXT_DATA_BLOCK and look for Text, TrackNumber and SequenceNumber (which is continuation of text reported). For example, slot for ALBUM_NAME “Satisfaction” will looks as following
| BlockNumber | 0×00 |
| CharacterPosition | 0×00 |
| CRC | 0x3EAB |
| SequenceNumber | 0×00 |
| Text | SATISFACTIO |
| BlockNumber | 0×00 |
| CharacterPosition | 0x0B |
| CRC | 0×0564 |
| SequenceNumber | 0×01 |
| Text | N |
And so on… What to do with all other data and how to use it to enhance listening (ripping/crunching/seeking) experience we’ll speak next time. Have a good day and be good people.
January 7th, 2009 · Comments (5)
USB FM radio library was published on CodePlex
I just published a part of my latest project – dynamic library to work with FM receivers on CodePlex under MS-PL. So, feel free do download, test and use it.
Note, that this release is preliminary and has a lot of bugs. Also, RDS is not fully implements as well as recording capabilities with Direct Sound.
I’m keep working to provide WPF UI for this library to “productize” it.
So, what are you waiting for? Download and Spear the word with this news! This is the first and only fully managed library (as far as I know) to work with RDS, TMC and FM data. Also, there are not a lot of information about HID usage as FM receiver in managed code.
Download latest release of USBFM.DLL >>
January 2nd, 2009 · Comments (10)
How to migrate from CS2007 to WordPress, Movable Type (or any other blog engine, supports XML-RPC) with C#
Today we’ll speak about migration from community server 2007 to another blog engine, when you have no access to CS and/or other database.
Let’s set targets first:
- You want to migrate all posts
- You want to migrate all comments
- You want to transfer all hosted images and media files
- You should update all internal links
Looks complicated? not really. First of all, grab any XML-RPC framework (for example xml-rcp.net). Then create a proxy to CS2007 – it uses Metablog API. You can see all defined methods by accessing /blogs/metablog.ashx
[XmlRpcUrl("http://blogs.microsoft.co.il/blogs/tamir/rsscomments.aspx?PostID=", posts[i].postid);
_rssReader = new XmlTextReader(commentsRSSURL);while (_rssReader.Read()) {
_rssReader.MoveToContent();
if (_rssReader.NodeType == XmlNodeType.Element) {
if (_rssReader.Name == "pubDate") { date = DateTime.Parse(_rssReader.ReadElementContentAsString()); }
if (_rssReader.Name == "dc:creator") { author = _rssReader.ReadElementContentAsString(); }
if (_rssReader.Name == "description") {
if (!shouldSkip) {
content = _rssReader.ReadElementContentAsString();
comments.Add(new Comment {
author = author,
date_created_gmt = date,
status = true
As you can see, now you have all comments. Next step is to detect and reupload all images to the new host.
private const string imgRX = "<img[^>]*src=\"?([^\"]*)\"?([^>]*alt=\"?([^\"]*)\"?)?[^>]*>";
var matches = Regex.Matches(posts[i].description, imgRX);
Console.WriteLine("Fixing {0} images…", matches.Count);
for (int j = 0; j < matches.Count; j++) {
Console.WriteLine("Retriving image #{0}", j);
var url = matches[j].Groups[1].Value;
if (url.Contains(baseURL)) {
try {
var data = wc.DownloadData(url);
Console.WriteLine("Uploading image #{0}", j);
var uf = newblog.uploadFile(newblogid, newUsername, newPassword, new MediaObject {
bits = data,
name = matches[j].Groups[1].Value.Substring(matches[j].Groups[1].Value.LastIndexOf(‘/’) + 1)
});
posts[i].description = posts[i].description.Replace(url, uf.url);
} catch { }
}
}
Now all images are stored in the new location and all image links are updated within stored posts. Next step is to upload all posts to the new location. CS stores tags as categories, which is wrong. Why? Because categories can be hierarchical, while tags cannot. So we have to convert all categories within retrieved posts into real tags. After it we can post everything
for (int i = posts.Length – 1; i >= 0; i–) {
posts[i].mt_keywords = string.Join(",", posts[i].categories);
var pid = newblog.newPost(newblogid, newUsername, newPassword, posts[i], true);
foreach (var comment in posts[i].comments) {
try {
var cid = newblog.newComment(newblogid, newUsername, newPassword, pid, comment);
} catch { }
}
Now we have to update all internal links within new locations. For this we should grab all posts back to learn new URLs.
var newPosts = newblog.getRecentPosts(newblogid, newUsername, newPassword, toFetch);
for (int i = 0; i < newPosts.Length; i++) {
foreach (var pi in _postsIndex) {
if (newPosts[i].description.Contains(pi.Key)) newPosts[i].description = newPosts[i].description.Replace(string.Concat(baseURL,pi.Key), pi.Value);
}
wpblog.editPost((string)newPosts[i].postid, newUsername, newPassword, newPosts[i], true);
if (!refereces.ContainsKey(newPosts[i].link)) refereces.Add(newPosts[i].link, posts[i].link);}
We done. Last, but not the least, is to update old posts with new URL to make visitors able to forward into new location.
csposts = csblog.getRecentPosts(csBlogid, csUsername, csPassword, toFetch);
for(int i=0;i< csposts.Length;i++) {
if (_postsIndex.ContainsKey(csposts[i].link)) {
string write = string.Format("<h3>[This blog was migrated. You will not be able to comment here.<br/>The new URL of this post is <a href=\"{0}\">{0}</a>]</h3><hr/>", _postsIndex[csposts[i].link]);
csposts[i].description = string.Concat(write, csposts[i].description);
csblog.editPost((string)csposts[i].postid, csUsername, csPassword, csposts[i], true);
Console.WriteLine("Post {0} was updated",i);
}
}
Have a nice day and be good people!
January 1st, 2009 · Comments (9)
Read and use FM radio (or any other USB HID device) from C#
Last time we spoke about reading and decoding RDS information from FM receivers. Also we already know how to stream sound from DirectSound compatible devices. However, before we can do it, we should be able to “speak” with such devices. So, today we’ll spoke about detection and reading information from Radio USB adapters (actually from any Human Input Devices). Let’s start.
First, if you want to do it, go and buy such device. The are not a lot of alternatives, but if you’ll seek, you’ll find it very quickly.
So, let’s start. First of all, we’ll use platform invoke to get and set the information. Also, we have to preserve handle of the device from being collected by GC. After we’ll finish using the device, we’ll have to dispose it. Thus it makes sense to inherit from SafeHandle and IDisposable.
[SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode = true)]
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
public class USBDevice : SafeHandleZeroOrMinusOneIsInvalid, IDisposable {
Next, we’ll set a number of arguments, that will be in use during the device lifetime.
public uint ProductID { get; private set; }
public uint VendorID { get; private set; }
public uint VersionNumber { get; private set; }
public string Name { get; private set; }
public string SerialNumber { get; private set; }
public override bool IsInvalid { get { return !isValid; } }internal ushort FeatureReportLength { get; private set; }
internal ushort[] Registers { get; set; }
Now, we have to find it. The best way of detection human input devices is by product and vendor IDs. Those values are always unique for certain device type.
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
internal USBDevice(uint pid, uint vid) : base(true) { findDevice(pid, vid); }
Next step is to find a device. To do this, we have to provide extern interfaces to methods of hid.dll and setupapi.dll. Here all methods we will use in our class
[SuppressUnmanagedCodeSecurity()]
internal static class Native {
#region methods
[DllImport("hid.dll", SetLastError = true)]
internal static extern void HidD_GetHidGuid(
ref Guid lpHidGuid);[DllImport("hid.dll", SetLastError = true)]
internal static extern bool HidD_GetAttributes(
IntPtr hDevice,
out HIDD_ATTRIBUTES Attributes);[DllImport("hid.dll", SetLastError = true)]
internal static extern bool HidD_GetPreparsedData(
IntPtr hDevice,
out IntPtr hData);[DllImport("hid.dll", SetLastError = true)]
internal static extern bool HidD_FreePreparsedData(
IntPtr hData);[DllImport("hid.dll", SetLastError = true)]
internal static extern bool HidP_GetCaps(
IntPtr hData,
out HIDP_CAPS capabilities);[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
internal static extern bool HidD_GetFeature(
IntPtr hDevice,
IntPtr hReportBuffer,
uint ReportBufferLength);[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
internal static extern bool HidD_SetFeature(
IntPtr hDevice,
IntPtr ReportBuffer,
uint ReportBufferLength);[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
internal static extern bool HidD_GetProductString(
IntPtr hDevice,
IntPtr Buffer,
uint BufferLength);[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
internal static extern bool HidD_GetSerialNumberString(
IntPtr hDevice,
IntPtr Buffer,
uint BufferLength);[DllImport("setupapi.dll", SetLastError = true)]
internal static extern IntPtr SetupDiGetClassDevs(
ref Guid ClassGuid,
[MarshalAs(UnmanagedType.LPTStr)] string Enumerator,
IntPtr hwndParent,
UInt32 Flags);[DllImport("setupapi.dll", SetLastError = true)]
internal static extern bool SetupDiEnumDeviceInterfaces(
IntPtr DeviceInfoSet,
int DeviceInfoData,
ref Guid lpHidGuid,
uint MemberIndex,
ref SP_DEVICE_INTERFACE_DATA lpDeviceInterfaceData);[DllImport("setupapi.dll", SetLastError = true)]
internal static extern bool SetupDiGetDeviceInterfaceDetail(
IntPtr DeviceInfoSet,
ref SP_DEVICE_INTERFACE_DATA lpDeviceInterfaceData,
IntPtr hDeviceInterfaceDetailData,
uint detailSize,
out uint requiredSize,
IntPtr hDeviceInfoData);[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
internal static extern IntPtr CreateFile(
string lpFileName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr SecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplateFile);[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
internal static extern bool CloseHandle(IntPtr hHandle);
Also, we will need a number of structures, such as device attributes and capabilities.
[StructLayout(LayoutKind.Sequential)]
internal struct SP_DEVICE_INTERFACE_DATA {
public int cbSize;
public Guid InterfaceClassGuid;
public int Flags;
public int Reserved;
}[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
internal class PSP_DEVICE_INTERFACE_DETAIL_DATA {
public int cbSize;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string DevicePath;
}[StructLayout(LayoutKind.Sequential)]
internal struct HIDD_ATTRIBUTES {
public int Size; // = sizeof (struct _HIDD_ATTRIBUTES) = 10
public UInt16 VendorID;
public UInt16 ProductID;
public UInt16 VersionNumber;
}
[StructLayout(LayoutKind.Sequential)]
internal struct HIDP_CAPS {
public UInt16 Usage;
public UInt16 UsagePage;
public UInt16 InputReportByteLength;
public UInt16 OutputReportByteLength;
public UInt16 FeatureReportByteLength;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 17)]
public UInt16[] Reserved;
public UInt16 NumberLinkCollectionNodes;
public UInt16 NumberInputButtonCaps;
public UInt16 NumberInputValueCaps;
public UInt16 NumberInputDataIndices;
public UInt16 NumberOutputButtonCaps;
public UInt16 NumberOutputValueCaps;
public UInt16 NumberOutputDataIndices;
public UInt16 NumberFeatureButtonCaps;
public UInt16 NumberFeatureValueCaps;
public UInt16 NumberFeatureDataIndices;
}
And a number of system constants
internal const uint DIGCF_PRESENT = 0×00000002;
internal const uint DIGCF_DEVICEINTERFACE = 0×00000010;
internal const uint GENERIC_READ = 0×80000000;
internal const uint GENERIC_WRITE = 0×40000000;
internal const uint FILE_SHARE_READ = 0×00000001;
internal const uint FILE_SHARE_WRITE = 0×00000002;
internal const int OPEN_EXISTING = 3;
internal const int FILE_FLAG_OVERLAPPED = 0×40000000;
internal const uint MAX_USB_DEVICES = 16;
Now, we are ready to start. So let’s find all devices and get its information
Native.HidD_GetHidGuid(ref _hidGuid);
hHidDeviceInfo = Native.SetupDiGetClassDevs(ref _hidGuid, null, IntPtr.Zero, Native.DIGCF_PRESENT | Native.DIGCF_DEVICEINTERFACE);
Now, if a handle we get is valid, we should search our specific device. For this purpose, we have to read device interface information and then get details info about this device.
if (hHidDeviceInfo.ToInt32() > -1) {
uint i = 0;
while (!isValid && i < Native.MAX_USB_DEVICES) {
var hidDeviceInterfaceData = new Native.SP_DEVICE_INTERFACE_DATA();
hidDeviceInterfaceData.cbSize = Marshal.SizeOf(hidDeviceInterfaceData);
if (Native.SetupDiEnumDeviceInterfaces(hHidDeviceInfo, 0, ref _hidGuid, i, ref hidDeviceInterfaceData)) {
Once we have all this and information is valid, let’s detect its capabilities
bool detailResult;
uint length, required;
Native.SetupDiGetDeviceInterfaceDetail(hHidDeviceInfo, ref hidDeviceInterfaceData, IntPtr.Zero, 0, out length, IntPtr.Zero);
var hidDeviceInterfaceDetailData = new Native.PSP_DEVICE_INTERFACE_DETAIL_DATA();
hidDeviceInterfaceDetailData.cbSize = 5; //DWORD cbSize (size 4) + Char[0] (size 1) for 32bit only!
var hDeviceInterfaceDetailData = Marshal.AllocHGlobal(Marshal.SizeOf(hidDeviceInterfaceDetailData));
Marshal.StructureToPtr(hidDeviceInterfaceDetailData, hDeviceInterfaceDetailData, true);
detailResult = Native.SetupDiGetDeviceInterfaceDetail(hHidDeviceInfo, ref hidDeviceInterfaceData, hDeviceInterfaceDetailData, length, out required, IntPtr.Zero);
Marshal.PtrToStructure(hDeviceInterfaceDetailData, hidDeviceInterfaceDetailData);
if (detailResult) {
To do this, we have to create memory file first and then share device attributes by using this file.
base.handle = Native.CreateFile(hidDeviceInterfaceDetailData.DevicePath,
Native.GENERIC_READ |
Native.GENERIC_WRITE,
Native.FILE_SHARE_READ |
Native.FILE_SHARE_WRITE,
IntPtr.Zero,
Native.OPEN_EXISTING,
Native.FILE_FLAG_OVERLAPPED,
IntPtr.Zero);
if (base.handle.ToInt32() > -1) {
Native.HIDD_ATTRIBUTES hidDeviceAttributes;
if (Native.HidD_GetAttributes(base.handle, out hidDeviceAttributes)) {
All the rest is straight forward. Just compare info retrieved with one we already have. And, of cause, release all resources were used (remember, we’re in win32 api world!)
if ((hidDeviceAttributes.VendorID == vid) && (hidDeviceAttributes.ProductID == pid)) {
isValid = true;
ProductID = pid;
VendorID = vid;
VersionNumber = hidDeviceAttributes.VersionNumber;
IntPtr buffer = Marshal.AllocHGlobal(126);//max alloc for string;
if (Native.HidD_GetProductString(this.handle, buffer, 126)) Name = Marshal.PtrToStringAuto(buffer);
if (Native.HidD_GetSerialNumberString(this.handle, buffer, 126)) SerialNumber = Marshal.PtrToStringAuto(buffer);
Marshal.FreeHGlobal(buffer);
var capabilities = new Native.HIDP_CAPS();
IntPtr hPreparsedData;
if (Native.HidD_GetPreparsedData(this.handle, out hPreparsedData)) {
if (Native.HidP_GetCaps(hPreparsedData, out capabilities)) FeatureReportLength = capabilities.FeatureReportByteLength;
Native.HidD_FreePreparsedData(hPreparsedData);
}
break;
}
} else {
Native.CloseHandle(base.handle);
}
}
}
Marshal.FreeHGlobal(hDeviceInterfaceDetailData);
}
i++;}
Now we have a handle to our device and can manipulate it. Like this:
using (var device = USBRadioDevice.FindDevice(0×0000, 0×1111)) {
…
}
But we still have to provide methods for such usage. Here there are no very complicated code.
public static USBDevice FindDevice(uint pid, uint vid) {
var device = new USBDevice(pid,vid);
var fillRegisters = device.InitRegisters();
if (!device.IsInvalid && fillRegisters) return device;
else throw new ArgumentOutOfRangeException(string.Format("Human input device {0} was not found.", pid));
}public override string ToString() {
return string.Format("{0} (Product:{1:x}, Vendor:{2:x}, Version:{3:x}, S/N:{4})", Name, ProductID, VendorID, VersionNumber, SerialNumber);
}[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
protected override bool ReleaseHandle() {
return Native.CloseHandle(base.handle);
}#region IDisposable Members
public void Dispose() {
Dispose(true);
GC.SuppressFinalize(this);}
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
void IDisposable.Dispose() {
if (base.handle != null && !base.IsInvalid) {
// Free the handle
base.Dispose();
}
}#endregion
We done. Have a nice day and be good people.
December 30th, 2008 · Comments (7)
Capturing and streaming sound by using DirectSound with C#
I already wrote a little about managed way to use DirectX DirectSound. Today we’ll speak about how to get sound from your microphone or any other DirectSound capturing device (such as FM receiver) and stream it out to your PC speakers and any other DirectSound Output device. So, let’s start creating our first echo service by using managed DirectX.
First of all we should decide what Wave format we want to use for capturing and recording. So, let’s choose anything reasonable
var format = new WaveFormat {
SamplesPerSecond = 96000,
BitsPerSample = 16,
Channels = 2,
FormatTag = WaveFormatTag.Pcm
};
Now, we should calculate block align and average byte per second value for this format. I’m wondering why it cannot be done automatically…
format.BlockAlign = (short)(format.Channels * (format.BitsPerSample / 8));
format.AverageBytesPerSecond = format.SamplesPerSecond * format.BlockAlign;
Next step is to set the size of two buffers – one for input and other for output. Generally those buffers are circular, and capturing one should be twice bigger, then output. Why? Because we choose two channels to use. Also, we should decide about chunk size of the buffer, we want to signal when filled.
_dwNotifySize = Math.Max(4096, format.AverageBytesPerSecond / 8);
_dwNotifySize -= _dwNotifySize % format.BlockAlign;
_dwCaptureBufferSize = NUM_BUFFERS * _dwNotifySize;
_dwOutputBufferSize = NUM_BUFFERS * _dwNotifySize / 2;
Next step is to create CaptureBufferDescriptor and actual capturing buffer. We’ll enumerate all devices and choose one, satisfies given string (captureDescriptor) – for example “Mic”
var cap = default(Capture);
var cdc = new CaptureDevicesCollection();
for (int i = 0; i < cdc.Count; i++) {
if (cdc[i].Description.ToLower().Contains(captureDescriptor.ToLower())) {
cap = new Capture(cdc[i].DriverGuid);
break;
}
}
var capDesc = new CaptureBufferDescription {
Format = format,
BufferBytes = _dwCaptureBufferSize
};
_dwCapBuffer = new CaptureBuffer(capDesc, cap);
Then we’ll create output device and buffer. To simplify program, we will use default speakers to output, however, you can choose output device the same way we did for capturing. Also, because DirectSound uses any window as it’s message pump, we have to use SetCooperativeLevel method. In my case (windowless application), I’ll use desktop window as message broker. This why you will have to add Windows.Forms as reference for your project, even if it console application. Also, do not forget to set GlobalFocus value to True, if you want to play echo, even if desktop window is not focused.
var dev = new Device();
dev.SetCooperativeLevel(Native.GetDesktopWindow(), CooperativeLevel.Priority);var devDesc = new BufferDescription {
BufferBytes = _dwOutputBufferSize,
Format = format,
DeferLocation = true,
GlobalFocus = true
};
_dwDevBuffer = new SecondaryBuffer(devDesc, dev);
Now, we will subscribe to buffer notifications and set autoResetEvent to be fired when it filled up.
var _resetEvent = new AutoResetEvent(false);
var _notify = new Notify(_dwCapBuffer);
//half&half
var bpn1 = new BufferPositionNotify();
bpn1.Offset = _dwCapBuffer.Caps.BufferBytes / 2 – 1;
bpn1.EventNotifyHandle = _resetEvent.SafeWaitHandle.DangerousGetHandle();
var bpn2 = new BufferPositionNotify();
bpn2.Offset = _dwCapBuffer.Caps.BufferBytes – 1;
bpn2.EventNotifyHandle = _resetEvent.SafeWaitHandle.DangerousGetHandle();_notify.SetNotificationPositions(new BufferPositionNotify[] { bpn1, bpn2 });
Almost done, the only thing we should do is to fire worker thread to take care on messages
int offset = 0;
_dwCaptureThread = new Thread((ThreadStart)delegate {
_dwCapBuffer.Start(true);while (IsReady) {
_resetEvent.WaitOne();
var read = _dwCapBuffer.Read(offset, typeof(byte), LockFlag.None, _dwOutputBufferSize);
_dwDevBuffer.Write(0, read, LockFlag.EntireBuffer);
offset = (offset + _dwOutputBufferSize) % _dwCaptureBufferSize;
_dwDevBuffer.SetCurrentPosition(0);
_dwDevBuffer.Play(0, BufferPlayFlags.Default);
}
_dwCapBuffer.Stop();
});
_dwCaptureThread.Start();
That’s it. Compile and run. Now if you’ll speak, you can hear your echo from PC speakers.
Merry Christmas for whom concerns and be good people – do not scare your co-workers with strange sounds – be polite and make the volume lower
December 25th, 2008 · Comments (49)
Reading and decoding RDS (Radio Data System) in C#
RDS or Radio Data System is very common in US and many European countries. It is communication protocol used to send small amount of digital information using regular FM radio broadcast. This protocol is used to “tell” your receiver about alternative frequencies, time, program notifications, program types, traffic information and regular text (such as singer name or genre). Unfortunately in Israel RDS is not very common and there is very limited number of radio stations broadcasts RDS information.
How RDS works?
As mentioned earlier, it uses FM subcarrier to broadcast digital information. It was designed to support 10 and 18 characters numeric and 80 characters alphanumeric displays. RDS operates at 1187.5 bps and based on 26-bit word consisting of 16 data and 10 error detection bits. Due to the fact, that FM carrier is not very reliable, error code allows correct information to be received even if an error of 3-5 bits exists within 26 bit block. Each four data blocks interpreted as 104-bit signal and named “group”. Depending of the type of information, contained within the group, as different group type code is defined and transmitted within the group as upper five bits code. Even if more, then 104 bits required to completely send the information, there is no requirement that the next segment of the transmission be sent in the next group. There are 32 known groups types, defined by RFC:
private enum groupType : byte {
RDS_TYPE_0A = (0 * 2 + 0),
RDS_TYPE_0B = (0 * 2 + 1),
RDS_TYPE_1A = (1 * 2 + 0),
RDS_TYPE_1B = (1 * 2 + 1),
RDS_TYPE_2A = (2 * 2 + 0),
RDS_TYPE_2B = (2 * 2 + 1),
RDS_TYPE_3A = (3 * 2 + 0),
RDS_TYPE_3B = (3 * 2 + 1),
RDS_TYPE_4A = (4 * 2 + 0),
RDS_TYPE_4B = (4 * 2 + 1),
RDS_TYPE_5A = (5 * 2 + 0),
RDS_TYPE_5B = (5 * 2 + 1),
RDS_TYPE_6A = (6 * 2 + 0),
RDS_TYPE_6B = (6 * 2 + 1),
RDS_TYPE_7A = (7 * 2 + 0),
RDS_TYPE_7B = (7 * 2 + 1),
RDS_TYPE_8A = (8 * 2 + 0),
RDS_TYPE_8B = (8 * 2 + 1),
RDS_TYPE_9A = (9 * 2 + 0),
RDS_TYPE_9B = (9 * 2 + 1),
RDS_TYPE_10A = (10 * 2 + 0),
RDS_TYPE_10B = (10 * 2 + 1),
RDS_TYPE_11A = (11 * 2 + 0),
RDS_TYPE_11B = (11 * 2 + 1),
RDS_TYPE_12A = (12 * 2 + 0),
RDS_TYPE_12B = (12 * 2 + 1),
RDS_TYPE_13A = (13 * 2 + 0),
RDS_TYPE_13B = (13 * 2 + 1),
RDS_TYPE_14A = (14 * 2 + 0),
RDS_TYPE_14B = (14 * 2 + 1),
RDS_TYPE_15A = (15 * 2 + 0),
RDS_TYPE_15B = (15 * 2 + 1)
}
Not all groups are in use all the time. However, there are some commitments, defined by the protocol. For example, 1A have to be transmitted at least once a second. This group contains special information, required for receivers to be synchronized and locked into the transmitting channel.
Within the error correction information we also receive the direction to treat them.
private enum correctedType : byte {
NONE = 0,
ONE_TO_TWO = 1,
THREE_TO_FIVE = 2,
UNCORRECTABLE = 3
}
Also, each message type has it own limits. For example RT (Radio Text – 64 character text to display on your receiver) and PS (Programme Service – eight character station identification) message are limited to 2 groups, when PI (Programme Identification – unique code of the station) and PTY (Programme Type – one of 31 predefined program types – e.g. News, Drama, Music) are limited to 4.
In addition to those constraints, block types are also different. But in this case, there are only 4 kinds
private enum blockType : byte {
A = 6,
B = 4,
C = 2,
D = 0
}
So, what we’re waiting for? Let’s start working.
Handling errors
First of all we should take care on errors and fix them if possible. For this purpose, we should first count them and detect the way of fixing
var errorCount = (byte)((registers[0xa] & 0x0E00) >> 9);
var errorFlags = (byte)(registers[0x6] & 0xFF);
if (errorCount < 4) {
_blocksValid += (byte)(4 – errorCount);
} else { /*drop data on more errors*/ return; }
Once it done, we can try to fix them
//Also drop the data if more than two errors were corrected
if (_getErrorsCorrected(errorFlags, blockType.B) > correctedType.ONE_TO_TWO) return;private correctedType _getErrorsCorrected(byte data, blockType block) { return (correctedType)((data >> (byte)block) & 0×30); }
Now, our registers should be fine and we can start the detection of group type
Group Type Detection
This is very simple task, all we have to do is to get five upper bites to get a type and version.
var group_type = (groupType)(registers[0xD] >> 11);
Then we can handle PI and PTY, which we always have in RDS.
PI and PTY treatment
Now, let’s update pi code, due to the fact, that B format always have PI in words A and C
_updatePI(registers[0xC]);
if (((byte)group_type & 0×01) != 0) {
_updatePI(registers[0xE]);
}
To update PI, we should check whether the new value is different from the previous and update it only in case it changed.
private void _updatePI(byte pi) {
uint rds_pi_validate_count = 0;
uint rds_pi_nonvalidated = 0;// if the pi value is the same for a certain number of times, update a validated pi variable
if (rds_pi_nonvalidated != pi) {
rds_pi_nonvalidated = pi;
rds_pi_validate_count = 1;
} else {
rds_pi_validate_count++;
}if (rds_pi_validate_count > PI_VALIDATE_LIMIT) {
_piDisplay = rds_pi_nonvalidated;
}
}
Then we will update PTY
_updatePTY((byte)((registers[0xd] >> 5) & 0x1f));
PTY treatment is very similar to PI, however it can be multiplied.
private void _updatePTY(byte pty) {
uint rds_pty_validate_count = 0;
uint rds_pty_nonvalidated = 0;// if the pty value is the same for a certain number of times, update a validated pty variable
if (rds_pty_nonvalidated != pty) {
rds_pty_nonvalidated = pty;
rds_pty_validate_count = 1;
} else {
rds_pty_validate_count++;
}if (rds_pty_validate_count > PTY_VALIDATE_LIMIT) {
_ptyDisplay = rds_pty_nonvalidated;
}
}
When we done with those two groups, we can start handling another. Today, we’ll handle only 0B, 2A and 2B types (I have a good reason for it, due to the fact, that only those are supported in Israel by now ) So,
Handling PS and different RTs
Simple switch on those groups
switch (group_type) {
case groupType.RDS_TYPE_0B:
addr = (byte)((registers[0xd] & 0×3) * 2);
_updatePS((byte)(addr + 0), (byte)(registers[0xf] >> 8));
_updatePS((byte)(addr + 1), (byte)(registers[0xf] & 0xff));
break;
case groupType.RDS_TYPE_2A:
addr = (byte)((registers[0xd] & 0xf) * 4);
abflag = (byte)((registers[0xb] & 0×0010) >> 4);
_updateRT(abflag, 4, addr, (byte[])registers.Skip(0xe), errorFlags);
break;
case groupType.RDS_TYPE_2B:
addr = (byte)((registers[0xd] & 0xf) * 2);
abflag = (byte)((registers[0xb] & 0×0010) >> 4);
// The last 32 bytes are unused in this format
_rtTmp0[32] = 0x0d;
_rtTmp1[32] = 0x0d;
_rtCnt[32] = RT_VALIDATE_LIMIT;
_updateRT(abflag, 2, addr, (byte[])registers.Skip(0xe), errorFlags);
break;
}
and let’s dig into PS.
In PS, we have high and low probability bits. So, if new bit in sequence matches the high probability bite and we have recieved enough bytes to max out the counter, we’ll push it into the low probability array.
if (_psTmp0[idx] == default(byte)) {
if (_psCnt[idx] < PS_VALIDATE_LIMIT) {
_psCnt[idx]++;
} else {
_psCnt[idx] = PS_VALIDATE_LIMIT;
_psTmp1[idx] = default(byte);
}
}
Else, if new byte matches with the low probability byte, we should swap them and then reset the counter, by flagging the text as in transition.
else if (_psTmp1[idx] == default(byte)) {
if (_psCnt[idx] >= PS_VALIDATE_LIMIT) {
isTextChange = true;
}
_psCnt[idx] = PS_VALIDATE_LIMIT + 1;
_psTmp1[idx] = _psTmp0[idx];
_psTmp0[idx] = default(byte);
}
When we have an empty byte in high probability array or new bytes does not match anything we know, we should put it into low probability array.
else if (_psCnt[idx] == null) {
_psTmp0[idx] = default(byte);
_psCnt[idx] = 1;
} else {
_psTmp1[idx] = default(byte);
}
Now, if we marked our text as changed, we should decrement the count for all characters to prevent displaying of partical message, which in still in transition.
if (isTextChange) {
for (byte i = 0; i < _psCnt.Length; i++) {
if (_psCnt[i] > 1) {
_psCnt[i]–;
}
}
}
Then by checking PS text for incompetence, when there are characters in high probability array has been seen fewer times, that was limited by validation.
for (byte i = 0; i < _psCnt.Length; i++) {
if (_psCnt[i] < PS_VALIDATE_LIMIT) {
isComplete = false;
break;
}
}
Only if PS text in the high probability array is complete, we’ll copy it into display.
if (isComplete) {
for (byte i = 0; i < _psDisplay.Length; i++) {
_psDisplay[i] = _psTmp0[i];
}
}
It is not very hard to treat PS. Isn’t it? Let’s see what’s going on with RT.
If A and B message flag changes, we’ll try to force a display by increasing the validation count for each byte. Then, we’ll wipe any cached text.
if (abFlag != _rtFlag && _rtFlagValid) {
// If the A/B message flag changes, try to force a display
// by increasing the validation count of each byte
for (i = 0; i < _rtCnt.Length; i++) _rtCnt[addr + i]++;
_updateRTValue();// Wipe out the cached text
for (i = 0; i < _rtCnt.Length; i++) {
_rtCnt[i] = 0;
_rtTmp0[i] = 0;
_rtTmp1[i] = 0;
}
}
Now A and B flags are safe, sp we can start with message processing. First of all, NULL in RDS means space
_rtFlag = abFlag;
_rtFlagValid = true;for (i = 0; i < count; i++) {
if (p[i] == null) p[i] = (byte)’ ‘;
The new byte matches the high probability byte also in this case. We habe to recieve this bite enough to max out counters. Then we can push it into the low probability as well.
if (_rtTmp0[addr + i] == p[i]) {
if (_rtCnt[addr + i] < RT_VALIDATE_LIMIT) _rtCnt[addr + i]++;
else {
_rtCnt[addr + i] = RT_VALIDATE_LIMIT;
_rtTmp1[addr + i] = p[i];
}
}
When the new byte matches with low probability byte, we’ll swap them as well and reset counters to update text in transition flag. However in this case, our counter will go higher, then the validation limit. So we’ll have to remove it down later.
else if (_rtTmp1[addr + i] == p[i]) {
if (_rtCnt[addr + i] >= PS_VALIDATE_LIMIT) isChange = true;
_rtCnt[addr + i] = RT_VALIDATE_LIMIT + 1;
_rtTmp1[addr + i] = _rtTmp0[addr + i];
_rtTmp0[addr + i] = p[i];
}
Now, the new byte is replaced an empty byte in the high probability array. Also, if this byte does not match anything, we should move it into low probability.
else if (_rtCnt[addr + i] == null) {
_rtTmp0[addr + i] = p[i];
_rtCnt[addr + i] = 1;
} else _rtTmp1[addr + i] = p[i];}
Now when the text is changing, we’ll decrement the counter for all characters exactly as we did for PS.
for (i = 0; i < _rtCnt.Length; i++) {
if (_rtCnt[i] > 1) _rtCnt[i]–;
}
}
However, right after, we’ll update display.
_updateRTValue();
}
Displaying RT
But how to convert all those byte arrays into readable message? Simple
First of all if text is incomplete, we should keep loading it. Also it makes sense to check whether the target array is shorter then maximum allowed to prevent junk from being displayed.
for (i = 0; i < _rtTmp0.Length; i++) {
if (_rtCnt[i] < RT_VALIDATE_LIMIT) {
isComplete = false;
break;
}
if (_rtTmp0[i] == 0x0d) {
break;
}
}
Now, when our Radio Text is in the high probability and it complete, we should copy buffers.
if (isComplete) {
_Text = string.Empty;for (i = 0; i < _rtDisplay.Length; i += 2) {
if ((_rtDisplay[i] != 0x0d) && (_rtDisplay[i + 1] != 0x0d)) {
_rtDisplay[i] = _rtTmp0[i + 1];
_rtDisplay[i + 1] = _rtTmp0[i];
} else {
_rtDisplay[i] = _rtTmp0[i];
_rtDisplay[i + 1] = _rtTmp0[i + 1];
}if (_rtDisplay[i] != 0x0d)
_Text += _rtDisplay[i];if (_rtDisplay[i + 1] != 0x0d)
_Text += _rtDisplay[i + 1];if ((_rtDisplay[i] == 0x0d) || (_rtDisplay[i + 1] == 0x0d))
i = (byte)_rtDisplay.Length;
}
And not forget to wipe out everything after the end of the message
for (i++; i < _rtDisplay.Length; i++) {
_rtDisplay[i] = 0;
_rtCnt[i] = 0;
_rtTmp0[i] = 0;
_rtTmp1[i] = 0;
}
}
And finally update the text
Text = _Text;
We done. Now we can handle RDS digital messages, but what to do with analog data we get? Don’t you already know? I blogged about it here.
Have a nice day and be good people, because you know how to write client, knows to get and parse radio data in managed code.
December 11th, 2008 · Comments (9)
Creating transparent buttons, panels and other control with Compact Framework and putting one into other
In WPF/Silverlight world it’s very simple to make transparent controls and put anything inside anything. However, that’s not the situation in WinForms, and even worth in the world of compact devices with CF. Within this worlds, there is only one way to make controls transparent – to use color masks. Today, we’ll create transparent controls with Compact Framework and put it into panel, which has image background.
So let’s start. First of all, we need create our own control. For this purpose, we have to inherit from Control and override couple of things. More precise: OnPaint and OnPaintBackground. We do not want to paint background for transparent control, so let’s prevent it.
public class TransparentImageButton : Control
protected override void OnPaintBackground(PaintEventArgs e) {
//prevent
}protected override void OnPaint(PaintEventArgs e) {
Next, we have to get graphics, delivered by OnPain event argument and draw our image over it. However, BitBlt (which is used by core graphics system) is not very fast method, so it’s better for us to draw everything first and then copy final image to the device.
Graphics gxOff;
Rectangle imgRect;
var image = (_isPressed && PressedImage != null) ? PressedImage : Image;if (_imgOffscreen == null) {
_imgOffscreen = new Bitmap(ClientSize.Width, ClientSize.Height);
}gxOff = Graphics.FromImage(_imgOffscreen);
gxOff.Clear(this.BackColor);
…
if (image != null) {
var imageLeft = (this.Width – image.Width) / 2;
var imageTop = (this.Height – image.Height) / 2;if (!_isPressed) imgRect = new Rectangle(imageLeft, imageTop, image.Width, image.Height);
else imgRect = new Rectangle(imageLeft + 1, imageTop + 1, image.Width, image.Height);
var imageAttr = new ImageAttributes();
To make images transparent, we have to use (as mentioned earlier) transparency color key (to tell windows what color it should not draw. We can code or provide this value to detect it by hitting any pixel on the image. Just like this:
public static Color BackgroundImageColor(this Bitmap bmp) {
return bmp.GetPixel(0, 0);
}
Now we can keep working.
imageAttr.SetColorKey(image.BackgroundImageColor(), image.BackgroundImageColor());
gxOff.DrawImage(image, imgRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imageAttr);
} if (_isPressed) {
var rc = this.ClientRectangle;
rc.Width–;
rc.Height–;
gxOff.DrawRectangle(new Pen(Color.Black), rc);
}
e.Graphics.DrawImage(_imgOffscreen, 0, 0);
Also, we have to provide others with possibility to handle this even too, thus we will not forget to add base.OnPaint(e); at the end.
Next step is to detect whether our button is clicked or not. We’ll override keyboard and mouse events to detect this.
protected override void OnKeyDown(KeyEventArgs e) {
_isPressed = this.Focused; this.Invalidate();
base.OnKeyDown(e);
}protected override void OnKeyUp(KeyEventArgs e) {
_isPressed = false; this.Invalidate();
base.OnKeyUp(e);
}protected override void OnMouseDown(MouseEventArgs e) {
_isPressed = this.Focused; this.Invalidate();
base.OnMouseDown(e);
}protected override void OnMouseUp(MouseEventArgs e) {
_isPressed = false; this.Invalidate();
base.OnMouseUp(e);
}
Compile and run to see no problem, when our transparent button lies on solid color control, however, we want to put it into panel with background – just like this one. In this case, you can use real transparent PNG and GIF images, also you can replace transparent color with well known Magenta (or any other color).
public class ImagePanel : Panel {
public Bitmap Image { get; set; }
protected override void OnPaintBackground(PaintEventArgs e) {
e.Graphics.DrawImage(Image, 0, 0);
}
}
When we’ll put it onto anything, that has no background color, we’ll see that our “fake transparency” disappears. Why this happen? To provide transparency Windows uses color masks, also while confederating facts, clipping algorithm within GDI is not very trustful, thus the only thing can be taken into account is color. But what to do if we have an image? We should clip it manually. We cannot just get the handle to parent device surface (see above about trustful GDI), so the only way to do it is by providing something, that we know for sure. For example interface, telling us, that parent has image, which drawn on the screen.
internal interface IHaveImage {
Bitmap Image { get; set; }
}
When we know it, all we have to do is to clip the region of this image (not device context) and draw it as part of our really transparent control.
if (this.Parent is IHaveImage) {
var par = this.Parent as IHaveImage;
gxOff.DrawImage(par.Image.Clip(this.Bounds), 0, 0);
}
The implementation of Image.Clip is very straight forward.
public static Bitmap GetSS(this Graphics grx, Rectangle bounds) {
var res = new Bitmap(bounds.Width, bounds.Height);
var gxc = Graphics.FromImage(res);
IntPtr hdc = grx.GetHdc();
PlatformAPI.BitBlt(gxc.GetHdc(), 0, 0, bounds.Width, bounds.Height, hdc, bounds.Left, bounds.Top, PlatformAPI.SRCCOPY);
grx.ReleaseHdc(hdc);
return res;
}public static Bitmap Clip(this Bitmap source, Rectangle bounds) {
var grx = Graphics.FromImage(source);
return grx.GetSS(bounds);
}
We done. Compiling all together will fake transparency for controls, even when it’s parents background is not pained with solid color brush.
P.S. Do not even try to inherit your custom Button control from framework Button class, dev team “forgot” to expose it’s event for override. So, OnPaint, OnPaintBackground, OnKeyUp, OnKeydown, OnMouseUp and OnMouseDown aside with most of other base events will not work for you, also BaseButton class has no default constructor, so the only class you can inherit from is Control.
Have a nice day and be good people.
November 20th, 2008 · Comments (5)
Discover other tags
My tools
- .NET Framework Detector
- Duplicate images finder
- Exchange Security Policy for Windows Mobile Devices Fix
- Gas Price Windows Vista SideBar gadget
- Israel Traffic Information Windows Vista SideBar gadget
- Localization fix for SAP ES Explorer for Visual Studio
- LocTester
- RTL and LTR in Windows Live Writer
- Silverlight controls library
- Snipping tool integration plugin for WLW
- USB FM receiver library
- Vista Battery Saver
- WebCam control for WPF
- Windows Live SkyDrive attachment for Windows Live Writer
- Wireless Migrator
- WPF Virtual Keyboard
