/*

     File: afsclient.cpp

 Abstract: n/a

  Version: 1.0.1

 Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple

 Inc. ("Apple") in consideration of your agreement to the following

 terms, and your use, installation, modification or redistribution of

 this Apple software constitutes acceptance of these terms.  If you do

 not agree with these terms, please do not use, install, modify or

 redistribute this Apple software.

 In consideration of your agreement to abide by the following terms, and

 subject to these terms, Apple grants you a personal, non-exclusive

 license, under Apple's copyrights in this original Apple software (the

 "Apple Software"), to use, reproduce, modify and redistribute the Apple

 Software, with or without modifications, in source and/or binary forms;

 provided that if you redistribute the Apple Software in its entirety and

 without modifications, you must retain this notice and the following

 text and disclaimers in all such redistributions of the Apple Software.

 Neither the name, trademarks, service marks or logos of Apple Inc. may

 be used to endorse or promote products derived from the Apple Software

 without specific prior written permission from Apple.  Except as

 expressly stated in this notice, no other rights or licenses, express or

 implied, are granted by Apple herein, including but not limited to any

 patent rights that may be infringed by your derivative works or by other

 works in which the Apple Software may be incorporated.

 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE

 MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION

 THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS

 FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND

 OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.

 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL

 OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,

 MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED

 AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),

 STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE

 POSSIBILITY OF SUCH DAMAGE.

 Copyright (C) 2013 Apple Inc. All Rights Reserved.

*/

#include <stdio.h>

#include <string.h>

#include <netdb.h>

#include <netinet/in.h>

#include <unistd.h>

#include <pthread.h>

#include <AudioToolbox/AudioToolbox.h>

#define PRINTERROR(LABEL)   printf("%s err %4.4s %ld\n", LABEL, (char *)&err, err)

const int port = 51515;         // the port we will use

const unsigned int kNumAQBufs = 3;          // number of audio queue buffers we allocate

const size_t kAQBufSize = 128 * 1024;       // number of bytes in each audio queue buffer

const size_t kAQMaxPacketDescs = 512;       // number of packet descriptions in our array

struct MyData

{

    AudioFileStreamID audioFileStream;  // the audio file stream parser

    AudioQueueRef audioQueue;                               // the audio queue

    AudioQueueBufferRef audioQueueBuffer[kNumAQBufs];       // audio queue buffers

    AudioStreamPacketDescription packetDescs[kAQMaxPacketDescs];    // packet descriptions for enqueuing audio

    unsigned int fillBufferIndex;   // the index of the audioQueueBuffer that is being filled

    size_t bytesFilled;             // how many bytes have been filled

    size_t packetsFilled;           // how many packets have been filled

    bool inuse[kNumAQBufs];         // flags to indicate that a buffer is still in use

    bool started;                   // flag to indicate that the queue has been started

    bool failed;                    // flag to indicate an error occurred

    pthread_mutex_t mutex;          // a mutex to protect the inuse flags

    pthread_cond_t cond;            // a condition varable for handling the inuse flags

    pthread_cond_t done;            // a condition varable for handling the inuse flags

};

typedef struct MyData MyData;

int  MyConnectSocket();

void MyAudioQueueOutputCallback(void* inClientData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer);

void MyAudioQueueIsRunningCallback(void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID);

void MyPropertyListenerProc(    void *                          inClientData,

                                AudioFileStreamID               inAudioFileStream,

                                AudioFileStreamPropertyID       inPropertyID,

                                UInt32 *                        ioFlags);

void MyPacketsProc(             void *                          inClientData,

                                UInt32                          inNumberBytes,

                                UInt32                          inNumberPackets,

                                const void *                    inInputData,

                                AudioStreamPacketDescription    *inPacketDescriptions);

OSStatus MyEnqueueBuffer(MyData* myData);

void WaitForFreeBuffer(MyData* myData);

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"); free(buf); return 1; }

    while (!myData->failed) {

        // read data from the socket

        printf("->recv\n");

        ssize_t bytesRecvd = recv(connection_socket, buf, kRecvBufSize, 0);

        printf("bytesRecvd %ld\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"); free(buf); return 1; }

    printf("stopping\n");

    err = AudioQueueStop(myData->audioQueue, false);

    if (err) { PRINTERROR("AudioQueueStop"); free(buf); 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;

}

void MyPropertyListenerProc(    void *                          inClientData,

                                AudioFileStreamID               inAudioFileStream,

                                AudioFileStreamPropertyID       inPropertyID,

                                UInt32 *                        ioFlags)

