430 lines
7.0 KiB
C++
430 lines
7.0 KiB
C++
/***********************************************************************
|
|
* AUTHOR: Marcus Overhagen
|
|
* FILE: SoundFile.cpp
|
|
* DESCR:
|
|
***********************************************************************/
|
|
#include <MediaFile.h>
|
|
#include <MediaTrack.h>
|
|
#include <SoundFile.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "MediaDebug.h"
|
|
|
|
/*************************************************************
|
|
* public BSoundFile
|
|
*************************************************************/
|
|
|
|
BSoundFile::BSoundFile()
|
|
{
|
|
_init_raw_stats();
|
|
}
|
|
|
|
|
|
BSoundFile::BSoundFile(const entry_ref *ref,
|
|
uint32 open_mode)
|
|
{
|
|
_init_raw_stats();
|
|
SetTo(ref,open_mode);
|
|
}
|
|
|
|
/* virtual */
|
|
BSoundFile::~BSoundFile()
|
|
{
|
|
delete fSoundFile;
|
|
delete fMediaFile;
|
|
// fMediaTrack will be deleted by the BMediaFile destructor
|
|
}
|
|
|
|
|
|
status_t
|
|
BSoundFile::InitCheck() const
|
|
{
|
|
if (!fSoundFile) {
|
|
return B_NO_INIT;
|
|
}
|
|
return fSoundFile->InitCheck();
|
|
}
|
|
|
|
|
|
status_t
|
|
BSoundFile::SetTo(const entry_ref *ref,
|
|
uint32 open_mode)
|
|
{
|
|
if (fMediaTrack) {
|
|
BMediaTrack * track = fMediaTrack;
|
|
fMediaTrack = 0;
|
|
fMediaFile->ReleaseTrack(track);
|
|
}
|
|
if (fMediaFile) {
|
|
BMediaFile * file = fMediaFile;
|
|
fMediaFile = 0;
|
|
delete file;
|
|
}
|
|
if (fSoundFile) {
|
|
BFile * file = fSoundFile;
|
|
fSoundFile = 0;
|
|
delete file;
|
|
}
|
|
if (open_mode == B_READ_ONLY) {
|
|
return _ref_to_file(ref);
|
|
} else {
|
|
UNIMPLEMENTED();
|
|
return B_ERROR;
|
|
}
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::FileFormat() const
|
|
{
|
|
return fFileFormat;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::SamplingRate() const
|
|
{
|
|
return fSamplingRate;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::CountChannels() const
|
|
{
|
|
return fChannelCount;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::SampleSize() const
|
|
{
|
|
return fSampleSize;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::ByteOrder() const
|
|
{
|
|
return fByteOrder;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::SampleFormat() const
|
|
{
|
|
return fSampleFormat;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::FrameSize() const
|
|
{
|
|
return fSampleSize * fChannelCount;
|
|
}
|
|
|
|
|
|
off_t
|
|
BSoundFile::CountFrames() const
|
|
{
|
|
return fFrameCount;
|
|
}
|
|
|
|
|
|
bool
|
|
BSoundFile::IsCompressed() const
|
|
{
|
|
return fIsCompressed;
|
|
}
|
|
|
|
|
|
int32
|
|
BSoundFile::CompressionType() const
|
|
{
|
|
return fCompressionType;
|
|
}
|
|
|
|
|
|
char *
|
|
BSoundFile::CompressionName() const
|
|
{
|
|
return fCompressionName;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetFileFormat(int32 format)
|
|
{
|
|
fFileFormat = format;
|
|
return fFileFormat;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetSamplingRate(int32 fps)
|
|
{
|
|
fSamplingRate = fps;
|
|
return fSamplingRate;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetChannelCount(int32 spf)
|
|
{
|
|
fChannelCount = spf;
|
|
return fChannelCount;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetSampleSize(int32 bps)
|
|
{
|
|
fSampleSize = bps;
|
|
return fSampleSize;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetByteOrder(int32 bord)
|
|
{
|
|
fByteOrder = bord;
|
|
return fByteOrder;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetSampleFormat(int32 fmt)
|
|
{
|
|
fSampleFormat = fmt;
|
|
return fSampleFormat;
|
|
}
|
|
|
|
|
|
/* virtual */ int32
|
|
BSoundFile::SetCompressionType(int32 type)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* virtual */ char *
|
|
BSoundFile::SetCompressionName(char *name)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* virtual */ bool
|
|
BSoundFile::SetIsCompressed(bool tf)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
/* virtual */ off_t
|
|
BSoundFile::SetDataLocation(off_t offset)
|
|
{
|
|
UNIMPLEMENTED();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* virtual */ off_t
|
|
BSoundFile::SetFrameCount(off_t count)
|
|
{
|
|
fFrameCount = count;
|
|
return fFrameCount;
|
|
}
|
|
|
|
|
|
size_t
|
|
BSoundFile::ReadFrames(char *buf,
|
|
size_t count)
|
|
{
|
|
size_t frameRead = 0;
|
|
int64 frames = count;
|
|
while (count > 0) {
|
|
status_t status = fMediaTrack->ReadFrames(
|
|
reinterpret_cast<void *>(buf), &frames);
|
|
count -= frames;
|
|
frameRead += frames;
|
|
buf += fSampleSize * fChannelCount * frames;
|
|
if (status != B_OK) {
|
|
if (frameRead > 0)
|
|
break;
|
|
return status;
|
|
}
|
|
}
|
|
return frameRead;
|
|
}
|
|
|
|
|
|
size_t
|
|
BSoundFile::WriteFrames(char *buf,
|
|
size_t count)
|
|
{
|
|
return fMediaTrack->WriteFrames(
|
|
reinterpret_cast<void *>(buf), count);
|
|
}
|
|
|
|
|
|
/* virtual */ off_t
|
|
BSoundFile::SeekToFrame(off_t n)
|
|
{
|
|
int64 frames = n;
|
|
status_t status = fMediaTrack->SeekToFrame(&frames);
|
|
|
|
if (status != B_OK)
|
|
return status;
|
|
|
|
return frames;
|
|
}
|
|
|
|
|
|
off_t
|
|
BSoundFile::FrameIndex() const
|
|
{
|
|
return fFrameIndex;
|
|
}
|
|
|
|
|
|
off_t
|
|
BSoundFile::FramesRemaining() const
|
|
{
|
|
return fFrameCount - FrameIndex();
|
|
}
|
|
|
|
/*************************************************************
|
|
* private BSoundFile
|
|
*************************************************************/
|
|
|
|
|
|
void BSoundFile::_ReservedSoundFile1() {}
|
|
void BSoundFile::_ReservedSoundFile2() {}
|
|
void BSoundFile::_ReservedSoundFile3() {}
|
|
|
|
void
|
|
BSoundFile::_init_raw_stats()
|
|
{
|
|
fSoundFile = 0;
|
|
fMediaFile = 0;
|
|
fMediaTrack = 0;
|
|
fFileFormat = B_UNKNOWN_FILE;
|
|
fSamplingRate = 44100;
|
|
fChannelCount = 2;
|
|
fSampleSize = 2;
|
|
fByteOrder = B_BIG_ENDIAN;
|
|
fSampleFormat = B_LINEAR_SAMPLES;
|
|
fFrameCount = 0;
|
|
fFrameIndex = 0;
|
|
fIsCompressed = false;
|
|
fCompressionType = -1;
|
|
fCompressionName = NULL;
|
|
}
|
|
|
|
|
|
static int32
|
|
_ParseMimeType(char *mime_type)
|
|
{
|
|
if (strcmp(mime_type, "audio/x-aiff") == 0)
|
|
return B_AIFF_FILE;
|
|
if (strcmp(mime_type, "audio/x-wav") == 0)
|
|
return B_WAVE_FILE;
|
|
return B_UNKNOWN_FILE;
|
|
}
|
|
|
|
|
|
status_t
|
|
BSoundFile::_ref_to_file(const entry_ref *ref)
|
|
{
|
|
status_t status;
|
|
BFile * file = new BFile(ref, B_READ_ONLY);
|
|
status = file->InitCheck();
|
|
if (status != B_OK) {
|
|
fSoundFile = file;
|
|
return status;
|
|
}
|
|
BMediaFile * media = new BMediaFile(file);
|
|
status = media->InitCheck();
|
|
if (status != B_OK) {
|
|
delete media;
|
|
delete file;
|
|
return status;
|
|
}
|
|
media_file_format mfi;
|
|
media->GetFileFormatInfo(&mfi);
|
|
switch (mfi.family) {
|
|
case B_AIFF_FORMAT_FAMILY: fFileFormat = B_AIFF_FILE; break;
|
|
case B_WAV_FORMAT_FAMILY: fFileFormat = B_WAVE_FILE; break;
|
|
default: fFileFormat = _ParseMimeType(mfi.mime_type); break;
|
|
}
|
|
int trackNum = 0;
|
|
BMediaTrack * track = 0;
|
|
media_format mf;
|
|
while (trackNum < media->CountTracks()) {
|
|
track = media->TrackAt(trackNum);
|
|
status = track->DecodedFormat(&mf);
|
|
if (status != B_OK) {
|
|
media->ReleaseTrack(track);
|
|
delete media;
|
|
delete file;
|
|
return status;
|
|
}
|
|
if (mf.IsAudio()) {
|
|
break;
|
|
}
|
|
media->ReleaseTrack(track);
|
|
track = 0;
|
|
}
|
|
if (track == 0) {
|
|
delete media;
|
|
delete file;
|
|
return B_ERROR;
|
|
}
|
|
media_raw_audio_format * raw = 0;
|
|
if (mf.type == B_MEDIA_ENCODED_AUDIO) {
|
|
raw = &mf.u.encoded_audio.output;
|
|
}
|
|
if (mf.type == B_MEDIA_RAW_AUDIO) {
|
|
raw = &mf.u.raw_audio;
|
|
}
|
|
|
|
if (raw == NULL) {
|
|
delete media;
|
|
delete file;
|
|
return B_ERROR;
|
|
}
|
|
|
|
fSamplingRate = (int)raw->frame_rate;
|
|
fChannelCount = raw->channel_count;
|
|
fSampleSize = raw->format & 0xf;
|
|
fByteOrder = raw->byte_order;
|
|
switch (raw->format) {
|
|
case media_raw_audio_format::B_AUDIO_FLOAT:
|
|
fSampleFormat = B_FLOAT_SAMPLES;
|
|
break;
|
|
case media_raw_audio_format::B_AUDIO_INT:
|
|
case media_raw_audio_format::B_AUDIO_SHORT:
|
|
case media_raw_audio_format::B_AUDIO_UCHAR:
|
|
case media_raw_audio_format::B_AUDIO_CHAR:
|
|
fSampleFormat = B_LINEAR_SAMPLES;
|
|
break;
|
|
default:
|
|
fSampleFormat = B_UNDEFINED_SAMPLES;
|
|
}
|
|
fByteOffset = 0;
|
|
fFrameCount = track->CountFrames();
|
|
fFrameIndex = 0;
|
|
if (mf.type == B_MEDIA_ENCODED_AUDIO) {
|
|
fIsCompressed = true;
|
|
fCompressionType = mf.u.encoded_audio.encoding;
|
|
}
|
|
fMediaFile = media;
|
|
fMediaTrack = track;
|
|
fSoundFile = file;
|
|
return B_OK;
|
|
}
|
|
|
|
|