Use the DVD Writer to Write a DVD Image

Use the DVD Writer to write a DVD image to the hard disk. To write to a DVD, perform the following steps:

  1. Declare the following structure that will be filled with the chapter names, as follows: 

    typedef struct _tagDVDTITLES 
{ 
   char pszChapters[2][256]; 
} DVDTITLES;

  2. Declare the following function to dispatch any incoming messages:

    C API
    void WaitForCompletion(IltmmConvert *pConvert) 
{ 
   long lState = ltmmConvert_State_Running; 
   MSG msg; 
   // Get the conversion state 
   IltmmConvert_get_State(pConvert, &lState); 
   // Dispatch messages during conversion 
   while( lState != ltmmConvert_State_Stopped ) 
   { 
      if( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) ) 
      { 
         TranslateMessage(&msg); 
         DispatchMessage(&msg); 
      } 
      IltmmConvert_get_State(pConvert, &lState); 
   } 
}
    C++
    void WaitForCompletion(IltmmConvert *pConvert) 
{ 
   long lState = ltmmConvert_State_Running; 
   MSG msg; 
   // Get the conversion state 
   pConvert->get_State(&lState); 
   // Dispatch messages during conversion 
   while( lState != ltmmConvert_State_Stopped ) 
   { 
      if( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) ) 
      { 
         TranslateMessage(&msg); 
         DispatchMessage(&msg); 
      } 
      pConvert->get_State(&lState); 
   } 
}

  3. Declare the following function to add the resize filter:

    C API
    BOOL AddResizeFilter(IltmmConvert *pConvert) 
{ 
   IltmmProcessors* pProcessors; 
   IltmmProcessors* pSelProcessors; 
   long lIndex = 0; 
   BSTR bstr; 
   IltmmProcessor* pProc; 
   HRESULT hr; 
   // Get the video processor's pointer 
   hr = IltmmConvert_get_VideoProcessors(pConvert, &pProcessors); 
   if (FAILED(hr)) 
   { 
      MessageBox(NULL, "Error working with video processors", "Error", MB_OK); 
      return FALSE; 
   } 
   // Get the selected video processor 
   hr = IltmmConvert_get_SelectedVideoProcessors(pConvert, &pSelProcessors); 
   if (FAILED(hr)) 
   { 
      MessageBox(NULL, "Error working with video processors", "Error", MB_OK); 
      IltmmProcessors_Release(pProcessors); 
      return FALSE; 
   } 
   // Find the index for the resize filter 
   bstr = SysAllocString(T2OLE("@device:sw:{E526D606-22E7-494C-B81E-AC0A94BFE603}\\{E2B7DCA5-38C5-11D5-91F6-00104BDB8FF9}")); 
   hr = IltmmProcessors_Find(pProcessors, bstr, &lIndex); 
   SysFreeString(bstr); 
   if (lIndex != -1) 
   { 
      // Add the resize filter 
      IltmmProcessors_Item(pProcessors, lIndex, &pProc); 
      hr = IltmmProcessors_RemoveAll(pSelProcessors); 
      IltmmProcessors_Add(pSelProcessors, pProc, 0); 
      IltmmProcessors_Release(pProc); 
      IltmmProcessors_Release(pProcessors); 
      IltmmProcessors_Release(pSelProcessors); 
      return TRUE; 
   } 
   else 
   { 
      IltmmProcessors_Release(pProcessors); 
      IltmmProcessors_Release(pSelProcessors); 
      return FALSE; 
   } 
   return FALSE; 
}
    C++
    BOOL AddResizeFilter(IltmmConvert *pConvert) 
{ 
   IltmmProcessors* pProcessors; 
   IltmmProcessors* pSelProcessors; 
   long lIndex = 0; 
   BSTR bstr; 
   IltmmProcessor* pProc; 
   HRESULT hr; 
   // Get the video processor's pointer 
   hr = pConvert->get_VideoProcessors(&pProcessors); 
   if (FAILED(hr)) 
   { 
      MessageBox(NULL, "Error working with video processors", "Error", MB_OK); 
      return FALSE; 
   } 
   // Get the selected video processor 
   hr = pConvert->get_SelectedVideoProcessors(&pSelProcessors); 
   if (FAILED(hr)) 
   { 
      MessageBox(NULL, "Error working with video processors", "Error", MB_OK); 
      pProcessors->Release(); 
      return FALSE; 
   } 
   // Find the index for the resize filter 
   bstr = SysAllocString(T2OLE("@device:sw:{E526D606-22E7-494C-B81E-AC0A94BFE603}\\{E2B7DCA5-38C5-11D5-91F6-00104BDB8FF9}")); 
   hr = pProcessors->Find(bstr, &lIndex); 
   SysFreeString(bstr); 
   if (lIndex != -1) 
   { 
      // Add the resize filter 
      pProcessors->Item(lIndex, &pProc); 
      hr = pSelProcessors->RemoveAll(); 
      pSelProcessors->Add(pProc, 0); 
      pProc->Release(); 
      pProcessors->Release(); 
      pSelProcessors->Release(); 
      return TRUE; 
   } 
   else 
   { 
      pProcessors->Release(); 
      pSelProcessors->Release(); 
      return FALSE; 
   } 
   return FALSE; 
}

  4. Configure the resize settings.

    C API
    void ConfigureResizeFilter(IltmmConvert *pConvert, long lWidth, long lHeight) 
{ 
   HRESULT    hr = S_OK; 
   IUnknown   *pUnk; 
   ILMVResize *pResize = NULL; 
   // Get the resize filter 
   hr = IltmmConvert_GetSubObject(pConvert, ltmmConvert_Object_SelVideoProcessor, &pUnk); 
   if (SUCCEEDED(hr)) 
   { 
      hr = IUnknown_QueryInterface(pUnk, &IID_ILMVResize, (void**)&pResize); 
      if (pResize) 
      { 
         // Set the resize filter settings 
         ILMVResize_put_Enabled(pResize, VARIANT_TRUE); 
         ILMVResize_put_AutoSize(pResize, VARIANT_FALSE); 
         ILMVResize_put_EnableQuickResize(pResize, VARIANT_FALSE); 
         ILMVResize_put_AspectRatio(pResize, VARIANT_TRUE); 
         ILMVResize_put_Width(pResize, lWidth); 
         ILMVResize_put_Height(pResize, lHeight); 
         ILMVResize_put_Flags(pResize, RESIZE_RESAMPLE); 
         ILMVResize_Release(pResize); 
      } 
      IUnknown_Release(pUnk); 
   } 
}
    C++
    void ConfigureResizeFilter(IltmmConvert *pConvert, long lWidth, long lHeight) 
{ 
   HRESULT    hr = S_OK; 
   IUnknown   *pUnk; 
   ILMVResize *pResize = NULL; 
   // Get the resize filter 
   hr = pConvert->GetSubObject(ltmmConvert_Object_SelVideoProcessor, &pUnk); 
   if (SUCCEEDED(hr)) 
   { 
      hr = pUnk->QueryInterface(IID_ILMVResize, (void**)&pResize); 
      if (pResize) 
      { 
         // Set the resize filter settings 
         pResize->put_Enabled(VARIANT_TRUE); 
         pResize->put_AutoSize(VARIANT_FALSE); 
         pResize->put_EnableQuickResize(VARIANT_FALSE); 
         pResize->put_AspectRatio(VARIANT_TRUE); 
         pResize->put_Width(lWidth); 
         pResize->put_Height(lHeight); 
         pResize->put_Flags(RESIZE_RESAMPLE); 
         pResize->Release(); 
      } 
      pUnk->Release(); 
   } 
}

  5. Declare the following variables: 

    IltmmConvert *pConvert = NULL; 
