void Audio_Stream::streamIsReadyRead()
{
if (m_audioStreamParserRunning) {
AS_TRACE("%s: parser already running!\n", __PRETTY_FUNCTION__);
return;
}
/* Check if the stream's MIME type begins with audio/ */
std::string contentType = m_httpStream->contentType();
const char *audioContentType = "audio/";
size_t audioContentTypeLength = strlen(audioContentType);
if (contentType.compare(0, audioContentTypeLength, audioContentType) != 0) {
closeAndSignalError(AS_ERR_OPEN);
return;
}
/* OK, it should be an audio stream, let's try to open it */
OSStatus result = AudioFileStreamOpen(this,
propertyValueCallback,
streamDataCallback,
audioStreamTypeFromContentType(contentType),
&m_audioFileStream);
if (result == 0) {
AS_TRACE("%s: audio file stream opened.\n", __PRETTY_FUNCTION__);
m_audioStreamParserRunning = true;
} else {
closeAndSignalError(AS_ERR_OPEN);
}
}
long AudioStreamDecoder::Start()
{
long err = AudioFileStreamOpen(this, StaticPropertyCallback, StaticPacketCallback, kAudioFileAAC_ADTSType, &mStream);
BAIL_IF(err, "AudioFileStreamOpen returned %ld\n", err);
bail:
return err;
}
DZAudioQueuePlayer::DZAudioQueuePlayer(AudioFileTypeID typeHint)
{
this->_parser = NULL;
this->_queue = NULL;
this->_magicCookie = NULL;
this->_magicCookieSize = 0;
if (dzDebugError(AudioFileStreamOpen(this, OnProperty, OnPackets, typeHint, &(this->_parser)),
"Open Audio File Stream Failed.")) {
this->_parser = NULL;
}
this->_bufferList = new DZAudioQueueBufferList();
this->_timeAmendment = 0;
this->_status = DZAudioQueuePlayerStatus_NotReady;
}
nsresult
AppleATDecoder::GetImplicitAACMagicCookie(const MediaRawData* aSample)
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
// Prepend ADTS header to AAC audio.
RefPtr<MediaRawData> adtssample(aSample->Clone());
if (!adtssample) {
return NS_ERROR_OUT_OF_MEMORY;
}
int8_t frequency_index =
mp4_demuxer::Adts::GetFrequencyIndex(mConfig.mRate);
bool rv = mp4_demuxer::Adts::ConvertSample(mConfig.mChannels,
frequency_index,
mConfig.mProfile,
adtssample);
if (!rv) {
NS_WARNING("Failed to apply ADTS header");
return NS_ERROR_FAILURE;
}
if (!mStream) {
OSStatus rv = AudioFileStreamOpen(this,
_MetadataCallback,
_SampleCallback,
kAudioFileAAC_ADTSType,
&mStream);
if (rv) {
NS_WARNING("Couldn't open AudioFileStream");
return NS_ERROR_FAILURE;
}
}
OSStatus status = AudioFileStreamParseBytes(mStream,
adtssample->Size(),
adtssample->Data(),
0 /* discontinuity */);
if (status) {
NS_WARNING("Couldn't parse sample");
}
if (status || mFileStreamError || mMagicCookie.Length()) {
// We have decoded a magic cookie or an error occurred as such
// we won't need the stream any longer.
AudioFileStreamClose(mStream);
mStream = nullptr;
}
return (mFileStreamError || status) ? NS_ERROR_FAILURE : NS_OK;
}
void Audio_Stream::streamIsReadyRead()
{
if (m_audioStreamParserRunning) {
AS_TRACE("%s: parser already running!\n", __PRETTY_FUNCTION__);
return;
}
CFStringRef audioContentType = CFSTR("audio/");
const CFIndex audioContentTypeLength = CFStringGetLength(audioContentType);
bool matchesAudioContentType = false;
CFStringRef contentType = m_httpStream->contentType();
if (m_contentType) {
CFRelease(m_contentType), m_contentType = 0;
}
if (contentType) {
m_contentType = CFStringCreateCopy(kCFAllocatorDefault, contentType);
/* Check if the stream's MIME type begins with audio/ */
matchesAudioContentType = (kCFCompareEqualTo ==
CFStringCompareWithOptions(contentType, CFSTR("audio/"),
CFRangeMake(0, audioContentTypeLength),
0));
}
if (m_strictContentTypeChecking && !matchesAudioContentType) {
closeAndSignalError(AS_ERR_OPEN);
return;
}
m_audioDataByteCount = 0;
/* OK, it should be an audio stream, let's try to open it */
OSStatus result = AudioFileStreamOpen(this,
propertyValueCallback,
streamDataCallback,
audioStreamTypeFromContentType(contentType),
&m_audioFileStream);
if (result == 0) {
AS_TRACE("%s: audio file stream opened.\n", __PRETTY_FUNCTION__);
m_audioStreamParserRunning = true;
} else {
closeAndSignalError(AS_ERR_OPEN);
}
}
nsresult
AppleMP3Reader::Init(MediaDecoderReader* aCloneDonor)
{
AudioFileTypeID fileType = kAudioFileMP3Type;
OSStatus rv = AudioFileStreamOpen(this,
_AudioMetadataCallback,
_AudioSampleCallback,
fileType,
&mAudioFileStream);
if (rv) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
nsresult
AppleATDecoder::GetImplicitAACMagicCookie(const mp4_demuxer::MP4Sample* aSample)
{
// Prepend ADTS header to AAC audio.
nsAutoPtr<mp4_demuxer::MP4Sample> adtssample(aSample->Clone());
if (!adtssample) {
return NS_ERROR_OUT_OF_MEMORY;
}
bool rv = mp4_demuxer::Adts::ConvertSample(mConfig.channel_count,
mConfig.frequency_index,
mConfig.aac_profile,
adtssample);
if (!rv) {
NS_WARNING("Failed to apply ADTS header");
return NS_ERROR_FAILURE;
}
if (!mStream) {
OSStatus rv = AudioFileStreamOpen(this,
_MetadataCallback,
_SampleCallback,
kAudioFileAAC_ADTSType,
&mStream);
if (rv) {
NS_WARNING("Couldn't open AudioFileStream");
return NS_ERROR_FAILURE;
}
}
OSStatus status = AudioFileStreamParseBytes(mStream,
adtssample->size,
adtssample->data,
0 /* discontinuity */);
if (status) {
NS_WARNING("Couldn't parse sample");
}
if (status || mFileStreamError || mMagicCookie.Length()) {
// We have decoded a magic cookie or an error occurred as such
// we won't need the stream any longer.
AudioFileStreamClose(mStream);
mStream = nullptr;
}
return (mFileStreamError || status) ? NS_ERROR_FAILURE : NS_OK;
}
nsresult
AppleATDecoder::Init()
{
LOG("Initializing Apple AudioToolbox AAC decoder");
AudioFileTypeID fileType = kAudioFileAAC_ADTSType;
OSStatus rv = AudioFileStreamOpen(this,
_MetadataCallback,
_SampleCallback,
fileType,
&mStream);
if (rv) {
NS_ERROR("Couldn't open AudioFileStream");
return NS_ERROR_FAILURE;
}
return NS_OK;
}
nsresult
AppleATDecoder::Init()
{
if (!mFileType) {
NS_ERROR("Non recognised format");
return NS_ERROR_FAILURE;
}
LOG("Initializing Apple AudioToolbox Audio decoder");
OSStatus rv = AudioFileStreamOpen(this,
_MetadataCallback,
_SampleCallback,
mFileType,
&mStream);
if (rv) {
NS_ERROR("Couldn't open AudioFileStream");
return NS_ERROR_FAILURE;
}
return NS_OK;
}
void *BarPlayerMacOSXThread(void *data){
struct audioPlayer *player = data;
char extraHeaders[25];
void *ret = PLAYER_RET_OK;
WaitressReturn_t wRet = WAITRESS_RET_ERR;
/* init handles */
player->waith.data = (void *) player;
/* extraHeaders will be initialized later */
player->waith.extraHeaders = extraHeaders;
player->songPlayed = 0;
switch (player->audioFormat) {
case PIANO_AF_AACPLUS:
{
OSStatus err = AudioFileStreamOpen(player, StreamPropertyListenerProc, StreamPacketsProc,
kAudioFileAAC_ADTSType, &player->audioFileStream);
if (err)
PRINTERROR ("Error opening stream!\n");
player->waith.callback = BarPlayerAACCb;
}
break;
case PIANO_AF_MP3:
case PIANO_AF_MP3_HI:
{
OSStatus err = AudioFileStreamOpen(player, StreamPropertyListenerProc, StreamPacketsProc,
kAudioFileMP3Type, &player->audioFileStream);
if (err)
PRINTERROR ("Error opening stream!\n");
player->waith.callback = BarPlayerAACCb;
}
break;
default:
PRINTERROR ("Unsupported audio format!\n");
return PLAYER_RET_OK;
break;
}
player->mode = PLAYER_INITIALIZED;
/* This loop should work around song abortions by requesting the
* missing part of the song */
do {
snprintf (extraHeaders, sizeof (extraHeaders), "Range: bytes=%zu-\r\n",
player->bytesReceived);
wRet = WaitressFetchCall (&player->waith);
} while (wRet == WAITRESS_RET_PARTIAL_FILE || wRet == WAITRESS_RET_TIMEOUT
|| wRet == WAITRESS_RET_READ_ERR);
switch (player->audioFormat) {
case PIANO_AF_AACPLUS:
case PIANO_AF_MP3:
case PIANO_AF_MP3_HI:
AudioQueueStop(player->audioQueue, false);
AudioFileStreamClose(player->streamID);
AudioQueueDispose(player->audioQueue, false);
break;
default:
/* this should never happen: thread is aborted above */
break;
}
WaitressFree (&player->waith);
pthread_mutex_lock(&player->mutex);
player->mode = PLAYER_FINISHED_PLAYBACK;
pthread_cond_broadcast(&player->cond);
pthread_mutex_unlock(&player->mutex);
return ret;
}
int main (int argc, char * const argv[])
{
// allocate a struct for storing our state
MyData* myData = (MyData*)calloc(1, sizeof(MyData));
// initialize a mutex and condition so that we can block on buffers in use.
pthread_mutex_init(&myData->mutex, NULL);
pthread_cond_init(&myData->cond, NULL);
pthread_cond_init(&myData->done, NULL);
// get connected
int connection_socket = MyConnectSocket();
if (connection_socket < 0) return 1;
printf("connected\n");
// allocate a buffer for reading data from a socket
const size_t kRecvBufSize = 40000;
char* buf = (char*)malloc(kRecvBufSize * sizeof(char));
// create an audio file stream parser
OSStatus err = AudioFileStreamOpen(myData, MyPropertyListenerProc, MyPacketsProc,
kAudioFileAAC_ADTSType, &myData->audioFileStream);
if (err) { PRINTERROR("AudioFileStreamOpen"); return 1; }
while (!myData->failed) {
// read data from the socket
printf("->recv\n");
ssize_t bytesRecvd = recv(connection_socket, buf, kRecvBufSize, 0);
printf("bytesRecvd %d\n", bytesRecvd);
if (bytesRecvd <= 0) break; // eof or failure
// parse the data. this will call MyPropertyListenerProc and MyPacketsProc
err = AudioFileStreamParseBytes(myData->audioFileStream, bytesRecvd, buf, 0);
if (err) { PRINTERROR("AudioFileStreamParseBytes"); break; }
}
// enqueue last buffer
MyEnqueueBuffer(myData);
printf("flushing\n");
err = AudioQueueFlush(myData->audioQueue);
if (err) { PRINTERROR("AudioQueueFlush"); return 1; }
printf("stopping\n");
err = AudioQueueStop(myData->audioQueue, false);
if (err) { PRINTERROR("AudioQueueStop"); return 1; }
printf("waiting until finished playing..\n");
pthread_mutex_lock(&myData->mutex);
pthread_cond_wait(&myData->done, &myData->mutex);
pthread_mutex_unlock(&myData->mutex);
printf("done\n");
// cleanup
free(buf);
err = AudioFileStreamClose(myData->audioFileStream);
err = AudioQueueDispose(myData->audioQueue, false);
close(connection_socket);
free(myData);
return 0;
}
