Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include "../winlib/winlib.h"

#include "sound.h"

#include "fplay.h"

int sample_rate;

double audio_base = -1.0;

{

    int    err;

    int    version =-1;

    char  *errstr;

    {

        mutex_unlock(&driver_lock);

        errstr = "Sound service not installed\n\r";

        goto exit_whith_error;

    };

        (SOUND_VERSION<(version >> 16)))

    {

        errstr = "Sound service version mismatch\n\r";

        goto exit_whith_error;

    }

    return 0;

};

static double  audio_delta;

static double  last_time_stamp;

{

    double tstamp;

    return tstamp - audio_delta;

};

{

    AVPacket   pkt;

    AVPacket    pkt_tmp;

    int         data_size=0;

        return 1;

        return 0;

    {

        data_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;

                                   &data_size, &pkt_tmp);

        {

//            if(audio_base == -1.0)

//            {

//                if (pkt.pts != AV_NOPTS_VALUE)

//                    audio_base = get_audio_base() * pkt.pts;

//                printf("audio base %f\n", audio_base);

//            };

            pkt_tmp.size -= len;

            memcpy(astream.buffer+astream.count, decoder_buffer, data_size);

            astream.count += data_size;

            mutex_unlock(&astream.lock);

       }

       else pkt_tmp.size = 0;

    }

    av_free_packet(&pkt);

    return 1;

};

{

    SND_EVENT   evnt;

    uint32_t    offset;

    double      time_stamp;

    {

        GetNotify(&evnt);

        {

            printf("invalid event code %d\n\r", evnt.code);

            continue;

        }

        {

            printf("invalid stream %x hBuff= %x\n\r",

                    evnt.stream, hbuff);

            continue;

        }

        audio_delta = time_stamp - last_time_stamp;

        {

            SetBuffer(hbuff, astream.buffer, offset, buffsize);

            samples_written+= buffsize/4;

            astream.count -= buffsize;

            if(astream.count)

                memcpy(astream.buffer, astream.buffer+buffsize, astream.count);

            mutex_unlock(&astream.lock);

        };

        break;

    };

#endif

{

    SND_EVENT evnt;

    int      samples;

    int       err;

    char     *errstr;

    int       active;

    {

        errstr = "Cannot create sound buffer\n\r";

        goto exit_whith_error;

    };

    {

        errstr = "Cannot get buffer size\n\r";

        goto exit_whith_error;

    };

               (player_state != CLOSED) )

        yield();

    {

        SetBuffer(hBuff, astream.buffer, 0, buffsize);

        samples_written+= buffsize/4;

        astream.count -= buffsize;

        if(astream.count)

            memcpy(astream.buffer, astream.buffer+buffsize, astream.count);

        mutex_unlock(&astream.lock);

    };

    {

        uint32_t  offset;

        double    event_stamp, wait_stamp;

        int       too_late = 0;

           (player_state == PLAY_INIT) )

        {

            if( active )

            {

                StopBuffer(hBuff);

                active = 0;

            };

            delay(1);

            continue;

        }

        else if(player_state == REWIND)

        {

            if( active )

            {

                StopBuffer(hBuff);

                active = 0;

            };

            mutex_lock(&astream.lock);

            astream.count = 0;

            mutex_unlock(&astream.lock);

            delay(1);

            continue;

        }

        else if(player_state == PAUSE_2_PLAY)

        {

//            SetTimeBase(hBuff, audio_base);

            GetTimeStamp(hBuff, &last_time_stamp);

//            printf("last_time_stamp %f\n", last_time_stamp);

            {

                errstr = "Cannot play buffer\n\r";

                goto exit_whith_error;

            };

            active = 1;

            sync_audio(hBuff, buffsize);

            player_state = PLAY;

            printf("render: set audio latency to %f\n", audio_delta);

        }

        else if(player_state == REWIND_2_PLAY)

        {

            while( (astream.count < buffsize*2) &&

                   (player_state != CLOSED) )

            yield();

            GetTimeStamp(hBuff, &last_time_stamp);

            printf("last audio time stamp %f\n", last_time_stamp);

            {

                errstr = "Cannot play buffer\n\r";

                goto exit_whith_error;

            };

            active = 1;

            sync_audio(hBuff, buffsize);

            player_state = PLAY;

            printf("render: set audio latency to %f\n", audio_delta);

        };

        {

            printf("invalid event code %d\n\r", evnt.code);

            continue;

        }

        {

            printf("invalid stream %x hBuff= %x\n\r",

                    evnt.stream, hBuff);

            continue;

        };

               (player_state != CLOSED) )

        {

            yield();

            GetTimeStamp(hBuff, &wait_stamp);

            if( (wait_stamp - event_stamp) >

                 samples*1500/sample_rate )

            {

                samples_lost+= samples;

                audio_delta = (double)samples_lost*1000/sample_rate;

//                printf("audio delta %f\n", audio_delta);

                too_late = 1;

                break;

            }

        };

        {

            too_late = 0;

            continue;

        };

        SetBuffer(hBuff, astream.buffer, offset, buffsize);

        samples_written+= buffsize/4;

        astream.count -= buffsize;

        if(astream.count)

            memcpy(astream.buffer, astream.buffer+buffsize, astream.count);

        mutex_unlock(&astream.lock);

    }

    DestroyBuffer(hBuff);

    return -1;