/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// Starts capture of the data to a file.
///
/// Because this code is intended for demo purposes and in the interests of
/// reducing complexity it is extremely linear and step-by-step. Doubtless
/// there is much refactoring that could be done.
///
/// </summary>
/// <history>
/// 01 Nov 18 Cynic - Started
/// </history>
private void CaptureToFile()
{
HResult hr;
IMFMediaType videoType = null;
IMFMediaType encoderType = null;
TantaMFDevice currentDevice = null;
try
{
// get the current video device.
currentDevice = ctlTantaVideoPicker1.CurrentDevice;
if (currentDevice == null)
{
MessageBox.Show("No current video device. Are there any video devices on this system?");
return;
}
// check our output filename is correct and usable
if ((textBoxCaptureFileNameAndPath == null) || (textBoxCaptureFileNameAndPath.Text.Length == 0))
{
MessageBox.Show("No Capture Filename and path. Cannot continue.");
return;
}
string pwszFileName = textBoxCaptureFileNameAndPath.Text;
// check the path is rooted
if (Path.IsPathRooted(pwszFileName) == false)
{
MessageBox.Show("No Capture Filename and path is not rooted. A full directory and path is required. Cannot continue.");
return;
}
// create a new call back handler. This, once we get it all wired up, will act
// as a pump to move the data from the source to the sink
workingSourceReaderCallBackHandler = new TantaSourceReaderCallbackHandler();
// the following code will create a SourceReader which is tied to a camera on the system,
// a SinkWriter which is tied to a file output and will hook up the two. Because we are using
// a SourceReader and SourceWriter we do not have the usual Topology or Pipeline. The SourceReader
// and SourceWriter are connected directly (input to output) in the code below and transfer their
// data via the callback handler. The callback handler also requests the next sample from
// the SourceReader when it has written the data to the sink. Note however it is possible
// that the SourceReader can automatically bring in a Transform for format conversion. This
// is done internally and you never deal with it - other than perhaps making it available
// to the process if it is not globally available.
// create the source reader
workingSourceReader = TantaWMFUtils.CreateSourceReaderAsyncFromDevice(currentDevice, workingSourceReaderCallBackHandler);
if (workingSourceReader == null)
{
MessageBox.Show("CreateSourceReaderAsyncFromDevice did not return a media source. Cannot continue.");
return;
}
// open up the sink Writer
workingSinkWriter = OpenSinkWriter(pwszFileName);
if (workingSinkWriter == null)
{
MessageBox.Show("OpenSinkWriter workingSinkWriter == null. Cannot continue.");
return;
}
// now set the source and the sink in the callback handler. It needs to know these
// in order to operate
workingSourceReaderCallBackHandler.SourceReader = workingSourceReader;
workingSourceReaderCallBackHandler.SinkWriter = workingSinkWriter;
workingSourceReaderCallBackHandler.InitForFirstSample();
workingSourceReaderCallBackHandler.SourceReaderAsyncCallBackError = HandleSourceReaderAsyncCallBackErrors;
// now we configure the video source. It will probably offer a lot of different types
// this example offers two modes: one mode where you choose the format and mode and
// effectively just say "Use this one". The other uses the general case where we
// present a list of reasonable types we can accept and then let it auto
// configure itself from one of those. Of course if it autoconfigures itself we
// don't know which one it has chosen. This is why, you will later see the video
// source being interrogated after the configuration so we know which one we hit.
if (radioButtonUseSpecified.Checked == true)
{
// we saved the video format container here - this is just the last one that came in
if ((radioButtonUseSpecified.Tag == null) || ((radioButtonUseSpecified.Tag is TantaMFVideoFormatContainer) == false))
{
MessageBox.Show("No source video device and format selected. Cannot continue.");
return;
}
// get the container
TantaMFVideoFormatContainer videoFormatCont = (radioButtonUseSpecified.Tag as TantaMFVideoFormatContainer);
// configure the Source Reader to use this format
hr = TantaWMFUtils.ConfigureSourceReaderWithVideoFormat(workingSourceReader, videoFormatCont);
if (hr != HResult.S_OK)
{
// we failed
MessageBox.Show("Failed on call to ConfigureSourceAsyncReaderWithVideoFormat (a), retVal=" + hr.ToString());
return;
}
}
else
{
// prepare a list of subtypes we are prepared to accept from the video source
// device. These will be tested in order - the first match will be used.
List <Guid> subTypes = new List <Guid>();
subTypes.Add(MFMediaType.NV12);
subTypes.Add(MFMediaType.YUY2);
subTypes.Add(MFMediaType.UYVY);
subTypes.Add(MFMediaType.RGB32);
subTypes.Add(MFMediaType.RGB24);
subTypes.Add(MFMediaType.IYUV);
// make sure the default Media Type is one of the above video formats
hr = TantaWMFUtils.ConfigureSourceReaderWithVideoFormat(workingSourceReader, subTypes, false);
if (hr != HResult.S_OK)
{
// we failed
MessageBox.Show("Failed on call to ConfigureSourceAsyncReaderWithVideoFormat (b), retVal=" + hr.ToString());
return;
}
}
// if we get here we know the source reader now has a configured format but we might not
// know which one it is. So we ask it. It will return a video type
// we will use this later on to configure our sink writer. Note, we have to properly dispose
// of the videoType object after we use it.
hr = workingSourceReader.GetCurrentMediaType(TantaWMFUtils.MF_SOURCE_READER_FIRST_VIDEO_STREAM, out videoType);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed on call to GetCurrentMediaType, retVal=" + hr.ToString());
}
// now we configure the encoder. This sets up the sink writer so that it knows what format
// the output data should be written in. The format we give the writer does not
// need to be the same as the format it outputs to disk - however to make life easier for ourselves
// we will copy a lot of the settings from the videoType retrieved above
// create a new empty media type for us to populate
hr = MFExtern.MFCreateMediaType(out encoderType);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed on call to MFCreateMediaType, retVal=" + hr.ToString());
}
// The major type defines the overall category of the media data. Major types include video, audio, script & etc.
hr = encoderType.SetGUID(MFAttributesClsid.MF_MT_MAJOR_TYPE, MFMediaType.Video);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed setting the MF_MT_MAJOR_TYPE, retVal=" + hr.ToString());
}
// The subtype GUID defines a specific media format type within a major type. For example, within video,
// the subtypes include MFMediaType.H264 (MP4), MFMediaType.WMV3 (WMV), MJPEG & etc. Within audio, the
// subtypes include PCM audio, Windows Media Audio 9, & etc.
hr = encoderType.SetGUID(MFAttributesClsid.MF_MT_SUBTYPE, MEDIA_TYPETO_WRITE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed setting the MF_MT_SUBTYPE, retVal=" + hr.ToString());
}
// this is the approximate data rate of the video stream, in bits per second, for a video media type
// in the MF.Net sample code this is 240000 but I found 2000000 to be much better. I am not sure,
// at this time, how this value is derived or what the tradeoffs are.
hr = encoderType.SetUINT32(MFAttributesClsid.MF_MT_AVG_BITRATE, TARGET_BIT_RATE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed setting the MF_MT_AVG_BITRATE, retVal=" + hr.ToString());
}
// populate our new encoding type with the frame size of the videoType selected earlier
hr = TantaWMFUtils.CopyAttributeData(videoType, encoderType, MFAttributesClsid.MF_MT_FRAME_SIZE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_FRAME_SIZE, retVal=" + hr.ToString());
}
// populate our new encoding type with the frame rate of the video type selected earlier
hr = TantaWMFUtils.CopyAttributeData(videoType, encoderType, MFAttributesClsid.MF_MT_FRAME_RATE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_FRAME_RATE, retVal=" + hr.ToString());
}
// populate our new encoding type with the pixel aspect ratio of the video type selected earlier
hr = TantaWMFUtils.CopyAttributeData(videoType, encoderType, MFAttributesClsid.MF_MT_PIXEL_ASPECT_RATIO);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_PIXEL_ASPECT_RATIO, retVal=" + hr.ToString());
}
// populate our new encoding type with the interlace mode of the video type selected earlier
hr = TantaWMFUtils.CopyAttributeData(videoType, encoderType, MFAttributesClsid.MF_MT_INTERLACE_MODE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_INTERLACE_MODE, retVal=" + hr.ToString());
}
// add a stream to the sink writer. The encoderType specifies the format of the samples that will be written
// to the file. Note that it does not necessarily need to match the input format. To set the input format
// use SetInputMediaType.
int sink_stream = 0;
hr = workingSinkWriter.AddStream(encoderType, out sink_stream);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed adding the output stream, retVal=" + hr.ToString());
}
// Windows 10, by default, provides an adequate set of codecs which the Sink Writer can
// find to write out the MP4 file. This is not true on Windows 7.
// If we are not on Windows 10 we register (locally) a codec
// the Sink Writer can find and use. The ColorConvertDMO is supplied by
// microsoft it is just not available to enumerate on Win7 etc.
// Making it available locally does not require administrator privs
// but only this process can see it and it disappears when the process
// closes
OperatingSystem os = Environment.OSVersion;
int versionID = ((os.Version.Major * 10) + os.Version.Minor);
if (versionID < 62)
{
Guid ColorConvertDMOGUID = new Guid("98230571-0087-4204-b020-3282538e57d3");
// Register the color converter DSP for this process, in the video
// processor category. This will enable the sink writer to enumerate
// the color converter when the sink writer attempts to match the
// media types.
hr = MFExtern.MFTRegisterLocalByCLSID(
ColorConvertDMOGUID,
MFTransformCategory.MFT_CATEGORY_VIDEO_PROCESSOR,
"",
MFT_EnumFlag.SyncMFT,
0,
null,
0,
null
);
}
// Set the input format for a stream on the sink writer. Note the use of the stream index here
// The input format does not have to match the target format that is written to the media sink
// If the formats do not match, this call attempts to load an transform
// that can convert from the input format to the target format. If it cannot find one, and this is not
// a sure thing, it will throw an exception.
hr = workingSinkWriter.SetInputMediaType(sink_stream, videoType, null);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed on calling SetInputMediaType on the writer, retVal=" + hr.ToString());
}
// now we initialize the sink writer for writing. We call this method after configuring the
// input streams but before we send any data to the sink writer. The underlying media sink must
// have at least one input stream and we know it does because we set it up earlier
hr = workingSinkWriter.BeginWriting();
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed on calling BeginWriting on the writer, retVal=" + hr.ToString());
}
// Request the first video frame from the media source. The TantaSourceReaderCallbackHandler
// set up earlier will be invoked and it will continue requesting and processing video
// frames after that.
hr = workingSourceReader.ReadSample(
TantaWMFUtils.MF_SOURCE_READER_FIRST_VIDEO_STREAM,
0,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero
);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed on calling the first ReadSample on the reader, retVal=" + hr.ToString());
}
// we are ready to start, flag this
buttonStartStopCapture.Text = STOP_CAPTURE;
// disable our screen controls
SetEnableStateOnScreenControls(false);
}
finally
{
// setting this to null will cause it to be cleaned up
currentDevice = null;
// close and release
if (videoType != null)
{
Marshal.ReleaseComObject(videoType);
videoType = null;
}
if (encoderType != null)
{
Marshal.ReleaseComObject(encoderType);
encoderType = null;
}
}
}
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// Starts the process of recording. creates the sink writer. We do not
/// check to see if the filename is viable or already exists. This is
/// assumed to have been done before this call.
/// </summary>
/// <param name="outputFileName">the output file name</param>
/// <param name="incomingVideoMediaType">the incoming media type</param>
/// <param name="wantTimebaseRebaseIn">if true we rebase all incoming sample
/// times to zero from the point we started recording and send a copy of the
/// sample to the sink writer instead of the input sample</param>
/// <returns>z success, nz fail</returns>
/// <history>
/// 01 Nov 18 Cynic - Started
/// </history>
public int StartRecording(string outputFileName, IMFMediaType incomingVideoMediaType, bool wantTimebaseRebaseIn)
{
HResult hr;
IMFMediaType encoderType = null;
LogMessage("MFTTantaSampleGrabber_Sync, StartRecording called");
// first stop any recordings now
StopRecording();
// check the output file name for sanity
if ((outputFileName == null) || (outputFileName.Length == 0))
{
LogMessage("StartRecording (outputFileName==null)|| (outputFileName.Length==0)");
return(100);
}
// check the media type for sanity
if (incomingVideoMediaType == null)
{
LogMessage("StartRecording videoMediaType == null");
return(150);
}
lock (sinkWriterLockObject)
{
// create the sink writer
workingSinkWriter = OpenSinkWriter(outputFileName, true);
if (workingSinkWriter == null)
{
LogMessage("StartRecording failed to create sink writer");
return(200);
}
// now configure the SinkWriter. This sets up the sink writer so that it knows what format
// the output data should be written in. The format we give the writer does not
// need to be the same as the format receives as input - however to make life easier for ourselves
// we will copy a lot of the settings from the videoType retrieved above
// create a new empty media type for us to populate
hr = MFExtern.MFCreateMediaType(out encoderType);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed on call to MFCreateMediaType, retVal=" + hr.ToString());
}
// The major type defines the overall category of the media data. Major types include video, audio, script & etc.
hr = encoderType.SetGUID(MFAttributesClsid.MF_MT_MAJOR_TYPE, MFMediaType.Video);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed setting the MF_MT_MAJOR_TYPE, retVal=" + hr.ToString());
}
// The subtype GUID defines a specific media format type within a major type. For example, within video,
// the subtypes include MFMediaType.H264 (MP4), MFMediaType.WMV3 (WMV), MJPEG & etc. Within audio, the
// subtypes include PCM audio, Windows Media Audio 9, & etc.
hr = encoderType.SetGUID(MFAttributesClsid.MF_MT_SUBTYPE, MEDIA_TYPETO_WRITE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed setting the MF_MT_SUBTYPE, retVal=" + hr.ToString());
}
// this is the approximate data rate of the video stream, in bits per second, for a
// video media type. The choice here is somewhat arbitrary but seems to work well.
hr = encoderType.SetUINT32(MFAttributesClsid.MF_MT_AVG_BITRATE, TARGET_BIT_RATE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed setting the MF_MT_AVG_BITRATE, retVal=" + hr.ToString());
}
// populate our new encoding type with the frame size of the videoType selected earlier
hr = TantaWMFUtils.CopyAttributeData(incomingVideoMediaType, encoderType, MFAttributesClsid.MF_MT_FRAME_SIZE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_FRAME_SIZE, retVal=" + hr.ToString());
}
// populate our new encoding type with the frame rate of the video type selected earlier
hr = TantaWMFUtils.CopyAttributeData(incomingVideoMediaType, encoderType, MFAttributesClsid.MF_MT_FRAME_RATE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_FRAME_RATE, retVal=" + hr.ToString());
}
// populate our new encoding type with the pixel aspect ratio of the video type selected earlier
hr = TantaWMFUtils.CopyAttributeData(incomingVideoMediaType, encoderType, MFAttributesClsid.MF_MT_PIXEL_ASPECT_RATIO);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_PIXEL_ASPECT_RATIO, retVal=" + hr.ToString());
}
// populate our new encoding type with the interlace mode of the video type selected earlier
hr = TantaWMFUtils.CopyAttributeData(incomingVideoMediaType, encoderType, MFAttributesClsid.MF_MT_INTERLACE_MODE);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("Failed copying the MF_MT_INTERLACE_MODE, retVal=" + hr.ToString());
}
// add a stream to the sink writer for the output Media type. The
// incomingVideoMediaType specifies the format of the samples that will
// be written to the file. Note that it does not necessarily need to
// match the input format.
hr = workingSinkWriter.AddStream(encoderType, out sinkWriterVideoStreamId);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("StartRecording Failed adding the output stream(v), retVal=" + hr.ToString());
}
// Windows 10, by default, provides an adequate set of codecs which the Sink Writer can
// find to write out the MP4 file. This is not true on Windows 7.
// If we are not on Windows 10 we register (locally) a codec
// the Sink Writer can find and use. The ColorConvertDMO is supplied by
// microsoft it is just not available to enumerate on Win7 etc.
// Making it available locally does not require administrator privs
// but only this process can see it and it disappears when the process
// closes
OperatingSystem os = Environment.OSVersion;
int versionID = ((os.Version.Major * 10) + os.Version.Minor);
if (versionID < 62)
{
Guid ColorConverterDMOGUID = new Guid("98230571-0087-4204-b020-3282538e57d3");
// Register the color converter DSP for this process, in the video
// processor category. This will enable the sink writer to enumerate
// the color converter when the sink writer attempts to match the
// media types.
hr = MFExtern.MFTRegisterLocalByCLSID(
ColorConverterDMOGUID,
MFTransformCategory.MFT_CATEGORY_VIDEO_PROCESSOR,
"",
MFT_EnumFlag.SyncMFT,
0,
null,
0,
null
);
}
// Set the input format for a stream on the sink writer. Note the use of the stream index here
// The input format does not have to match the target format that is written to the media sink
// If the formats do not match, this call attempts to load an transform
// that can convert from the input format to the target format. If it cannot find one, (and this is not
// a sure thing), it will throw an exception.
hr = workingSinkWriter.SetInputMediaType(sinkWriterVideoStreamId, incomingVideoMediaType, null);
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("StartRecording Failed on calling SetInputMediaType(v) on the writer, retVal=" + hr.ToString());
}
// set this flag now
wantTimebaseRebase = wantTimebaseRebaseIn;
// now we initialize the sink writer for writing. We call this method after configuring the
// input streams but before we send any data to the sink writer. The underlying media sink must
// have at least one input stream and we know it does because we set it up above
hr = workingSinkWriter.BeginWriting();
if (hr != HResult.S_OK)
{
// we failed
throw new Exception("StartRecording Failed on calling BeginWriting on the writer, retVal=" + hr.ToString());
}
}
return(0);
}