Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

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

#include "sound.h"

#include "fplay.h"

int resampler_size;

volatile int sound_level_0;

volatile int sound_level_1;

volatile enum player_state decoder_state;

volatile enum player_state sound_state;

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;

};

{

    SetVolume(hBuff, left, right);

};

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;

        {

            if(astream.count < buffsize)

            {

                memset(astream.buffer+astream.count,

                       0, buffsize-astream.count);

                astream.count = buffsize;

            };

            samples_written+= buffsize/4;

            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;

    };

    {

        uint32_t  offset;

        double    event_stamp, wait_stamp;

        int       too_late = 0;

        {

            case PREPARE:

                    if(astream.count < buffsize*2)

                    {

                        memset(astream.buffer+astream.count,

                               0, buffsize*2-astream.count);

                        astream.count = buffsize*2;

                    };

                    astream.count -= buffsize*2;

                    if(astream.count)

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

                mutex_unlock(&astream.lock);

                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);

                sound_state = PLAY;

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

                GetNotify(&evnt);

                {

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

                    continue;

                }

                {

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

                            evnt.stream, hBuff);

                    continue;

                };

                if(astream.count < buffsize)

                {

                    memset(astream.buffer+astream.count,

                           0, buffsize-astream.count);

                    astream.count = buffsize;

                };

                    double  val = 0;

                    int16_t *src = (int16_t*)astream.buffer;

                    int samples = buffsize/2;

                    int i;

                        if(val < abs(*src))

                            val= abs(*src); // * *src;

                        if(val < abs(*src))

                            val= abs(*src); // * *src;

                };

                if(astream.count)

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

                mutex_unlock(&astream.lock);

                break;

                if( active )

                {

                    ResetBuffer(hBuff, SND_RESET_ALL);

                    audio_base = -1.0;

                    active = 0;

                }

                sound_state = STOP;

                break;

                if( active )

                {

                    StopBuffer(hBuff);

                };

                sound_state = PAUSE;

            case STOP:

                delay(1);

        };

    }

    DestroyBuffer(hBuff);

    return -1;