{   

    // this is called by audio file stream when it finds property values

    MyData* myData = (MyData*)inClientData;

    OSStatus err = noErr;

    printf("found property '%c%c%c%c'\n", (char)(inPropertyID>>24)&255, (char)(inPropertyID>>16)&255, (char)(inPropertyID>>8)&255, (char)inPropertyID&255);

    switch (inPropertyID) {

        case kAudioFileStreamProperty_ReadyToProducePackets :

        {

            // the file stream parser is now ready to produce audio packets.

            // get the stream format.

            AudioStreamBasicDescription asbd;

            UInt32 asbdSize = sizeof(asbd);

            err = AudioFileStreamGetProperty(inAudioFileStream, kAudioFileStreamProperty_DataFormat, &asbdSize, &asbd);

            if (err) { PRINTERROR("get kAudioFileStreamProperty_DataFormat"); myData->failed = true; break; }

            // create the audio queue

            err = AudioQueueNewOutput(&asbd, MyAudioQueueOutputCallback, myData, NULL, NULL, 0, &myData->audioQueue);

            if (err) { PRINTERROR("AudioQueueNewOutput"); myData->failed = true; break; }

            // allocate audio queue buffers

            for (unsigned int i = 0; i < kNumAQBufs; ++i) {

                err = AudioQueueAllocateBuffer(myData->audioQueue, kAQBufSize, &myData->audioQueueBuffer[i]);

                if (err) { PRINTERROR("AudioQueueAllocateBuffer"); myData->failed = true; break; }

            }

            // get the cookie size

            UInt32 cookieSize;

            Boolean writable;

            err = AudioFileStreamGetPropertyInfo(inAudioFileStream, kAudioFileStreamProperty_MagicCookieData, &cookieSize, &writable);

            if (err) { PRINTERROR("info kAudioFileStreamProperty_MagicCookieData"); break; }

            printf("cookieSize %d\n", (unsigned int)cookieSize);

            // get the cookie data

            void* cookieData = calloc(1, cookieSize);

            err = AudioFileStreamGetProperty(inAudioFileStream, kAudioFileStreamProperty_MagicCookieData, &cookieSize, cookieData);

            if (err) { PRINTERROR("get kAudioFileStreamProperty_MagicCookieData"); free(cookieData); break; }

            // set the cookie on the queue.

            err = AudioQueueSetProperty(myData->audioQueue, kAudioQueueProperty_MagicCookie, cookieData, cookieSize);

            free(cookieData);

            if (err) { PRINTERROR("set kAudioQueueProperty_MagicCookie"); break; }

            // listen for kAudioQueueProperty_IsRunning

            err = AudioQueueAddPropertyListener(myData->audioQueue, kAudioQueueProperty_IsRunning, MyAudioQueueIsRunningCallback, myData);

            if (err) { PRINTERROR("AudioQueueAddPropertyListener"); myData->failed = true; break; }

            break;

        }

    }

}

void MyPacketsProc(             void *                          inClientData,

                                UInt32                          inNumberBytes,

                                UInt32                          inNumberPackets,

                                const void *                    inInputData,

                                AudioStreamPacketDescription    *inPacketDescriptions)

{

    // this is called by audio file stream when it finds packets of audio

    MyData* myData = (MyData*)inClientData;

    printf("got data.  bytes: %d  packets: %d\n", (unsigned int)inNumberBytes, (unsigned int)inNumberPackets);

    // the following code assumes we're streaming VBR data. for CBR data, you'd need another code branch here.

    for (int i = 0; i < inNumberPackets; ++i) {

        SInt64 packetOffset = inPacketDescriptions[i].mStartOffset;

        SInt64 packetSize   = inPacketDescriptions[i].mDataByteSize;

        // if the space remaining in the buffer is not enough for this packet, then enqueue the buffer.

        size_t bufSpaceRemaining = kAQBufSize - myData->bytesFilled;

        if (bufSpaceRemaining < packetSize) {

            MyEnqueueBuffer(myData);

            WaitForFreeBuffer(myData);

        }

        // copy data to the audio queue buffer

        AudioQueueBufferRef fillBuf = myData->audioQueueBuffer[myData->fillBufferIndex];

        memcpy((char*)fillBuf->mAudioData + myData->bytesFilled, (const char*)inInputData + packetOffset, packetSize);

        // fill out packet description

        myData->packetDescs[myData->packetsFilled] = inPacketDescriptions[i];

        myData->packetDescs[myData->packetsFilled].mStartOffset = myData->bytesFilled;

        // keep track of bytes filled and packets filled

        myData->bytesFilled += packetSize;

        myData->packetsFilled += 1;

        // if that was the last free packet description, then enqueue the buffer.

        size_t packetsDescsRemaining = kAQMaxPacketDescs - myData->packetsFilled;

        if (packetsDescsRemaining == 0) {

            MyEnqueueBuffer(myData);

            WaitForFreeBuffer(myData);

        }

    }   

}

