forked from KolibriOS/kolibrios
446 lines
12 KiB
C
446 lines
12 KiB
C
|
|
#include <stdint.h>
|
|
#include <libavcodec/avcodec.h>
|
|
#include <libavformat/avformat.h>
|
|
#include "libswresample/swresample.h"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "winlib/winlib.h"
|
|
#include "sound.h"
|
|
#include "fplay.h"
|
|
|
|
|
|
astream_t astream;
|
|
|
|
extern uint8_t *decoder_buffer;
|
|
int resampler_size;
|
|
volatile int sound_level_0;
|
|
volatile int sound_level_1;
|
|
|
|
volatile enum player_state player_state;
|
|
volatile enum player_state decoder_state;
|
|
volatile enum player_state sound_state;
|
|
|
|
extern mutex_t driver_lock;
|
|
|
|
static SNDBUF hBuff;
|
|
|
|
static int snd_format;
|
|
int sample_rate;
|
|
|
|
static uint32_t samples_written = 0;
|
|
double audio_base = -1.0;
|
|
|
|
double get_audio_base();
|
|
|
|
int init_audio(int format)
|
|
{
|
|
int err;
|
|
int version =-1;
|
|
char *errstr;
|
|
|
|
mutex_lock(&driver_lock);
|
|
|
|
if((err = InitSound(&version)) !=0 )
|
|
{
|
|
mutex_unlock(&driver_lock);
|
|
errstr = "Sound service not installed\n\r";
|
|
goto exit_whith_error;
|
|
};
|
|
|
|
mutex_unlock(&driver_lock);
|
|
|
|
// printf("sound version 0x%x\n", version);
|
|
|
|
if( (SOUND_VERSION>(version&0xFFFF)) ||
|
|
(SOUND_VERSION<(version >> 16)))
|
|
{
|
|
errstr = "Sound service version mismatch\n\r";
|
|
goto exit_whith_error;
|
|
}
|
|
|
|
snd_format = format;
|
|
|
|
create_thread(audio_thread, 0, 163840);
|
|
|
|
return 1;
|
|
|
|
exit_whith_error:
|
|
|
|
printf(errstr);
|
|
return 0;
|
|
};
|
|
|
|
void set_audio_volume(int left, int right)
|
|
{
|
|
SetVolume(hBuff, left, right);
|
|
};
|
|
|
|
static uint64_t samples_lost;
|
|
static double audio_delta;
|
|
static double last_time_stamp;
|
|
|
|
|
|
double get_master_clock(void)
|
|
{
|
|
double tstamp;
|
|
|
|
GetTimeStamp(hBuff, &tstamp);
|
|
return tstamp - audio_delta;
|
|
};
|
|
|
|
int decode_audio(AVCodecContext *ctx, queue_t *qa)
|
|
{
|
|
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;
|
|
AVPacket pkt_tmp;
|
|
int64_t dec_channel_layout;
|
|
int len, len2;
|
|
int got_frame;
|
|
int data_size;
|
|
|
|
|
|
if( astream.count > 192000*2)
|
|
return -1;
|
|
|
|
if( get_packet(qa, &pkt) == 0 )
|
|
return 0;
|
|
|
|
// __asm__("int3");
|
|
|
|
if (!aFrame)
|
|
{
|
|
if (!(aFrame = avcodec_alloc_frame()))
|
|
return -1;
|
|
} else
|
|
avcodec_get_frame_defaults(aFrame);
|
|
|
|
pkt_tmp = pkt;
|
|
|
|
while(pkt_tmp.size > 0)
|
|
{
|
|
data_size = 192000;
|
|
|
|
// len = avcodec_decode_audio3(ctx,(int16_t*)decoder_buffer,
|
|
// &data_size, &pkt_tmp);
|
|
got_frame = 0;
|
|
len = avcodec_decode_audio4(ctx, aFrame, &got_frame, &pkt_tmp);
|
|
|
|
if(len >= 0 && got_frame)
|
|
{
|
|
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(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.data += len;
|
|
pkt_tmp.size -= len;
|
|
|
|
dec_channel_layout =
|
|
(aFrame->channel_layout && aFrame->channels == av_get_channel_layout_nb_channels(aFrame->channel_layout)) ?
|
|
aFrame->channel_layout : av_get_default_channel_layout(aFrame->channels);
|
|
|
|
if (aFrame->format != src_fmt ||
|
|
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_layout = dec_channel_layout;
|
|
src_channels = aFrame->channels;
|
|
src_freq = aFrame->sample_rate;
|
|
src_fmt = aFrame->format;
|
|
};
|
|
|
|
if (swr_ctx)
|
|
{
|
|
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_lock(&astream.lock);
|
|
|
|
samples = astream.buffer+astream.count;
|
|
|
|
memcpy(samples, decoder_buffer, data_size);
|
|
/*
|
|
memcpy(samples, aFrame->extended_data[0], plane_size);
|
|
|
|
if (planar && ctx->channels > 1)
|
|
{
|
|
uint8_t *out = ((uint8_t *)samples) + plane_size;
|
|
for (ch = 1; ch < ctx->channels; ch++)
|
|
{
|
|
memcpy(out, aFrame->extended_data[ch], plane_size);
|
|
out += plane_size;
|
|
}
|
|
}
|
|
*/
|
|
astream.count += data_size;
|
|
mutex_unlock(&astream.lock);
|
|
};
|
|
}
|
|
else pkt_tmp.size = 0;
|
|
}
|
|
av_free_packet(&pkt);
|
|
return 1;
|
|
};
|
|
|
|
|
|
static void sync_audio(SNDBUF hbuff, int buffsize)
|
|
{
|
|
SND_EVENT evnt;
|
|
uint32_t offset;
|
|
double time_stamp;
|
|
|
|
#ifdef BLACK_MAGIC_SOUND
|
|
|
|
while( player_state != CLOSED)
|
|
{
|
|
GetNotify(&evnt);
|
|
|
|
if(evnt.code != 0xFF000001)
|
|
{
|
|
printf("invalid event code %d\n\r", evnt.code);
|
|
continue;
|
|
}
|
|
|
|
if(evnt.stream != hbuff)
|
|
{
|
|
printf("invalid stream %x hBuff= %x\n\r",
|
|
evnt.stream, hbuff);
|
|
continue;
|
|
}
|
|
|
|
GetTimeStamp(hbuff, &time_stamp);
|
|
audio_delta = time_stamp - last_time_stamp;
|
|
|
|
offset = evnt.offset;
|
|
|
|
mutex_lock(&astream.lock);
|
|
{
|
|
if(astream.count < buffsize)
|
|
{
|
|
memset(astream.buffer+astream.count,
|
|
0, buffsize-astream.count);
|
|
astream.count = buffsize;
|
|
};
|
|
|
|
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
|
|
|
|
};
|
|
|
|
int audio_thread(void *param)
|
|
{
|
|
SND_EVENT evnt;
|
|
|
|
int buffsize;
|
|
int samples;
|
|
int err;
|
|
char *errstr;
|
|
int active;
|
|
|
|
if((err = CreateBuffer(snd_format|PCM_RING,0, &hBuff)) != 0)
|
|
{
|
|
errstr = "Cannot create sound buffer\n\r";
|
|
goto exit_whith_error;
|
|
};
|
|
|
|
SetVolume(hBuff,-900,-900);
|
|
|
|
if((err = GetBufferSize(hBuff, &buffsize)) != 0)
|
|
{
|
|
errstr = "Cannot get buffer size\n\r";
|
|
goto exit_whith_error;
|
|
};
|
|
|
|
__sync_or_and_fetch(&threads_running,AUDIO_THREAD);
|
|
|
|
resampler_size = buffsize = buffsize/2;
|
|
|
|
samples = buffsize/4;
|
|
|
|
while( player_state != CLOSED)
|
|
{
|
|
uint32_t offset;
|
|
double event_stamp, wait_stamp;
|
|
int too_late = 0;
|
|
|
|
switch(sound_state)
|
|
{
|
|
case PREPARE:
|
|
|
|
mutex_lock(&astream.lock);
|
|
if(astream.count < buffsize*2)
|
|
{
|
|
memset(astream.buffer+astream.count,
|
|
0, buffsize*2-astream.count);
|
|
astream.count = buffsize*2;
|
|
};
|
|
|
|
SetBuffer(hBuff, astream.buffer, 0, buffsize*2);
|
|
astream.count -= buffsize*2;
|
|
if(astream.count)
|
|
memcpy(astream.buffer, astream.buffer+buffsize*2, astream.count);
|
|
mutex_unlock(&astream.lock);
|
|
|
|
SetTimeBase(hBuff, audio_base);
|
|
|
|
case PAUSE_2_PLAY:
|
|
GetTimeStamp(hBuff, &last_time_stamp);
|
|
// printf("last audio time stamp %f\n", last_time_stamp);
|
|
|
|
if((err = PlayBuffer(hBuff, 0)) !=0 )
|
|
{
|
|
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);
|
|
|
|
/* breaktrough */
|
|
|
|
case PLAY:
|
|
GetNotify(&evnt);
|
|
|
|
if(evnt.code != 0xFF000001)
|
|
{
|
|
printf("invalid event code %d\n\r", evnt.code);
|
|
continue;
|
|
}
|
|
|
|
if(evnt.stream != hBuff)
|
|
{
|
|
printf("invalid stream %x hBuff= %x\n\r",
|
|
evnt.stream, hBuff);
|
|
continue;
|
|
};
|
|
|
|
offset = evnt.offset;
|
|
|
|
mutex_lock(&astream.lock);
|
|
if(astream.count < buffsize)
|
|
{
|
|
memset(astream.buffer+astream.count,
|
|
0, buffsize-astream.count);
|
|
astream.count = buffsize;
|
|
};
|
|
|
|
SetBuffer(hBuff, astream.buffer, offset, buffsize);
|
|
|
|
{
|
|
double val = 0;
|
|
int16_t *src = (int16_t*)astream.buffer;
|
|
int samples = buffsize/2;
|
|
int i;
|
|
|
|
for(i = 0, val = 0; i < samples/2; i++, src++)
|
|
if(val < abs(*src))
|
|
val= abs(*src); // * *src;
|
|
|
|
sound_level_0 = val; //sqrt(val / (samples/2));
|
|
|
|
for(i = 0, val = 0; i < samples/2; i++, src++)
|
|
if(val < abs(*src))
|
|
val= abs(*src); // * *src;
|
|
|
|
sound_level_1 = val; //sqrt(val / (samples/2));
|
|
|
|
// printf("%d\n", sound_level);
|
|
};
|
|
|
|
samples_written+= buffsize/4;
|
|
|
|
astream.count -= buffsize;
|
|
if(astream.count)
|
|
memcpy(astream.buffer, astream.buffer+buffsize, astream.count);
|
|
mutex_unlock(&astream.lock);
|
|
break;
|
|
|
|
case PLAY_2_STOP:
|
|
if( active )
|
|
{
|
|
ResetBuffer(hBuff, SND_RESET_ALL);
|
|
audio_base = -1.0;
|
|
active = 0;
|
|
}
|
|
sound_state = STOP;
|
|
break;
|
|
|
|
case PLAY_2_PAUSE:
|
|
if( active )
|
|
{
|
|
StopBuffer(hBuff);
|
|
};
|
|
sound_state = PAUSE;
|
|
|
|
case PAUSE:
|
|
case STOP:
|
|
delay(1);
|
|
};
|
|
}
|
|
|
|
__sync_and_and_fetch(&threads_running,~AUDIO_THREAD);
|
|
|
|
StopBuffer(hBuff);
|
|
DestroyBuffer(hBuff);
|
|
|
|
return 0;
|
|
|
|
exit_whith_error:
|
|
|
|
printf(errstr);
|
|
return -1;
|
|
|
|
};
|
|
|