IUnknown *pDvdWriter = NULL; 
ILTDvdWriter *pIDvdWriter = NULL; 
BSTR szFileName = NULL; 
IltmmCompressors *pCompressors; 
long lIndex = 0; 
BOOL bRet = FALSE; 
int nTitle, nChapter; 
char szTitle[256]; 
BSTR strTitle, strChapter, strBackground; 
DVDTITLES aTitles[2] = 
{ 
   { 
      "C:\\Movie1.mpg", "C:\\Movie2.mpg" 
   }, 
   { 
      "C:\\Movie3.mpg", "C:\\Movie4.mpg" 
   } 
};

  6. Create the converter object.

    C API
    CoCreateInstance(&CLSID_ltmmConvert, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmConvert, (void**) &pConvert);
    C++
    CoCreateInstance(CLSID_ltmmConvert, NULL, CLSCTX_INPROC_SERVER, IID_IltmmConvert, (void**) &pConvert);

  7. Set the target format to be a DVD.

    C API
    IltmmConvert_put_TargetFormat(pConvert, ltmmConvert_TargetFormat_DVD);
    C++
    pConvert->put_TargetFormat(ltmmConvert_TargetFormat_DVD);

  8. Set the DVD compatible video encoder to be the LEAD MPEG2 encoder (2.0).

    C API
    IltmmConvert_get_VideoCompressors(pConvert, &pCompressors); 
IltmmCompressors_Find(pCompressors, L"@device:sw:{33D9A760-90C8-11D0-BD43-00A0C911CE86}\\LEAD MPEG2 Encoder (2.0)", &lIndex); 
IltmmCompressors_put_Selection(pCompressors, lIndex); 
IltmmCompressors_Release(pCompressors);
    C++
    pConvert->get_VideoCompressors(&pCompressors); 
