static void tcp_recv(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf)
{
uv_loop_t *loop = handle->loop;
struct worker_ctx *worker = loop->data;
/* Check for originator connection close. */
if (nread <= 0) {
if (handle->data) {
worker_exec(worker, (uv_handle_t *)handle, NULL, NULL);
}
if (!uv_is_closing((uv_handle_t *)handle)) {
uv_close((uv_handle_t *)handle, handle_free);
}
return;
}
int ret = worker_process_tcp(worker, (uv_handle_t *)handle, (const uint8_t *)buf->base, nread);
if (ret == 0) {
/* Push - pull, stop reading from this handle until
* the task is finished. Since the handle has no track of the
* pending tasks, it might be freed before the task finishes
* leading various errors. */
uv_unref((uv_handle_t *)handle);
io_stop_read((uv_handle_t *)handle);
}
mp_flush(worker->pkt_pool.ctx);
}
static void
video_seek(rtmp_t *r, media_pipe_t *mp, media_buf_t **mbp,
int64_t pos, const char *txt)
{
if(pos < 0)
pos = 0;
TRACE(TRACE_DEBUG, "Video", "seek %s to %.2f", txt, pos / 1000000.0);
RTMP_SendSeek(r->r, pos / 1000);
r->seekpos_video = pos;
r->seekpos_audio = pos;
mp->mp_video.mq_seektarget = pos;
mp->mp_audio.mq_seektarget = pos;
mp_flush(mp);
if(mbp != NULL && *mbp != NULL) {
media_buf_free_unlocked(mp, *mbp);
*mbp = NULL;
}
prop_set_float(prop_create(mp->mp_prop_root, "seektime"), pos / 1000000.0);
}
static int64_t
video_seek(rtmp_t *r, media_pipe_t *mp, media_buf_t **mbp,
int64_t pos, int backward, const char *txt)
{
if(pos < 0)
pos = 0;
TRACE(TRACE_DEBUG, "Video", "seek %s to %.2f", txt, pos / 1000000.0);
RTMP_SendSeek(r->r, pos / 1000);
r->seekpos = pos;
mp->mp_video.mq_seektarget = pos;
mp->mp_audio.mq_seektarget = pos;
mp_flush(mp, 0);
if(mbp != NULL && *mbp != NULL) {
media_buf_free(*mbp);
*mbp = NULL;
}
prop_set_float(prop_create(mp->mp_prop_root, "seektime"), pos / 1000000.0);
r->lastsubpts = AV_NOPTS_VALUE;
return pos;
}
static void tcp_recv(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf)
{
uv_loop_t *loop = handle->loop;
struct session *s = handle->data;
struct worker_ctx *worker = loop->data;
/* TCP pipelining is rather complicated and requires cooperation from the worker
* so the whole message reassembly and demuxing logic is inside worker */
int ret = 0;
if (s->has_tls) {
ret = tls_process(worker, handle, (const uint8_t *)buf->base, nread);
} else {
ret = worker_process_tcp(worker, handle, (const uint8_t *)buf->base, nread);
}
if (ret < 0) {
worker_end_tcp(worker, (uv_handle_t *)handle);
/* Exceeded per-connection quota for outstanding requests
* stop reading from stream and close after last message is processed. */
if (!s->outgoing && !uv_is_closing((uv_handle_t *)&s->timeout)) {
uv_timer_stop(&s->timeout);
if (s->tasks.len == 0) {
uv_close((uv_handle_t *)&s->timeout, tcp_timeout);
} else { /* If there are tasks running, defer until they finish. */
uv_timer_start(&s->timeout, tcp_timeout_trigger, 1, KR_CONN_RTT_MAX/2);
}
}
/* Connection spawned more than one request, reset its deadline for next query. */
} else if (ret > 0 && !s->outgoing) {
uv_timer_again(&s->timeout);
}
mp_flush(worker->pkt_pool.ctx);
}
static void
seekflush(media_pipe_t *mp, media_buf_t **mbp)
{
mp_flush(mp, 0);
if(*mbp != NULL && *mbp != MB_SPECIAL_EOF)
media_buf_free_unlocked(mp, *mbp);
*mbp = NULL;
}
static void
seekflush(media_pipe_t *mp, media_buf_t **mbp)
{
mp_flush(mp, 0);
if(*mbp != NULL) {
media_buf_free_unlocked(mp, *mbp);
*mbp = NULL;
}
}
static event_t *
rtmp_playvideo(const char *url0, media_pipe_t *mp,
int flags, int priority,
char *errbuf, size_t errlen,
const char *mimetype)
{
rtmp_t r = {0};
event_t *e;
char *url = mystrdupa(url0);
prop_set_string(mp->mp_prop_type, "video");
RTMP_LogSetLevel(RTMP_LOGINFO);
r.r = RTMP_Alloc();
RTMP_Init(r.r);
if(!RTMP_SetupURL(r.r, url)) {
snprintf(errbuf, errlen, "Unable to setup RTMP-session");
rtmp_free(&r);
return NULL;
}
if(!RTMP_Connect(r.r, NULL)) {
snprintf(errbuf, errlen, "Unable to connect RTMP-session");
rtmp_free(&r);
return NULL;
}
if(!RTMP_ConnectStream(r.r, 0)) {
snprintf(errbuf, errlen, "Unable to connect RTMP-stream");
rtmp_free(&r);
return NULL;
}
mp->mp_audio.mq_stream = 0;
mp->mp_video.mq_stream = 0;
mp_configure(mp, MP_PLAY_CAPS_PAUSE, MP_BUFFER_DEEP);
mp->mp_max_realtime_delay = (r.r->Link.timeout - 1) * 1000000;
mp_become_primary(mp);
e = rtmp_loop(&r, mp, url, errbuf, errlen);
mp_flush(mp, 0);
mp_shutdown(mp);
TRACE(TRACE_DEBUG, "RTMP", "End of stream");
rtmp_free(&r);
return e;
}
static int tcp_event_serve(tcp_context_t *tcp, unsigned i)
{
int fd = tcp->set.pfd[i].fd;
int ret = tcp_handle(tcp, fd, &tcp->iov[0], &tcp->iov[1]);
/* Flush per-query memory. */
mp_flush(tcp->overlay.mm->ctx);
if (ret == KNOT_EOK) {
/* Update socket activity timer. */
rcu_read_lock();
fdset_set_watchdog(&tcp->set, i, conf()->max_conn_idle);
rcu_read_unlock();
}
return ret;
}
void udp_recv(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf,
const struct sockaddr *addr, unsigned flags)
{
uv_loop_t *loop = handle->loop;
struct worker_ctx *worker = loop->data;
if (nread <= 0) {
if (nread < 0) { /* Error response, notify resolver */
worker_submit(worker, (uv_handle_t *)handle, NULL, addr);
} /* nread == 0 is for freeing buffers, we don't need to do this */
return;
}
knot_pkt_t *query = knot_pkt_new(buf->base, nread, &worker->pkt_pool);
if (query) {
query->max_size = KNOT_WIRE_MAX_PKTSIZE;
worker_submit(worker, (uv_handle_t *)handle, query, addr);
}
mp_flush(worker->pkt_pool.ctx);
}
event_t *
fa_xmp_playfile(media_pipe_t *mp, FILE *f, char *errbuf, size_t errlen,
int hold, const char *url, size_t size)
{
event_t *e = NULL;
xmp_context ctx = xmp_create_context();
// struct xmp_module_info mi;
struct xmp_frame_info fi;
char *u = mystrdupa(url);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, MP_CAN_PAUSE | MP_CAN_SEEK,
MP_BUFFER_SHALLOW, 0, "tracks");
mp_become_primary(mp);
if(xmp_load_modulef(ctx, f, u, size) >= 0) {
if(xmp_start_player(ctx, 44100, 0) == 0) {
media_buf_t *mb = NULL;
media_queue_t *mq = &mp->mp_audio;
while(1) {
if(mb == NULL) {
if(xmp_play_frame(ctx)) {
e = event_create_type(EVENT_EOF);
break;
}
xmp_get_frame_info(ctx, &fi);
if(fi.loop_count > 0) {
e = event_create_type(EVENT_EOF);
break;
}
mb = media_buf_alloc_unlocked(mp, fi.buffer_size);
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_rate = 44100;
mb->mb_pts = fi.time * 1000;
mb->mb_drive_clock = 1;
memcpy(mb->mb_data, fi.buffer, fi.buffer_size);
mp_set_duration(mp, fi.total_time * 1000);
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_action(e, ACTION_SKIP_BACKWARD) ||
event_is_action(e, ACTION_SKIP_FORWARD) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
xmp_end_player(ctx);
} else {
snprintf(errbuf, errlen, "XMP failed to start");
}
} else {
snprintf(errbuf, errlen, "XMP Loading error");
}
// prop_ref_dec(dur);
xmp_free_context(ctx);
return e;
}
static event_t *
fa_gme_playfile_internal(media_pipe_t *mp, const void *buf, size_t size,
char *errbuf, size_t errlen, int hold, int track,
const char *url)
{
media_queue_t *mq = &mp->mp_audio;
Music_Emu *emu;
gme_err_t err;
int sample_rate = 48000;
media_buf_t *mb = NULL;
event_t *e;
int registered_play = 0;
err = gme_open_data(buf, size, &emu, sample_rate);
if(err != NULL) {
snprintf(errbuf, errlen, "Unable to load file -- %s", err);
return NULL;
}
gme_start_track(emu, track);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, MP_PLAY_CAPS_PAUSE | MP_PLAY_CAPS_SEEK,
MP_BUFFER_SHALLOW, 0);
mp_become_primary(mp);
while(1) {
if(gme_track_ended(emu)) {
e = event_create_type(EVENT_EOF);
break;
}
if(mb == NULL) {
mb = media_buf_alloc_unlocked(mp, sizeof(int16_t) * CHUNK_SIZE * 2);
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_rate = sample_rate;
mb->mb_pts = gme_tell(emu) * 1000;
mb->mb_drive_clock = 1;
if(!registered_play && mb->mb_pts > METADB_AUDIO_PLAY_THRESHOLD) {
registered_play = 1;
metadb_register_play(url, 1, CONTENT_AUDIO);
}
gme_play(emu, CHUNK_SIZE * mb->mb_channels, mb->mb_data);
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_type(e, EVENT_SEEK)) {
event_ts_t *ets = (event_ts_t *)e;
gme_seek(emu, ets->ts / 1000);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SKIP_BACKWARD) ||
event_is_action(e, ACTION_SKIP_FORWARD) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
gme_delete(emu);
if(mb != NULL)
media_buf_free_unlocked(mp, mb);
return e;
}
static event_t *
rtmp_loop(rtmp_t *r, media_pipe_t *mp, char *url, char *errbuf, size_t errlen)
{
RTMPPacket p = {0};
int pos = -1, ret;
uint32_t dts;
event_t *e = NULL;
mp_set_playstatus_by_hold(mp, 0, NULL);
while(1) {
if(pos == -1) {
mp->mp_eof = 0;
ret = RTMP_GetNextMediaPacket(r->r, &p);
if(ret == 2) {
/* Wait for queues to drain */
mp->mp_eof = 1;
again:
e = mp_wait_for_empty_queues(mp);
if(e != NULL) {
e = rtmp_process_event(r, e, NULL);
if(e == NULL)
goto again;
}
mp_set_playstatus_stop(mp);
if(e == NULL)
e = event_create_type(EVENT_EOF);
break;
}
if(ret == 0) {
RTMP_Close(r->r);
RTMP_Init(r->r);
memset(&p, 0, sizeof(p));
TRACE(TRACE_DEBUG, "RTMP", "Reconnecting stream at pos %d",
r->seekbase);
if(!RTMP_SetupURL(r->r, url)) {
snprintf(errbuf, errlen, "Unable to setup RTMP session");
e = NULL;
break;
}
if(!RTMP_Connect(r->r, NULL)) {
snprintf(errbuf, errlen, "Unable to connect RTMP session");
e = NULL;
break;
}
if(!RTMP_ConnectStream(r->r, r->can_seek ? r->seekbase / 1000 : 0)) {
snprintf(errbuf, errlen, "Unable to stream RTMP session");
return NULL;
}
r->epoch++;
r->lastdts = 0;
r->seekbase = AV_NOPTS_VALUE;
mp_flush(mp, 0);
continue;
}
dts = p.m_nTimeStamp;
switch(p.m_packetType) {
case RTMP_PACKET_TYPE_INFO:
if(handle_metadata(r, p.m_body, p.m_nBodySize, mp, errbuf, errlen)) {
RTMPPacket_Free(&p);
return NULL;
}
break;
case RTMP_PACKET_TYPE_VIDEO:
e = get_packet_v(r, (void *)p.m_body, p.m_nBodySize, dts, mp);
break;
case RTMP_PACKET_TYPE_AUDIO:
e = get_packet_a(r, (void *)p.m_body, p.m_nBodySize, dts, mp);
break;
case 0x16:
pos = 0;
break;
default:
TRACE(TRACE_DEBUG, "RTMP",
"Got unknown packet type %d\n", p.m_packetType);
break;
}
if(pos == -1)
RTMPPacket_Free(&p);
}
if(pos != -1) {
if(pos + 11 < p.m_nBodySize) {
uint32_t ds = AMF_DecodeInt24(p.m_body + pos + 1);
if(pos + 11 + ds + 4 > p.m_nBodySize) {
snprintf(errbuf, errlen, "Corrupt stream");
RTMPPacket_Free(&p);
return NULL;
}
dts = AMF_DecodeInt24(p.m_body + pos + 4);
dts |= (p.m_body[pos + 7] << 24);
if(p.m_body[pos] == RTMP_PACKET_TYPE_INFO) {
if(handle_metadata(r, p.m_body, p.m_nBodySize, mp, errbuf, errlen)) {
RTMPPacket_Free(&p);
return NULL;
}
} else if(p.m_body[pos] == RTMP_PACKET_TYPE_VIDEO) {
e = get_packet_v(r, (void *)p.m_body + pos + 11, ds, dts, mp);
} else if(p.m_body[pos] == RTMP_PACKET_TYPE_AUDIO) {
e = get_packet_a(r, (void *)p.m_body + pos + 11, ds, dts, mp);
} else {
TRACE(TRACE_DEBUG, "RTMP",
"Got unknown packet type %d\n", p.m_body[pos]);
}
pos += 11 + ds + 4;
} else {
pos = -1;
RTMPPacket_Free(&p);
}
}
if(e != NULL)
break;
}
return e;
}
/**
* Play given track.
*
* We only expect this to be called from the playqueue system.
*/
static event_t *
be_sid2player_play(const char *url0, media_pipe_t *mp,
char *errbuf, size_t errlen, int hold,
const char *mimetype)
{
media_queue_t *mq = &mp->mp_audio;
char *url, *p;
int sample = 0;
media_buf_t *mb = NULL;
event_t *e;
int subsong;
int registered_play = 0;
void *player;
url0 += strlen("sidplayer:");
url = mystrdupa(url0);
p = strrchr(url, '/');
if(p == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return NULL;
}
*p++= 0;
subsong = atoi(p);
buf_t *b;
if((b = fa_load(url, NULL, errbuf, errlen, NULL, 0,
NULL, NULL)) == NULL)
return NULL;
player = sidcxx_load(b->b_ptr, b->b_size, subsong, errbuf, errlen);
buf_release(b);
if(player == NULL)
return NULL;
mp_set_playstatus_by_hold(mp, hold, NULL);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, MP_PLAY_CAPS_PAUSE, MP_BUFFER_NONE, 0);
mp_become_primary(mp);
while(1) {
if(mb == NULL) {
mb = media_buf_alloc_unlocked(mp, sizeof(int16_t) * CHUNK_SIZE * 2);
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_rate = 44100;
mb->mb_pts = sample * 1000000LL / mb->mb_rate;
mb->mb_drive_clock = 1;
if(!registered_play && mb->mb_pts > METADB_AUDIO_PLAY_THRESHOLD) {
registered_play = 1;
metadb_register_play(url0, 1, CONTENT_AUDIO);
}
sample += CHUNK_SIZE;
int16_t *samples = mb->mb_data;
sidcxx_play(player, samples,
CHUNK_SIZE * sizeof(int16_t) * mb->mb_channels);
// Crossmix 25%
int i, l, r, L, R;
for(i = 0; i < CHUNK_SIZE; i++) {
l = samples[i * 2 + 0];
r = samples[i * 2 + 1];
L = 3 * l + r * 2;
R = 3 * r + l * 2;
L = L / 4;
R = R / 4;
if(L > 32767)
L = 32767;
if(L < -32768)
L = -32768;
if(R > 32767)
R = 32767;
if(R < -32768)
R = -32768;
samples[i * 2 + 0] = L;
samples[i * 2 + 1] = R;
}
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_action(e, ACTION_SKIP_BACKWARD) ||
event_is_action(e, ACTION_SKIP_FORWARD) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
sidcxx_stop(player);
return e;
}
static event_t *
rtmp_playvideo(const char *url0, media_pipe_t *mp,
int flags, int priority,
char *errbuf, size_t errlen,
const char *mimetype,
const char *canonical_url)
{
rtmp_t r = {0};
event_t *e;
char *url = mystrdupa(url0);
prop_set_string(mp->mp_prop_type, "video");
RTMP_LogSetLevel(RTMP_LOGINFO);
r.r = RTMP_Alloc();
RTMP_Init(r.r);
int64_t start = video_get_restartpos(canonical_url);
if(!RTMP_SetupURL(r.r, url)) {
snprintf(errbuf, errlen, "Unable to setup RTMP-session");
rtmp_free(&r);
return NULL;
}
if(!RTMP_Connect(r.r, NULL)) {
snprintf(errbuf, errlen, "Unable to connect RTMP-session");
rtmp_free(&r);
return NULL;
}
if(!RTMP_ConnectStream(r.r, start)) {
snprintf(errbuf, errlen, "Unable to connect RTMP-stream");
rtmp_free(&r);
return NULL;
}
r.seek_origin = start;
r.mp = mp;
r.hold = 0;
r.lost_focus = 0;
r.epoch = 1;
mp->mp_audio.mq_stream = 0;
mp->mp_video.mq_stream = 0;
if(start > 0) {
r.seekpos = start * 1000;
r.seekbase = r.seekpos;
mp->mp_video.mq_seektarget = r.seekpos;
mp->mp_audio.mq_seektarget = r.seekpos;
} else {
mp->mp_video.mq_seektarget = AV_NOPTS_VALUE;
mp->mp_audio.mq_seektarget = AV_NOPTS_VALUE;
r.seekbase = AV_NOPTS_VALUE;
r.seekpos = AV_NOPTS_VALUE;
}
mp_configure(mp, MP_PLAY_CAPS_PAUSE, MP_BUFFER_DEEP);
mp->mp_max_realtime_delay = (r.r->Link.timeout - 1) * 1000000;
mp_become_primary(mp);
metadb_register_play(canonical_url, 0, CONTENT_VIDEO);
r.canonical_url = canonical_url;
r.restartpos_last = -1;
e = rtmp_loop(&r, mp, url, errbuf, errlen);
if(r.total_duration) {
int p = r.seekbase / (r.total_duration * 10);
if(p >= video_settings.played_threshold) {
TRACE(TRACE_DEBUG, "RTMP", "Playback reached %d%%, counting as played",
p);
metadb_register_play(canonical_url, 1, CONTENT_VIDEO);
metadb_set_video_restartpos(canonical_url, -1);
}
}
mp_flush(mp, 0);
mp_shutdown(mp);
TRACE(TRACE_DEBUG, "RTMP", "End of stream");
rtmp_free(&r);
return e;
}
static event_t *
rtmp_playvideo(const char *url0, media_pipe_t *mp,
char *errbuf, size_t errlen,
video_queue_t *vq, struct vsource_list *vsl,
const video_args_t *va0)
{
video_args_t va = *va0;
rtmp_t r = {0};
event_t *e;
char *url = mystrdupa(url0);
va.flags |= BACKEND_VIDEO_NO_FS_SCAN;
prop_set_string(mp->mp_prop_type, "video");
rtmp_log_level = RTMP_LOGINFO;
RTMP_LogSetLevel(rtmp_log_level);
r.r = RTMP_Alloc();
RTMP_Init(r.r);
int64_t start = 0;
if(va.flags & BACKEND_VIDEO_RESUME ||
(video_settings.resume_mode == VIDEO_RESUME_YES &&
!(va.flags & BACKEND_VIDEO_START_FROM_BEGINNING)))
start = video_get_restartpos(va.canonical_url);
if(!RTMP_SetupURL(r.r, url)) {
snprintf(errbuf, errlen, "Unable to setup RTMP-session");
rtmp_free(&r);
return NULL;
}
r.r->Link.lFlags |= RTMP_LF_SWFV;
if(!RTMP_Connect(r.r, NULL)) {
snprintf(errbuf, errlen, "Unable to connect RTMP-session");
rtmp_free(&r);
return NULL;
}
if(!RTMP_ConnectStream(r.r, 0)) {
snprintf(errbuf, errlen, "Unable to connect RTMP-stream");
rtmp_free(&r);
return NULL;
}
if(start)
RTMP_SendSeek(r.r, start);
r.mp = mp;
mp->mp_audio.mq_stream = 0;
mp->mp_video.mq_stream = 0;
if(start > 0) {
r.seekpos_video = start * 1000;
r.seekpos_audio = start * 1000;
mp->mp_seek_base = r.seekpos_video;
mp->mp_video.mq_seektarget = r.seekpos_video;
mp->mp_audio.mq_seektarget = r.seekpos_video;
} else {
mp->mp_video.mq_seektarget = AV_NOPTS_VALUE;
mp->mp_audio.mq_seektarget = AV_NOPTS_VALUE;
mp->mp_seek_base = 0;
r.seekpos_audio = AV_NOPTS_VALUE;
r.seekpos_video = AV_NOPTS_VALUE;
}
mp_configure(mp, MP_PLAY_CAPS_PAUSE, MP_BUFFER_DEEP, 0);
mp->mp_max_realtime_delay = (r.r->Link.timeout - 1) * 1000000;
mp_become_primary(mp);
metadb_register_play(va.canonical_url, 0, CONTENT_VIDEO);
r.canonical_url = va.canonical_url;
r.restartpos_last = -1;
sub_scanner_t *ss =
sub_scanner_create(url, mp->mp_prop_subtitle_tracks, &va, 0);
e = rtmp_loop(&r, mp, url, errbuf, errlen);
sub_scanner_destroy(ss);
if(r.total_duration) {
int p = mp->mp_seek_base / (r.total_duration * 10);
if(p >= video_settings.played_threshold) {
TRACE(TRACE_DEBUG, "RTMP", "Playback reached %d%%, counting as played",
p);
metadb_register_play(va.canonical_url, 1, CONTENT_VIDEO);
metadb_set_video_restartpos(va.canonical_url, -1);
}
}
mp_flush(mp, 0);
mp_shutdown(mp);
TRACE(TRACE_DEBUG, "RTMP", "End of stream");
rtmp_free(&r);
return e;
}
event_t *
be_file_playaudio(const char *url, media_pipe_t *mp,
char *errbuf, size_t errlen, int hold)
{
AVFormatContext *fctx;
AVIOContext *avio;
AVCodecContext *ctx;
AVPacket pkt;
media_format_t *fw;
int i, r, si;
media_buf_t *mb = NULL;
media_queue_t *mq;
event_ts_t *ets;
int64_t ts, pts4seek = 0;
media_codec_t *cw;
event_t *e;
int lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
if((avio = fa_libav_open(url, 32768, errbuf, errlen)) == NULL)
return NULL;
// First we need to check for a few other formats
#if ENABLE_LIBOPENSPC || ENABLE_LIBGME
uint8_t pb[128];
size_t psiz;
psiz = avio_read(avio, pb, sizeof(pb));
if(psiz < sizeof(pb)) {
fa_libav_close(avio);
snprintf(errbuf, errlen, "Fill too small");
return NULL;
}
#if ENABLE_LIBGME
if(*gme_identify_header(pb))
return fa_gme_playfile(mp, avio, errbuf, errlen, hold);
#endif
#if ENABLE_LIBOPENSPC
if(!memcmp(pb, "SNES-SPC700 Sound File Data", 27))
return openspc_play(mp, avio, errbuf, errlen);
#endif
#endif
if((fctx = fa_libav_open_format(avio, url, errbuf, errlen)) == NULL) {
fa_libav_close(avio);
return NULL;
}
TRACE(TRACE_DEBUG, "Audio", "Starting playback of %s", url);
mp_set_play_caps(mp, MP_PLAY_CAPS_SEEK | MP_PLAY_CAPS_PAUSE);
mp->mp_audio.mq_stream = -1;
mp->mp_video.mq_stream = -1;
fw = media_format_create(fctx);
cw = NULL;
for(i = 0; i < fctx->nb_streams; i++) {
ctx = fctx->streams[i]->codec;
if(ctx->codec_type != AVMEDIA_TYPE_AUDIO)
continue;
cw = media_codec_create(ctx->codec_id, 0, fw, ctx, NULL, mp);
mp->mp_audio.mq_stream = i;
break;
}
if(cw == NULL) {
media_format_deref(fw);
snprintf(errbuf, errlen, "Unable to open codec");
return NULL;
}
mp_become_primary(mp);
mq = &mp->mp_audio;
while(1) {
/**
* Need to fetch a new packet ?
*/
if(mb == NULL) {
if((r = av_read_frame(fctx, &pkt)) < 0) {
while((e = mp_wait_for_empty_queues(mp, 0)) != NULL) {
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP) ||
event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
if(e == NULL)
e = event_create_type(EVENT_EOF);
break;
}
si = pkt.stream_index;
if(si == mp->mp_audio.mq_stream) {
/* Current audio stream */
mb = media_buf_alloc();
mb->mb_data_type = MB_AUDIO;
} else {
/* Check event queue ? */
av_free_packet(&pkt);
continue;
}
mb->mb_pts = rescale(fctx, pkt.pts, si);
mb->mb_dts = rescale(fctx, pkt.dts, si);
mb->mb_duration = rescale(fctx, pkt.duration, si);
mb->mb_cw = media_codec_ref(cw);
/* Move the data pointers from ffmpeg's packet */
mb->mb_stream = pkt.stream_index;
av_dup_packet(&pkt);
mb->mb_data = pkt.data;
pkt.data = NULL;
mb->mb_size = pkt.size;
pkt.size = 0;
if(mb->mb_pts != AV_NOPTS_VALUE) {
if(fctx->start_time == AV_NOPTS_VALUE)
mb->mb_time = mb->mb_pts;
else
mb->mb_time = mb->mb_pts - fctx->start_time;
pts4seek = mb->mb_time;
} else
mb->mb_time = AV_NOPTS_VALUE;
av_free_packet(&pkt);
}
/*
* Try to send the buffer. If mb_enqueue() returns something we
* catched an event instead of enqueueing the buffer. In this case
* 'mb' will be left untouched.
*/
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_type(e, EVENT_SEEK)) {
ets = (event_ts_t *)e;
ts = ets->pts + fctx->start_time;
if(ts < fctx->start_time)
ts = fctx->start_time;
av_seek_frame(fctx, -1, ts, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FAST_BACKWARD)) {
av_seek_frame(fctx, -1, pts4seek - 60000000, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_BACKWARD)) {
av_seek_frame(fctx, -1, pts4seek - 15000000, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FAST_FORWARD)) {
av_seek_frame(fctx, -1, pts4seek + 60000000, 0);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FORWARD)) {
av_seek_frame(fctx, -1, pts4seek + 15000000, 0);
seekflush(mp, &mb);
#if 0
} else if(event_is_action(e, ACTION_RESTART_TRACK)) {
av_seek_frame(fctx, -1, 0, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
#endif
} else if(event_is_action(e, ACTION_PLAYPAUSE) ||
event_is_action(e, ACTION_PLAY) ||
event_is_action(e, ACTION_PAUSE)) {
hold = action_update_hold_by_event(hold, e);
mp_send_cmd_head(mp, mq, hold ? MB_CTRL_PAUSE : MB_CTRL_PLAY);
lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
} else if(event_is_type(e, EVENT_MP_NO_LONGER_PRIMARY)) {
hold = 1;
lost_focus = 1;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_type(e, EVENT_MP_IS_PRIMARY)) {
if(lost_focus) {
hold = 0;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, hold, NULL);
}
} else if(event_is_type(e, EVENT_INTERNAL_PAUSE)) {
hold = 1;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
if(mb != NULL)
media_buf_free(mb);
media_codec_deref(cw);
media_format_deref(fw);
if(hold) {
// If we were paused, release playback again.
mp_send_cmd(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, 0, NULL);
}
return e;
}
static event_t *
fa_gme_playfile_internal(media_pipe_t *mp, void *fh,
char *errbuf, size_t errlen, int hold, int track)
{
media_queue_t *mq = &mp->mp_audio;
Music_Emu *emu;
gme_err_t err;
char *buf;
int lost_focus = 0;
size_t size, r;
int sample_rate = 48000;
media_buf_t *mb = NULL;
event_t *e;
size = fa_fsize(fh);
buf = malloc(size);
r = fa_read(fh, buf, size);
if(r != size) {
snprintf(errbuf, errlen, "Unable to read file");
free(buf);
return NULL;
}
err = gme_open_data(buf, size, &emu, sample_rate);
free(buf);
if(err != NULL) {
snprintf(errbuf, errlen, "Unable to load file -- %s", err);
return NULL;
}
gme_start_track(emu, track);
mp_set_playstatus_by_hold(mp, hold, NULL);
mp->mp_audio.mq_stream = 0;
mp_set_play_caps(mp, MP_PLAY_CAPS_PAUSE | MP_PLAY_CAPS_SEEK);
mp_become_primary(mp);
while(1) {
if(gme_track_ended(emu)) {
e = event_create_type(EVENT_EOF);
break;
}
if(mb == NULL) {
mb = media_buf_alloc();
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_size = sizeof(int16_t) * CHUNK_SIZE * mb->mb_channels;
mb->mb_data = malloc(mb->mb_size);
mb->mb_rate = sample_rate;
mb->mb_time = gme_tell(emu) * 1000;
gme_play(emu, CHUNK_SIZE * mb->mb_channels, mb->mb_data);
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_type(e, EVENT_SEEK)) {
event_ts_t *ets = (event_ts_t *)e;
gme_seek(emu, ets->pts / 1000);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FAST_BACKWARD)) {
deltaseek(mp, &mb, emu, -60000);
} else if(event_is_action(e, ACTION_SEEK_BACKWARD)) {
deltaseek(mp, &mb, emu, -15000);
} else if(event_is_action(e, ACTION_SEEK_FAST_FORWARD)) {
deltaseek(mp, &mb, emu, 60000);
} else if(event_is_action(e, ACTION_SEEK_FORWARD)) {
deltaseek(mp, &mb, emu, 15000);
} else if(event_is_action(e, ACTION_PLAYPAUSE) ||
event_is_action(e, ACTION_PLAY) ||
event_is_action(e, ACTION_PAUSE)) {
hold = action_update_hold_by_event(hold, e);
mp_send_cmd_head(mp, mq, hold ? MB_CTRL_PAUSE : MB_CTRL_PLAY);
lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
} else if(event_is_type(e, EVENT_MP_NO_LONGER_PRIMARY)) {
hold = 1;
lost_focus = 1;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_type(e, EVENT_MP_IS_PRIMARY)) {
if(lost_focus) {
hold = 0;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, hold, NULL);
}
} else if(event_is_type(e, EVENT_INTERNAL_PAUSE)) {
hold = 1;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
gme_delete(emu);
if(mb != NULL)
media_buf_free(mb);
if(hold) {
// If we were paused, release playback again.
mp_send_cmd(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, 0, NULL);
}
return e;
}
event_t *
be_file_playaudio(const char *url, media_pipe_t *mp,
char *errbuf, size_t errlen, int hold, const char *mimetype)
{
AVFormatContext *fctx;
AVCodecContext *ctx;
AVPacket pkt;
media_format_t *fw;
int i, r, si;
media_buf_t *mb = NULL;
media_queue_t *mq;
event_ts_t *ets;
int64_t ts, seekbase = 0;
media_codec_t *cw;
event_t *e;
int lost_focus = 0;
int registered_play = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
fa_handle_t *fh = fa_open_ex(url, errbuf, errlen, FA_BUFFERED_SMALL, NULL);
if(fh == NULL)
return NULL;
// First we need to check for a few other formats
#if ENABLE_LIBOPENSPC || ENABLE_LIBGME
uint8_t pb[128];
size_t psiz;
psiz = fa_read(fh, pb, sizeof(pb));
if(psiz < sizeof(pb)) {
fa_close(fh);
snprintf(errbuf, errlen, "Fill too small");
return NULL;
}
#if ENABLE_LIBGME
if(*gme_identify_header(pb))
return fa_gme_playfile(mp, fh, errbuf, errlen, hold, url);
#endif
#if ENABLE_LIBOPENSPC
if(!memcmp(pb, "SNES-SPC700 Sound File Data", 27))
return openspc_play(mp, fh, errbuf, errlen);
#endif
#endif
AVIOContext *avio = fa_libav_reopen(fh);
if(avio == NULL) {
fa_close(fh);
return NULL;
}
if((fctx = fa_libav_open_format(avio, url,
errbuf, errlen, mimetype)) == NULL) {
fa_libav_close(avio);
return NULL;
}
TRACE(TRACE_DEBUG, "Audio", "Starting playback of %s", url);
mp_configure(mp, MP_PLAY_CAPS_SEEK | MP_PLAY_CAPS_PAUSE,
MP_BUFFER_SHALLOW);
mp->mp_audio.mq_stream = -1;
mp->mp_video.mq_stream = -1;
fw = media_format_create(fctx);
cw = NULL;
for(i = 0; i < fctx->nb_streams; i++) {
ctx = fctx->streams[i]->codec;
if(ctx->codec_type != AVMEDIA_TYPE_AUDIO)
continue;
cw = media_codec_create(ctx->codec_id, 0, fw, ctx, NULL, mp);
mp->mp_audio.mq_stream = i;
break;
}
if(cw == NULL) {
media_format_deref(fw);
snprintf(errbuf, errlen, "Unable to open codec");
return NULL;
}
mp_become_primary(mp);
mq = &mp->mp_audio;
while(1) {
/**
* Need to fetch a new packet ?
*/
if(mb == NULL) {
mp->mp_eof = 0;
r = av_read_frame(fctx, &pkt);
if(r == AVERROR(EAGAIN))
continue;
if(r == AVERROR_EOF || r == AVERROR(EIO)) {
mb = MB_SPECIAL_EOF;
mp->mp_eof = 1;
continue;
}
if(r != 0) {
char msg[100];
fa_ffmpeg_error_to_txt(r, msg, sizeof(msg));
TRACE(TRACE_ERROR, "Audio", "Playback error: %s", msg);
while((e = mp_wait_for_empty_queues(mp)) != NULL) {
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP) ||
event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
if(e == NULL)
e = event_create_type(EVENT_EOF);
break;
}
si = pkt.stream_index;
if(si != mp->mp_audio.mq_stream) {
av_free_packet(&pkt);
continue;
}
mb = media_buf_alloc_unlocked(mp, pkt.size);
mb->mb_data_type = MB_AUDIO;
mb->mb_pts = rescale(fctx, pkt.pts, si);
mb->mb_dts = rescale(fctx, pkt.dts, si);
mb->mb_duration = rescale(fctx, pkt.duration, si);
mb->mb_cw = media_codec_ref(cw);
/* Move the data pointers from ffmpeg's packet */
mb->mb_stream = pkt.stream_index;
memcpy(mb->mb_data, pkt.data, pkt.size);
if(mb->mb_pts != AV_NOPTS_VALUE) {
if(fctx->start_time == AV_NOPTS_VALUE)
mb->mb_time = mb->mb_pts;
else
mb->mb_time = mb->mb_pts - fctx->start_time;
} else
mb->mb_time = AV_NOPTS_VALUE;
mb->mb_send_pts = 1;
av_free_packet(&pkt);
}
/*
* Try to send the buffer. If mb_enqueue() returns something we
* catched an event instead of enqueueing the buffer. In this case
* 'mb' will be left untouched.
*/
if(mb == MB_SPECIAL_EOF) {
// We have reached EOF, drain queues
e = mp_wait_for_empty_queues(mp);
if(e == NULL) {
e = event_create_type(EVENT_EOF);
break;
}
} else if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_type(e, EVENT_CURRENT_PTS)) {
ets = (event_ts_t *)e;
seekbase = ets->ts;
if(registered_play == 0) {
if(ets->ts - fctx->start_time > METADB_AUDIO_PLAY_THRESHOLD) {
registered_play = 1;
metadb_register_play(url, 1, CONTENT_AUDIO);
}
}
} else if(event_is_type(e, EVENT_SEEK)) {
ets = (event_ts_t *)e;
ts = ets->ts + fctx->start_time;
if(ts < fctx->start_time)
ts = fctx->start_time;
av_seek_frame(fctx, -1, ts, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FAST_BACKWARD)) {
av_seek_frame(fctx, -1, seekbase - 60000000, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_BACKWARD)) {
av_seek_frame(fctx, -1, seekbase - 15000000, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FAST_FORWARD)) {
av_seek_frame(fctx, -1, seekbase + 60000000, 0);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FORWARD)) {
av_seek_frame(fctx, -1, seekbase + 15000000, 0);
seekflush(mp, &mb);
#if 0
} else if(event_is_action(e, ACTION_RESTART_TRACK)) {
av_seek_frame(fctx, -1, 0, AVSEEK_FLAG_BACKWARD);
seekflush(mp, &mb);
#endif
} else if(event_is_action(e, ACTION_PLAYPAUSE) ||
event_is_action(e, ACTION_PLAY) ||
event_is_action(e, ACTION_PAUSE)) {
hold = action_update_hold_by_event(hold, e);
mp_send_cmd_head(mp, mq, hold ? MB_CTRL_PAUSE : MB_CTRL_PLAY);
lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
} else if(event_is_type(e, EVENT_MP_NO_LONGER_PRIMARY)) {
hold = 1;
lost_focus = 1;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_type(e, EVENT_MP_IS_PRIMARY)) {
if(lost_focus) {
hold = 0;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, hold, NULL);
}
} else if(event_is_type(e, EVENT_INTERNAL_PAUSE)) {
hold = 1;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
if(mb != NULL && mb != MB_SPECIAL_EOF)
media_buf_free_unlocked(mp, mb);
media_codec_deref(cw);
media_format_deref(fw);
if(hold) {
// If we were paused, release playback again.
mp_send_cmd(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, 0, NULL);
}
return e;
}
static int
pa_audio_start(audio_mode_t *am, audio_fifo_t *af)
{
pa_audio_mode_t *pam = (pa_audio_mode_t *)am;
audio_buf_t *ab = NULL;
size_t l, length;
int64_t pts;
media_pipe_t *mp;
int r = 0;
pa_threaded_mainloop_lock(mainloop);
#if PA_API_VERSION >= 12
pa_proplist *pl = pa_proplist_new();
pa_proplist_sets(pl, PA_PROP_APPLICATION_ID, "com.lonelycoder.hts.showtime");
pa_proplist_sets(pl, PA_PROP_APPLICATION_NAME, "Showtime");
/* Create a new connection context */
pam->context = pa_context_new_with_proplist(api, "Showtime", pl);
pa_proplist_free(pl);
#else
pam->context = pa_context_new(api, "Showtime");
#endif
if(pam->context == NULL) {
pa_threaded_mainloop_unlock(mainloop);
return -1;
}
pa_context_set_state_callback(pam->context, context_state_callback, pam);
/* Connect the context */
if(pa_context_connect(pam->context, NULL, 0, NULL) < 0) {
TRACE(TRACE_ERROR, "PA", "pa_context_connect() failed: %s",
pa_strerror(pa_context_errno(pam->context)));
pa_threaded_mainloop_unlock(mainloop);
return -1;
}
/* Need at least one packet of audio */
/* Subscribe to updates of master volume */
pam->sub_mvol =
prop_subscribe(PROP_SUB_DIRECT_UPDATE,
PROP_TAG_CALLBACK_FLOAT, set_mastervol, pam,
PROP_TAG_ROOT, prop_mastervol,
PROP_TAG_EXTERNAL_LOCK, mainloop, prop_pa_lockmgr,
NULL);
/* Subscribe to updates of master volume mute */
pam->sub_mute =
prop_subscribe(PROP_SUB_DIRECT_UPDATE,
PROP_TAG_CALLBACK_INT, set_mastermute, pam,
PROP_TAG_ROOT, prop_mastermute,
PROP_TAG_EXTERNAL_LOCK, mainloop, prop_pa_lockmgr,
NULL);
while(1) {
if(ab == NULL) {
pa_threaded_mainloop_unlock(mainloop);
ab = af_deq2(af, 1, am);
pa_threaded_mainloop_lock(mainloop);
if(ab == AF_EXIT) {
ab = NULL;
break;
}
}
if(pa_context_get_state(pam->context) == PA_CONTEXT_TERMINATED ||
pa_context_get_state(pam->context) == PA_CONTEXT_FAILED) {
r = -1;
break;
}
if(pam->stream != NULL &&
(pam->cur_format != ab->ab_format ||
pam->cur_rate != ab->ab_samplerate ||
pam->cur_isfloat != ab->ab_isfloat)) {
stream_destroy(pam);
}
if(pam->stream == NULL &&
pa_context_get_state(pam->context) == PA_CONTEXT_READY) {
/* Context is ready, but we don't have a stream yet, set it up */
stream_setup(pam, ab);
}
if(pam->stream == NULL) {
pa_threaded_mainloop_wait(mainloop);
continue;
}
switch(pa_stream_get_state(pam->stream)) {
case PA_STREAM_UNCONNECTED:
case PA_STREAM_CREATING:
pa_threaded_mainloop_wait(mainloop);
continue;
case PA_STREAM_READY:
break;
case PA_STREAM_TERMINATED:
case PA_STREAM_FAILED:
pa_stream_unref(pam->stream);
pam->stream = NULL;
char msg[100];
snprintf(msg, sizeof(msg),
"Audio stream disconnected from "
"PulseAudio server -- %s.",
pa_strerror(pam->stream_error));
mp_flush(ab->ab_mp, 0);
mp_enqueue_event(ab->ab_mp, event_create_str(EVENT_INTERNAL_PAUSE, msg));
audio_fifo_purge(af, NULL, NULL);
if(ab != NULL) {
ab_free(ab);
ab = NULL;
}
continue;
}
if(ab->ab_flush) {
pa_operation *o;
o = pa_stream_flush(pam->stream, NULL, NULL);
if(o != NULL)
pa_operation_unref(o);
ab->ab_flush = 0;
}
l = pa_stream_writable_size(pam->stream);
if(l == 0) {
pa_threaded_mainloop_wait(mainloop);
continue;
}
length = ab->ab_frames * pa_frame_size(&pam->ss) - ab->ab_tmp;
if(l > length)
l = length;
if((pts = ab->ab_pts) != AV_NOPTS_VALUE && ab->ab_mp != NULL) {
int64_t pts;
pa_usec_t delay;
pts = ab->ab_pts;
ab->ab_pts = AV_NOPTS_VALUE;
if(!pa_stream_get_latency(pam->stream, &delay, NULL)) {
mp = ab->ab_mp;
hts_mutex_lock(&mp->mp_clock_mutex);
mp->mp_audio_clock = pts - delay;
mp->mp_audio_clock_realtime = showtime_get_ts();
mp->mp_audio_clock_epoch = ab->ab_epoch;
hts_mutex_unlock(&mp->mp_clock_mutex);
}
}
pa_stream_write(pam->stream, ab->ab_data + ab->ab_tmp,
l, NULL, 0LL, PA_SEEK_RELATIVE);
ab->ab_tmp += l;
assert(ab->ab_tmp <= ab->ab_frames * pa_frame_size(&pam->ss));
if(ab->ab_frames * pa_frame_size(&pam->ss) == ab->ab_tmp) {
ab_free(ab);
ab = NULL;
}
}
prop_unsubscribe(pam->sub_mvol);
prop_unsubscribe(pam->sub_mute);
if(pam->stream != NULL)
stream_destroy(pam);
pa_threaded_mainloop_unlock(mainloop);
pa_context_unref(pam->context);
if(ab != NULL) {
ab_free(ab);
ab = NULL;
}
return r;
}
/**
* Play given track.
*
* We only expect this to be called from the playqueue system.
*/
static event_t *
be_sid2player_play(const char *url0, media_pipe_t *mp,
char *errbuf, size_t errlen, int hold,
const char *mimetype)
{
media_queue_t *mq = &mp->mp_audio;
char *url, *p;
int sample = 0, lost_focus = 0;
media_buf_t *mb = NULL;
event_t *e;
int subsong;
void *player;
void *data;
struct fa_stat fs;
url0 += strlen("sidplayer:");
url = mystrdupa(url0);
p = strrchr(url, '/');
if(p == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return NULL;
}
*p++= 0;
subsong = atoi(p);
if((data = fa_quickload(url, &fs, NULL, errbuf, errlen)) == NULL)
return NULL;
player = sidcxx_load(data, fs.fs_size, subsong, errbuf, errlen);
free(data);
if(player == NULL)
return NULL;
mp_set_playstatus_by_hold(mp, hold, NULL);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, MP_PLAY_CAPS_PAUSE, MP_BUFFER_NONE);
mp_become_primary(mp);
while(1) {
if(mb == NULL) {
mb = media_buf_alloc();
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_size = sizeof(int16_t) * CHUNK_SIZE * mb->mb_channels;
mb->mb_data = malloc(mb->mb_size);
mb->mb_rate = 44100;
mb->mb_time = sample * 1000000LL / mb->mb_rate;
sample += CHUNK_SIZE;
int16_t *samples = mb->mb_data;
sidcxx_play(player, samples,
CHUNK_SIZE * sizeof(int16_t) * mb->mb_channels);
// Crossmix 25%
int i, l, r, L, R;
for(i = 0; i < CHUNK_SIZE; i++) {
l = samples[i * 2 + 0];
r = samples[i * 2 + 1];
L = 3 * l + r * 2;
R = 3 * r + l * 2;
L = L / 4;
R = R / 4;
if(L > 32767)
L = 32767;
if(L < -32768)
L = -32768;
if(R > 32767)
R = 32767;
if(R < -32768)
R = -32768;
samples[i * 2 + 0] = L;
samples[i * 2 + 1] = R;
}
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_action(e, ACTION_PLAYPAUSE) ||
event_is_action(e, ACTION_PLAY) ||
event_is_action(e, ACTION_PAUSE)) {
hold = action_update_hold_by_event(hold, e);
mp_send_cmd_head(mp, mq, hold ? MB_CTRL_PAUSE : MB_CTRL_PLAY);
lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
} else if(event_is_type(e, EVENT_MP_NO_LONGER_PRIMARY)) {
hold = 1;
lost_focus = 1;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_type(e, EVENT_MP_IS_PRIMARY)) {
if(lost_focus) {
hold = 0;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, hold, NULL);
}
} else if(event_is_type(e, EVENT_INTERNAL_PAUSE)) {
hold = 1;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
sidcxx_stop(player);
return e;
}
static event_t *
openspc_play(media_pipe_t *mp, AVIOContext *avio, char *errbuf, size_t errlen)
{
media_queue_t *mq = &mp->mp_audio;
#error fa_fsize can return -1 .. deal with it
size_t r, siz = fa_fsize(fh);
uint8_t *buf = malloc(siz);
media_buf_t *mb = NULL;
event_t *e;
int hold = 0, lost_focus = 0;
int sample = 0;
unsigned int duration = INT32_MAX;
mp_set_playstatus_by_hold(mp, hold, NULL);
mp->mp_audio.mq_stream = 0;
fa_seek(fh, 0, SEEK_SET);
r = fa_read(fh, buf, siz);
fa_close(fh);
if(r != siz) {
free(buf);
snprintf(errbuf, errlen, "openspc: Unable to read file");
return NULL;
}
if(OSPC_Init(buf, siz)) {
free(buf);
snprintf(errbuf, errlen, "openspc: Unable to initialize file");
return NULL;
}
if(!memcmp("v0.30", buf + 0x1c, 4) && buf[0x23] == 0x1a) {
char str[4];
memcpy(str, buf + 0xa9, 3);
str[3] = 0;
duration = atoi(str) * 32000;
}
mp_set_play_caps(mp, MP_PLAY_CAPS_PAUSE);
mp_become_primary(mp);
while(1) {
if(mb == NULL) {
if(sample > duration) {
while((e = mp_wait_for_empty_queues(mp, 0)) != NULL) {
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP) ||
event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
if(e == NULL)
e = event_create_type(EVENT_EOF);
break;
}
mb = media_buf_alloc();
mb->mb_data_type = MB_AUDIO;
mb->mb_size = sizeof(int16_t) * 2048 * 2;
mb->mb_data = malloc(mb->mb_size);
mb->mb_size = OSPC_Run(-1, mb->mb_data, mb->mb_size);
mb->mb_channels = 2;
mb->mb_rate = 32000;
mb->mb_time = sample * 1000000LL / mb->mb_rate;
sample += 2048;
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_action(e, ACTION_PLAYPAUSE) ||
event_is_action(e, ACTION_PLAY) ||
event_is_action(e, ACTION_PAUSE)) {
hold = action_update_hold_by_event(hold, e);
mp_send_cmd_head(mp, mq, hold ? MB_CTRL_PAUSE : MB_CTRL_PLAY);
lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
} else if(event_is_type(e, EVENT_MP_NO_LONGER_PRIMARY)) {
hold = 1;
lost_focus = 1;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_type(e, EVENT_MP_IS_PRIMARY)) {
if(lost_focus) {
hold = 0;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, hold, NULL);
}
} else if(event_is_type(e, EVENT_INTERNAL_PAUSE)) {
hold = 1;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
free(buf);
return e;
}
static void *
test_generator_thread(void *aux)
{
media_pipe_t *mp = aux;
media_buf_t *mb = NULL;
event_t *e;
media_queue_t *mq = &mp->mp_audio;
pcm_sound_t voices[8];
AVFrame *frame = av_frame_alloc();
AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_AC3);
AVCodecContext *ctx = avcodec_alloc_context3(codec);
ctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
ctx->sample_rate = 48000;
ctx->channel_layout = AV_CH_LAYOUT_5POINT1;
if(avcodec_open2(ctx, codec, NULL) < 0) {
TRACE(TRACE_ERROR, "audio", "Unable to open encoder");
return NULL;
}
float *genbuf[8];
for(int i = 0; i < 8; i++) {
genbuf[i] = av_malloc(ctx->frame_size * sizeof(float));
frame->data[i] = (void *)genbuf[i];
}
frame->nb_samples = ctx->frame_size;
media_codec_t *mc = media_codec_create(AV_CODEC_ID_AC3, 0,
NULL, NULL, NULL, mp);
mp_set_playstatus_by_hold(mp, 0, NULL);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, 0, MP_BUFFER_NONE, 0, "testsignal");
mp_become_primary(mp);
int sample = 0;
unpack_speaker_positions(voices);
while(1) {
if(mb == NULL) {
int got_packet;
AVPacket pkt = {0};
generator_t *g;
switch(signal_type) {
case 0:
for(int c = 0; c < 8; c++) {
int z = ctx->frame_size;
if(test_channels[c]) {
int j = sample & 0xffff;
int to_copy = MIN(ctx->frame_size, (voices[c].samples - j));
if(to_copy < 0)
to_copy = 0;
for(int i = 0; i < to_copy; i++) {
genbuf[c][i] = voices[c].data[j+i] / 32767.0f;
}
z = ctx->frame_size - to_copy;
}
memset(genbuf[c] + ctx->frame_size - z, 0, sizeof(float) * z);
}
sample += ctx->frame_size;
goto encode;
default: g = &gen_pink_noise; break;
case 2: g = &gen_sinewave; break;
}
for(int i = 0; i < ctx->frame_size; i++) {
float x = g(sample);
for(int c = 0; c < 8; c++) {
genbuf[c][i] = test_channels[c] ? x : 0;
}
sample++;
}
encode:
av_init_packet(&pkt);
int r = avcodec_encode_audio2(ctx, &pkt, frame, &got_packet);
if(!r && got_packet) {
mb = media_buf_from_avpkt_unlocked(mp, &pkt);
av_free_packet(&pkt);
} else {
sleep(1);
}
mb->mb_cw = media_codec_ref(mc);
mb->mb_data_type = MB_AUDIO;
mb->mb_pts = PTS_UNSET;
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_EXIT)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
av_frame_free(&frame);
for(int i = 0; i < 8; i++)
av_freep(&genbuf[i]);
for(int i = 0; i < 8; i++)
free(voices[i].data);
media_codec_deref(mc);
return NULL;
}