Return to recordchaintest.c CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / SoundAndMusic / SoundLibrary

Annotation of Examples/SoundAndMusic/SoundLibrary/recordchaintest.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * recordchaintest.c - this test shows how to chain small recordings
        !             3:  * and append them to a soundfile.
        !             4:  * 
        !             5:  * 2/28/94 -- Made architecture independent (rkd).
        !             6:  */ 
        !             7:  
        !             8: #import        <stdio.h>
        !             9: #import        <sound/sound.h>
        !            10: #import <architecture/byte_order.h>
        !            11: 
        !            12: #define        NUM_BUFFERS     2
        !            13: #define        BUF_SIZE        8192
        !            14: #define        SECONDS         5.0
        !            15: 
        !            16: static SNDSoundStruct *buffers[NUM_BUFFERS];
        !            17: static FILE *sfp;
        !            18: static int requestedDataSize, recordedDataSize = 0;
        !            19: static int lastBufNum;
        !            20: 
        !            21: static void record(int tag);
        !            22: 
        !            23: static int recordDone(SNDSoundStruct *s, int tag, int err)
        !            24: /*
        !            25:  * Called when a buffer has been recorded.
        !            26:  * Appends the buffer to the soundfile and initiates recording into it again.
        !            27:  */
        !            28: {
        !            29:     if (recordedDataSize >= requestedDataSize)
        !            30:        return 0;
        !            31:     if (err)
        !            32:         fprintf(stderr, "recordDone: %s\n", SNDSoundError(err));
        !            33:     if (fwrite((void *)((char *)s + s->dataLocation), 1, s->dataSize, sfp) !=
        !            34:        s->dataSize)
        !            35:        fprintf(stderr, "recordDone: could not write data to soundfile\n");
        !            36:     recordedDataSize += s->dataSize;
        !            37:     record((lastBufNum + 1) % NUM_BUFFERS);
        !            38:     return 0;
        !            39: }
        !            40: 
        !            41: static void record(int bufNum)
        !            42: /*
        !            43:  * Initiates recording into a buffers[bufNum].
        !            44:  */
        !            45: {
        !            46:     int err;
        !            47:     static int tag = 1;
        !            48:     
        !            49:     lastBufNum = bufNum;
        !            50:     if (err = SNDStartRecording(buffers[bufNum], tag++, 0, 0, SND_NULL_FUN,
        !            51:                                recordDone))
        !            52:         fprintf(stderr, "record: %s\n", SNDSoundError(err));
        !            53: }
        !            54: 
        !            55: static void init(int n, int size, char *fileName)
        !            56: /*
        !            57:  * Allocate n sound buffers.
        !            58:  * Creates the soundfile.
        !            59:  */
        !            60: {
        !            61:     int i, err;
        !            62:     SNDSoundStruct s;
        !            63: 
        !            64:     for (i = 0; i < n; i++)
        !            65:         if (err = SNDAlloc(&buffers[i], size, SND_FORMAT_MULAW_8,
        !            66:                           SND_RATE_CODEC, 1, 4))
        !            67:            fprintf(stderr, "init: %s\n", SNDSoundError(err));
        !            68:     if ((sfp = fopen(fileName, "w")) == NULL)
        !            69:        fprintf(stderr, "init: could not open soundfile %s\n", fileName);
        !            70:     if (fwrite((void *)&s, sizeof(SNDSoundStruct), 1, sfp) != 1)
        !            71:        fprintf(stderr, "init: could not write dummy header to soundfile\n");
        !            72: }
        !            73: 
        !            74: static void cleanup(void)
        !            75: /*
        !            76:  * Write the soundfile header.
        !            77:  */
        !            78: {
        !            79:     SNDSoundStruct s;
        !            80: 
        !            81:     s.magic = NXSwapHostIntToBig(SND_MAGIC);
        !            82:     s.dataLocation = NXSwapHostIntToBig(sizeof(SNDSoundStruct));
        !            83:     s.dataSize = NXSwapHostIntToBig(recordedDataSize);
        !            84:     s.dataFormat = NXSwapHostIntToBig(SND_FORMAT_MULAW_8);
        !            85:     s.samplingRate = NXSwapHostIntToBig(SND_RATE_CODEC);
        !            86:     s.channelCount = NXSwapHostIntToBig(1);
        !            87:     s.info[0] = '\0';
        !            88:     
        !            89:     rewind(sfp);
        !            90:     if (fwrite((void *)&s, sizeof(SNDSoundStruct), 1, sfp) != 1)
        !            91:        fprintf(stderr, "cleanup: could not write header to soundfile\n");
        !            92: }
        !            93: 
        !            94: main(int argc, char *argv[])
        !            95: {
        !            96:     int i;
        !            97: 
        !            98:     if (argc != 2) {
        !            99:        fprintf(stderr, "usage: recordchaintest file\n");
        !           100:        exit(1);
        !           101:     }
        !           102: 
        !           103:     requestedDataSize = SECONDS * SND_RATE_CODEC;
        !           104:     init(NUM_BUFFERS, BUF_SIZE, argv[1]);
        !           105:     printf("recording...\n");
        !           106:     for (i = 0; i < NUM_BUFFERS; i++)
        !           107:        record(i);
        !           108:     SNDWait(0);
        !           109:     cleanup();
        !           110: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.