pCompressors->Find(L"@device:sw:{33D9A760-90C8-11D0-BD43-00A0C911CE86}\\LEAD MPEG2 Encoder (2.0)", &lIndex); 
pCompressors->put_Selection(lIndex); 
pCompressors->Release();

  9. Set the DVD compatible audio encoder to be the LEAD MPEG audio encoder (2.0).

    C API
    IltmmConvert_get_AudioCompressors(pConvert, &pCompressors); 
IltmmCompressors_Find(pCompressors, L"@device:sw:{33D9A761-90C8-11D0-BD43-00A0C911CE86}\\LEAD MPEG Audio Encoder (2.0)", &lIndex); 
IltmmCompressors_put_Selection(pCompressors, lIndex); 
IltmmCompressors_Release(pCompressors);
    C++
    pConvert->get_AudioCompressors(&pCompressors); 
pCompressors->Find(L"@device:sw:{33D9A761-90C8-11D0-BD43-00A0C911CE86}\\LEAD MPEG Audio Encoder (2.0)", &lIndex); 
pCompressors->put_Selection(lIndex); 
pCompressors->Release();

  10. Add the resize filter as a process. Use the resize filter to change the video size so the dimensions are standard DVD dimensions.

    (In order for a DVD to be accepted by DVD players, the video size must be acceptable. It is recommended to use the DVD full resolution (720X480 for NTSC) because not all DVD navigators can handle the conversion from a DVD to a DVD image that is less than 720X480.)

    C API
    if (AddResizeFilter(pConvert) != TRUE) 
{ 
   MessageBox(NULL, "Can't insert the resize filter", "Error", MB_OK); 
   IltmmConvert_Release(pConvert); 
   return; 
}
    C++
    if (AddResizeFilter(pConvert) != TRUE) 
{ 
   ::MessageBox(NULL, "Can't insert the resize filter", "Error", MB_OK); 
   pConvert->Release(); 
   return; 
}

  11. Configure the resize settings. Set the dimensions to be 720 x 480. 

    ConfigureResizeFilter(pConvert, 720, 480);

  12. Set the DVD target folder.

    C API
    IltmmConvert_put_TargetFile(pConvert, T2OLE("C:\\DVDImage"));
    C++
    pConvert->put_TargetFile(T2OLE("C:\\DVDImage"));

  13. Retrieve the DVD Writer interface.

    C API
    IltmmConvert_GetSubObject(pConvert, ltmmConvert_Object_Sink, &pDvdWriter); 
IUnknown_QueryInterface(pDvdWriter, &IID_ILTDvdWriter, (void**)&pIDvdWriter);
    C++
    pConvert->GetSubObject(ltmmConvert_Object_Sink, &pDvdWriter); 