OSStatus StartQueueIfNeeded(MyData* myData)

{

    OSStatus err = noErr;

    if (!myData->started) {     // start the queue if it has not been started already

        err = AudioQueueStart(myData->audioQueue, NULL);

        if (err) { PRINTERROR("AudioQueueStart"); myData->failed = true; return err; }      

        myData->started = true;

        printf("started\n");

    }

    return err;

}

OSStatus MyEnqueueBuffer(MyData* myData)

{

    OSStatus err = noErr;

    myData->inuse[myData->fillBufferIndex] = true;      // set in use flag

    // enqueue buffer

    AudioQueueBufferRef fillBuf = myData->audioQueueBuffer[myData->fillBufferIndex];

    fillBuf->mAudioDataByteSize = myData->bytesFilled;      

    err = AudioQueueEnqueueBuffer(myData->audioQueue, fillBuf, myData->packetsFilled, myData->packetDescs);

    if (err) { PRINTERROR("AudioQueueEnqueueBuffer"); myData->failed = true; return err; }      

    StartQueueIfNeeded(myData);

    return err;

}

void WaitForFreeBuffer(MyData* myData)

{

    // go to next buffer

    if (++myData->fillBufferIndex >= kNumAQBufs) myData->fillBufferIndex = 0;

    myData->bytesFilled = 0;        // reset bytes filled

    myData->packetsFilled = 0;      // reset packets filled

    // wait until next buffer is not in use

    printf("->lock\n");

    pthread_mutex_lock(&myData->mutex); 

    while (myData->inuse[myData->fillBufferIndex]) {

        printf("... WAITING ...\n");

        pthread_cond_wait(&myData->cond, &myData->mutex);

    }

    pthread_mutex_unlock(&myData->mutex);

    printf("<-unlock\n");

}

int MyFindQueueBuffer(MyData* myData, AudioQueueBufferRef inBuffer)

{

    for (unsigned int i = 0; i < kNumAQBufs; ++i) {

        if (inBuffer == myData->audioQueueBuffer[i]) 

            return i;

    }

    return -1;

}

void MyAudioQueueOutputCallback(    void*                   inClientData, 

                                    AudioQueueRef           inAQ, 

                                    AudioQueueBufferRef     inBuffer)

{

    // this is called by the audio queue when it has finished decoding our data. 

    // The buffer is now free to be reused.

    MyData* myData = (MyData*)inClientData;

    unsigned int bufIndex = MyFindQueueBuffer(myData, inBuffer);

    // signal waiting thread that the buffer is free.

    pthread_mutex_lock(&myData->mutex);

    myData->inuse[bufIndex] = false;

    pthread_cond_signal(&myData->cond);

    pthread_mutex_unlock(&myData->mutex);

}

void MyAudioQueueIsRunningCallback(     void*                   inClientData, 

                                        AudioQueueRef           inAQ, 

                                        AudioQueuePropertyID    inID)

{

    MyData* myData = (MyData*)inClientData;

    UInt32 running;

    UInt32 size;

    OSStatus err = AudioQueueGetProperty(inAQ, kAudioQueueProperty_IsRunning, &running, &size);

    if (err) { PRINTERROR("get kAudioQueueProperty_IsRunning"); return; }

    if (!running) {

        pthread_mutex_lock(&myData->mutex);

        pthread_cond_signal(&myData->done);

        pthread_mutex_unlock(&myData->mutex);

    }

}

int MyConnectSocket()

{

    int connection_socket;

    struct hostent *host = gethostbyname("127.0.0.1");

    if (!host) { printf("can't get host\n"); return -1; }

    connection_socket = socket(AF_INET, SOCK_STREAM, 0);

    if (connection_socket < 0) { printf("can't create socket\n"); return -1; }

    struct sockaddr_in server_sockaddr;

    server_sockaddr.sin_family = host->h_addrtype;

    memcpy(&server_sockaddr.sin_addr.s_addr, host->h_addr_list[0], host->h_length);

    server_sockaddr.sin_port = htons(port);

    int err = connect(connection_socket, (struct sockaddr*)&server_sockaddr, sizeof(server_sockaddr));

    if (err < 0) { printf("can't connect\n"); return -1; }

    return connection_socket;

}