IltmmTargetFormat::put_UseFilterCache Example for C

#include "ltmm.h" 
#include "Filters/ILMMpg2MxT.h" 
#include <time.h> 
 
HRESULT UseFilterCache_Example (IltmmCapture* pCapture) 
{ 
   HRESULT hr; 
   IltmmDevices* devices   = NULL; 
   IltmmCompressors* compressors = NULL; 
   IltmmTargetFormats* pformats = NULL; 
   IltmmTargetFormat*  pformat  = NULL; 
   IUnknown*           pUnknown = NULL; 
   ILMMpg2MxT*         pMpgMux = NULL; 
   long lIndex = 0; 
   BSTR bstr; 
 
   // mpeg2 compressor 
   static TCHAR SZ_MPEG2_Compressor[] = "@device:sw:{33D9A760-90C8-11D0-BD43-00A0C911CE86}\\LEAD MPEG2 Encoder (3.0)"; 
 
   // get the video devices collection 
   hr = IltmmCapture_get_VideoDevices(pCapture, &devices); 
   if(FAILED(hr)) 
      return hr; 
 
   // select the capture device 
   hr = IltmmDevices_put_Selection(devices, 1); // Use a different video device if you want 
 
   // release the video devices collection object 
   IltmmDevices_Release(devices); 
   if(FAILED(hr)) 
      return hr; 
 
   // get the video compressors collection 
   hr = IltmmCapture_get_VideoCompressors(pCapture, &compressors); 
   if(FAILED(hr)) 
      return hr; 
 
   // find mpeg2 compressor 
   hr = IltmmCompressors_Find(compressors, T2OLE(SZ_MPEG2_Compressor), &lIndex); 
   if(FAILED(hr) || lIndex == -1) 
   { 
      // release the compressors collection object 
      IltmmCompressors_Release(compressors); 
      return S_FALSE; 
   } 
 
   // set the video compressor (only if the capture device is not already capturing compressed video) 
   IltmmCompressors_put_Selection(compressors, lIndex); 
 
   // release the compressors collection object 
   IltmmCompressors_Release(compressors); 
 
   // set the target output file 
   bstr = SysAllocString(L"c:\\CaptureKLV.avi"); 
   IltmmCapture_put_TargetFile(pCapture, bstr); 
   SysFreeString(bstr); 
 
   // just 10 seconds of capture time 
   IltmmCapture_put_UseTimeLimit (pCapture, VARIANT_TRUE); 
   IltmmCapture_put_TimeLimit(pCapture, 10); 
 
   // get the target formats collection 
   hr = IltmmCapture_get_TargetFormats(pCapture, &pformats); 
   if(FAILED(hr)) 
      return hr; 
 
   // get the MPEG2Transport target format object 
   hr = IltmmTargetFormats_Item(pformats, ltmmCapture_TargetFormat_MPEG2_TRANSPORT, &pformat); 
   if(FAILED(hr)) 
   { 
      // release the formats collection object 
      IltmmTargetFormats_Release(pformats); 
      return hr; 
   } 
 
   // IN a capture situation 
   // in order to get the mux in a capture situation, set the UseFilterCache property for the target format to TRUE 
   // This tells the toolkit to create a Mux object and keep it around when building or rebuilding graphs 
   // enable filter cache 
   hr = IltmmTargetFormat_put_UseFilterCache(pformat, VARIANT_TRUE); 
   if(FAILED(hr)) 
   { 
      // release the format and collection objects 
      IltmmTargetFormat_Release(pformat); 
      IltmmTargetFormats_Release(pformats); 
      return hr; 
   } 
 
   // select MPEG2Transport target format 
   hr = IltmmCapture_put_TargetFormat (pCapture, ltmmCapture_TargetFormat_MPEG2_TRANSPORT); 
   if(FAILED(hr)) 
      return hr; 
 
   // get the multiplexer object for this format 
   hr = IltmmTargetFormat_GetCacheObject(pformat, ltmmTargetFormat_Object_Mux, &pUnknown); 
   if(FAILED(hr)) 
   { 
      // release the format and collection objects 
      IltmmTargetFormat_Release(pformat); 
      IltmmTargetFormats_Release(pformats); 
      return hr;  
   } 
 
   // release the format and collection objects 
   IltmmTargetFormat_Release(pformat); 
   IltmmTargetFormats_Release(pformats); 
   hr = IUnknown_QueryInterface(pUnknown, &IID_ILMMpg2MxT, (void **)&pMpgMux); 
   IUnknown_Release(pUnknown); 
   if(FAILED(hr))  
      return hr; 
 
   if(pMpgMux) 
   { 
      ILMMpg2MxT_put_PrivateDataPID(pMpgMux, 0x70); 
      ILMMpg2MxT_put_PrivateDataFormatID(pMpgMux, 0x41564c4b); 
      ILMMpg2MxT_put_EnablePrivateData(pMpgMux, VARIANT_TRUE); 
   } 
 
   // release the multiplexer object 
   ILMMpg2MxT_Release(pMpgMux); 
 
   // start capture 
   hr = IltmmCapture_StartCapture(pCapture, ltmmCapture_Mode_Video); 
   if(FAILED(hr)) 
      return hr; 
 
   hr = WriteKLVData(pMpgMux); 
   return hr; 
} 
 
HRESULT WriteKLVData (ILMMpg2MxT*   pMpgMux ) 
{ 
   HRESULT hr = S_OK; 
   time_t basetime; 
   unsigned __int64 timestamp ; 
   ILMKlvBuilder* builder = NULL; 
   VARIANT v; 
   BSTR bstr; 
 
   time(&basetime); 
   timestamp = ((unsigned __int64) basetime * 1000000); 
 
   // get the mux builder 
   hr = ILMMpg2MxT_get_KlvBuilder(pMpgMux, &builder); 
   if(FAILED(hr)) 
      goto abort; 
 
   // clear out any existing data 
   ILMKlvBuilder_Clear(builder); 
   bstr = SysAllocString(L"06 0E 2B 34 01 01 01 03 07 02 01 01 01 05 00 00"); 
 
   // write the UDS timestamp 
   hr = ILMKlvBuilder_InsertUInt64(builder, -1L, bstr, timestamp); 
   SysFreeString(bstr); 
   if(FAILED(hr)) 
   { 
      ILMKlvBuilder_Release(builder); 
      goto abort; 
   } 
 
   // get KLV data 
   VariantInit(&v); 
   hr = ILMKlvBuilder_GetData(builder, &v); 
   if(FAILED(hr)) 
   { 
      ILMKlvBuilder_Release(builder); 
      goto abort; 
   } 
 
   // write one KLV data at the beginning 
   hr = ILMMpg2MxT_WritePrivateData(pMpgMux, Mpg2MxT_WriteFlag_PTSValid | Mpg2MxT_WriteFlag_PTSInSeconds, 1.0, v, -1); 
   VariantClear(&v); 
   if(FAILED(hr)) 
   { 
      ILMKlvBuilder_Release(builder); 
      goto abort; 
   } 
 
   ILMKlvBuilder_Release(builder); 
 
abort: 
   // close the stream 
   ILMMpg2MxT_ClosePrivateData(pMpgMux); 
 
   return hr; 
}