pDvdWriter->QueryInterface(IID_ILTDvdWriter, (void**)&pIDvdWriter);

  14. Set the DVD temporary folder.

    C API
    ILTDvdWriter_put_TempPath(pIDvdWriter, T2OLE("C:\\Temp"));
    C++
    pIDvdWriter->put_TempPath(T2OLE("C:\\Temp"));

  15. Remove all of the menu titles.

    C API
    ILTDvdWriter_RemoveAllMenuTitles(pIDvdWriter);
    C++
    pIDvdWriter->RemoveAllMenuTitles();

  16. Set the MenulessTitlePlay option to TRUE. This will concatenate all the titles for playback so each title will be played automatically, in sequential order.

    C API
    ILTDvdWriter_put_MenulessTitlePlay(pIDvdWriter, VARIANT_TRUE);
    C++
    pIDvdWriter->put_MenulessTitlePlay(VARIANT_TRUE);

  17. Create multiple titles, each title containing multiple chapters.

    Note: In order to add a new title to the DVD image being created, overwriting must be disabled before writing the image.

    C API
    for (nTitle = 0; nTitle < 2; nTitle++) 
{ 
   // Open a title 
   ILTDvdWriter_put_TitleBreak(pIDvdWriter, VARIANT_FALSE); 
   // Add a menu for the current title 
   wsprintf(szTitle, "Title %d", nTitle + 1); 
   strTitle = SysAllocString(T2OLE(szTitle)); 
   ILTDvdWriter_AddMenuTitle(pIDvdWriter, strTitle, -1); 
   SysFreeString(strTitle); 
   // Create two chapters in the title 
   for (nChapter = 0; nChapter < 2; nChapter++) 
   { 
      // Put the source movie file 
      strChapter = SysAllocString(T2OLE(aTitles[nTitle].pszChapters[nChapter])); 
      IltmmConvert_put_SourceFile(pConvert, strChapter); 
      // Start writing the chapter 
      IltmmConvert_StartConvert(pConvert); 
      // Wait for the conversion to finish. You can use a window 
      // to receive notifications 
      WaitForCompletion(pConvert); 
      // Free the chapter's name 
      SysFreeString(strChapter); 
   } 
   // Close the title 
   ILTDvdWriter_put_TitleBreak(pIDvdWriter, VARIANT_TRUE); 
   // Disable Overwrite so the title will be appended to the 
   // existing DVD image 
   ILTDvdWriter_put_Overwrite(pIDvdWriter, VARIANT_FALSE); 
}
    C++
    for (nTitle = 0; nTitle < 2; nTitle++) 
{ 
   // Open a title 
   pIDvdWriter->put_TitleBreak(VARIANT_FALSE); 
   // Add a menu for the current title 
   wsprintf(szTitle, "Title%d", nTitle + 1); 
   strTitle = SysAllocString(T2OLE(szTitle)); 
   pIDvdWriter->AddMenuTitle(strTitle, -1); 
   SysFreeString(strTitle); 
   // Create two chapters in the title 
   for (nChapter = 0; nChapter < 2; nChapter++) 
   { 
      // Put the source movie file 
      strChapter = SysAllocString(T2OLE(aTitles[nTitle].pszChapters[nChapter])); 
      pConvert->put_SourceFile(strChapter); 
      // Start writing the chapter 
      pConvert->StartConvert(); 
      // Wait for the conversion to finish. You can use a window 
      // to receive notifications 
      WaitForCompletion(pConvert); 
      // Free the chapter's name 
      SysFreeString(strChapter); 
   } 
   // Close the title 
   pIDvdWriter->put_TitleBreak(VARIANT_TRUE); 
   // Disable Overwrite so the title will be appended to the 
   // existing DVD image 
   pIDvdWriter->put_Overwrite(VARIANT_FALSE); 
}

  18. Write the menu title. Menu writing should be the last step in a DVD image authoring process. Writing the menu first will cause an error and if a new title is written after the menu has been written, the menu will be destroyed.

    C API
    // Change the writing state to indicate that the next conversion is 
// a menu 
ILTDvdWriter_put_TitleMenu(pIDvdWriter, VARIANT_TRUE); 
// Set the loop behavior for the menu background. 
ILTDvdWriter_put_MenuLoop(pIDvdWriter, TRUE); 
// Set the source background movie (or you could use a still image // file as the background menu) 
strBackground = SysAllocString(T2OLE("c:\\background.mpg")); 
IltmmConvert_put_SourceFile(pConvert, strBackground); 
SysFreeString(strBackground); 
// Start writing the menu 
IltmmConvert_StartConvert(pConvert); 
// Wait for the conversion to finish 
WaitForCompletion(pConvert);
    C++
    // Change the writing state to indicate that the next conversion is 
// a menu 
pIDvdWriter->put_TitleMenu(VARIANT_TRUE); 
// Set the loop behavior for the menu background. 
pIDvdWriter->put_MenuLoop(TRUE); 
// Set the source background movie (or you could use a still image // file as the background menu) 
strBackground = SysAllocString(T2OLE("c:\\background.mpg")); 
pConvert->put_SourceFile(strBackground); 
SysFreeString(strBackground); 
// Start writing the menu 
pConvert->StartConvert(); 
// Wait for the conversion to finish 
WaitForCompletion(pConvert);

  19. Finish the menu conversion by calling ILTDvdWriter::put_TitleMenu, passing VARIANT_FALSE for the newVal parameter to close the "menu write" mode. This merges the menu subtitle information with the background video and modifies the DVD image.

    C API
    ILTDvdWriter_put_TitleMenu(pIDvdWriter, VARIANT_FALSE); 
ILTDvdWriter_put_Overwrite(pIDvdWriter, VARIANT_TRUE);
    C++
    pIDvdWriter->put_TitleMenu(VARIANT_FALSE); 
pIDvdWriter->put_Overwrite(VARIANT_TRUE);

  20. Free the Convert and DVD writer objects.

    C API
    ILTDvdWriter_Release(pIDvdWriter); 
IltmmConvert_Release(pConvert);
    C++
    pIDvdWriter->Release(); 
pConvert->Release();

Help Version 22.0.2023.1.26
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2023 LEAD Technologies, Inc. All Rights Reserved.

LEADTOOLS Multimedia C API Help
Introduction
Version History
Getting Started
Copyright Notice
Directories
Multimedia Files You Must Include With Your Application (Redistributables)
Frequently Asked Questions
LEADTOOLS Multimedia Features
Add-on Modules
Programming with LEADTOOLS Multimedia
Appendix
LEADTOOLS Licensing
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2023 LEAD Technologies, Inc. All Rights Reserved.