Unable to write to Disc Using IMAPI2 AddAudioTrack

DWORD CMyClass::BurnThread(LPVOID pParam)
{
    CMyClass* pThis = (CMyClass*)pParam;
	HRESULT hResult;
	
	CoInitialize(NULL);
 
	// Get all the required Interfaces
	IDiscMaster2*	discMaster;
	hResult = CoCreateInstance(__uuidof(MsftDiscMaster2), NULL, CLSCTX_INPROC_SERVER,
		__uuidof(IDiscMaster2), (void**)&discMaster);
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Initialize IDiscMaster2 - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Initialize IDiscMaster2"), 2);
		//pThis->StopAllThreads();
		return 0;
	}
		
	IDiscRecorder2* discRecorder2;
	hResult = CoCreateInstance(__uuidof(MsftDiscRecorder2), NULL, CLSCTX_INPROC_SERVER,
		__uuidof(IDiscRecorder2), (void**)&discRecorder2);
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Initialize IDiscRecorder2 - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Initialize IDiscRecorder2"), 2);
		//pThis->StopAllThreads();
		return 0;
	}
 
	
	IDiscFormat2TrackAtOnce* trackAtOnce;
	hResult = CoCreateInstance(__uuidof(MsftDiscFormat2TrackAtOnce), NULL, CLSCTX_INPROC_SERVER,
		__uuidof(IDiscFormat2TrackAtOnce), (void**)&trackAtOnce);
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Initialize IDiscFormat2TrackAtOnce - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Initialize IDiscFormat2TrackAtOnce"), 2);
		//pThis->StopAllThreads();
		return 0;
	}
 
	BSTR RecID = (pThis->GetCurrentRecorder()->GetUniqueId()).AllocSysString();
		hResult = discRecorder2->InitializeDiscRecorder(RecID);
		::SysFreeString( RecID );
		if (!SUCCEEDED(hResult))
		{
			pThis->m_strErrorMessage.Format(_T("Unable to Initialize DiscRecorder - Error:0x%08x"), hResult);
			ServerLog::Write(_T("BurnThread:Unable to Initialize IDiscFormat2TrackAtOnce"), 2);
			//pThis->StopAllThreads();
			return 0;
		}
	//}
	//else
	//{
	//	pThis->m_strErrorMessage.Format(_T("Unable to Initialize IDiscFormat2TrackAtOnce - Error:0x%08x"), hResult);
	//	ServerLog::Write(_T("BurnThread:BurnData was NULL"), 2);
	//	//pThis->StopAllThreads();
	//	return 0;
	//}
 
	//BSTR CName=(pThis->m_clientName).AllocSysString();
	
	// Attach Client Name with TrackAtOnce
		CString strClientName("DistraBurn");
	BSTR CName =strClientName.AllocSysString();
    hResult = trackAtOnce->put_ClientName(CName);
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Put ClientName - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Put ClientName"), 2);
		//pThis->StopAllThreads();
		return 0;
	}	
 
	// Attach the recorder with TrackAtOnce
    hResult = trackAtOnce->put_Recorder( discRecorder2);
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Put Recorder to TrackAtOnce - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Put Recorder to TrackAtOnce "), 2);
		pThis->StopAllThreads();
		return 0;
	}
 
	// Create the event sink
	
	CTrackAtOnceEvent* eventSink = CTrackAtOnceEvent::CreateEventSink();
	if (eventSink == NULL)
	{
		pThis->m_strErrorMessage = _T("Unable to create event sink");
		ServerLog::Write(_T("BurnThread:Unable to create event sink"), 2);
		pThis->StopAllThreads();
		return 0;
	}
	
	// Connect EventSink with TrackAtOnce
	pThis->m_trackAtOnce = trackAtOnce;
	if (!eventSink->ConnectTrackAtOnceData(pThis->m_trackAtOnce))
	{
		pThis->m_strErrorMessage = _T("Unable to connect event sink with interface");
		ServerLog::Write(_T("BurnThread:Unable to connect event sink with interface"), 2);
		pThis->StopAllThreads();
		return 0;
	}
	eventSink->SetHwnd(pThis->m_hWnd);
 
	// Acquire Exclusive Access to Recorder for writing
	hResult = discRecorder2->AcquireExclusiveAccess(TRUE, CName);
	::SysFreeString( CName );
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Acquire Exclusive Access to Recorder - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Acquire Exclusive Access to Recorder "), 2);
		pThis->StopAllThreads();
		return 0;
	}
 
	
 
	hResult = trackAtOnce->PrepareMedia();
	if (!SUCCEEDED(hResult))
	{
		pThis->m_strErrorMessage.Format(_T("Unable to Prepare Media - Error:0x%08x"), hResult);
		ServerLog::Write(_T("BurnThread:Unable to Prepare Media "), 2);
		pThis->StopAllThreads();
		return 0;
	}
 
	// send OK message
	//pThis->PostMessage(WM_READY_FOR_BURN);
 
	CTrackInfo* trackInfo = NULL;
	
	// Create local copy for easy reference
	CPlayList* pTrackList = NULL;
	pTrackList = pThis->GetCurrentPlayList();
	
	int count = 0;
	
	if(pTrackList)
	{
		// Fill Burndata with some data
		count = pTrackList->GetTotalNoOfSongs();
		//pBurnData->currentTrackNumber = 0;
	}
	else
	{
		pThis->m_strErrorMessage.Format(_T("TrackList was NULL"));
		ServerLog::Write(_T("BurnThread: TrackList was NULL "), 2);
		//pThis->StopAllThreads();
		return 0;
	}
 
	// Set the Ready event for beginin other threads
	//SetEvent(pThis->m_hEventReady);
	
	//MediaFile* pMediaFile = NULL;
	for(int index=0; index < count; index++)
    {
		// If we have already burned all the converted files then
		// Wait for the Conversion Event Here
		if( !(pThis->m_nBurned < pThis->m_nConverted) )
		{
			WaitForSingleObject(pThis->m_hEventConverted, INFINITE);
		}
		//Reset the Event Anyways
		ResetEvent(pThis->m_hEventConverted);
 
		//
        // Check if we've cancelled
        //
        if (pThis->GetCancelBurning())
        {
			TRACE("\n\tCancelling Streaming / Burning \n");
			ServerLog::Write(_T(" BurnThread:Cancelling Streaming"), 2);
			pThis->m_strErrorMessage = _T("User Cancelled the operation");
            break;
        }
 
		// Get track information
		trackInfo = pTrackList->GetTrackAtIndex(index);
 
		if(trackInfo)
		{
 
			//Get the MediaFile Object for current track
			//pMediaFile = (MediaFile*)trackInfo->GetMediaFile();
 
			if(trackInfo->IsMediaFilePresent())
			{
				//Prepare the Stream of the file
				if ( trackInfo->GetStatus() == TRACK_CONVERTED)
				{
					TRACE("\n\t\t\tStreaming Audio Track %d\n", index );
					ServerLog::Write(_T("Streaming Audio Track"), 2);
					//if(!pMediaFile->PrepareStream())
					if(!trackInfo->PrepareTrackStream())
					{
						ServerLog::Write(_T("Can't Preapre Stream"), 2);
						// Increment Converted songs count. This is necessary
						pThis->m_nBurned++;
						continue;//break;
					}
 
					// Set status to STREAMED
					trackInfo->SetStatus(TRACK_STREAMED);
					pThis->m_nStreamed++;
				}
			
				//
				// Check if we've cancelled
				//
				if (pThis->GetCancelBurning())
				{
					TRACE("\n\tCancelling Streaming / Burning \n");
					ServerLog::Write(_T("BurnThread:Cancelling Burning"), 2);
					pThis->m_strErrorMessage = _T("User Cancelled the operation");
					break;
				}
 
				// if the track is already Streamed then only we will Burn it to Disc
				if ( trackInfo->GetStatus() == TRACK_STREAMED)
				{
					// Add audio track
					//pBurnData->filename = pMediaFile->ToString();
					IStream* stream = NULL;
					stream = trackInfo->GetTrackIStream();
					
					if(stream)
					{
 
						TRACE("\n\t\t\tAdding Audio Track %d\n", index );
						ServerLog::Write(_T("Adding Audio Track"), 2);
						hResult = trackAtOnce->AddAudioTrack(stream);
						if(SUCCEEDED(hResult))
						{
							// Set status to CONVERTED and delete the global stream
							trackInfo->SetStatus(TRACK_BURNED);
							TRACE("\n\t\t\tAdded Audio Track %d\n", index );
							ServerLog::Write(_T("Added Audio Track"), 2);
							//delete mediaFile;
						}
						else
						{
							// Set status to CONVERTED and delete the global stream
							trackInfo->SetStatus(TRACK_BURNED, false);
							TRACE("\n\t\t\tUnable to Add Audio Track %d\n", index );
							ServerLog::Write(_T("Unable to Add Audio Track"), 2);
						}
					}
 
					// Delete the media File and free memory
					trackInfo->ReleaseMediaFile();
										
				}
				// Increment Converted songs count
				pThis->m_nBurned++;
			}
		}
			
	}
 
	//Delete all the Streams that are not deleted(mainly in case of User Cancel)
	for(int index=pThis->m_nBurned; index < pThis->m_nStreamed; index++)
    {
		trackInfo = pTrackList->GetTrackAtIndex(index);
 
		//Get the MediaFile Object for current track
		trackInfo->ReleaseMediaFile();
	}
 
	// Delete the Event Sink Now
	delete eventSink;
 
	// Release all the interfaces
	trackAtOnce->ReleaseMedia();
	trackAtOnce->Release();
 
	// If User selected the Eject Option then Eject Disc
	//if(pThis->m_bEjectAfterBurn)
		discRecorder2->EjectMedia();
 
	//Release Exclusive Access from Recorder
	discRecorder2->ReleaseExclusiveAccess();
	discRecorder2->Release();
 
	discMaster->Release();
	
	// Set the Burner Thread finish Event
	SetEvent(pThis->m_hThreadEvents[2]);
	
	return 0;
}

                                  

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294: