void
load_syms(void)
{
char sympath[256];
char errbuf[256];
snprintf(sympath, sizeof(sympath), "%s/showtime.syms", showtime_dataroot());
my_trace("sympath: %s\n", sympath);
fa_handle_t *fh = fa_open(sympath, errbuf, sizeof(errbuf));
if(fh == NULL) {
my_trace("Unable to open symbol file %s -- %s",
sympath, errbuf);
return;
}
int size = fa_fsize(fh);
char *buf = halloc(size + 1);
int r = fa_read(fh, buf, size);
if(r != size) {
my_trace("Unable to read %d bytes", size);
hfree(buf, size+1);
} else {
buf[size] = 0;
my_trace("Loaded symbol table %d bytes to %p",
size, buf);
symbuf = buf;
}
fa_close(fh);
}
static int64_t
fa_libav_seek(void *opaque, int64_t offset, int whence)
{
fa_handle_t *fh = opaque;
if(whence == AVSEEK_SIZE)
return fa_fsize(fh);
return fa_seek(fh, offset, whence & ~AVSEEK_FORCE);
}
/**
* fd
*/
static int
es_file_fsize(duk_context *ctx)
{
es_fd_t *efd = es_fd_get(ctx, 0);
int64_t siz = fa_fsize(efd->efd_fh);
if(siz < 0)
duk_error(ctx, DUK_ERR_ERROR, "File not seekable");
duk_push_number(ctx, siz);
return 1;
}
AVIOContext *
fa_libav_reopen(fa_handle_t *fh)
{
AVIOContext *avio;
if(fa_seek(fh, 0, SEEK_SET) != 0)
return NULL;
int buf_size = 32768;
void *buf = av_malloc(buf_size);
avio = avio_alloc_context(buf, buf_size, 0, fh, fa_libav_read, NULL,
fa_libav_seek);
if(avio != NULL && fa_fsize(fh) == -1)
avio->seekable = 0;
return avio;
}
static int64_t
cmp_fsize(fa_handle_t *handle)
{
cmp_t *s = (cmp_t *)handle;
int64_t r1 = fa_fsize(s->s_src);
struct stat st;
if(fstat(s->s_fd, &st)) {
TRACE(TRACE_ERROR, "FACMP","Stat failed -- %s", strerror(errno));
exit(1);
}
if(st.st_size != r1) {
TRACE(TRACE_ERROR, "FACMP",
"fsize() failed fa:%"PRId64" local:%"PRId64,
r1, st.st_size);
exit(1);
}
return r1;
}
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;
}
pixmap_t *
fa_imageloader(const char *url, const struct image_meta *im,
const char **vpaths, char *errbuf, size_t errlen,
int *cache_control, cancellable_t *c)
{
uint8_t p[16];
int r;
int width = -1, height = -1, orientation = 0;
fa_handle_t *fh;
pixmap_t *pm;
pixmap_type_t fmt;
#if ENABLE_LIBAV
if(strchr(url, '#'))
return fa_image_from_video(url, im, errbuf, errlen, cache_control, c);
#endif
if(!im->im_want_thumb)
return fa_imageloader2(url, vpaths, errbuf, errlen, cache_control, c);
fa_open_extra_t foe = {
.foe_c = c
};
if((fh = fa_open_vpaths(url, vpaths, errbuf, errlen,
FA_BUFFERED_SMALL, &foe)) == NULL)
return NULL;
if(ONLY_CACHED(cache_control)) {
snprintf(errbuf, errlen, "Not cached");
return NULL;
}
if(fa_read(fh, p, sizeof(p)) != sizeof(p)) {
snprintf(errbuf, errlen, "File too short");
fa_close(fh);
return NULL;
}
/* Probe format */
if((p[6] == 'J' && p[7] == 'F' && p[8] == 'I' && p[9] == 'F') ||
(p[6] == 'E' && p[7] == 'x' && p[8] == 'i' && p[9] == 'f')) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_reader, fh,
JPEG_INFO_DIMENSIONS |
JPEG_INFO_ORIENTATION |
(im->im_want_thumb ? JPEG_INFO_THUMBNAIL : 0),
p, sizeof(p), errbuf, errlen)) {
fa_close(fh);
return NULL;
}
if(im->im_want_thumb && ji.ji_thumbnail) {
pixmap_t *pm = pixmap_dup(ji.ji_thumbnail);
fa_close(fh);
jpeg_info_clear(&ji);
return pm;
}
fmt = PIXMAP_JPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
fmt = PIXMAP_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
fmt = PIXMAP_GIF;
} else if(!memcmp(svgsig1, p, sizeof(svgsig1)) ||
!memcmp(svgsig2, p, sizeof(svgsig2))) {
fmt = PIXMAP_SVG;
} else {
snprintf(errbuf, errlen, "Unknown format");
fa_close(fh);
return NULL;
}
int64_t s = fa_fsize(fh);
if(s < 0) {
snprintf(errbuf, errlen, "Can't read from non-seekable file");
fa_close(fh);
return NULL;
}
pm = pixmap_alloc_coded(NULL, s, fmt);
if(pm == NULL) {
snprintf(errbuf, errlen, "Out of memory");
fa_close(fh);
return NULL;
}
pm->pm_width = width;
pm->pm_height = height;
pm->pm_orientation = orientation;
fa_seek(fh, SEEK_SET, 0);
r = fa_read(fh, pm->pm_data, pm->pm_size);
fa_close(fh);
if(r != pm->pm_size) {
pixmap_release(pm);
snprintf(errbuf, errlen, "Read error");
return NULL;
}
return pm;
}
static int64_t
bwlimit_fsize(fa_handle_t *handle)
{
bwlimit_t *s = (bwlimit_t *)handle;
return fa_fsize(s->s_src);
}
static int
gme_probe(metadata_t *md, const char *url, fa_handle_t *fh)
{
uint8_t b4[4], *buf;
gme_err_t err;
Music_Emu *emu;
gme_info_t *info;
int tracks;
size_t size;
const char *type;
if(fa_read(fh, b4, 4) != 4)
return 0;
type = gme_identify_header(b4);
if(*type == 0)
return 0;
size = fa_fsize(fh);
if(size == -1)
return -1;
buf = malloc(size);
fa_seek(fh, 0, SEEK_SET);
if(fa_read(fh, buf, size) != size) {
free(buf);
return 0;
}
err = gme_open_data(buf, size, &emu, gme_info_only);
free(buf);
if(err != NULL)
return 0;
err = gme_track_info(emu, &info, 0);
if(err != NULL) {
gme_delete(emu);
return 0;
}
tracks = gme_track_count(emu);
#if 0
printf("tracks : %d\n", tracks);
printf("system : %s\n", info->system);
printf("game : %s\n", info->game);
printf("song : %s\n", info->song);
printf("author : %s\n", info->author);
printf("copyright: %s\n", info->copyright);
printf("comment : %s\n", info->comment);
printf("dumper : %s\n", info->dumper);
#endif
if(tracks == 1) {
md->md_title = info->song[0] ? rstr_alloc(info->song) : NULL;
md->md_album = info->game[0] ? rstr_alloc(info->game) : NULL;
md->md_artist = info->author[0] ? rstr_alloc(info->author) : NULL;
md->md_duration = info->play_length / 1000.0;
md->md_contenttype = CONTENT_AUDIO;
} else {
md->md_title = info->game[0] ? rstr_alloc(info->game) : NULL;
md->md_artist = info->author[0] ? rstr_alloc(info->author) : NULL;
md->md_contenttype = CONTENT_ALBUM;
metdata_set_redirect(md, "gmefile://%s/", url);
}
gme_free_info(info);
gme_delete(emu);
return 1;
}
static int
gmefile_scandir(fa_dir_t *fd, const char *url, char *errbuf, size_t errlen)
{
void *fh = NULL;
char *p, *fpath = mystrdupa(url);
char name[32];
char turl[URL_MAX];
int tracks, i, size;
fa_dir_entry_t *fde;
const char *title;
char *buf;
Music_Emu *emu;
gme_info_t *info;
gme_err_t err;
size_t r;
if((p = strrchr(fpath, '/')) == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return -1;
}
*p = 0;
if((fh = fa_open(fpath, errbuf, errlen)) == NULL)
return -1;
size = fa_fsize(fh);
buf = malloc(size);
r = fa_read(fh, buf, size);
fa_close(fh);
if(r != size) {
snprintf(errbuf, errlen, "Unable to read file");
free(buf);
return -1;
}
err = gme_open_data(buf, size, &emu, gme_info_only);
free(buf);
if(err != NULL)
return 0;
tracks = gme_track_count(emu);
for(i = 0; i < tracks; i++) {
snprintf(turl, sizeof(turl), "gmeplayer:%s/%d", fpath, i + 1);
err = gme_track_info(emu, &info, i);
if(err == NULL && info->song[0]) {
title = info->song;
} else {
snprintf(name, sizeof(name), "Track %02d", i + 1);
title = name;
}
fde = fa_dir_add(fd, turl, title, CONTENT_AUDIO);
fde->fde_probestatus = FDE_PROBE_DEEP;
fde->fde_metadata = prop_create_root("metadata");
prop_set_string(prop_create(fde->fde_metadata, "title"), title);
if(err == NULL) {
if(info->game[0])
prop_set_string(prop_create(fde->fde_metadata, "album"), info->game);
if(info->author[0])
prop_set_string(prop_create(fde->fde_metadata, "artist"), info->author);
prop_set_float(prop_create(fde->fde_metadata, "duration"),
info->play_length / 1000.0);
gme_free_info(info);
}
}
gme_delete(emu);
return 0;
}
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;
}
image_t *
fa_imageloader(const char *url, const struct image_meta *im,
const char **vpaths, char *errbuf, size_t errlen,
int *cache_control, cancellable_t *c)
{
uint8_t p[16];
int r;
int width = -1, height = -1, orientation = 0;
fa_handle_t *fh;
image_t *img;
image_coded_type_t fmt;
#if ENABLE_LIBAV
if(strchr(url, '#'))
return fa_image_from_video(url, im, errbuf, errlen, cache_control, c);
#endif
if(!im->im_want_thumb)
return fa_imageloader2(url, vpaths, errbuf, errlen, cache_control, c);
fa_open_extra_t foe = {
.foe_cancellable = c
};
if((fh = fa_open_vpaths(url, vpaths, errbuf, errlen,
FA_BUFFERED_SMALL, &foe)) == NULL)
return NULL;
if(ONLY_CACHED(cache_control)) {
snprintf(errbuf, errlen, "Not cached");
return NULL;
}
if(fa_read(fh, p, sizeof(p)) != sizeof(p)) {
snprintf(errbuf, errlen, "File too short");
fa_close(fh);
return NULL;
}
/* Probe format */
if(p[0] == 0xff && p[1] == 0xd8 && p[2] == 0xff) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_reader, fh,
JPEG_INFO_DIMENSIONS |
JPEG_INFO_ORIENTATION |
(im->im_want_thumb ? JPEG_INFO_THUMBNAIL : 0),
p, sizeof(p), errbuf, errlen)) {
fa_close(fh);
return NULL;
}
if(im->im_want_thumb && ji.ji_thumbnail) {
image_t *im = image_retain(ji.ji_thumbnail);
fa_close(fh);
jpeg_info_clear(&ji);
im->im_flags |= IMAGE_ADAPTED;
return im;
}
fmt = IMAGE_JPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
fmt = IMAGE_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
fmt = IMAGE_GIF;
} else if(p[0] == 'B' && p[1] == 'M') {
fmt = IMAGE_BMP;
} else if(!memcmp(svgsig1, p, sizeof(svgsig1)) ||
!memcmp(svgsig2, p, sizeof(svgsig2))) {
fmt = IMAGE_SVG;
} else {
snprintf(errbuf, errlen, "Unknown format");
fa_close(fh);
return NULL;
}
int64_t s = fa_fsize(fh);
if(s < 0) {
snprintf(errbuf, errlen, "Can't read from non-seekable file");
fa_close(fh);
return NULL;
}
void *ptr;
img = image_coded_alloc(&ptr, s, fmt);
if(img == NULL) {
snprintf(errbuf, errlen, "Out of memory");
fa_close(fh);
return NULL;
}
img->im_width = width;
img->im_height = height;
img->im_orientation = orientation;
fa_seek(fh, SEEK_SET, 0);
r = fa_read(fh, ptr, s);
fa_close(fh);
if(r != s) {
image_release(img);
snprintf(errbuf, errlen, "Read error");
return NULL;
}
return img;
}
