mirror of
https://github.com/love2d/megasource.git
synced 2026-08-19 12:14:41 +02:00
Add OpenAL-Soft 1.15.1.
This commit is contained in:
rude
@@ -0,0 +1,638 @@
|
||||
/*
|
||||
* FFmpeg Decoder Helpers
|
||||
*
|
||||
* Copyright (c) 2011 by Chris Robinson <chris.kcat@gmail.com>
|
||||
*
|
||||
* 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;
|
||||
}
|
||||
@@ -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 */
|
||||
@@ -0,0 +1,327 @@
|
||||
/*
|
||||
* OpenAL Helpers
|
||||
*
|
||||
* Copyright (c) 2011 by Chris Robinson <chris.kcat@gmail.com>
|
||||
*
|
||||
* 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"
|
||||
|
||||
|
||||
/* InitAL opens the default device and sets up a context using default
|
||||
* attributes, making the program ready to call OpenAL functions. */
|
||||
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;
|
||||
}
|
||||
|
||||
printf("Opened \"%s\"\n", alcGetString(device, ALC_DEVICE_SPECIFIER));
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* CloseAL closes the device belonging to the current context, and destroys the
|
||||
* context. */
|
||||
void CloseAL(void)
|
||||
{
|
||||
ALCdevice *device;
|
||||
ALCcontext *ctx;
|
||||
|
||||
ctx = alcGetCurrentContext();
|
||||
if(ctx == NULL)
|
||||
return;
|
||||
|
||||
device = alcGetContextsDevice(ctx);
|
||||
|
||||
alcMakeContextCurrent(NULL);
|
||||
alcDestroyContext(ctx);
|
||||
alcCloseDevice(device);
|
||||
}
|
||||
|
||||
|
||||
/* GetFormat retrieves a compatible buffer format given the channel config 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)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
@@ -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 */
|
||||
Reference in New Issue
Block a user