Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 745fcc45b8
Fetching contributors…

Cannot retrieve contributors at this time

231 lines (173 sloc) 4.591 kb
#ifndef UTILITY_H
#define UTILITY_H
#ifdef _MSC_VER
#pragma warning(disable : 4786)
#endif
#include <algorithm>
#include <map>
#include <string>
#include <utility>
#include "audiere.h"
#include "types.h"
#if defined(_MSC_VER) && _MSC_VER <= 1200 && !defined(_STLPORT_VERSION)
// std::min and std::max are broken in VC++ 6, so define our own.
// Unfortunately, this means we must include utility.h to use
// std::min and std::max
namespace std {
#ifdef min
#undef min
#endif
#ifdef max
#undef max
#endif
template<typename T>
inline T min(T a, T b) {
return (a < b ? a : b);
}
template<typename T>
inline T max(T a, T b) {
return (a > b ? a : b);
}
}
#else
#include <algorithm>
#endif
namespace audiere {
template<typename T>
T clamp(T min, T x, T max) {
return std::max(std::min(x, max), min);
}
class ParameterList {
public:
ParameterList(const char* parameters);
std::string getValue(const std::string& key, const std::string& defValue) const;
bool getBoolean(const std::string& key, bool def) const;
int getInt(const std::string& key, int def) const;
private:
std::map<std::string, std::string> m_values;
};
int strcmp_case(const char* a, const char* b);
inline int GetFrameSize(SampleSource* source) {
int channel_count, sample_rate;
SampleFormat sample_format;
source->getFormat(channel_count, sample_rate, sample_format);
return GetSampleSize(sample_format) * channel_count;
}
inline int GetFrameSize(const SampleSourcePtr& source) {
return GetFrameSize(source.get());
}
inline u16 read16_le(const u8* b) {
return b[0] + (b[1] << 8);
}
inline u16 read16_be(const u8* b) {
return (b[0] << 8) + b[1];
}
inline u32 read32_le(const u8* b) {
return read16_le(b) + (read16_le(b + 2) << 16);
}
inline u32 read32_be(const u8* b) {
return (read16_be(b) << 16) + read16_be(b + 2);
}
/// Converts an 80-bit IEEE 754 floating point number to a u32.
inline u32 readLD_be(const u8* b) {
u32 mantissa = read32_be(b + 2);
u8 exp = 30 - b[1];
u32 last = 0;
while (exp--) {
last = mantissa;
mantissa >>= 1;
}
if (last & 0x1) {
mantissa++;
}
return mantissa;
}
inline int GetFileLength(File* file) {
int pos = file->tell();
file->seek(0, File::END);
int length = file->tell();
file->seek(pos, File::BEGIN);
return length;
}
inline SampleSource* OpenBufferStream(
void* samples, int sample_count,
int channel_count, int sample_rate, SampleFormat sample_format)
{
return CreateSampleBuffer(
samples, sample_count,
channel_count, sample_rate, sample_format)->openStream();
}
class QueueBuffer {
public:
QueueBuffer() {
m_capacity = 256;
m_size = 0;
m_buffer = (u8*)malloc(m_capacity);
}
~QueueBuffer() {
m_buffer = (u8*)realloc(m_buffer, 0);
}
int getSize() {
return m_size;
}
void write(const void* buffer, int size) {
bool need_realloc = false;
while (size + m_size > m_capacity) {
m_capacity *= 2;
need_realloc = true;
}
if (need_realloc) {
m_buffer = (u8*)realloc(m_buffer, m_capacity);
}
memcpy(m_buffer + m_size, buffer, size);
m_size += size;
}
int read(void* buffer, int size) {
int to_read = std::min(size, m_size);
memcpy(buffer, m_buffer, to_read);
memmove(m_buffer, m_buffer + to_read, m_size - to_read);
m_size -= to_read;
return to_read;
}
void clear() {
m_size = 0;
}
private:
u8* m_buffer;
int m_capacity;
int m_size;
// private and unimplemented to prevent their use
QueueBuffer(const QueueBuffer&);
QueueBuffer& operator=(const QueueBuffer&);
};
class SizedBuffer {
public:
SizedBuffer() {
m_capacity = 256;
m_buffer = malloc(m_capacity);
}
~SizedBuffer() {
m_buffer = realloc(m_buffer, 0);
}
void ensureSize(int size) {
bool need_realloc = false;
while (m_capacity < size) {
m_capacity *= 2;
need_realloc = true;
}
if (need_realloc) {
m_buffer = realloc(m_buffer, m_capacity);
}
}
void* get() {
return m_buffer;
}
private:
void* m_buffer;
int m_capacity;
// private and unimplemented to prevent their use
SizedBuffer(const SizedBuffer&);
SizedBuffer& operator=(const SizedBuffer&);
};
}
#endif
Jump to Line
Something went wrong with that request. Please try again.