Next Previous

Retired Document

Important: This sample code may not represent best practices for current development. The project may use deprecated symbols and illustrate technologies and techniques that are no longer recommended.

Relevant replacement documents include:

http://developer.apple.com/samplecode/QTExtractAndConvertToMovieFile/index.html

AudioConvert.c

//////////

//

//  File:       AudioConvert.c

//

//  Contains:   Sample code showing how to use the Sound Manager's SoundConverter routines.

//

//  Written by: Jim Reekes

//  Revised by: Tim Monroe

//

//  Copyright:  © 1999 by Apple Computer, Inc., all rights reserved.

//

//  Change History (most recent first):

//

//     <5>      03/29/00    rtm     made changes to get things running under CarbonLib

//     <4>      07/13/99    rtm     final adjustments; fixed cross-platform problems resulting from using

//                                  kSoundNotCompressed ('NONE') format (thanks to EJ Campbell!); see NOTE below

//     <3>      07/07/99    rtm     further work; revised coding style; added some comments

//     <2>      03/12/99    rtm     added (theDialog == NULL) check to AudConv_SFGetDialogHook to prevent

//                                  crashing on Windows; simplified UPP handling

//     <1>      03/09/99    rtm     first file from jr; added some comments; added Windows-specific code

//                                  and endian macros

//

//  This code shows how to use the SoundConverter routines (introduced in Sound Manager version 3.2). It

//  provides routines that convert an AIFF or AIFF-C file into either a QuickTime movie or into an AIFF or

//  AIFF-C file. The user can select the desired target format and settings in a dialog box displayed by

//  a call to SCRequestImageSettings.

//

//  You should note in particular that this sample code shows how to handle the compression parameters chunk

//  that might be present in an AIFF or AIFF-C file. The compression parameters chunk contains parameters

//  that are required to decompress the audio data in the file.

//

//  NOTE: Do not use kSoundNotCompressed as an output format for multi-byte audio data if you want to create

//  movies that are to be shared across platforms. QuickTime needs to know the endianness of the sound data,

//  and kSoundNotCompressed does not indicate whether the data is big- or little-endian. Since in this sample

//  code we are reading our data from an AIFF file, we specify that any non-compressed multi-byte data is of

//  the format k16BitBigEndianFormat.

//

//////////

#include "AudioConvert.h"

//////////

//

// main/WinMain

// The main function for this application.

//

//////////

#if TARGET_OS_MAC

void main (void)

#elif TARGET_OS_WIN32

int CALLBACK WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR theCmdLine, int nCmdShow)

#endif

    SoundComponentData      myDestInfo;

#if TARGET_API_MAC_CARBON

    NavReplyRecord          myReply;

    NavDialogOptions        myDialogOptions;

    AEKeyword               myKeyword;

    DescType                myActualType;

    Size                    myActualSize = 0;

    NavEventUPP             myEventUPP = NewNavEventUPP(AudConv_HandleNavEvent);

    NavObjectFilterUPP      myFilterProc = NewNavObjectFilterUPP(AudConv_NavObjectFilterProc);

#else

    OSType                  myTypeList[2] = {kQTFileTypeAIFF, kQTFileTypeAIFC};

    StandardFileReply       myReply;

#endif

    FSSpec                  myInputFSSpec;

    FSSpec                  myOutputFSSpec;

    Boolean                 myOutputAIFF;

    Str255                  myAppName;

    OSErr                   myErr = noErr;

#if TARGET_OS_WIN32

    char                    myFileName[MAX_PATH];

    DWORD                   myLength;

    short                   myAppResFile = -1;                  // file reference number for this application's resource file

    InitializeQTML(0L);                                         // initialize QuickTime Media Layer

#endif

#if TARGET_OS_MAC

#if !TARGET_API_MAC_CARBON

    MaxApplZone();                                              // init everything

    InitGraf(&qd.thePort);

    InitFonts();

    FlushEvents(everyEvent,0);

    InitWindows();

    InitMenus();

    InitDialogs(NULL);

    TEInit();

#endif

    InitCursor();

#endif

    myErr = EnterMovies();

    FailIf(myErr != noErr, Exit);

