Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-06 11:36:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

finalize AirPlay sync

Browse Source
This commit is contained in:
philippe44
2019-08-20 13:18:43 -07:00
parent 6364ab5ee9
commit f547a52c1e
3 changed files with 57 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/raop/raop_sink.h
View File

@@ -16,7 +16,7 @@
typedef enum { RAOP_SETUP, RAOP_STREAM, RAOP_PLAY, RAOP_FLUSH, RAOP_PAUSE, RAOP_STOP, RAOP_VOLUME, RAOP_TIMING } raop_event_t ;
typedef void (*raop_cmd_cb_t)(raop_event_t event, void *param);
typedef void (*raop_data_cb_t)(const u8_t *data, size_t len);
typedef void (*raop_data_cb_t)(const u8_t *data, size_t len, u32_t playtime);
/**
* @brief init sink mode (need to be provided)

25
components/raop/rtp.c
View File

@@ -70,8 +70,10 @@
static log_level *loglevel = &raop_loglevel;
//#define __RTP_STORE
// default buffer size
#define BUFFER_FRAMES ( (150 * RAOP_SAMPLE_RATE * 2) / (352 * 100) )
#define MAX_PACKET 1408
#define MIN_LATENCY 11025
#define MAX_LATENCY ( (120 * RAOP_SAMPLE_RATE * 2) / 100 )
@@ -396,13 +398,13 @@ static void buffer_put_packet(rtp_t *ctx, seq_t seqno, unsigned rtptime, bool fi
pthread_mutex_lock(&ctx->ab_mutex);
if (!ctx->playing) {
if (!ctx->playing) {
if ((ctx->flush_seqno == -1 || seq_order(ctx->flush_seqno, seqno)) &&
(ctx->synchro.status & (RTP_SYNC | NTP_SYNC))) {
ctx->ab_write = seqno-1;
ctx->ab_read = seqno;
ctx->flush_seqno = -1;
ctx->playing = true;
ctx->playing = true;
ctx->resent_req = ctx->resent_rec = ctx->silent_frames = ctx->discarded = 0;
playtime = ctx->synchro.time + (((s32_t)(rtptime - ctx->synchro.rtp)) * 1000) / RAOP_SAMPLE_RATE;
ctx->cmd_cb(RAOP_PLAY, &playtime);
@@ -493,11 +495,11 @@ static void buffer_push_packet(rtp_t *ctx) {
if (now > playtime) {
LOG_DEBUG("[%p]: discarded frame now:%u missed by:%d (W:%hu R:%hu)", ctx, now, now - playtime, ctx->ab_write, ctx->ab_read);
ctx->discarded++;
ctx->discarded++;
} else if (curframe->ready) {
ctx->data_cb((const u8_t*) curframe->data, curframe->len, playtime);
curframe->ready = 0;
} else if (playtime - now <= hold) {
} else if (playtime - now <= hold) {
LOG_DEBUG("[%p]: created zero frame (W:%hu R:%hu)", ctx, ctx->ab_write, ctx->ab_read);
ctx->data_cb(silence_frame, ctx->frame_size * 4, playtime);
ctx->silent_frames++;
@@ -609,11 +611,15 @@ static void *rtp_thread_func(void *arg) {
}
// sync packet
case 0x54: {
u32_t rtp_now_latency = ntohl(*(u32_t*)(pktp+4));
u64_t remote = (((u64_t) ntohl(*(u32_t*)(pktp+8))) << 32) + ntohl(*(u32_t*)(pktp+12));
u32_t rtp_now = ntohl(*(u32_t*)(pktp+16));
u16_t flags = ntohs(*(u16_t*)(pktp+2));
pthread_mutex_lock(&ctx->ab_mutex);
// re-align timestamp and expected local playback time (and magic 11025 latency)
ctx->latency = rtp_now - rtp_now_latency;
if (flags == 7 || flags == 4) ctx->latency += 11025;
if (ctx->latency < MIN_LATENCY) ctx->latency = MIN_LATENCY;
@@ -635,6 +641,8 @@ static void *rtp_thread_func(void *arg) {
ctx, ctx->latency, rtp_now_latency, rtp_now, remote, ctx->synchro.time, ctx->synchro.rtp, gettime_ms());
if (!count--) {
rtp_request_timing(ctx);
count = 3;
}
if (ctx->synchro.status & (NTP_SYNC | RTP_SYNC)) ctx->cmd_cb(RAOP_TIMING, NULL);
@@ -661,11 +669,6 @@ static void *rtp_thread_func(void *arg) {
drifting
*/
expected = ctx->timing.remote + MS2NTP(reference - ctx->timing.local);
ctx->timing.remote = remote;
ctx->timing.local = reference;
if (ctx->synchro.status & NTP_SYNC) {
ctx->timing.remote = remote;
ctx->timing.local = reference;

57
components/squeezelite/decode_external.c
View File

@@ -39,8 +39,10 @@ extern log_level loglevel;
static raop_event_t raop_state;
static bool raop_expect_stop = false;
static struct {
s32_t total, count;
u32_t start_time, msplayed;
bool start;
s32_t error;
u32_t start_time;
u32_t playtime, len;
} raop_sync;
/****************************************************************************************
@@ -142,6 +144,17 @@ static void bt_sink_cmd_handler(bt_sink_cmd_t cmd, ...)
va_end(args);
}
/****************************************************************************************
* raop sink data handler
*/
static void raop_sink_data_handler(const uint8_t *data, uint32_t len, u32_t playtime) {
raop_sync.playtime = playtime;
raop_sync.len = len;
sink_data_handler(data, len);
}
/****************************************************************************************
* AirPlay sink command handler
*/
@@ -160,29 +173,40 @@ void raop_sink_cmd_handler(raop_event_t event, void *param)
// this is async, so player might have been deleted
switch (event) {
case RAOP_TIMING: {
u32_t now = gettime_ms();
u32_t ms, now = gettime_ms();
s32_t error;
if (output.state < OUTPUT_RUNNING || output.frames_played_dmp < output.device_frames) break;
raop_sync.total += *(s32_t*) param;
raop_sync.count++;
raop_sync.msplayed = now - output.updated + ((u64_t) (output.frames_played_dmp - output.device_frames) * 1000) / RAOP_SAMPLE_RATE;
error = raop_sync.msplayed - (now - raop_sync.start_time);
// first must make sure we started on time
if (raop_sync.start) {
// how many ms have we really played
ms = now - output.updated + ((u64_t) (output.frames_played_dmp - output.device_frames) * 1000) / RAOP_SAMPLE_RATE;
error = ms - (now - raop_sync.start_time);
LOG_INFO("backend played %u, desired %u, (delta:%d)", ms, now - raop_sync.start_time, error);
if (abs(error) < 10 && abs(raop_sync.error) < 10) raop_sync.start = false;
} else {
// in how many ms will the most recent block play (there is one extra block of FRAME_BLOCK == MAX_SILENCE_FRAMES which is not in queue and not in outputbuf)
ms = ((u64_t) ((_buf_used(outputbuf) - raop_sync.len) / BYTES_PER_FRAME + output.device_frames + MAX_SILENCE_FRAMES) * 1000) / RAOP_SAMPLE_RATE - (now - output.updated);
error = (raop_sync.playtime - now) - ms;
LOG_INFO("head local:%u, remote:%u (delta:%d)", ms, raop_sync.playtime - now, error);
//break;
}
LOG_INFO("now:%u updated:%u played_dmp:%u device:%u", now, output.updated, output.frames_played_dmp, output.device_frames);
LOG_INFO("backend played %u, desired %u, (delta:%d raop:%d)", raop_sync.msplayed, now - raop_sync.start_time, error, raop_sync.total / raop_sync.count);
if (error < -10) {
output.skip_frames = (abs(error) * RAOP_SAMPLE_RATE) / 1000;
if (error < -10 && raop_sync.error < -10) {
output.skip_frames = (abs(error + raop_sync.error) / 2 * RAOP_SAMPLE_RATE) / 1000;
output.state = OUTPUT_SKIP_FRAMES;
raop_sync.error = 0;
LOG_INFO("skipping %u frames", output.skip_frames);
} else if (error > 10) {
output.pause_frames = (abs(error) * RAOP_SAMPLE_RATE) / 1000;
} else if (error > 10 && raop_sync.error > 10) {
output.pause_frames = (abs(error + raop_sync.error) / 2 * RAOP_SAMPLE_RATE) / 1000;
output.state = OUTPUT_PAUSE_FRAMES;
raop_sync.error = 0;
LOG_INFO("pausing for %u frames", output.pause_frames);
}
raop_sync.error = error;
break;
}
case RAOP_SETUP:
@@ -192,7 +216,8 @@ void raop_sink_cmd_handler(raop_event_t event, void *param)
case RAOP_STREAM:
LOG_INFO("Stream", NULL);
raop_state = event;
raop_sync.total = raop_sync.count = 0;
raop_sync.error = 0;
raop_sync.start = true;
output.external = true;
output.next_sample_rate = RAOP_SAMPLE_RATE;
output.state = OUTPUT_STOPPED;
@@ -253,7 +278,7 @@ void register_other(void) {
#endif
#ifdef CONFIG_AIRPLAY_SINK
if (!strcasestr(output.device, "BT ")) {
raop_sink_init(raop_sink_cmd_handler, sink_data_handler);
raop_sink_init(raop_sink_cmd_handler, raop_sink_data_handler);
LOG_INFO("Initializing AirPlay sink");
} else {
LOG_WARN("Cannot be an AirPlay sink and BT source");