summaryrefslogtreecommitdiffstats
path: root/examples/common
diff options
context:
space:
mode:
Diffstat (limited to 'examples/common')
-rw-r--r--examples/common/alffmpeg.c638
-rw-r--r--examples/common/alffmpeg.h66
-rw-r--r--examples/common/alhelpers.c319
-rw-r--r--examples/common/alhelpers.h47
4 files changed, 1070 insertions, 0 deletions
diff --git a/examples/common/alffmpeg.c b/examples/common/alffmpeg.c
new file mode 100644
index 00000000..16f73866
--- /dev/null
+++ b/examples/common/alffmpeg.c
@@ -0,0 +1,638 @@
+/*
+ * FFmpeg Decoder Helpers
+ *
+ * Copyright (c) 2011 by Chris Robinson <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* This file contains routines for helping to decode audio using libavformat
+ * and libavcodec (ffmpeg). There's very little OpenAL-specific code here. */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <assert.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "alhelpers.h"
+#include "alffmpeg.h"
+
+
+static size_t NextPowerOf2(size_t value)
+{
+ size_t powerOf2 = 1;
+
+ if(value)
+ {
+ value--;
+ while(value)
+ {
+ value >>= 1;
+ powerOf2 <<= 1;
+ }
+ }
+ return powerOf2;
+}
+
+
+struct MemData {
+ char *buffer;
+ size_t length;
+ size_t pos;
+};
+
+static int MemData_read(void *opaque, uint8_t *buf, int buf_size)
+{
+ struct MemData *membuf = (struct MemData*)opaque;
+ int rem = membuf->length - membuf->pos;
+
+ if(rem > buf_size)
+ rem = buf_size;
+
+ memcpy(buf, &membuf->buffer[membuf->pos], rem);
+ membuf->pos += rem;
+
+ return rem;
+}
+
+static int MemData_write(void *opaque, uint8_t *buf, int buf_size)
+{
+ struct MemData *membuf = (struct MemData*)opaque;
+ int rem = membuf->length - membuf->pos;
+
+ if(rem > buf_size)
+ rem = buf_size;
+
+ memcpy(&membuf->buffer[membuf->pos], buf, rem);
+ membuf->pos += rem;
+
+ return rem;
+}
+
+static int64_t MemData_seek(void *opaque, int64_t offset, int whence)
+{
+ struct MemData *membuf = (struct MemData*)opaque;
+
+ whence &= ~AVSEEK_FORCE;
+ switch(whence)
+ {
+ case SEEK_SET:
+ if(offset < 0 || (uint64_t)offset > membuf->length)
+ return -1;
+ membuf->pos = offset;
+ break;
+
+ case SEEK_CUR:
+ if((offset >= 0 && (uint64_t)offset > membuf->length-membuf->pos) ||
+ (offset < 0 && (uint64_t)(-offset) > membuf->pos))
+ return -1;
+ membuf->pos += offset;
+ break;
+
+ case SEEK_END:
+ if(offset > 0 || (uint64_t)(-offset) > membuf->length)
+ return -1;
+ membuf->pos = membuf->length + offset;
+ break;
+
+ case AVSEEK_SIZE:
+ return membuf->length;
+
+ default:
+ return -1;
+ }
+
+ return membuf->pos;
+}
+
+
+struct PacketList {
+ AVPacket pkt;
+ struct PacketList *next;
+};
+
+struct MyStream {
+ AVCodecContext *CodecCtx;
+ int StreamIdx;
+
+ struct PacketList *Packets;
+
+ AVFrame *Frame;
+
+ const uint8_t *FrameData;
+ size_t FrameDataSize;
+
+ FilePtr parent;
+};
+
+struct MyFile {
+ AVFormatContext *FmtCtx;
+
+ StreamPtr *Streams;
+ size_t StreamsSize;
+
+ struct MemData membuf;
+};
+
+
+static int done_init = 0;
+
+FilePtr openAVFile(const char *fname)
+{
+ FilePtr file;
+
+ /* We need to make sure ffmpeg is initialized. Optionally silence warning
+ * output from the lib */
+ if(!done_init) {av_register_all();
+ av_log_set_level(AV_LOG_ERROR);
+ done_init = 1;}
+
+ file = (FilePtr)calloc(1, sizeof(*file));
+ if(file && avformat_open_input(&file->FmtCtx, fname, NULL, NULL) == 0)
+ {
+ /* After opening, we must search for the stream information because not
+ * all formats will have it in stream headers */
+ if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
+ return file;
+ avformat_close_input(&file->FmtCtx);
+ }
+
+ free(file);
+ return NULL;
+}
+
+FilePtr openAVData(const char *name, char *buffer, size_t buffer_len)
+{
+ FilePtr file;
+
+ if(!done_init) {av_register_all();
+ av_log_set_level(AV_LOG_ERROR);
+ done_init = 1;}
+
+ if(!name)
+ name = "";
+
+ file = (FilePtr)calloc(1, sizeof(*file));
+ if(file && (file->FmtCtx=avformat_alloc_context()) != NULL)
+ {
+ file->membuf.buffer = buffer;
+ file->membuf.length = buffer_len;
+ file->membuf.pos = 0;
+
+ file->FmtCtx->pb = avio_alloc_context(NULL, 0, 0, &file->membuf,
+ MemData_read, MemData_write,
+ MemData_seek);
+ if(file->FmtCtx->pb && avformat_open_input(&file->FmtCtx, name, NULL, NULL) == 0)
+ {
+ if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
+ return file;
+ avformat_close_input(&file->FmtCtx);
+ }
+ if(file->FmtCtx)
+ avformat_free_context(file->FmtCtx);
+ file->FmtCtx = NULL;
+ }
+
+ free(file);
+ return NULL;
+}
+
+FilePtr openAVCustom(const char *name, void *user_data,
+ int (*read_packet)(void *user_data, uint8_t *buf, int buf_size),
+ int (*write_packet)(void *user_data, uint8_t *buf, int buf_size),
+ int64_t (*seek)(void *user_data, int64_t offset, int whence))
+{
+ FilePtr file;
+
+ if(!done_init) {av_register_all();
+ av_log_set_level(AV_LOG_ERROR);
+ done_init = 1;}
+
+ if(!name)
+ name = "";
+
+ file = (FilePtr)calloc(1, sizeof(*file));
+ if(file && (file->FmtCtx=avformat_alloc_context()) != NULL)
+ {
+ file->FmtCtx->pb = avio_alloc_context(NULL, 0, 0, user_data,
+ read_packet, write_packet, seek);
+ if(file->FmtCtx->pb && avformat_open_input(&file->FmtCtx, name, NULL, NULL) == 0)
+ {
+ if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
+ return file;
+ avformat_close_input(&file->FmtCtx);
+ }
+ if(file->FmtCtx)
+ avformat_free_context(file->FmtCtx);
+ file->FmtCtx = NULL;
+ }
+
+ free(file);
+ return NULL;
+}
+
+
+void clearAVAudioData(StreamPtr stream)
+{
+ while(stream->Packets)
+ {
+ struct PacketList *self;
+
+ self = stream->Packets;
+ stream->Packets = self->next;
+
+ av_free_packet(&self->pkt);
+ av_free(self);
+ }
+}
+
+
+void closeAVFile(FilePtr file)
+{
+ size_t i;
+
+ if(!file) return;
+
+ for(i = 0;i < file->StreamsSize;i++)
+ {
+ StreamPtr stream = file->Streams[i];
+
+ while(stream->Packets)
+ {
+ struct PacketList *self;
+
+ self = stream->Packets;
+ stream->Packets = self->next;
+
+ av_free_packet(&self->pkt);
+ av_free(self);
+ }
+
+ avcodec_close(stream->CodecCtx);
+ av_free(stream->Frame);
+ free(stream);
+ }
+ free(file->Streams);
+
+ avformat_close_input(&file->FmtCtx);
+ free(file);
+}
+
+
+int getAVFileInfo(FilePtr file, int *numaudiostreams)
+{
+ unsigned int i;
+ int audiocount = 0;
+
+ if(!file) return 1;
+ for(i = 0;i < file->FmtCtx->nb_streams;i++)
+ {
+ if(file->FmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
+ audiocount++;
+ }
+ *numaudiostreams = audiocount;
+ return 0;
+}
+
+StreamPtr getAVAudioStream(FilePtr file, int streamnum)
+{
+ unsigned int i;
+ if(!file) return NULL;
+ for(i = 0;i < file->FmtCtx->nb_streams;i++)
+ {
+ if(file->FmtCtx->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
+ continue;
+
+ if(streamnum == 0)
+ {
+ StreamPtr stream;
+ AVCodec *codec;
+ void *temp;
+ size_t j;
+
+ /* Found the requested stream. Check if a handle to this stream
+ * already exists and return it if it does */
+ for(j = 0;j < file->StreamsSize;j++)
+ {
+ if(file->Streams[j]->StreamIdx == (int)i)
+ return file->Streams[j];
+ }
+
+ /* Doesn't yet exist. Now allocate a new stream object and fill in
+ * its info */
+ stream = (StreamPtr)calloc(1, sizeof(*stream));
+ if(!stream) return NULL;
+
+ stream->parent = file;
+ stream->CodecCtx = file->FmtCtx->streams[i]->codec;
+ stream->StreamIdx = i;
+
+ /* Try to find the codec for the given codec ID, and open it */
+ codec = avcodec_find_decoder(stream->CodecCtx->codec_id);
+ if(!codec || avcodec_open2(stream->CodecCtx, codec, NULL) < 0)
+ {
+ free(stream);
+ return NULL;
+ }
+
+ /* Allocate space for the decoded data to be stored in before it
+ * gets passed to the app */
+ stream->Frame = avcodec_alloc_frame();
+ if(!stream->Frame)
+ {
+ avcodec_close(stream->CodecCtx);
+ free(stream);
+ return NULL;
+ }
+ stream->FrameData = NULL;
+ stream->FrameDataSize = 0;
+
+ /* Append the new stream object to the stream list. The original
+ * pointer will remain valid if realloc fails, so we need to use
+ * another pointer to watch for errors and not leak memory */
+ temp = realloc(file->Streams, (file->StreamsSize+1) *
+ sizeof(*file->Streams));
+ if(!temp)
+ {
+ avcodec_close(stream->CodecCtx);
+ av_free(stream->Frame);
+ free(stream);
+ return NULL;
+ }
+ file->Streams = (StreamPtr*)temp;
+ file->Streams[file->StreamsSize++] = stream;
+ return stream;
+ }
+ streamnum--;
+ }
+ return NULL;
+}
+
+int getAVAudioInfo(StreamPtr stream, ALuint *rate, ALenum *channels, ALenum *type)
+{
+ if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
+ return 1;
+
+ /* Get the sample type for OpenAL given the format detected by ffmpeg. */
+ if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_U8)
+ *type = AL_UNSIGNED_BYTE_SOFT;
+ else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_S16)
+ *type = AL_SHORT_SOFT;
+ else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_S32)
+ *type = AL_INT_SOFT;
+ else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_FLT)
+ *type = AL_FLOAT_SOFT;
+ else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_DBL)
+ *type = AL_DOUBLE_SOFT;
+ else
+ {
+ fprintf(stderr, "Unsupported ffmpeg sample format: %s\n",
+ av_get_sample_fmt_name(stream->CodecCtx->sample_fmt));
+ return 1;
+ }
+
+ /* Get the OpenAL channel configuration using the channel layout detected
+ * by ffmpeg. NOTE: some file types may not specify a channel layout. In
+ * that case, one must be guessed based on the channel count. */
+ if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
+ *channels = AL_MONO_SOFT;
+ else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_STEREO)
+ *channels = AL_STEREO_SOFT;
+ else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_QUAD)
+ *channels = AL_QUAD_SOFT;
+ else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK)
+ *channels = AL_5POINT1_SOFT;
+ else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_7POINT1)
+ *channels = AL_7POINT1_SOFT;
+ else if(stream->CodecCtx->channel_layout == 0)
+ {
+ /* Unknown channel layout. Try to guess. */
+ if(stream->CodecCtx->channels == 1)
+ *channels = AL_MONO_SOFT;
+ else if(stream->CodecCtx->channels == 2)
+ *channels = AL_STEREO_SOFT;
+ else
+ {
+ fprintf(stderr, "Unsupported ffmpeg raw channel count: %d\n",
+ stream->CodecCtx->channels);
+ return 1;
+ }
+ }
+ else
+ {
+ char str[1024];
+ av_get_channel_layout_string(str, sizeof(str), stream->CodecCtx->channels,
+ stream->CodecCtx->channel_layout);
+ fprintf(stderr, "Unsupported ffmpeg channel layout: %s\n", str);
+ return 1;
+ }
+
+ *rate = stream->CodecCtx->sample_rate;
+
+ return 0;
+}
+
+
+/* Used by getAV*Data to search for more compressed data, and buffer it in the
+ * correct stream. It won't buffer data for streams that the app doesn't have a
+ * handle for. */
+static int getNextPacket(FilePtr file, int streamidx)
+{
+ struct PacketList *packet;
+
+ packet = (struct PacketList*)av_malloc(sizeof(*packet));
+ packet->next = NULL;
+
+next_packet:
+ while(av_read_frame(file->FmtCtx, &packet->pkt) >= 0)
+ {
+ StreamPtr *iter = file->Streams;
+ StreamPtr *iter_end = iter + file->StreamsSize;
+
+ /* Check each stream the user has a handle for, looking for the one
+ * this packet belongs to */
+ while(iter != iter_end)
+ {
+ if((*iter)->StreamIdx == packet->pkt.stream_index)
+ {
+ struct PacketList **last;
+
+ last = &(*iter)->Packets;
+ while(*last != NULL)
+ last = &(*last)->next;
+
+ *last = packet;
+ if((*iter)->StreamIdx == streamidx)
+ return 1;
+
+ packet = (struct PacketList*)av_malloc(sizeof(*packet));
+ packet->next = NULL;
+ goto next_packet;
+ }
+ iter++;
+ }
+ /* Free the packet and look for another */
+ av_free_packet(&packet->pkt);
+ }
+
+ av_free(packet);
+ return 0;
+}
+
+uint8_t *getAVAudioData(StreamPtr stream, size_t *length)
+{
+ int got_frame;
+ int len;
+
+ if(length) *length = 0;
+
+ if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
+ return NULL;
+
+next_packet:
+ if(!stream->Packets && !getNextPacket(stream->parent, stream->StreamIdx))
+ return NULL;
+
+ /* Decode some data, and check for errors */
+ avcodec_get_frame_defaults(stream->Frame);
+ while((len=avcodec_decode_audio4(stream->CodecCtx, stream->Frame,
+ &got_frame, &stream->Packets->pkt)) < 0)
+ {
+ struct PacketList *self;
+
+ /* Error? Drop it and try the next, I guess... */
+ self = stream->Packets;
+ stream->Packets = self->next;
+
+ av_free_packet(&self->pkt);
+ av_free(self);
+
+ if(!stream->Packets)
+ goto next_packet;
+ }
+
+ if(len < stream->Packets->pkt.size)
+ {
+ /* Move the unread data to the front and clear the end bits */
+ int remaining = stream->Packets->pkt.size - len;
+ memmove(stream->Packets->pkt.data, &stream->Packets->pkt.data[len],
+ remaining);
+ memset(&stream->Packets->pkt.data[remaining], 0,
+ stream->Packets->pkt.size - remaining);
+ stream->Packets->pkt.size -= len;
+ }
+ else
+ {
+ struct PacketList *self;
+
+ self = stream->Packets;
+ stream->Packets = self->next;
+
+ av_free_packet(&self->pkt);
+ av_free(self);
+ }
+
+ if(!got_frame || stream->Frame->nb_samples == 0)
+ goto next_packet;
+
+ /* Set the output buffer size */
+ *length = av_samples_get_buffer_size(NULL, stream->CodecCtx->channels,
+ stream->Frame->nb_samples,
+ stream->CodecCtx->sample_fmt, 1);
+
+ return stream->Frame->data[0];
+}
+
+size_t readAVAudioData(StreamPtr stream, void *data, size_t length)
+{
+ size_t dec = 0;
+
+ if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
+ return 0;
+
+ while(dec < length)
+ {
+ /* If there's no decoded data, find some */
+ if(stream->FrameDataSize == 0)
+ {
+ stream->FrameData = getAVAudioData(stream, &stream->FrameDataSize);
+ if(!stream->FrameData)
+ break;
+ }
+
+ if(stream->FrameDataSize > 0)
+ {
+ /* Get the amount of bytes remaining to be written, and clamp to
+ * the amount of decoded data we have */
+ size_t rem = length-dec;
+ if(rem > stream->FrameDataSize)
+ rem = stream->FrameDataSize;
+
+ /* Copy the data to the app's buffer and increment */
+ if(data != NULL)
+ {
+ memcpy(data, stream->FrameData, rem);
+ data = (char*)data + rem;
+ }
+ dec += rem;
+
+ /* If there's any decoded data left, move it to the front of the
+ * buffer for next time */
+ stream->FrameData += rem;
+ stream->FrameDataSize -= rem;
+ }
+ }
+
+ /* Return the number of bytes we were able to get */
+ return dec;
+}
+
+void *decodeAVAudioStream(StreamPtr stream, size_t *length)
+{
+ char *outbuf = NULL;
+ size_t buflen = 0;
+ void *inbuf;
+ size_t got;
+
+ *length = 0;
+ if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
+ return NULL;
+
+ while((inbuf=getAVAudioData(stream, &got)) != NULL && got > 0)
+ {
+ void *ptr;
+
+ ptr = realloc(outbuf, NextPowerOf2(buflen+got));
+ if(ptr == NULL)
+ break;
+ outbuf = (char*)ptr;
+
+ memcpy(&outbuf[buflen], inbuf, got);
+ buflen += got;
+ }
+ outbuf = (char*)realloc(outbuf, buflen);
+
+ *length = buflen;
+ return outbuf;
+}
diff --git a/examples/common/alffmpeg.h b/examples/common/alffmpeg.h
new file mode 100644
index 00000000..27e49ab4
--- /dev/null
+++ b/examples/common/alffmpeg.h
@@ -0,0 +1,66 @@
+#ifndef ALFFMPEG_H
+#define ALFFMPEG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+
+/* Opaque handles to files and streams. Apps don't need to concern themselves
+ * with the internals */
+typedef struct MyFile *FilePtr;
+typedef struct MyStream *StreamPtr;
+
+/* Opens a file with ffmpeg and sets up the streams' information */
+FilePtr openAVFile(const char *fname);
+
+/* Opens a named file image with ffmpeg and sets up the streams' information */
+FilePtr openAVData(const char *name, char *buffer, size_t buffer_len);
+
+/* Opens a named data stream with ffmpeg, using the specified data pointer and
+ * callbacks, and sets up the streams' information */
+FilePtr openAVCustom(const char *name, void *user_data,
+ int (*read_packet)(void *user_data, uint8_t *buf, int buf_size),
+ int (*write_packet)(void *user_data, uint8_t *buf, int buf_size),
+ int64_t (*seek)(void *user_data, int64_t offset, int whence));
+
+/* Closes/frees an opened file and any of its streams */
+void closeAVFile(FilePtr file);
+
+/* Reports certain information from the file, eg, the number of audio
+ * streams. Returns 0 on success. */
+int getAVFileInfo(FilePtr file, int *numaudiostreams);
+
+/* Retrieves a handle for the given audio stream number (generally 0, but some
+ * files can have multiple audio streams in one file). */
+StreamPtr getAVAudioStream(FilePtr file, int streamnum);
+
+/* Returns information about the given audio stream. Returns 0 on success. */
+int getAVAudioInfo(StreamPtr stream, ALuint *rate, ALenum *channels, ALenum *type);
+
+/* Returns a pointer to the next available packet of decoded audio. Any data
+ * from a previously-decoded packet is dropped. The size (in bytes) of the
+ * returned data buffer is stored in 'length', and the returned pointer is only
+ * valid until the next call to getAVAudioData or readAVAudioData. */
+uint8_t *getAVAudioData(StreamPtr stream, size_t *length);
+
+/* The "meat" function. Decodes audio and writes, at most, length bytes into
+ * the provided data buffer. Will only return less for end-of-stream or error
+ * conditions. Returns the number of bytes written. */
+size_t readAVAudioData(StreamPtr stream, void *data, size_t length);
+
+/* Decodes all remaining data from the stream and returns a buffer containing
+ * the audio data, with the size stored in 'length'. The returned pointer must
+ * be freed with a call to free(). Note that since this decodes the whole
+ * stream, using it on lengthy streams (eg, music) will use a lot of memory.
+ * Such streams are better handled using getAVAudioData or readAVAudioData to
+ * keep smaller chunks in memory at any given time. */
+void *decodeAVAudioStream(StreamPtr stream, size_t *length);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* ALFFMPEG_H */
diff --git a/examples/common/alhelpers.c b/examples/common/alhelpers.c
new file mode 100644
index 00000000..dbfe2383
--- /dev/null
+++ b/examples/common/alhelpers.c
@@ -0,0 +1,319 @@
+/*
+ * OpenAL Helpers
+ *
+ * Copyright (c) 2011 by Chris Robinson <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* This file contains routines to help with some menial OpenAL-related tasks,
+ * such as opening a device and setting up a context, closing the device and
+ * destroying its context, converting between frame counts and byte lengths,
+ * finding an appropriate buffer format, and getting readable strings for
+ * channel configs and sample types. */
+
+#include <stdio.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "alhelpers.h"
+
+
+const char *ChannelsName(ALenum chans)
+{
+ switch(chans)
+ {
+ case AL_MONO_SOFT: return "Mono";
+ case AL_STEREO_SOFT: return "Stereo";
+ case AL_REAR_SOFT: return "Rear";
+ case AL_QUAD_SOFT: return "Quadraphonic";
+ case AL_5POINT1_SOFT: return "5.1 Surround";
+ case AL_6POINT1_SOFT: return "6.1 Surround";
+ case AL_7POINT1_SOFT: return "7.1 Surround";
+ }
+ return "Unknown Channels";
+}
+
+const char *TypeName(ALenum type)
+{
+ switch(type)
+ {
+ case AL_BYTE_SOFT: return "S8";
+ case AL_UNSIGNED_BYTE_SOFT: return "U8";
+ case AL_SHORT_SOFT: return "S16";
+ case AL_UNSIGNED_SHORT_SOFT: return "U16";
+ case AL_INT_SOFT: return "S32";
+ case AL_UNSIGNED_INT_SOFT: return "U32";
+ case AL_FLOAT_SOFT: return "Float32";
+ case AL_DOUBLE_SOFT: return "Float64";
+ }
+ return "Unknown Type";
+}
+
+
+ALsizei FramesToBytes(ALsizei size, ALenum channels, ALenum type)
+{
+ switch(channels)
+ {
+ case AL_MONO_SOFT: size *= 1; break;
+ case AL_STEREO_SOFT: size *= 2; break;
+ case AL_REAR_SOFT: size *= 2; break;
+ case AL_QUAD_SOFT: size *= 4; break;
+ case AL_5POINT1_SOFT: size *= 6; break;
+ case AL_6POINT1_SOFT: size *= 7; break;
+ case AL_7POINT1_SOFT: size *= 8; break;
+ }
+
+ switch(type)
+ {
+ case AL_BYTE_SOFT: size *= sizeof(ALbyte); break;
+ case AL_UNSIGNED_BYTE_SOFT: size *= sizeof(ALubyte); break;
+ case AL_SHORT_SOFT: size *= sizeof(ALshort); break;
+ case AL_UNSIGNED_SHORT_SOFT: size *= sizeof(ALushort); break;
+ case AL_INT_SOFT: size *= sizeof(ALint); break;
+ case AL_UNSIGNED_INT_SOFT: size *= sizeof(ALuint); break;
+ case AL_FLOAT_SOFT: size *= sizeof(ALfloat); break;
+ case AL_DOUBLE_SOFT: size *= sizeof(ALdouble); break;
+ }
+
+ return size;
+}
+
+ALsizei BytesToFrames(ALsizei size, ALenum channels, ALenum type)
+{
+ return size / FramesToBytes(1, channels, type);
+}
+
+
+ALenum GetFormat(ALenum channels, ALenum type, LPALISBUFFERFORMATSUPPORTEDSOFT palIsBufferFormatSupportedSOFT)
+{
+ ALenum format = AL_NONE;
+
+ /* If using AL_SOFT_buffer_samples, try looking through its formats */
+ if(palIsBufferFormatSupportedSOFT)
+ {
+ /* AL_SOFT_buffer_samples is more lenient with matching formats. The
+ * specified sample type does not need to match the returned format,
+ * but it is nice to try to get something close. */
+ if(type == AL_UNSIGNED_BYTE_SOFT || type == AL_BYTE_SOFT)
+ {
+ if(channels == AL_MONO_SOFT) format = AL_MONO8_SOFT;
+ else if(channels == AL_STEREO_SOFT) format = AL_STEREO8_SOFT;
+ else if(channels == AL_QUAD_SOFT) format = AL_QUAD8_SOFT;
+ else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_8_SOFT;
+ else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_8_SOFT;
+ else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_8_SOFT;
+ }
+ else if(type == AL_UNSIGNED_SHORT_SOFT || type == AL_SHORT_SOFT)
+ {
+ if(channels == AL_MONO_SOFT) format = AL_MONO16_SOFT;
+ else if(channels == AL_STEREO_SOFT) format = AL_STEREO16_SOFT;
+ else if(channels == AL_QUAD_SOFT) format = AL_QUAD16_SOFT;
+ else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_16_SOFT;
+ else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_16_SOFT;
+ else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_16_SOFT;
+ }
+ else if(type == AL_UNSIGNED_BYTE3_SOFT || type == AL_BYTE3_SOFT ||
+ type == AL_UNSIGNED_INT_SOFT || type == AL_INT_SOFT ||
+ type == AL_FLOAT_SOFT || type == AL_DOUBLE_SOFT)
+ {
+ if(channels == AL_MONO_SOFT) format = AL_MONO32F_SOFT;
+ else if(channels == AL_STEREO_SOFT) format = AL_STEREO32F_SOFT;
+ else if(channels == AL_QUAD_SOFT) format = AL_QUAD32F_SOFT;
+ else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_32F_SOFT;
+ else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_32F_SOFT;
+ else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_32F_SOFT;
+ }
+
+ if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
+ format = AL_NONE;
+
+ /* A matching format was not found or supported. Try 32-bit float. */
+ if(format == AL_NONE)
+ {
+ if(channels == AL_MONO_SOFT) format = AL_MONO32F_SOFT;
+ else if(channels == AL_STEREO_SOFT) format = AL_STEREO32F_SOFT;
+ else if(channels == AL_QUAD_SOFT) format = AL_QUAD32F_SOFT;
+ else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_32F_SOFT;
+ else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_32F_SOFT;
+ else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_32F_SOFT;
+
+ if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
+ format = AL_NONE;
+ }
+ /* 32-bit float not supported. Try 16-bit int. */
+ if(format == AL_NONE)
+ {
+ if(channels == AL_MONO_SOFT) format = AL_MONO16_SOFT;
+ else if(channels == AL_STEREO_SOFT) format = AL_STEREO16_SOFT;
+ else if(channels == AL_QUAD_SOFT) format = AL_QUAD16_SOFT;
+ else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_16_SOFT;
+ else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_16_SOFT;
+ else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_16_SOFT;
+
+ if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
+ format = AL_NONE;
+ }
+ /* 16-bit int not supported. Try 8-bit int. */
+ if(format == AL_NONE)
+ {
+ if(channels == AL_MONO_SOFT) format = AL_MONO8_SOFT;
+ else if(channels == AL_STEREO_SOFT) format = AL_STEREO8_SOFT;
+ else if(channels == AL_QUAD_SOFT) format = AL_QUAD8_SOFT;
+ else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_8_SOFT;
+ else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_8_SOFT;
+ else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_8_SOFT;
+
+ if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
+ format = AL_NONE;
+ }
+
+ return format;
+ }
+
+ /* We use the AL_EXT_MCFORMATS extension to provide output of Quad, 5.1,
+ * and 7.1 channel configs, AL_EXT_FLOAT32 for 32-bit float samples, and
+ * AL_EXT_DOUBLE for 64-bit float samples. */
+ if(type == AL_UNSIGNED_BYTE_SOFT)
+ {
+ if(channels == AL_MONO_SOFT)
+ format = AL_FORMAT_MONO8;
+ else if(channels == AL_STEREO_SOFT)
+ format = AL_FORMAT_STEREO8;
+ else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+ {
+ if(channels == AL_QUAD_SOFT)
+ format = alGetEnumValue("AL_FORMAT_QUAD8");
+ else if(channels == AL_5POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_51CHN8");
+ else if(channels == AL_6POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_61CHN8");
+ else if(channels == AL_7POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_71CHN8");
+ }
+ }
+ else if(type == AL_SHORT_SOFT)
+ {
+ if(channels == AL_MONO_SOFT)
+ format = AL_FORMAT_MONO16;
+ else if(channels == AL_STEREO_SOFT)
+ format = AL_FORMAT_STEREO16;
+ else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+ {
+ if(channels == AL_QUAD_SOFT)
+ format = alGetEnumValue("AL_FORMAT_QUAD16");
+ else if(channels == AL_5POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_51CHN16");
+ else if(channels == AL_6POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_61CHN16");
+ else if(channels == AL_7POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_71CHN16");
+ }
+ }
+ else if(type == AL_FLOAT_SOFT && alIsExtensionPresent("AL_EXT_FLOAT32"))
+ {
+ if(channels == AL_MONO_SOFT)
+ format = alGetEnumValue("AL_FORMAT_MONO_FLOAT32");
+ else if(channels == AL_STEREO_SOFT)
+ format = alGetEnumValue("AL_FORMAT_STEREO_FLOAT32");
+ else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+ {
+ if(channels == AL_QUAD_SOFT)
+ format = alGetEnumValue("AL_FORMAT_QUAD32");
+ else if(channels == AL_5POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_51CHN32");
+ else if(channels == AL_6POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_61CHN32");
+ else if(channels == AL_7POINT1_SOFT)
+ format = alGetEnumValue("AL_FORMAT_71CHN32");
+ }
+ }
+ else if(type == AL_DOUBLE_SOFT && alIsExtensionPresent("AL_EXT_DOUBLE"))
+ {
+ if(channels == AL_MONO_SOFT)
+ format = alGetEnumValue("AL_FORMAT_MONO_DOUBLE");
+ else if(channels == AL_STEREO_SOFT)
+ format = alGetEnumValue("AL_FORMAT_STEREO_DOUBLE");
+ }
+
+ /* NOTE: It seems OSX returns -1 from alGetEnumValue for unknown enums, as
+ * opposed to 0. Correct it. */
+ if(format == -1)
+ format = 0;
+
+ return format;
+}
+
+
+void AL_APIENTRY wrap_BufferSamples(ALuint buffer, ALuint samplerate,
+ ALenum internalformat, ALsizei samples,
+ ALenum channels, ALenum type,
+ const ALvoid *data)
+{
+ alBufferData(buffer, internalformat, data,
+ FramesToBytes(samples, channels, type),
+ samplerate);
+}
+
+
+int InitAL(void)
+{
+ ALCdevice *device;
+ ALCcontext *ctx;
+
+ /* Open and initialize a device with default settings */
+ device = alcOpenDevice(NULL);
+ if(!device)
+ {
+ fprintf(stderr, "Could not open a device!\n");
+ return 1;
+ }
+
+ ctx = alcCreateContext(device, NULL);
+ if(ctx == NULL || alcMakeContextCurrent(ctx) == ALC_FALSE)
+ {
+ if(ctx != NULL)
+ alcDestroyContext(ctx);
+ alcCloseDevice(device);
+ fprintf(stderr, "Could not set a context!\n");
+ return 1;
+ }
+
+ return 0;
+}
+
+void CloseAL(void)
+{
+ ALCdevice *device;
+ ALCcontext *ctx;
+
+ /* Close the device belonging to the current context, and destroy the
+ * context. */
+ ctx = alcGetCurrentContext();
+ if(ctx == NULL)
+ return;
+
+ device = alcGetContextsDevice(ctx);
+
+ alcMakeContextCurrent(NULL);
+ alcDestroyContext(ctx);
+ alcCloseDevice(device);
+}
diff --git a/examples/common/alhelpers.h b/examples/common/alhelpers.h
new file mode 100644
index 00000000..eda8925e
--- /dev/null
+++ b/examples/common/alhelpers.h
@@ -0,0 +1,47 @@
+#ifndef ALHELPERS_H
+#define ALHELPERS_H
+
+#ifndef _WIN32
+#include <unistd.h>
+#define Sleep(x) usleep((x)*1000)
+#else
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Some helper functions to get the name from the channel and type enums. */
+const char *ChannelsName(ALenum chans);
+const char *TypeName(ALenum type);
+
+/* Helpers to convert frame counts and byte lengths. */
+ALsizei FramesToBytes(ALsizei size, ALenum channels, ALenum type);
+ALsizei BytesToFrames(ALsizei size, ALenum channels, ALenum type);
+
+/* Retrieves a compatible buffer format given the channel configuration and
+ * sample type. If an alIsBufferFormatSupportedSOFT-compatible function is
+ * provided, it will be called to find the closest-matching format from
+ * AL_SOFT_buffer_samples. Returns AL_NONE (0) if no supported format can be
+ * found. */
+ALenum GetFormat(ALenum channels, ALenum type, LPALISBUFFERFORMATSUPPORTEDSOFT palIsBufferFormatSupportedSOFT);
+
+/* Loads samples into a buffer using the standard alBufferData call, but with a
+ * LPALBUFFERSAMPLESSOFT-compatible prototype. Assumes internalformat is valid
+ * for alBufferData, and that channels and type match it. */
+void AL_APIENTRY wrap_BufferSamples(ALuint buffer, ALuint samplerate,
+ ALenum internalformat, ALsizei samples,
+ ALenum channels, ALenum type,
+ const ALvoid *data);
+
+/* Easy device init/deinit functions. InitAL returns 0 on success. */
+int InitAL(void);
+void CloseAL(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* ALHELPERS_H */