#if TARGET_OS_WIN32

    // open the application's resource file, if it exists

    myLength = GetModuleFileName(NULL, myFileName, MAX_PATH);   // NULL means: the current process

    if (myLength != 0) {

        FSSpec              myFSSpec;

        NativePathNameToFSSpec(myFileName, &myFSSpec, 0L);

        myAppResFile = FSpOpenResFile(&myFSSpec, fsRdWrPerm);

        if (myAppResFile != -1)

            UseResFile(myAppResFile);

#endif

    GetIndString(myAppName, rStringsResID, rAppNameStringIndex);

    myOutputAIFF = false;                                       // set default file format to 'MooV' file

#if TARGET_API_MAC_CARBON

    // we are running under Carbon; use Navigation Services

    //////////

//

    // elicit an AIFF or an AIFC file from the user

//

    //////////

    // specify the options for the dialog box

    NavGetDefaultDialogOptions(&myDialogOptions);

    myDialogOptions.dialogOptionFlags -= kNavNoTypePopup;

    myDialogOptions.dialogOptionFlags -= kNavAllowMultipleFiles;

    BlockMoveData(myAppName, myDialogOptions.clientName, myAppName[0] + 1);

    myErr = NavGetFile(NULL, &myReply, &myDialogOptions, myEventUPP, NULL, (NavObjectFilterUPP)myFilterProc, NULL, NULL);

    if ((myErr == noErr) && myReply.validRecord) {

        StringPtr               myPrompt = AudConv_ConvertCToPascalString(kACSavePrompt);

        StringPtr               myFileName = AudConv_ConvertCToPascalString(kMovieFileSaveName);

        NavMenuItemSpecHandle   myMenuItemHandle = NULL;

        // get the FSSpec for the selected file

        myErr = AEGetNthPtr(&(myReply.selection), 1, typeFSS, &myKeyword, &myActualType, &myInputFSSpec, sizeof(FSSpec), &myActualSize);

        NavDisposeReply(&myReply);

        // elicit a file to save the converted sound data into;

        // we want to allow the user to save as a movie or as an AIFF file

        myMenuItemHandle = (NavMenuItemSpecHandle)NewHandleClear(sizeof(NavMenuItemSpec));

        if (myMenuItemHandle != NULL) {

            (**myMenuItemHandle).version = kNavMenuItemSpecVersion;

            (**myMenuItemHandle).menuCreator = FOUR_CHAR_CODE('AuCo');

            (**myMenuItemHandle).menuType = kQTFileTypeAIFF;

            GetIndString((**myMenuItemHandle).menuItemName, rStringsResID, rAIFFMenuLabelIndex);

        NavGetDefaultDialogOptions(&myDialogOptions);

        myDialogOptions.dialogOptionFlags -= kNavAllowStationery;

        myDialogOptions.dialogOptionFlags += kNavDontAutoTranslate;

        myDialogOptions.popupExtension = myMenuItemHandle;

        BlockMoveData(myFileName, myDialogOptions.savedFileName, myFileName[0] + 1);

        BlockMoveData(myAppName, myDialogOptions.clientName, myAppName[0] + 1);

        BlockMoveData(myPrompt, myDialogOptions.message, myPrompt[0] + 1);

        myErr = NavPutFile(NULL, &myReply, &myDialogOptions, myEventUPP, MovieFileType, sigMoviePlayer, &myOutputAIFF);

        if ((myErr == noErr) && myReply.validRecord) {

            // get the FSSpec for the selected file

            myErr = AEGetNthPtr(&(myReply.selection), 1, typeFSS, &myKeyword, &myActualType, &myOutputFSSpec, sizeof(FSSpec), &myActualSize);

            if (myReply.replacing) {

                myErr = FSpDelete(&myOutputFSSpec);

                FailIf(myErr != noErr, Failure);

            myErr = AudConv_GetOutputFormat(&myDestInfo);

            if (myErr == noErr) {

                if (myOutputAIFF)

                    myErr = AudConv_ConvertToAIFF(&myInputFSSpec, &myOutputFSSpec, &myDestInfo);

                else

                    myErr = AudConv_ConvertToMovie(&myInputFSSpec, &myOutputFSSpec, &myDestInfo);

                FailIf(myErr != noErr, Failure);

            if (myErr == userCanceledErr)

                myErr = noErr;

            FailIf(myErr != noErr, Failure);

            NavDisposeReply(&myReply);

        free(myPrompt);

        free(myFileName);

    DisposeNavEventUPP(myEventUPP);

    DisposeNavObjectFilterUPP(myFilterProc);

#else

    // we are NOT running under Carbon; use Standard File Package

    //////////

//

    // elicit an AIFF or an AIFC file from the user

//

    //////////

    StandardGetFile(NULL, 2, myTypeList, &myReply);

    if (myReply.sfGood) {

        DlgHookYDUPP        myDlgHookUPP = NULL;

        Point               myTopLeft;

        myDlgHookUPP = NewDlgHookYDProc(AudConv_SFGetDialogHook);

        myInputFSSpec = myReply.sfFile;                         // save input file spec

        // elicit a file to save the converted sound data into

        myTopLeft.v = -1;                                       // -1,-1 means to center the dialog

        myTopLeft.h = -1;

        CustomPutFile(NULL, c2pstr(kAIFFFileSaveName), &myReply, rCustomGetFileDialog, myTopLeft, myDlgHookUPP, NULL, NULL, NULL, &myOutputAIFF);

        if (myReply.sfGood) {

            myOutputFSSpec = myReply.sfFile;                        // save output file spec

            if (myReply.sfReplacing) {

                myErr = FSpDelete(&myOutputFSSpec);

                FailIf(myErr != noErr, Failure);

            myErr = AudConv_GetOutputFormat(&myDestInfo);

            if (myErr == noErr) {

                if (myOutputAIFF)

                    myErr = AudConv_ConvertToAIFF(&myInputFSSpec, &myOutputFSSpec, &myDestInfo);

                else

                    myErr = AudConv_ConvertToMovie(&myInputFSSpec, &myOutputFSSpec, &myDestInfo);

                FailIf(myErr != noErr, Failure);

            if (myErr == userCanceledErr)

                myErr = noErr;

            FailIf(myErr != noErr, Failure);

#endif

Failure:

    ExitMovies();

Exit:

#if TARGET_OS_WIN32

    // terminate the QuickTime Media Layer

    TerminateQTML();

    return(1);

#endif

#if TARGET_OS_MAC

    return;

#endif

//////////

//

// AudConv_ConvertToAIFF

// Read the source AIFF file and convert to the destination format; output a new AIFF file.

// The new file must include the compression parameters chunk, if used.

//

//////////

OSErr AudConv_ConvertToAIFF (ConstFSSpecPtr theInputFSSpec, ConstFSSpecPtr theOutputFSSpec, SoundComponentDataPtr theDestInfo)

    SoundComponentData      mySourceInfo;

    Handle                  mySourceCompParamsHandle = NULL;

    Handle                  myDestHandle = NULL;

    Handle                  myDestCompParamsHandle = NULL;

    long                    mySourceOffset;

    long                    mySourceSize;

    short                   myInputFile;

    short                   myOutputFile;

    long                    myCount;

    OSErr                   myErr = noErr;

    // open the source file and parse it

    myErr = FSpOpenDF(theInputFSSpec, fsRdPerm, &myInputFile);

    FailIf(myErr != noErr, NoInputFile);

    myErr = AudConv_GetDataFromAIFF(myInputFile, &mySourceInfo, &mySourceOffset, &mySourceSize, &mySourceCompParamsHandle);

    FailIf(myErr != noErr, NoData);

    // create the buffer into which we read the source data

    mySourceInfo.buffer = (Byte *)NewPtrClear(mySourceSize);

    FailWithAction(mySourceInfo.buffer == NULL, myErr = MemError(), NoSource);

    // create the buffer to hold the converted data

    myDestHandle = NewHandle(0);

    FailWithAction(myDestHandle == NULL, myErr = MemError(), NoDest);

    // read the source data from the source file into the source data buffer

    myErr = SetFPos(myInputFile, fsFromStart, mySourceOffset);

    FailIf(myErr != noErr, InputFileErr);

    myErr = FSRead(myInputFile, &mySourceSize, mySourceInfo.buffer);

    FailIf(myErr != noErr, InputFileErr);

    // create the output AIFF file, to hold the converted data

    myErr = FSpCreate(theOutputFSSpec, sigMoviePlayer, AIFFID, smSystemScript);

    FailIf(myErr != noErr, CreateOutputErr);

    myErr = FSpOpenDF(theOutputFSSpec, fsRdWrPerm, &myOutputFile);

    FailIf(myErr != noErr, OutputFileErr);

    // convert the source data into the output data

    myErr = AudConv_ConvertAudioIntoHandle(&mySourceInfo, mySourceCompParamsHandle, myDestHandle, theDestInfo, &myDestCompParamsHandle, NULL);

    FailIf(myErr != noErr, ConvertErr);

    // put the output data into the output AIFF file

    myErr = AudConv_PrepFileAsAIFF(myOutputFile, theDestInfo, myDestCompParamsHandle);

    FailIf(myErr != noErr, ConvertErr);

    HLock(myDestHandle);

    myCount = GetHandleSize(myDestHandle);

    myErr = FSWrite(myOutputFile, &myCount, *myDestHandle);

    HUnlock(myDestHandle);

    FailIf(myErr != noErr, ConvertErr);

    myErr = AudConv_FinishFileAsAIFF(myOutputFile, theDestInfo->sampleCount, myCount);

    FailIf(myErr != noErr, ConvertErr);

    // close the input and output files

    myErr = FSClose(myInputFile);

    FailIf(myErr != noErr, ConvertErr);

    myErr = FSClose(myOutputFile);

    FailIf(myErr != noErr, ConvertErr);

    // dispose of any storage we allocated and no longer need

    if (mySourceInfo.buffer != NULL)

        DisposePtr((Ptr)mySourceInfo.buffer);

    if (myDestHandle != NULL)

        DisposeHandle(myDestHandle);

    if (mySourceCompParamsHandle != NULL)

        DisposeHandle(mySourceCompParamsHandle);

    if (myDestCompParamsHandle != NULL)

        DisposeHandle(myDestCompParamsHandle);

    return(noErr);

ConvertErr:

    FSClose(myOutputFile);

OutputFileErr:

    FSpDelete(theOutputFSSpec);

CreateOutputErr:

InputFileErr:

    if (myDestHandle != NULL)

        DisposeHandle(myDestHandle);

NoDest:

    if (mySourceInfo.buffer != NULL)

        DisposePtr((Ptr)mySourceInfo.buffer);

NoSource:

    if (mySourceCompParamsHandle != NULL)

        DisposeHandle(mySourceCompParamsHandle);

NoData:

    FSClose(myInputFile);

NoInputFile:

    return(myErr);

//////////

//

// AudConv_ConvertToMovie

// Read the source AIFF file and convert to the destination format; output a new movie file.

// The new file must include the compression parameters chunk, if used.

//

//////////

OSErr AudConv_ConvertToMovie (ConstFSSpecPtr theInputFSSpec, ConstFSSpecPtr theOutputFSSpec, SoundComponentDataPtr theDestInfo)

    SoundComponentData      mySourceInfo;

    Handle                  mySourceCompParamsHandle = NULL;

    Handle                  myDestHandle = NULL;

    Handle                  myDestCompParamsHandle = NULL;

    long                    mySourceOffset;

    long                    mySourceSize;

    short                   myInputFile;

    CompressionInfo         myDestCompInfo;

    Movie                   myMovie;

    Track                   myTrack;

    short                   myResRefNum = -1;

    short                   myResID = movieInDataForkResID;

    long                    myFlags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;

    OSErr                   myErr = noErr;

    // open the source file and parse it

    myErr = FSpOpenDF(theInputFSSpec, fsRdPerm, &myInputFile);

    FailIf(myErr != noErr, NoInputFile);

    myErr = AudConv_GetDataFromAIFF(myInputFile, &mySourceInfo, &mySourceOffset, &mySourceSize, &mySourceCompParamsHandle);

    FailIf(myErr != noErr, NoData);

    // create the buffer into which we read the source data

    mySourceInfo.buffer = (Byte *)NewPtrClear(mySourceSize);

    FailWithAction(mySourceInfo.buffer == NULL, myErr = MemError(), NoSource);

    // create the buffer to hold the converted data

    myDestHandle = NewHandle(0);

    FailWithAction(myDestHandle == NULL, myErr = MemError(), NoDest);

    // read the source data from the source file into the source data buffer

    myErr = SetFPos(myInputFile, fsFromStart, mySourceOffset);

    FailIf(myErr != noErr, InputFileErr);

    myErr = FSRead(myInputFile, &mySourceSize, mySourceInfo.buffer);

    FailIf(myErr != noErr, InputFileErr);

    // create the output movie file, to hold the converted data

    myErr = CreateMovieFile(theOutputFSSpec, sigMoviePlayer, smCurrentScript, myFlags, &myResRefNum, &myMovie);

    FailIf(myErr != noErr, CreateOutputErr);

    // convert the source data into the output data

    myErr = AudConv_ConvertAudioIntoHandle(&mySourceInfo, mySourceCompParamsHandle, myDestHandle, theDestInfo, &myDestCompParamsHandle, &myDestCompInfo);

    FailIf(myErr != noErr, CompressErr);

    // put the output data into a track in the output movie file

    myTrack = NewMovieTrack(myMovie, 0, 0, kFullVolume);

    myErr = GetMoviesError();

    FailIf(myErr != noErr, CompressErr);

    myErr = AudConv_PutAudioIntoTrack(myTrack, myDestHandle, theDestInfo, myDestCompParamsHandle, &myDestCompInfo);

    FailIf(myErr != noErr, CompressErr);

    myErr = AddMovieResource(myMovie, myResRefNum, &myResID, NULL);

    FailIf(myErr != noErr, CompressErr);

    // close the movie and movie file

    if (myResRefNum != -1)

        CloseMovieFile(myResRefNum);

    if (myMovie != NULL)

        DisposeMovie(myMovie);

    // dispose of any storage we allocated and no longer need

    if (mySourceInfo.buffer != NULL)

        DisposePtr((Ptr)mySourceInfo.buffer);

    if (myDestHandle != NULL)

        DisposeHandle(myDestHandle);

    if (mySourceCompParamsHandle != NULL)

        DisposeHandle(mySourceCompParamsHandle);

    if (myDestCompParamsHandle != NULL)

        DisposeHandle(myDestCompParamsHandle);

    return(noErr);

CompressErr:

    if (myMovie != NULL)

        DisposeMovie(myMovie);

    if (myResRefNum != -1)

        CloseMovieFile(myResRefNum);

CreateOutputErr:

InputFileErr:

    if (mySourceCompParamsHandle != NULL)

        DisposeHandle(mySourceCompParamsHandle);

NoDest:

    if (mySourceInfo.buffer != NULL)

        DisposePtr((Ptr)mySourceInfo.buffer);

NoSource:

    if (mySourceCompParamsHandle != NULL)

        DisposeHandle(mySourceCompParamsHandle);

NoData:

    FSClose(myInputFile);

NoInputFile:

    return(myErr);

//////////

//

// AudConv_GetDataFromAIFF

// Parse the specified file and read the data in the required chunks in it.

//

// This is a very simple AIFF parser which will read three basic chunks: the

// main ContainerChunk, the Common or ExtCommonChunk, and the SoundDataChunk.

// That's all that's required. One last chunk is read if found, which contains the

// decompression parameters required to decompress this audio. It's a simple

// chunk with unknown data contained within. Copy this data into a handle, and

// it becomes the audio atoms used with the siDecompressionParams selector.

//

// Keep in mind that the data in an AIFF file is always big-endian.

//

//////////

OSErr AudConv_GetDataFromAIFF (short theRefNum, SoundComponentDataPtr theSourceInfo, long *theSourceOffset, long *theSourceSize, Handle *theDestCompParams)

    union {

        ContainerChunk  cnt;

        CommonChunk     com;

        ExtCommonChunk  ext;

        SoundDataChunk  snd;

    }                   myChunk;

    ChunkHeader         myCHeader;

    Handle              myDestCompParamsHandle;

    long double         mySampleRate;

    long                myOffset;

    long                myDataSize;

    long                myByteCount;

    OSErr               myErr = noErr;

    myErr = SetFPos(theRefNum, fsFromStart, 0);     // we have to start at the beginning

    FailIf(myErr != noErr, Failure);

    // everything is contained in a container chunk, which therefore is the first chunk in the file;

    // read the beginning of the container chunk into memory

    myByteCount = sizeof(ContainerChunk);

    myErr = FSRead(theRefNum, &myByteCount, &myChunk);

    FailIf(myErr != noErr, Failure);

    // make sure it's a FORM chunk

    FailWithAction(EndianU32_BtoN(myChunk.cnt.ckID) != FORMID, myErr = badFileFormat, Failure);

    // find the CommonChunk or ExtCommonChunk

    myErr = AudConv_SetFPosToChunk(theRefNum, CommonID);

    FailIf(myErr != noErr, Failure);

    switch (EndianU32_BtoN(myChunk.cnt.formType)) {

        case AIFFID:

            myByteCount = sizeof(CommonChunk);

            myErr = FSRead(theRefNum, &myByteCount, &myChunk);

            FailIf(myErr != noErr, Failure);

            theSourceInfo->format = k16BitBigEndianFormat;

            break;

        case AIFCID:

            myByteCount = offsetof(ExtCommonChunk, compressionName);

            myErr = FSRead(theRefNum, &myByteCount, &myChunk);

            FailIf(myErr != noErr, Failure);

            theSourceInfo->format = EndianU32_BtoN(myChunk.ext.compressionType);

            break;

        default:

            FailWithAction(badFileFormat, myErr = badFileFormat, Failure);

            break;

    theSourceInfo->flags = 0L;

    theSourceInfo->numChannels = EndianS16_BtoN(myChunk.com.numChannels);

    theSourceInfo->sampleSize = EndianS16_BtoN(myChunk.com.sampleSize);

#if TARGET_CPU_68K

    mySampleRate = myChunk.com.sampleRate;

#else

    x80told(&myChunk.com.sampleRate, &mySampleRate);

#endif

    theSourceInfo->sampleRate = (unsigned long)(mySampleRate * 65536.0);

    theSourceInfo->sampleCount = EndianU32_BtoN(myChunk.com.numSampleFrames);

    theSourceInfo->buffer = NULL;

    theSourceInfo->reserved = 0;

    myErr = AudConv_SetFPosToChunk(theRefNum, SoundDataID);

    FailIf(myErr != noErr, Failure);

    myByteCount = sizeof(SoundDataChunk);

    myErr = FSRead(theRefNum, &myByteCount, &myChunk);

    FailIf(myErr != noErr, Failure);

    myDataSize = EndianS32_BtoN(myChunk.snd.ckSize) - sizeof(SoundDataChunk);   // size of source data

    myErr = GetFPos(theRefNum, &myOffset);

    FailIf(myErr != noErr, Failure);

    // return NULL if no siDecompressionParams

    myDestCompParamsHandle = NULL;

    myErr = AudConv_SetFPosToChunk(theRefNum, siDecompressionParams);

    if (myErr == noErr) {

        myByteCount = sizeof(myCHeader);

        myErr = FSRead(theRefNum, &myByteCount, &myCHeader);

        FailIf(myErr != noErr, Failure);

        myByteCount = EndianS32_BtoN(myCHeader.ckSize);

        myDestCompParamsHandle = NewHandle(myByteCount);

        FailIf(myDestCompParamsHandle == NULL, Failure);

        HLock(myDestCompParamsHandle);

        myErr = FSRead(theRefNum, &myByteCount, *myDestCompParamsHandle);

        HUnlock(myDestCompParamsHandle);

        FailIf(myErr != noErr, ReadParamsErr);

    *theSourceOffset = myOffset;                        // offset from start of file to audio samples

    *theSourceSize = myDataSize;                        // size in bytes of the audio samples

    *theDestCompParams = myDestCompParamsHandle;        // possible handle to the decompression parameters

    return(noErr);

ReadParamsErr:

    if (myDestCompParamsHandle != NULL)

        DisposeHandle(myDestCompParamsHandle);

Failure:

    return(myErr);

//////////

//

// AudConv_ConvertAudioIntoHandle

// Convert the specified sound data.

//

//////////

OSErr AudConv_ConvertAudioIntoHandle (  SoundComponentDataPtr theSourceInfo,

                                        Handle theSourceCompParamsHandle,

                                        Handle theDestHandle,

                                        SoundComponentDataPtr theDestInfo,

                                        Handle *theDestCompParamsHandle,

                                        CompressionInfoPtr theDestCompInfo)

    SoundConverter      myConverter;

    Handle              myDestCompParamsHandle = NULL;

    CompressionInfo     myCompressionInfo;

    unsigned short      mySourceBytesPerFrame;

    UInt16              hasOptionsDialog = 0;

    OSErr               myErr = noErr;

    // perform in non-real time for best quality

    theDestInfo->flags |= kNoRealtimeProcessing;

    //////////

//

    // open a sound converter

//

    //////////

    myErr = SoundConverterOpen(theSourceInfo, theDestInfo, &myConverter);

    FailIf(myErr != noErr, Exit);

    //////////

//

    // display the options dialog for the sound converter

//

    // the GetInfo call isn't required; you can just call SetInfo and it will show the dialog

    // or return the same error that GetInfo would have; you might call GetInfo to determine

    // whether the options dialog is supported, perhaps because you want to show a button that

    // would bring up this dialog

//

    //////////

    myErr = SoundConverterGetInfo(myConverter, siOptionsDialog, &hasOptionsDialog);

    if ((myErr == noErr) && (hasOptionsDialog != 0)) {

        myErr = SoundConverterSetInfo(myConverter, siOptionsDialog, NULL);

        FailIf(myErr != noErr, DialogErr);

    // set the number of output channels

    myErr = SoundConverterSetInfo(myConverter, siCompressionChannels, &theDestInfo->numChannels);

    // ignore this error, some codecs don't use this selector (makes QDesign work)

    //////////

//

    // get any custom decompression settings

//

    // not all sound compressors have custom settings, in which case myDestCompParamsHandle

    // will be returned unchanged (NULL); we return these custom settings to the caller, who

    // will put them in the proper place; if this audio is stored in a QuickTime movie, these

    // settings will be stored in a SoundDescriptionExtension of type siDecompressionParams

//

    //////////

    SoundConverterGetInfo(myConverter, siCompressionParams, &myDestCompParamsHandle);

    // send the source and destination compression settings to the sound converter; this is

    // necessary to make some sound converters (for instance, QDesign) work properly

    if (myDestCompParamsHandle != NULL) {

        HLockHi(myDestCompParamsHandle);

        myErr = SoundConverterSetInfo(myConverter, siCompressionParams, *myDestCompParamsHandle);

        HUnlock(myDestCompParamsHandle);

        FailIf(myErr != noErr, ConverterErr);

    if (theSourceCompParamsHandle != NULL) {

        HLockHi(theSourceCompParamsHandle);

        myErr = SoundConverterSetInfo(myConverter, siDecompressionParams, *theSourceCompParamsHandle);

        HUnlock(theSourceCompParamsHandle);

        FailIf(myErr != noErr, ConverterErr);

    *theDestCompParamsHandle = myDestCompParamsHandle;

    //////////

//

    // get the sizes of the source and destination sample frames

//

    // we return the destination sample frame size to the caller, who will put it in the

    // proper place; if this audio data is stored in a QuickTime movie, this size will be

    // stored the Version 1 sound description handle

//

    //////////

    // get the source number of bytes in each sample frame

    myErr = SoundConverterGetInfo(myConverter, siCompressionFactor, &myCompressionInfo);

    if ((myErr != noErr) || (myCompressionInfo.format != theSourceInfo->format)) {

        myErr = GetCompressionInfo(fixedCompression, theSourceInfo->format, theSourceInfo->numChannels, theSourceInfo->sampleSize, &myCompressionInfo);

        FailIf(myErr != noErr, ConverterErr);

    // bytesPerFrame is not filled in by GetCompressionInfo, so we set it here

    mySourceBytesPerFrame = myCompressionInfo.bytesPerPacket * theSourceInfo->numChannels;

    // get the destination number of bytes in each sample frame

    if (theDestCompInfo != NULL) {

        // get info about destination compression.

        myErr = SoundConverterGetInfo(myConverter, siCompressionFactor, theDestCompInfo);

        if ((myErr != noErr) || (theDestCompInfo->format != theDestInfo->format)) {

            myErr = GetCompressionInfo(fixedCompression, theDestInfo->format, theDestInfo->numChannels, theDestInfo->sampleSize, theDestCompInfo);

            FailIf(myErr != noErr, ConverterErr);

        // bytesPerFrame is not filled in by GetCompressionInfo, so we set it here

        theDestCompInfo->bytesPerFrame = theDestCompInfo->bytesPerPacket * theDestInfo->numChannels;

    //////////

//

    // do the actual data conversion

//

    //////////

    myErr = AudConv_WriteAudioToHandle(myConverter, theSourceInfo, mySourceBytesPerFrame, theDestInfo, theDestHandle);

    FailIf(myErr != noErr, ConverterErr);

    SoundConverterClose(myConverter);

    return(noErr);

ConverterErr:

    if (myDestCompParamsHandle != NULL)

        DisposeHandle(myDestCompParamsHandle);

DialogErr:

    if (myConverter != NULL)

        SoundConverterClose(myConverter);

Exit:

    return(myErr);

//////////

//

// AudConv_WriteAudioToHandle

// Convert the source data into an ever-expanding handle of the given format.

// Of course this means you've only got one shot at converting the data, and it

// all has to fit into memory. Converting larger amounts is left to the reader.

//

//////////

OSErr AudConv_WriteAudioToHandle (SoundConverter theConverter, SoundComponentDataPtr theSourceInfo, short theSourceBytesPerFrame, SoundComponentDataPtr theDestInfo, Handle theDestHandle)

    unsigned long   myNumFramesLeft;

    unsigned long   mySourceFrames;

    unsigned long   myDestFrames;

    unsigned long   mySourceBytes;

    unsigned long   myDestBytes;

    unsigned long   myDataOffset = 0;

    Ptr             myDestPtr = NULL;

    OSErr           myErr = noErr;

    // get sound converter buffer size info

    myErr = SoundConverterGetBufferSizes(theConverter, kMaxSndConvtBufferSize, &mySourceFrames, &mySourceBytes, &myDestBytes);

    FailIf(myErr != noErr, Exit);

    // create destination data buffer

    myDestPtr = NewPtrClear(myDestBytes);

    FailWithAction(myErr != noErr, myErr = MemError(), Exit);

    //////////

//

    // convert the sound to the desired output format

//

    //////////

    myErr = SoundConverterBeginConversion(theConverter);

    FailIf(myErr != noErr, ConverterErr);

    // initialize destination total frame count to zero

    theDestInfo->sampleCount = 0;

    myNumFramesLeft = (unsigned long)theSourceInfo->sampleCount;

    while (myNumFramesLeft > 0) {

        // if there are fewer frames remaining than our source buffer size,

        // we're near the end of our data, so get just what's remaining

        if (mySourceFrames > myNumFramesLeft)

            mySourceFrames = myNumFramesLeft;

        myErr = SoundConverterConvertBuffer(theConverter, theSourceInfo->buffer + myDataOffset, mySourceFrames, myDestPtr, &myDestFrames, &myDestBytes);

        FailIf(myErr != noErr, ConverterErr);

        // write this data to the output handle

        if (myDestBytes > 0) {

            myErr = PtrAndHand(myDestPtr, theDestHandle, myDestBytes);

            FailIf(myErr != noErr, ConverterErr);

        // move offset to appropriate place in source data

        myDataOffset += mySourceFrames * theSourceBytesPerFrame;

        // keep track of total frames returned by converter

        theDestInfo->sampleCount += myDestFrames;

        myNumFramesLeft -= mySourceFrames;

    // end the conversion, and see if we get back a few more bytes of data

    myErr = SoundConverterEndConversion(theConverter, myDestPtr, &myDestFrames, &myDestBytes);

    FailIf(myErr != noErr, ConverterErr);

    if (myDestBytes > 0) {

        // write this data to the output handle

        myErr = PtrAndHand(myDestPtr, theDestHandle, myDestBytes);

        FailIf(myErr != noErr, ConverterErr);

    theDestInfo->sampleCount += myDestFrames;           // update final amount of samples

ConverterErr:

    if (myDestPtr != NULL)

        DisposePtr(myDestPtr);

Exit:

    return(myErr);

//////////

//

// AudConv_GetOutputFormat

// Display the QuickTime standard sound settings dialog to obtain the output format.

//

//////////

OSErr AudConv_GetOutputFormat (SoundComponentDataPtr theDestInfo)

    ComponentInstance   myComponent = NULL;

    ComponentResult     myErr = noErr;

    myComponent = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubTypeSound);

    FailWithAction(myComponent == NULL, myErr = cantFindHandler, NoComponent);

    myErr = SCRequestImageSettings(myComponent);            // show the dialog to user

    if (myErr == noErr) {                                   // then get the settings

        myErr = SCGetInfo(myComponent, scSoundCompressionType, &theDestInfo->format);

        FailIf(myErr != noErr, SCGetInfoFailed);

        myErr = SCGetInfo(myComponent, scSoundChannelCountType, &theDestInfo->numChannels);

        FailIf(myErr != noErr, SCGetInfoFailed);

        myErr = SCGetInfo(myComponent, scSoundSampleSizeType, &theDestInfo->sampleSize);

        FailIf(myErr != noErr, SCGetInfoFailed);

        myErr = SCGetInfo(myComponent, scSoundSampleRateType, &theDestInfo->sampleRate);

        FailIf(myErr != noErr, SCGetInfoFailed);

        // any non-compressed format appears as 'raw ', which is not what the Sound Manager expects

        if (theDestInfo->format == k8BitOffsetBinaryFormat) {

            if (theDestInfo->sampleSize > 8)

                theDestInfo->format = k16BitBigEndianFormat;

            else

                theDestInfo->format = kSoundNotCompressed;

        // clear the rest of the unused parameters

        theDestInfo->flags = 0;

        theDestInfo->sampleCount = 0;

        theDestInfo->buffer = NULL;

        theDestInfo->reserved = 0L;

    return((OSErr)myErr);

SCGetInfoFailed:

    CloseComponent(myComponent);

NoComponent:

    return((OSErr)myErr);

//////////

//

// AudConv_SetFPosToChunk

// Set the file's position to the start of the given chunk.

//

//////////

OSErr AudConv_SetFPosToChunk (short theRefNum, ID theChunkID)

    long                myCount;

    ChunkHeader         myCHeader;

    OSErr               myErr = noErr;

    // position the file mark past the ContainerChunk, which is always the first thing in the file

    myErr = SetFPos(theRefNum, fsFromStart, sizeof(ContainerChunk));

    FailIf(myErr != noErr, Exit);

    while (true) {

        myCount = sizeof(myCHeader);

        myErr = FSRead(theRefNum, &myCount, &(myCHeader.ckID));

        if (myErr == eofErr)                            // reached the end of file, exit gracefully

            break;

        FailIf(myErr != noErr, Exit);

        if (theChunkID == EndianU32_BtoN(myCHeader.ckID)) {

            myCount = -myCount;                         // rewind ptr to top of chunk if found

            myErr = SetFPos(theRefNum, fsFromMark, myCount);

            FailIf(myErr != noErr, Exit);

            break;

        } else {                                        // else skip over the entire chunk

            myErr = SetFPos(theRefNum, fsFromMark, EndianS32_BtoN(myCHeader.ckSize));

            if (myErr == eofErr)                        // reached the end of file, exit gracefully

                break;

            FailIf(myErr != noErr, Exit);

Exit:

    return(myErr);

//////////

//

// AudConv_PrepFileAsAIFF

// Write out the necessary chunks, without audio samples, to prepare for writing;

// leave file position at the proper place for audio samples.

//

//////////

OSErr AudConv_PrepFileAsAIFF (short theOutputFile, SoundComponentDataPtr theDestInfo, Handle theDestParams)

    Str255              myCompressionName;

    ContainerChunk      myContainer;

    FormatVersionChunk  myVersion;

    ExtCommonChunk      myCommon;

    SoundDataChunk      mySoundData;

    ID                  myFormType;

    long                myCount;

    OSErr               myErr = noErr;

    switch (theDestInfo->format) {

        case kSoundNotCompressed:

        case k8BitOffsetBinaryFormat:

        case k16BitBigEndianFormat:

        case k24BitFormat:

        case k32BitFormat:

            myFormType = AIFFID;

            break;

        default :

            myFormType = AIFCID;

            break;

    myErr = SetFPos(theOutputFile, fsFromStart, 0);

    FailIf(myErr != noErr, Exit);

    // write out the first chunk

    myContainer.ckID = EndianU32_NtoB(FORMID);

    myContainer.ckSize = EndianU32_NtoB(0);                                 // nothing in the file just yet

    myContainer.formType = EndianU32_NtoB(myFormType);

    myCount = sizeof(myContainer);

    myErr = FSWrite(theOutputFile, &myCount, &myContainer);

    FailIf(myErr != noErr, Exit);

    // write out the version chunk for AIFC files

    if (myFormType == AIFCID) {

        myVersion.ckID = EndianU32_NtoB(FormatVersionID);

        myVersion.ckSize = EndianS32_NtoB(sizeof(FormatVersionChunk) - sizeof(ChunkHeader));

        myVersion.timestamp = EndianU32_NtoB(AIFCVersion1);                 // timestamp for this version

        myCount = sizeof(myVersion);

        myErr = FSWrite(theOutputFile, &myCount, &myVersion);

        FailIf(myErr != noErr, Exit);

    // write out the CommonChunk or ExtCommonChunk if the data is compressed

    myCommon.ckID = EndianU32_NtoB(CommonID);

    myCommon.ckSize = EndianS32_NtoB(sizeof(CommonChunk) - sizeof(ChunkHeader));    // size of common chunk variables without compression info

    myCommon.numChannels = EndianS16_NtoB(theDestInfo->numChannels);

    myCommon.numSampleFrames = EndianU32_NtoB(0);                           // nothing in the file just yet

    myCommon.sampleSize = EndianS16_NtoB(theDestInfo->sampleSize);

#if TARGET_CPU_68K

    myCommon.sampleRate = theDestInfo->sampleRate / 65536.0;

#else

        long double     ldRate;

        ldRate = theDestInfo->sampleRate / 65536.0;

        ldtox80(&ldRate, &myCommon.sampleRate);

#endif

    myCommon.compressionType = EndianU32_NtoB(theDestInfo->format);

    myCommon.compressionName[0] = 0;

    if (myFormType == AIFCID) {

        myErr = GetCompressionName(theDestInfo->format, myCompressionName);

        if (myErr == noErr) {

            // write out the ExtCommonChunk for compressed data, with the name

            myCount = offsetof(ExtCommonChunk, compressionName);

            myCommon.ckSize = myCount - sizeof(ChunkHeader) + myCompressionName[0] + 1;

            myCommon.ckSize = ++myCommon.ckSize & ~1;           // must be word aligned

            myCommon.ckSize = EndianS32_NtoB(myCommon.ckSize);

            myErr = FSWrite(theOutputFile, &myCount, &myCommon);

            FailIf(myErr != noErr, Exit);

            myCount = myCompressionName[0] + 1;

            myCount = ++myCount & ~1;                           // must be word aligned

            myErr = FSWrite(theOutputFile, &myCount, &myCompressionName);

            FailIf(myErr != noErr, Exit);

        } else {

            // write out the ExtCommonChunk for compressed data, without the name

            myCommon.ckSize = EndianS32_NtoB(sizeof(ExtCommonChunk) - sizeof(ChunkHeader)); // size of common chunk variables without compression info

            myCount = offsetof(ExtCommonChunk, compressionName);

            myErr = FSWrite(theOutputFile, &myCount, &myCommon);

            FailIf(myErr != noErr, Exit);

    } else {    // write out the CommonChunk for non-compressed data

        myCount = sizeof(CommonChunk);

        myErr = FSWrite(theOutputFile, &myCount, &myCommon);

        FailIf(myErr != noErr, Exit);

    if (theDestParams != NULL) {

        ChunkHeader     myCHeader;

        myCHeader.ckID = EndianU32_NtoB(siDecompressionParams);

        myCHeader.ckSize = EndianS32_NtoB(GetHandleSize(theDestParams));

        myCount = sizeof(myCHeader);

        myErr = FSWrite(theOutputFile, &myCount, &myCHeader);

        FailIf(myErr != noErr, Exit);

        myCount = EndianS32_BtoN(myCHeader.ckSize);

        HLock(theDestParams);

        myErr = FSWrite(theOutputFile, &myCount, *theDestParams);

        FailIf(myErr != noErr, Exit);

    mySoundData.ckID = EndianU32_NtoB(SoundDataID);

    mySoundData.ckSize = EndianS32_NtoB(0);                         // nothing in the file just yet

    mySoundData.offset = EndianU32_NtoB(0);

    mySoundData.blockSize = EndianU32_NtoB(0);

    myCount = sizeof(mySoundData);

    myErr = FSWrite(theOutputFile, &myCount, &mySoundData);

    FailIf(myErr != noErr, Exit);

    // now go back and update Container to current file size

    myErr = SetFPos(theOutputFile, fsFromStart, 0);

    FailIf(myErr != noErr, Exit);

    myCount = sizeof(myContainer);

    myErr = FSRead(theOutputFile, &myCount, &myContainer);

    FailIf(myErr != noErr, Exit);

    myErr = GetEOF(theOutputFile, &myContainer.ckSize);

    FailIf(myErr != noErr, Exit);

    myErr = SetFPos(theOutputFile, fsFromStart, 0);

    FailIf(myErr != noErr, Exit);

    myContainer.ckSize -= sizeof(ChunkHeader);

    myContainer.ckSize = EndianS32_NtoB(myContainer.ckSize);

    myCount = sizeof(myContainer);

    myErr = FSWrite(theOutputFile, &myCount, &myContainer);

    FailIf(myErr != noErr, Exit);

    // set current file position to the end of end of the file

    // the last chunk is the SoundDataChunk, and that's where to begin writing data

    myErr = SetFPos(theOutputFile, fsFromStart, EndianS32_BtoN(myContainer.ckSize) + sizeof(ChunkHeader));

    FailIf(myErr != noErr, Exit);

Exit:

    return(myErr);

//////////

//

// AudConv_FinishFileAsAIFF

// This assumes that all the necessary chunks have been written to the file and

// then audio samples have been added. Finally, update the chunks to reflect the

// samples that were added.

//

//////////

OSErr AudConv_FinishFileAsAIFF (short theOutputFile, unsigned long destFramesMoved, unsigned long destBytesMoved)

    CommonChunk         myCommon;

    SoundDataChunk      mySoundData;

    long                myCount;

    OSErr               myErr = noErr;

    // find the CommonChunk and update the numSampleFrames

    myErr = AudConv_SetFPosToChunk(theOutputFile, CommonID);

    FailIf(myErr != noErr, Exit);

    myCount = sizeof(myCommon);

    myErr = FSRead(theOutputFile, &myCount, &myCommon);

    FailIf(myErr != noErr, Exit);

    myErr = SetFPos(theOutputFile, fsFromMark, -myCount);       // reset to start of chunk

    FailIf(myErr != noErr, Exit);

    myCommon.numSampleFrames = EndianU32_NtoB(destFramesMoved);

    myCount = sizeof(myCommon);

    myErr = FSWrite(theOutputFile, &myCount, &myCommon);

    FailIf(myErr != noErr, Exit);

    // find the SoundDataChunk and update the ckSize

    myErr = AudConv_SetFPosToChunk(theOutputFile, SoundDataID);

    FailIf(myErr != noErr, Exit);

    myCount = sizeof(mySoundData);

    myErr = FSRead(theOutputFile, &myCount, &mySoundData);

    FailIf(myErr != noErr, Exit);

    myErr = SetFPos(theOutputFile, fsFromMark, -myCount);       // reset to start of chunk

    FailIf(myErr != noErr, Exit);

    mySoundData.ckSize = EndianS32_NtoB(sizeof(SoundDataChunk) - sizeof(ChunkHeader) + destBytesMoved);

    myCount = sizeof(mySoundData);

    myErr = FSWrite(theOutputFile, &myCount, &mySoundData);

    FailIf(myErr != noErr, Exit);

Exit:

    return(myErr);

//////////

//

// AudConv_PutAudioIntoTrack

// Add the audio as a track with the necessary decompression extension.

//

//////////

OSErr AudConv_PutAudioIntoTrack (   Track theTrack,

                                    Handle theDestAudioData,

                                    SoundComponentDataPtr theDestInfo,

                                    Handle theDestCompParamsHandle,

                                    CompressionInfoPtr theDestCompInfo)

    SoundDescriptionV1Handle    mySampleDesc;

    Media                       myMedia;

    OSErr                       myErr = noErr;

    //////////

//

    // create a media for the track passed in

//

    //////////

    // set new track to be a sound track

    myMedia = NewTrackMedia(theTrack, SoundMediaType, theDestInfo->sampleRate >> 16, NULL, 0);

    myErr = GetMoviesError();

    FailIf(myErr != noErr, Exit);

    // start a media editing session

    myErr = BeginMediaEdits(myMedia);

    FailIf(myErr != noErr, Exit);

    //////////

//

    // create a sound sample description

//

    //////////

    // use the SoundDescription format 1 because it adds fields for data size information

    // and is required by AddSoundDescriptionExtension if an extension is required for the compression format

    mySampleDesc = (SoundDescriptionV1Handle)NewHandleClear(sizeof(SoundDescriptionV1));

    FailWithAction(myErr != noErr, myErr = MemError(), Exit);

    (**mySampleDesc).desc.descSize          = sizeof(SoundDescriptionV1);

    (**mySampleDesc).desc.dataFormat        = theDestInfo->format;

    (**mySampleDesc).desc.resvd1            = 0;

    (**mySampleDesc).desc.resvd2            = 0;

    (**mySampleDesc).desc.dataRefIndex      = 1;

    (**mySampleDesc).desc.version           = 1;

    (**mySampleDesc).desc.revlevel          = 0;

    (**mySampleDesc).desc.vendor            = 0;

    (**mySampleDesc).desc.numChannels       = theDestInfo->numChannels;

    (**mySampleDesc).desc.sampleSize        = theDestInfo->sampleSize;

    (**mySampleDesc).desc.compressionID     = 0;

    (**mySampleDesc).desc.packetSize        = 0;

    (**mySampleDesc).desc.sampleRate        = theDestInfo->sampleRate;

    (**mySampleDesc).samplesPerPacket       = theDestCompInfo->samplesPerPacket;

    (**mySampleDesc).bytesPerPacket         = theDestCompInfo->bytesPerPacket;

    (**mySampleDesc).bytesPerFrame          = theDestCompInfo->bytesPerFrame;

    (**mySampleDesc).bytesPerSample         = theDestCompInfo->bytesPerSample;

    // not all compression formats have compression params, so we need to add a

    // sound description extension only for those that do

    if (theDestCompParamsHandle != NULL) {

        myErr = AddSoundDescriptionExtension((SoundDescriptionHandle)mySampleDesc, theDestCompParamsHandle, siDecompressionParams);

        FailIf(myErr != noErr, MediaErr);

    //////////

//

    // add samples to the media

//

    //////////

    myErr = AddMediaSample( myMedia,

                            theDestAudioData,

0,

                            theDestInfo->sampleCount * theDestCompInfo->bytesPerFrame,

1,

                            (SampleDescriptionHandle)mySampleDesc,

                            theDestInfo->sampleCount * theDestCompInfo->samplesPerPacket,

0,

                            NULL);

    FailIf(myErr != noErr, MediaErr);

    myErr = EndMediaEdits(myMedia);

    FailIf(myErr != noErr, MediaErr);

    //////////

//

    // insert the media into the track

//

    //////////

    myErr = InsertMediaIntoTrack(theTrack, 0, 0, GetMediaDuration(myMedia), fixed1);

    FailIf(myErr != noErr, MediaErr);

MediaErr:

    if (mySampleDesc != NULL)

        DisposeHandle((Handle)mySampleDesc);

Exit:

    return(myErr);

//////////

//

// AudConv_SFGetDialogHook

// Hook function for the get file dialog box.

//

//////////

PASCAL_RTN short AudConv_SFGetDialogHook (short theItem, DialogPtr theDialog, void *theOutputAIFF)

    ControlHandle           myAIFFControl;

    ControlHandle           myMovieControl;

    Rect                    myRect;

    short                   myKind;

    // make sure we've got a real dialog

    if (theDialog == NULL)

        return(theItem);

    GetDialogItem(theDialog, kOutputAIFFButton, &myKind, (Handle *)&myAIFFControl, &myRect);

    GetDialogItem(theDialog, kOutputMovieButton, &myKind, (Handle *)&myMovieControl, &myRect);

    switch (theItem) {

        case sfHookFirstCall:

            if (*(Boolean *)theOutputAIFF)

                SetControlValue(myAIFFControl, kControlRadioButtonCheckedValue);

            else

                SetControlValue(myMovieControl, kControlRadioButtonUncheckedValue);

            break;

        case kOutputAIFFButton:

            SetControlValue(myAIFFControl, kControlRadioButtonCheckedValue);

            SetControlValue(myMovieControl, kControlRadioButtonUncheckedValue);

            *(Boolean *)theOutputAIFF = true;

            break;

        case kOutputMovieButton:

            SetControlValue(myAIFFControl, kControlRadioButtonUncheckedValue);

            SetControlValue(myMovieControl, kControlRadioButtonCheckedValue);

            *(Boolean *)theOutputAIFF = false;

            break;

    return(theItem);

//////////

//

// AudConv_NavObjectFilterProc

// Object filter function for the get file dialog box.

//

//////////

PASCAL_RTN Boolean AudConv_NavObjectFilterProc (AEDesc *theItem, void *theInfo, void *theCallBackUD, NavFilterModes theFilterMode)

#pragma unused(theCallBackUD, theFilterMode)

    NavFileOrFolderInfo     *myInfo = (NavFileOrFolderInfo *)theInfo;

    if (theItem->descriptorType == typeFSS) {

        if (!myInfo->isFolder) {

            OSType          myType = myInfo->fileAndFolder.fileInfo.finderInfo.fdType;

            // see whether the file type is in the list of file types that our application can open

            if ((myType == kQTFileTypeAIFF) || (myType == kQTFileTypeAIFC))

                return(true);

            // if we got to here, it's a file we cannot open

            return(false);

    // if we got to here, it's a folder or non-HFS object

    return(true);

//////////

//

// AudConv_ConvertCToPascalString

// Convert a C string into a Pascal string.

//

// The caller is responsible for disposing of the pointer returned by this function (by calling free).

//

//////////

StringPtr AudConv_ConvertCToPascalString (char *theString)

    StringPtr   myString = malloc(strlen(theString) + 1);

    short       myIndex = 0;

    while (theString[myIndex] != '\0') {

        myString[myIndex + 1] = theString[myIndex];

        myIndex++;

    myString[0] = (unsigned char)myIndex;

    return(myString);

//////////

//

// AudConv_HandleNavEvent

// A callback procedure that handles events while a Navigation Service dialog box is displayed.

//

//////////

PASCAL_RTN void AudConv_HandleNavEvent (NavEventCallbackMessage theCallBackSelector, NavCBRecPtr theCallBackParms, void *theCallBackUD)

    Boolean             myOutputAIFF = *(Boolean *)theCallBackUD;

    NavMenuItemSpec     myMenuItemSpec;

    Str255              myFileName;

    static Str15        myMooVExt;

    static Str15        myAIFFExt;

    if (theCallBackSelector == kNavCBStart) {

        // get the filename extensions

        GetIndString(myMooVExt, rStringsResID, rMooVExtensionIndex);

        GetIndString(myAIFFExt, rStringsResID, rAIFFExtensionIndex);

    if (theCallBackSelector == kNavCBPopupMenuSelect) {

        myMenuItemSpec = *(NavMenuItemSpec *)theCallBackParms->eventData.eventDataParms.param;

        myOutputAIFF = (myMenuItemSpec.menuType == kQTFileTypeAIFF);

    if (*(Boolean *)theCallBackUD != myOutputAIFF) {

        // the output file type has changed, so adjust the filename extension accordingly

        short           myIndex;

        short           myCount;

        // get the current filename

        NavCustomControl(theCallBackParms->context, kNavCtlGetEditFileName, &myFileName);

        // find the position of the last filename separator in the current filename

        myIndex = myFileName[0];

        while ((myFileName[myIndex] != kFileExtSeparator) && (myIndex > 0))

            myIndex--;

        if (myIndex != 0) {

            if (myOutputAIFF) {

                for (myCount = 1; myCount <= myAIFFExt[0]; myCount++)

                    myFileName[myIndex + myCount - 1] = myAIFFExt[myCount];

            } else {

                for (myCount = 1; myCount <= myMooVExt[0]; myCount++)

                    myFileName[myIndex + myCount - 1] = myMooVExt[myCount];

            myFileName[0] = myIndex + myCount - 2;

            NavCustomControl(theCallBackParms->context, kNavCtlSetEditFileName, &myFileName);

        *(Boolean *)theCallBackUD = myOutputAIFF;

Next Previous