Replace Audio using IltmmMultiStreamSource and IltmmMultiStreamTarget Example for C

LPOLESTR T2OLE(LPCTSTR lpt) 
{ 
   static OLECHAR lpw[512]; 
 
   if(!lpt) 
      return NULL; 
 
   lpw[0] = L'\0'; 
 
   MultiByteToWideChar(CP_ACP, 0, lpt, -1, lpw, 512); 
 
   return lpw; 
} 
 
void PrepareSampleAndTarget(IltmmConvert* pSourceConvert, char pszSourceFile[256], char mtType[40], IltmmSampleTarget** ppSampleTarget, IltmmMultiStreamSource* pVideoAndAudioSource, long lStream) 
{ 
   IltmmMediaTypeDisp *pInsertedMeidaType; 
   IltmmMediaTypeDisp *pmt; 
   BSTR bstrSourceFile; 
   HRESULT hr; 
   BSTR bstrType; 
 
   bstrSourceFile = T2OLE(pszSourceFile); 
   IltmmConvert_put_SourceFile(pSourceConvert, bstrSourceFile); 
   SysFreeString(bstrSourceFile); 
 
   hr = CoCreateInstance(&CLSID_ltmmSampleTarget, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmSampleTarget, (void**) ppSampleTarget); 
   if(FAILED(hr)) 
   { 
      return; 
   } 
 
   hr = CoCreateInstance(&CLSID_ltmmMediaType, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmMediaTypeDisp, (void**) &pmt); 
   if(FAILED(hr)) 
   { 
      return; 
   } 
 
   // create a ltmmMediaType and indicate the accepted type 
   bstrType = T2OLE(mtType); 
   IltmmMediaTypeDisp_put_Type(pmt, bstrType); 
   SysFreeString(bstrType); 
 
   // make the SampleTarget object accept connections of this media type 
   hr = IltmmSampleTarget_SetAcceptedMediaType(*ppSampleTarget, pmt); 
 
   IltmmMediaTypeDisp_Release(pmt); 
   pmt = NULL; 
 
   // set the output target object to be sample target 
   IltmmConvert_put_TargetObject(pSourceConvert, *ppSampleTarget); 
 
   // start the conversion, so I know the exact media type 
   IltmmConvert_StartConvert(pSourceConvert); 
 
   // set the media type for the source stream to be the same as the media type in the input file (video or audio) 
   IltmmSampleTarget_GetConnectedMediaType(*ppSampleTarget, &pmt); 
   IltmmMultiStreamSource_SetMediaType(pVideoAndAudioSource, lStream, pmt); 
 
   // check set sucess: 
   IltmmMultiStreamSource_GetMediaType(pVideoAndAudioSource, lStream, &pInsertedMeidaType); 
   if (pInsertedMeidaType) 
      IltmmMediaTypeDisp_Release(pInsertedMeidaType); 
} 
 
void CopySamples(IltmmConvert* pSourceCtrl, IltmmSampleTarget* pSampleTarget, IltmmMultiStreamSource *pVideoAndAudioSource, long lStream) 
{ 
   IltmmMediaSampleDisp*  pmsSrc = NULL; 
   IltmmMediaSampleDisp*  pmsDst = NULL; 
   long              lStartTimeHi; 
   long              lStartTimeLo; 
   long              lStopTimeHi; 
   long              lStopTimeLo; 
   HRESULT hr; 
   VARIANT  vBuffer; 
   long     lActualDataLength; 
   VARIANT_BOOL vBool; 
 
   for ( ; ; ) 
   { 
      hr = IltmmSampleTarget_GetSample(pSampleTarget, 3000, &pmsSrc); 
      if (!pmsSrc) 
         break; 
 
      // get a source sample 
      hr = IltmmMultiStreamSource_GetSampleBuffer(pVideoAndAudioSource, lStream, 2000, &pmsDst); 
 
      // copy the data to the source sample 
 
      hr = IltmmMediaSampleDisp_get_Buffer(pmsSrc, &vBuffer); 
      hr = IltmmMediaSampleDisp_get_ActualDataLength(pmsSrc, &lActualDataLength); 
      hr = IltmmMediaSampleDisp_SetData(pmsDst, lActualDataLength, vBuffer); 
 
      // copy the sample time 
      IltmmMediaSampleDisp_GetTime(pmsSrc, &lStartTimeHi, &lStartTimeLo, &lStopTimeHi, &lStopTimeLo); 
      IltmmMediaSampleDisp_SetTime(pmsDst, lStartTimeHi, lStartTimeLo, lStopTimeHi, lStopTimeLo); 
 
      // copy the other flags 
      IltmmMediaSampleDisp_get_Discontinuity(pmsSrc, &vBool); 
      IltmmMediaSampleDisp_put_Discontinuity(pmsDst, vBool); 
 
      IltmmMediaSampleDisp_get_Preroll(pmsSrc, &vBool); 
      IltmmMediaSampleDisp_put_Preroll(pmsDst, vBool); 
 
      IltmmMediaSampleDisp_get_SyncPoint(pmsSrc, &vBool); 
      IltmmMediaSampleDisp_put_SyncPoint(pmsDst, vBool); 
 
      //release the source sample 
      IltmmMediaSampleDisp_Release(pmsSrc); 
      pmsSrc = NULL; 
 
      // deliver the source sample 
      IltmmMultiStreamSource_DeliverSample(pVideoAndAudioSource, lStream, 2000, pmsDst); 
 
      // release the source sample 
      IltmmMediaSampleDisp_Release(pmsDst); 
      pmsDst = NULL; 
   } 
    
   // stop the conversion in the source control 
   IltmmConvert_StopConvert(pSourceCtrl); 
 
   // deliver end of stream for the current source stream 
   hr = IltmmMultiStreamSource_DeliverEndOfStream(pVideoAndAudioSource, lStream, 5000); 
} 
 
