Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

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

    {

        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;

};

{

    static struct SwrContext *swr_ctx;

    static int64_t src_layout;

    static int src_freq;

    static int src_channels;

    static enum AVSampleFormat src_fmt = -1;

    static AVFrame *aFrame;

    AVPacket    pkt_tmp;

    int64_t dec_channel_layout;

    int len, len2;

    int got_frame;

    int data_size;

        return -1;

        return 0;

    {

        if (!(aFrame = av_frame_alloc()))

            return -1;

    } else

        avcodec_get_frame_defaults(aFrame);

    {

        data_size = 192000;

        len = avcodec_decode_audio4(ctx, aFrame, &got_frame, &pkt_tmp);

        {

            char *samples;

            int ch, plane_size;

            int planar    = av_sample_fmt_is_planar(ctx->sample_fmt);

            int data_size = av_samples_get_buffer_size(&plane_size, ctx->channels,

                                                   aFrame->nb_samples,

                                                   ctx->sample_fmt, 1);

//            {

//                if (pkt.pts != AV_NOPTS_VALUE)

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

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

//            };

            pkt_tmp.size -= len;

                (aFrame->channel_layout && aFrame->channels == av_get_channel_layout_nb_channels(aFrame->channel_layout)) ?

                aFrame->channel_layout : av_get_default_channel_layout(aFrame->channels);

                dec_channel_layout      != src_layout  ||

                aFrame->sample_rate     != src_freq    ||

                !swr_ctx)

            {

                swr_free(&swr_ctx);

                swr_ctx = swr_alloc_set_opts(NULL, AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16,

                                             aFrame->sample_rate, dec_channel_layout,aFrame->format,

                                             aFrame->sample_rate, 0, NULL);

                if (!swr_ctx || swr_init(swr_ctx) < 0)

                {

                    printf("Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",

                        aFrame->sample_rate,   av_get_sample_fmt_name(aFrame->format), (int)aFrame->channels,

                        aFrame->sample_rate, av_get_sample_fmt_name(AV_SAMPLE_FMT_S16), 2);

                    break;

                }

                src_channels = aFrame->channels;

                src_freq     = aFrame->sample_rate;

                src_fmt      = aFrame->format;

            };

            {

                const uint8_t **in = (const uint8_t **)aFrame->extended_data;

                uint8_t *out[] = {decoder_buffer};

                int out_count = 192000 * 3 / 2 / av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);

                len2 = swr_convert(swr_ctx, out, out_count, in, aFrame->nb_samples);

                if (len2 < 0) {

                    printf("swr_convert() failed\n");

                    break;

                }

                if (len2 == out_count) {

                    printf("warning: audio buffer is probably too small\n");

                    swr_init(swr_ctx);

                }

                data_size = len2 * 2 * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);

                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;