Gapless Audio CD Recording with VB or C Sharp

CreateStreamOnHGlobal(fileData, true, ref wavStream);// create the stream
Files[i].Stream = wavStream;// use this stream to burn to the disc
return wavStream;
}

You may begin the burn once all tracks have been loaded into streams.

As stated before, the burn process needs to run in a different thread than the main program so that burn progress can be reported. Create a thread that will run the burn sub. Start the thread.

DLL Code:

//
// Start the burn thread
//
public void Burn()
{
oThread = new Thread(new ThreadStart(this.BurnDAO));

oThread.Start();
}

The burn thread has several checks to perform to ensure that all conditions are ready. For instance, there needs to be a blank cd in the drive, it must be a drive that supports audio recording, the disc must be the proper type for audio and DiscAtOnce classes must be registered on the machine. Once all these checks are completed you can procede to step three of MS's helpful guide to using DAO (configureing the burner).

Is the disc to be gapless? If so then turn off Gapless recording in MsftRawCDImageCreator. When disabled the audio tracks will have the standard 2-second (150 sectors) silent gap between tracks. When enabled, the last 2 seconds of audio data from the previous audio track are encoded in the pre-gap area of the next audio track, enabling seamless transitions between tracks.

DLL Code:

DiscAtOnceImage.DisableGaplessAudio = false;// enable gapless recording

There is also the 2 second gap before the first track to be aware of. For this there is a sub routine in MsftRawCDImageCreator called AddSpecialPregap. It is optional but this example uses the first two seconds of the first track. This stream is created in FindSpecialPreGap. It is very similar to PrepareStream so I won't go into the gory details again except to say the we limit the stream size to 352800 bytes. (2 seconds * 2 channels * 2 bytes per sample * 44100 samples per second = 352800).

We now need to inform the burner which routine to call for burn progress updates:

DLL Code:

DiscFormat2RawCD.Update += new DiscFormat2RawCD_EventHandler(DiscAtOnce_Update);// tell imapi where your progress handler is

Next we need to add the tracks to the image creator

DLL Code:

for (i = 0; i <= tracklist.Length - 1; i++) // one at a time add the tracks to the stream to be burned
{
j = DiscAtOnceImage.AddTrack( IMAPI2 .Interop . IMAPI_CD_SECTOR_TYPE.IMAPI_CD_SECTOR_AUDIO, Files[i].Stream);
l += Files[i].PlayLength;
}