int ReplaceAudiousingIltmmMultiStreamSourceandIltmmMultiStreamTarget_Example ( ) 
{ 
   IltmmConvert* pVideoConvert; 
   IltmmConvert* pAudioConvert; 
   IltmmConvert* pDestConvert; 
   HRESULT hr; 
   IltmmSampleTarget* pVideoTarget = NULL; 
   IltmmSampleTarget* pAudioTarget = NULL; 
   IltmmMultiStreamSource *pVideoAndAudioSource = NULL; 
 
   BSTR bstr; 
   long lState; 
 
   pVideoConvert = NULL; 
   pAudioConvert = NULL; 
   pDestConvert = NULL; 
 
   CoInitialize(NULL); 
 
   hr = CoCreateInstance(&CLSID_ltmmConvert, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmConvert, (void**) &pVideoConvert); 
   if(FAILED(hr)) 
   { 
      MessageBox(0, "Can't instantiate convert library", "Error", 0); 
      return -1; 
   } 
 
   hr = CoCreateInstance(&CLSID_ltmmConvert, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmConvert, (void**) &pAudioConvert); 
   if(FAILED(hr)) 
   { 
      MessageBox(0, "Can't instantiate convert library", "Error", 0); 
      return -1; 
   } 
 
   hr = CoCreateInstance(&CLSID_ltmmConvert, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmConvert, (void**) &pDestConvert); 
   if(FAILED(hr)) 
   { 
      MessageBox(0, "Can't instantiate convert library", "Error", 0); 
      return -1; 
   } 
 
   hr = CoCreateInstance(&CLSID_ltmmMultiStreamSource, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmMultiStreamSource, (void**) &pVideoAndAudioSource); 
   if(FAILED(hr)) 
   { 
      MessageBox(0, "Can't instantiate convert library", "Error", 0); 
      return -1; 
   } 
 
   IltmmMultiStreamSource_put_StreamCount(pVideoAndAudioSource, 2); 
   /*   
   Prepare pVideoConvert and set its source file to VideoFile. 
   Convert only the video stream 
   Create a new pVideoTarget object and set as the sample target object in pVideoConvert 
   Set the stream media type for pin 0 of VideoAndAudioSource to be the same as the video media type 
   Also starts the conversion in pVideoConvert 
   */ 
 
   PrepareSampleAndTarget(pVideoConvert, "c:\\Video.avi", (char*)ltmmMEDIATYPE_Video, &pVideoTarget, pVideoAndAudioSource, 0); 
 
   /* 
   Prepare AudioCtrl and set its source file to AudioFile. 
   Convert only the audio stream 
   Create a new AudioTarget object and set as the sample target object in AudioCtrl 
   Set the stream media type for pin 1 of VideoAndAudioSource to be the same as the audio media type 
   Also starts the conversion in AudioCtrl 
   */ 
 
   PrepareSampleAndTarget(pAudioConvert, "C:\\Voice.wav", (char*)ltmmMEDIATYPE_Audio, &pAudioTarget, pVideoAndAudioSource, 1); 
 
   // prepare the destination file 
   IltmmConvert_put_SourceObject(pDestConvert, pVideoAndAudioSource); 
   IltmmConvert_put_TargetFormat(pDestConvert, ltmmConvert_TargetFormat_Avi); 
 
   bstr = T2OLE("C:\\Video_And_Voice.avi"); 
   IltmmConvert_put_TargetFile(pDestConvert, bstr); 
 
   SysFreeString(bstr); 
   IltmmConvert_StartConvert(pDestConvert); 
 
   // Copy all the video samples from the Video file to the destination file 
   CopySamples(pVideoConvert, pVideoTarget, pVideoAndAudioSource, 0); 
 
   // Copy all the audio samples from the Audio file to the destination file 
   CopySamples(pAudioConvert, pAudioTarget, pVideoAndAudioSource, 1); 
 
   // wait for the destination control to stop the conversion 
   IltmmConvert_get_State(pDestConvert, &lState); 
   if( lState == ltmmConvert_State_Running ) 
   { 
      IltmmConvert_StopConvert(pDestConvert); 
   } 
 
   IltmmConvert_ResetSource(pDestConvert); 
 
   if (pVideoConvert) 
   { 
      IltmmConvert_Release(pVideoConvert); 
      pVideoConvert = NULL; 
   } 
 
   if (pAudioConvert) 
   { 
      IltmmConvert_Release(pAudioConvert); 
      pAudioConvert = NULL; 
   } 
 
   if (pDestConvert) 
   { 
      IltmmConvert_Release(pDestConvert); 
      pDestConvert = NULL; 
   } 
 
   if (pVideoAndAudioSource) 
   { 
      IltmmMultiStreamSource_Release(pVideoAndAudioSource); 
      pVideoAndAudioSource = NULL; 
   } 
 
   CoUninitialize(); 
 
   return 0; 
}