Skip to main content

Open Source

Go Search
Home
ALchemy
Beta - Audigy [CLOSED]
Beta - Linux
Beta - Windows
Developer
E-MU
MarCom
OpenAL
Open Source
PR
  
Creative Labs: Connect > Open Source > Wiki > mtp_xfer_code  

mtp_xfer_code

#include "stdafx.h"
#include "stdio.h"
#include "conio.h"
// WMDM includes
#include "mswmdm_i.c"
#include "mswmdm.h"
#include "sac.h"
#include "scclient.h"
int main(int argc, char* argv[])
{
  HRESULT hr;
  IComponentAuthenticate* pICompAuth;
  CSecureChannelClient *m_pSacClient = new CSecureChannelClient;
  IWMDeviceManager3* m_pIdvMgr = NULL;
  //these are generic keys
  BYTE abPVK[] = {0x00};
  BYTE abCert[] = {0x00};
  printf("MTP Transfer\n");
  printf("============\n");
  CoInitialize(NULL);
  // get an authentication interface
  hr = CoCreateInstance(CLSID_MediaDevMgr, NULL, CLSCTX_ALL ,IID_IComponentAuthenticate, (void **)&pICompAuth);
  if SUCCEEDED(hr)
  {
    // create a secure channel client certificate
    hr = m_pSacClient->SetCertificate(SAC_CERT_V1, (BYTE*) abCert, sizeof(abCert), (BYTE*) abPVK, sizeof(abPVK));
    if SUCCEEDED(hr)
    {
      // bind the authentication interface to the secure channel client
      m_pSacClient->SetInterface(pICompAuth);
      // trigger communication
      hr = m_pSacClient->Authenticate(SAC_PROTOCOL_V1);                   
      if SUCCEEDED(hr)
      {
        // get main interface to media device manager
        hr = pICompAuth->QueryInterface(IID_IWMDeviceManager2, (void**)&m_pIdvMgr);
        if SUCCEEDED(hr)
        {
          // we now have a media device manager interface...
          // enumerate devices...
          IWMDMEnumDevice *pIEnumDev;
          wchar_t pwsString[256];
          char ch[256];
          hr = m_pIdvMgr->EnumDevices2(&pIEnumDev);
          if SUCCEEDED(hr) {
            hr = pIEnumDev->Reset(); // Next will now return the first device
            if SUCCEEDED(hr) {
              printf("");
              IWMDMDevice3* pIDevice;
              unsigned long ulNumFetched;
              size_t ret;
              hr = pIEnumDev->Next(1, (IWMDMDevice **)&pIDevice, &ulNumFetched);
              while (SUCCEEDED(hr) && (hr != S_FALSE)) {
                // output device name
                hr = pIDevice->GetName(pwsString, 256);
                if SUCCEEDED(hr) {
                  wcstombs_s(&ret, ch, 256, pwsString,_TRUNCATE);
                  printf("Found device %s\n", ch);
                }
                // get storage info
                DWORD tempDW;
                pIDevice->GetType(&tempDW);
                if (tempDW & WMDM_DEVICE_TYPE_STORAGE) {
                  IWMDMEnumStorage *pIEnumStorage = NULL;
                  IWMDMEnumStorage *pIEnumFileStorage = NULL;
                  IWMDMEnumStorage *pIEnumFileStorageL2 = NULL;
                  IWMDMStorage *pIStorage = NULL;
                  IWMDMStorage3 *pIFileStorage = NULL;
                  IWMDMStorage3 *pIFileStorage_L2 = NULL;
                  _WAVEFORMATEX format;
                  hr = pIDevice->EnumStorage(&pIEnumStorage);
                  if SUCCEEDED(hr) {
                    pIEnumStorage->Reset();
                    hr = pIEnumStorage->Next(1, (IWMDMStorage **)&pIStorage, &ulNumFetched);
                    while (SUCCEEDED(hr) && (hr != S_FALSE)) {
                      hr = pIStorage->EnumStorage(&pIEnumFileStorage);
                      if SUCCEEDED(hr) {
                        pIEnumFileStorage->Reset();
                        hr = pIEnumFileStorage->Next(1, (IWMDMStorage **)&pIFileStorage, &ulNumFetched);
                        while (SUCCEEDED(hr) && hr != S_FALSE) {
                          hr = pIFileStorage->GetName(pwsString, 256);
                          hr = pIFileStorage->GetAttributes(&tempDW, &format);
                          if SUCCEEDED(hr) {
                            if (tempDW & WMDM_FILE_ATTR_FOLDER) {                             
                              if (wcscmp(pwsString, L"Music") == 0) {
                                IWMDMStorage3 *pNewStorage;
                                hr = pIFileStorage->QueryInterface(IID_IWMDMStorage3, (void **)&pNewStorage);
                                if SUCCEEDED(hr) {
                                  IWMDMStorageControl3 *pIWMDMStorageControl;
                                  hr = pNewStorage->QueryInterface(IID_IWMDMStorageControl3,
                                                   (void**)&pIWMDMStorageControl);
                                  if SUCCEEDED(hr)
                                  {
                                    IWMDMMetaData *pIWMDMMetaData = NULL;
                                    hr = pNewStorage->CreateEmptyMetadataObject(&pIWMDMMetaData);
                                    if (SUCCEEDED(hr)) {
                                      DWORD dw = WMDM_FORMATCODE_MP3;
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_DWORD, g_wszWMDMFormatCode, (BYTE *)&dw, sizeof(dw));
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_STRING, g_wszWMDMTitle, (BYTE *)L"TSOS-05-23-2006", 32);
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_STRING, g_wszWMDMAlbumTitle, (BYTE *)L"
www.skinnyonsports.com", 46);
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_STRING, g_wszWMDMAuthor, (BYTE *)L"The Skinny on Sports", 42);
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_STRING, g_wszWMDMGenre, (BYTE *)L"Podcast", 16);
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_STRING, g_wszWMDMYear, (BYTE *)L"2006", 10);
                                      dw = 0;
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_DWORD, g_wszWMDMTrack, (BYTE *)&dw, sizeof(dw));
                                      DWORD ow[2];
                                      ow[0] = 0x77825f00;
                                      ow[1] = 1;
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_QWORD, g_wszWMDMDuration, (BYTE *)ow, 2 * sizeof(dw));
                                      ow[0] = 0x7532e5;
                                      ow[1] = 0;
                                      hr = pIWMDMMetaData->AddItem(WMDM_TYPE_QWORD, g_wszWMDMFileSize, (BYTE *)ow, 2 * sizeof(dw));
                                      if (SUCCEEDED(hr)) {
                                        IWMDMStorage *pNewObject = NULL;
                                        hr = pIWMDMStorageControl->Insert3(
                                             WMDM_MODE_BLOCK | WMDM_CONTENT_FILE,
                                             0,
                                             L"C:\\Music\\testfile.mp3",
                                             NULL,
                                             NULL,
                                             NULL,
                                             pIWMDMMetaData,
                                             NULL,
                                             (IWMDMStorage **)&pNewObject);
                                       
                                        if SUCCEEDED(hr)
                                          wprintf(L"Insert Succeeded\n");
                                      }
                                    }
                                  }
                                }
                              }
                               
                            } else {
                              printf("\n");
                            }
                          } else {
                            printf("\n");
                          }
                          pIFileStorage->Release();
                          hr = pIEnumFileStorage->Next(1, (IWMDMStorage **)&pIFileStorage, &ulNumFetched);
                        }
                        pIEnumFileStorage->Release();
                      }

                      hr = pIEnumStorage->Next(1, (IWMDMStorage **)&pIStorage, &ulNumFetched);
                    }
                    pIEnumStorage->Release();
                  }
                }
                // move to next device
                hr = pIEnumDev->Next(1, (IWMDMDevice **)&pIDevice, &ulNumFetched);
              }
              pIEnumDev->Release();
            }
            m_pIdvMgr->Release();
          }
          pICompAuth->Release();
        }
      }
    }
  }
  char c = _getch();
  CoUninitialize();
  return 0;
}
 

Last modified at 12/5/2007 2:16 PM  by Phillip Williams