After adding all the tracks you need to use the image creator to create the final stream (an amalgum of all the little streams. The size of the final stream must me an even multiple of 2048 so while adding tracks we keep track of the size we are adding and then we bump that number up to a even multiple of 2048. We create a stream of that size and let the image creator load it.

DLL Code:

j = l / 2048;
j = (j + 1) * 2048;// the size of the Final Prepared Stream
m = new IntPtr(j - 1);
IntPtr fileData = Marshal.AllocHGlobal(m);//j - 1);
CreateStreamOnHGlobal(fileData, true, ref FinalStream); //Create the Stream
FinalStream.SetSize(j); // Set the stream size
FinalStream = DiscAtOnceImage.CreateResultImage(); // let imapi prepare the stream for burn

We are now ready to call DiscFormat2RawCD.WriteMedia.

Putting it all together we have:

DLL Code:

//
//The burn should take place in its own thread so that events can be handled
//
private void BurnDAO()
{
try
{
int i = 0;
long l = 0;
long j = 0;
IntPtr m;
if (!DAO_Available)// quit if the enviroment does not support Disc at Once
return;
canceling = false;
Boolean Doit = false;

IMAPI_MEDIA_PHYSICAL_TYPE mediaType;
IMAPI_FORMAT2_DATA_MEDIA_STATE curMediaStatus;
MsftDiscFormat2Data datawriter = new MsftDiscFormat2Data();
IStream FinalStream = null;
Burning = true;
datawriter.Recorder = (MsftDiscRecorder2)AudioDiscRecorder;// choose the recorder for media status data
try
{
mediaType =(IMAPI_MEDIA_PHYSICAL_TYPE ) datawriter.CurrentPhysicalMediaType;// get the current media
curMediaStatus = (IMAPI_FORMAT2_DATA_MEDIA_STATE)datawriter.CurrentMediaStatus;// get the current media status
// if the media is blank or appendable
if ((curMediaStatus & IMAPI_FORMAT2_DATA_MEDIA_STATE.IMAPI_FORMAT2_DATA_MEDIA_STATE_BLANK) == IMAPI_FORMAT2_DATA_MEDIA_STATE.IMAPI_FORMAT2_DATA_MEDIA_STATE_BLANK)
{
try
{
System.Array a = DiscFormat2RawCD.SupportedMediaTypes; // find out if this media is supported
foreach ( IMAPI_MEDIA_PHYSICAL_TYPE mt in a)
{
if (mt == mediaType)
{
Doit = true;
}
}
if (Doit)//MediaSupported?
{
DiscFormat2RawCD.Recorder = AudioDiscRecorder;// choose the recorder

if (gapless)// gapless recording
{
DiscAtOnceImage.DisableGaplessAudio = false;// enable gapless recording
IStream PregapStream = FindSpecialPreGap(); // find the spegial data for the first two seconds
DiscAtOnceImage.AddSpecialPregap(PregapStream);// add that stream
}
else
{

DiscAtOnceImage.DisableGaplessAudio = true; //disable gapless recording
}

DiscFormat2RawCD.Update += new DiscFormat2RawCD_EventHandler(DiscAtOnce_Update);// tell imapi where your progress handler is
for (i = 0; i <= tracklist.Length - 1; i++) // one at a time add the tracks to the stream to be burned
{
j = DiscAtOnceImage.AddTrack( IMAPI2 .Interop . IMAPI_CD_SECTOR_TYPE.IMAPI_CD_SECTOR_AUDIO, Files[i].Stream);
l += Files[i].PlayLength;
}
j = l / 2048;
j = (j + 1) * 2048;// the size of the Final Prepared Stream
m = new IntPtr(j - 1);
IntPtr fileData = Marshal.AllocHGlobal(m);//j - 1);
CreateStreamOnHGlobal(fileData, true, ref FinalStream); //Create the Stream
FinalStream.SetSize(j); // Set the stream size
FinalStream = DiscAtOnceImage.CreateResultImage(); // let imapi prepare the stream for burn

DiscFormat2RawCD.ClientName = sClientName;
DiscFormat2RawCD.PrepareMedia(); // locks the drive
DiscFormat2RawCD.RequestedSectorType = IMAPI2.Interop .IMAPI_FORMAT2_RAW_CD_DATA_SECTOR_TYPE.IMAPI_FORMAT2_RAW_CD_SUBCODE_IS_RAW;// this seems to be the only sector type viable for this kind of DAO
DiscFormat2RawCD.BufferUnderrunFreeDisabled = bufferunderrun;
if (!canceling)
{
DiscFormat2RawCD.WriteMedia(FinalStream);// burn
}
else
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.BurnCanceled;
}
}
else // mediatype not supported
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.DiscNotSupported;
}
}
catch
{
if (!canceling)
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.UnknownBurnError;
}
else
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.BurnCanceled;
}
}
}
else // disc not blank
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.DiscNotBlank;
}
}
catch // no disc in the drive
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.DriveEmpty;
}
try
{
DiscFormat2RawCD.Update -= new DiscFormat2RawCD_EventHandler(DiscAtOnce_Update); // remove the progrss handler
DiscFormat2RawCD.ReleaseMedia(); // unlock the drive
datawriter = null;
}
catch
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.UnknownBurnError;

}
}
catch
{
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.UnknownBurnError;
}
if (eject)
AudioDiscRecorder.EjectMedia();
InitObjects();// re init the obects so we can burn another disc wiithout stopping and starting again
if (BurnError == BurnErrors.BurnNotDone) BurnError = BurnErrors.BurnDoneSuccess;
canceling = false;
Burning = false;
oThread.Abort();
oThread = null;
}