static audio_result_t init(audio_worker_t* worker, const char* file_or_url, el_bool file)
{
//static int ogg_initialized = 0;
//static int ogg_error = 0;
ogg_t* ogg=(ogg_t*) mc_malloc(sizeof(ogg_t));
worker->can_seek = can_seek;
worker->play = play;
worker->pause = pause;
worker->seek = seek;
worker->guard = guard;
worker->destroy = destroy;
worker->length_in_ms = length_in_ms;
worker->load_file = load_file;
worker->load_url = load_url;
worker->set_volume = set_volume;
worker->worker_data = (void*) ogg;
ogg->volume_scale = 1.0;
ogg->client_notification = worker->fifo;
ogg->player_control = audio_event_fifo_new();
//int error;
ogg->is_open = el_false;
ogg->length = -1;
//sem_init(&ogg->length_set, 0, 0);
ogg->length_set = psem_new(0);
ogg->buffer = (char*) mc_malloc(BUFFER_SIZE(ogg));
ogg->ao_handle = aodev_new();
if (file) {
ogg->can_seek = el_true;
ogg->is_file = el_true;
ogg->file_or_url = mc_strdup(file_or_url);
post_event(ogg->player_control, INTERNAL_CMD_LOAD_FILE, -1);
} else { // URL
ogg->can_seek = el_false;
ogg->is_file = el_false;
ogg->file_or_url = mc_strdup(file_or_url);
post_event(ogg->player_control, INTERNAL_CMD_LOAD_URL, -1);
}
int thread_id = pthread_create(&ogg->player_thread, NULL, player_thread, ogg);
// wait until fully loaded (length is set)
psem_wait(ogg->length_set);
return AUDIO_OK;
}
static data_entry_t *mydata_entry_new(const char *path, cue_entry_t * entry, struct stat *st)
{
data_entry_t *e = (data_entry_t *) mc_malloc(sizeof(data_entry_t));
e->path = mc_strdup(path);
e->entry = entry;
e->open_count = 0;
if (st != NULL) {
struct stat *stn = (struct stat *)mc_malloc(sizeof(struct stat));
memcpy((void *)stn, (void *)st, sizeof(struct stat));
e->st = stn;
} else {
e->st = NULL;
}
}
playlists_model_t* playlists_model_new(library_t* lib)
{
playlists_model_t* model = (playlists_model_t*) mc_malloc(sizeof(playlists_model_t));
model->library = lib;
model->model = gtk_list_model_new(model, n_columns, column_type, n_rows, cell_value);
return model;
}
char *cue_entry_alloc_id(cue_entry_t * ce)
{
int l = strlen(cue_entry_vfile(ce)) + strlen(cue_audio_file(cue_entry_sheet(ce))) + 1;
char *s = (char *)mc_malloc(l);
strcpy(s, cue_entry_vfile(ce));
strcat(s, cue_audio_file(cue_entry_sheet(ce)));
return s;
}
int main() {
struct test **list;
for (int i=0; i<50; i++) {
block_list_size();
list[i] = mc_malloc(sizeof(struct test));
}
mc_free(list[15]);
block_list_size();
mc_free(list[32]);
block_list_size();
mc_free(list[33]);
block_list_size();
mc_free(list[14]);
block_list_size();
for (int j=0; j<50; j++) {
block_list_size();
list[j] = mc_malloc(sizeof(struct test));
}
}
mc_source_record_list_t *mc_src_create()
{
mc_source_record_list_t *src = NULL;
src = (mc_source_record_list_t *)mc_malloc(sizeof(mc_source_record_list_t));
if(src) {
memset(src, 0, sizeof(mc_source_record_list_t));
}
return src;
}
int
mc_elf_open(const char *fname, struct mc_elf *elf)
{
long offset;
memset(elf, 0, sizeof(elf));
if ((elf->f = mc_fopen(fname, "r")) == NULL)
return -1;
if (mc_fread(&elf->eh, sizeof(elf->eh), 1, elf->f) != 1)
goto bail;
if (memcmp(elf->eh.ident, "\177ELF", 4) != 0)
goto bail;
if (elf->eh.shentsize != sizeof(struct elf_sheader))
goto bail;
offset = elf->eh.shoffset;
mc_fseek(elf->f, offset, SEEK_SET);
if ((elf->sh = mc_malloc(elf->eh.shentsize * elf->eh.shnum)) == NULL)
goto bail;
if (mc_fread(elf->sh, elf->eh.shentsize * elf->eh.shnum, 1, elf->f) != 1)
goto bail;
/* load the string table */
if (elf->eh.shstrndx >= elf->eh.shnum)
goto bail;
elf->strtabsz = elf->sh[elf->eh.shstrndx].size;
if ((elf->strtab = mc_malloc(elf->strtabsz)) == NULL)
goto bail;
offset = elf->sh[elf->eh.shstrndx].offset;
if (mc_fseek(elf->f, offset, SEEK_SET) == -1 ||
mc_fread(elf->strtab, elf->strtabsz, 1, elf->f) != 1)
goto bail;
return 0;
bail:
mc_elf_close(elf);
return -1;
}
library_view_t* library_view_new(Backtobasics* btb, library_t* library)
{
library_view_t* view = (library_view_t*) mc_malloc(sizeof(library_view_t));
view->btb = btb;
view->builder = btb->builder;
view->library = library;
view->playlist_model = mc_take_over(playlist_model_new());
//view->library_list_changed = el_false;
//view->library_list_hash = playlist_model_tracks_hash(view->playlist_model);
view->genre_model = string_model_new();
view->artist_model = string_model_new();
view->album_model = string_model_new();
view->aspect = GENRE_ASPECT;
view->previous_aspect = NONE_ASPECT;
playlist_model_set_playlist(view->playlist_model, library_current_selection(view->library, _("Library")));
string_model_set_array(view->genre_model, library_genres(view->library), el_false);
string_model_set_array(view->artist_model, library_artists(view->library), el_false);
string_model_set_array(view->album_model, library_albums(view->library), el_false);
view->run_timeout = el_true;
view->time_in_ms = -1;
view->len_in_ms = -1;
view->track_index = -1;
view->track_id = NULL;
view->sliding = 0;
view->repeat = -1;
view->img_w = el_config_get_int(btb_config(view->btb), "image_art.width", 200);
view->img_h = el_config_get_int(btb_config(view->btb), "image_art.height", 200);
log_debug3("image art w=%d, h=%d", view->img_w, view->img_h);
view->btn_play = NULL;
view->btn_pause = NULL;
view->cols = NULL;
view->ignore_sel_changed = el_false;
view->playlists_model = playlists_model_new(view->library);
view->current_lyric_track_id = NULL;
view->column_layout_changing = el_false;
return view;
}
char *mymake_path(const char *path)
{
int l = strlen(path) + strlen(BASEDIR) + 1;
char *np = (char *)mc_malloc(l);
fprintf(stderr, "np=%p\n", np);
if (np == NULL) {
return np;
} else {
strcpy(np, BASEDIR);
strcat(np, path);
log_debug2("fullpath=%s", np);
//fprintf(stderr,"fullpath=%s\n",np);
return np;
}
}
static scan_result_t scan_cb(scan_job_t* job, el_bool ready,
const char* msg, const char* submsg,
int n, int of_n)
{
scanjob_info_t* info = (scanjob_info_t*) mc_malloc(sizeof(scanjob_info_t));
info->ready = ready;
info->msg = mc_strdup(msg);
info->submsg = mc_strdup(submsg);
info->n = n;
info->of_n = of_n;
scanjob_fifo_enqueue(job->fifo, info);
return (job->cancelled) ? SCAN_CANCEL : SCAN_CONTINUE;
}
static char *getCueFileForTrack(const char *full_path_of_track, int with_ext) {
char *fp = (char *)mc_malloc(strlen(full_path_of_track) + strlen(".cue") + 1);
strcpy(fp, full_path_of_track);
int i,N;
for(N = strlen(fp), i = N-1; i >= 0 && fp[i] != '/'; --i);
if (i<0) {
log_error("Unexpected!");
return fp;
} else {
fp[i] = '\0';
if (with_ext) {
strcat(fp, ".cue");
}
return fp;
}
}
ao_t* aodev_new(void)
{
log_debug("new");
static int initialize = 1;
if (initialize) {
initialize = 0;
ao_initialize();
atexit(ao_shutdown);
}
ao_t* handle = (ao_t*) mc_malloc(sizeof(ao_t));
handle->driver = ao_default_driver_id();
handle->device = NULL;
return handle;
}
const char *cue_entry_vfile(cue_entry_t * ce)
{
if (ce->vfile == NULL) {
cue_t *c = (cue_t *) ce->sheet;
char *name = (char *)mc_malloc(10 + strlen(cue_entry_title(ce)) + 4);
char *ext = getExt(cue_audio_file(c));
sprintf(name, "%02d - %s.%s", ce->tracknr, ce->title, ext);
int i,N;
for(i=0,N=strlen(name);i<N;i++) {
if (name[i]=='/') { name[i]=' '; }
}
mc_free(ext);
ce->vfile = name;
}
return ce->vfile;
}
static cue_entry_t *cue_entry_new(cue_t * s)
{
cue_entry_t *r = (cue_entry_t *) mc_malloc(sizeof(cue_entry_t));
if (r == NULL) {
return NULL;
}
r->title = NULL;
r->performer = NULL;
r->year = NULL;
r->composer = NULL;
r->tracknr = -1;
r->begin_offset_in_ms = -1;
r->end_offset_in_ms = -1;
r->sheet = (void *)s;
r->vfile = NULL;
return r;
}
void
xs_timeInterval_constructor(xsMachine *the)
{
mc_timeinterval_t *ti;
unsigned long interval;
if ((ti = mc_malloc(sizeof(mc_timeinterval_t))) == NULL)
mc_xs_throw(the, "TimeInteval: no mem");
interval = xsToInteger(xsArg(1));
xsSet(xsThis, xsID("_callback"), xsArg(0));
ti->obj = xsThis;
if ((ti->tc = mc_interval_set(interval, timeInterval_callback, ti)) == NULL) {
xs_timeInterval_destructor(ti);
mc_xs_throw(the, "TimeInterval: no time slot");
}
xsSetHostData(xsThis, ti);
}
segmenter_t *segmenter_new()
{
segmenter_t *s = (segmenter_t *) mc_malloc(sizeof(segmenter_t));
s->memory_block = NULL;
s->size = -1;
s->last_result = SEGMENTER_NONE;
s->segment.filename = mc_strdup("");
s->segment.artist = mc_strdup("");
s->segment.album = mc_strdup("");
s->segment.album_artist = mc_strdup("");
s->segment.title = mc_strdup("");
s->segment.composer = mc_strdup("");
s->segment.comment = mc_strdup("");
s->segment.genre = mc_strdup("");
s->segment.track = -1;
s->stream = NULL;
return s;
}
char *make_rel_path2(const char *path, const char *file)
{
int pl = strlen(path);
int l = strlen(path) + strlen("/") + strlen(file) + 1;
char *fp = (char *)mc_malloc(l);
if (fp == NULL) {
return NULL;
} else {
strcpy(fp, path);
if (pl > 0) {
if (fp[pl - 1] != '/') {
strcat(fp, "/");
}
}
strcat(fp, file);
return fp;
}
}
static void library_view_process_lyric(char* lyric, void* data)
{
struct lyric_cb* cb = (struct lyric_cb*) data;
char* t_id = cb->track_id;
library_view_t* view = cb->view;
mc_free(cb);
if (view->current_lyric_track_id != NULL) {
mc_free(view->current_lyric_track_id);
}
view->current_lyric_track_id = t_id;
track_t* t = library_get(view->library, t_id);
if (t != NULL) {
if (strcmp(lyric, "") != 0) {
track_set_lyric(t, lyric);
}
char *artist = text_to_html(track_get_artist(t));
char *title = text_to_html(track_get_title(t));
char* s = (char*) mc_malloc(strlen(artist)+sizeof(", ")+strlen(title)+200);
sprintf(s,"<span size=\"x-small\"><i><b>%s\n%s</b></i></span>", artist, title);
gtk_label_set_markup(view->lbl_lyric_track,s);
mc_free(s);
mc_free(title);
mc_free(artist);
char* html = lyric_text_to_html(lyric);
write_lyric(t, lyric, el_false); // write but don't overwrite
webkit_web_view_load_string(view->lyric_view, html, NULL, NULL, "");
mc_free(html);
} else {
char* html = "<html><head></head><body></body></html>";
gtk_label_set_markup(view->lbl_lyric_track, "");
webkit_web_view_load_string(view->lyric_view, html, NULL, NULL, "");
}
mc_free(lyric);
}
void
xs_gpt_constructor(xsMachine *the)
{
int id = xsToInteger(xsArg(0));
int channel = xsToInteger(xsArg(1));
mc_gpt_t *gpt;
if (id >= MC_GPT_MAX_ID)
mc_xs_throw(the, "gpt: bad arg");
if (!mc_gpt_ids[id]) {
gpt_drv_init(id);
mc_gpt_ids[id]++;
}
if ((gpt = mc_malloc(sizeof(mc_gpt_t))) == NULL)
mc_xs_throw(the, "gpt: no mem");
gpt->id = id;
gpt->channel = channel;
gpt->running = 0;
xsSetHostData(xsThis, gpt);
}
void add_seg_entry(cue_entry_t * e, segmenter_t * s)
{
log_debug("lock segment list");
seglist_lock(SEGMENT_LIST);
{
log_debug("first look if we need to destroy a segment");
seg_entry_t *se;
se = seglist_start_iter(SEGMENT_LIST, LIST_FIRST);
double count_mb = 0.0;
while (se != NULL) {
count_mb += segmenter_size(se->segment) / (1024.0 * 1024.0);
se = seglist_next_iter(SEGMENT_LIST);
}
log_debug("drop last ones as long we're above our memory limit");
int n = seglist_count(SEGMENT_LIST);
int k = 0;
while (((int)count_mb) > MAX_MEM_USAGE_IN_MB && k < 5) {
se = seglist_start_iter(SEGMENT_LIST, LIST_LAST);
if (se != NULL) {
if (segmenter_stream(se->segment) == NULL) {
count_mb -= segmenter_size(se->segment) / (1024.0 * 1024.0);
seglist_drop_iter(SEGMENT_LIST);
k = 0;
} else {
seglist_move_iter(SEGMENT_LIST, LIST_FIRST);
k += 1;
}
} else {
count_mb = 0;
}
}
log_debug("add our segment on front");
se = (seg_entry_t *) mc_malloc(sizeof(seg_entry_t));
se->id = cue_entry_alloc_id(e);
se->segment = s;
seglist_start_iter(SEGMENT_LIST, LIST_FIRST);
seglist_prepend_iter(SEGMENT_LIST, se);
}
log_debug("unlock segmentlist");
seglist_unlock(SEGMENT_LIST);
}
void
xs_i2c_constructor(xsMachine *the)
{
wm_i2c *i2c;
int ac = xsToInteger(xsArgc);
int port = xsToInteger(xsArg(0));
uint8_t addr = (uint8_t)xsToInteger(xsArg(1));
int fast = ac > 2 ? xsToBoolean(xsArg(2)) : false;
if ((i2c = mc_malloc(sizeof(wm_i2c))) == NULL)
mc_xs_throw(the, "I2C: no mem");
i2c->port = port;
i2c->reg = (i2c_reg_t *)i2cAddr[port];
i2c->slave_addr = addr;
i2c->fast = fast;
i2c->txtout = i2c->rxtout = DEFAULT_TOUT;
i2c->scl_low = fast ? MIN_SCL_LOW_TIME_FAST : MIN_SCL_LOW_TIME_STANDARD;
i2c->scl_high = fast ? MIN_SCL_HIGH_TIME_FAST : MIN_SCL_HIGH_TIME_STANDARD;
i2c_init(i2c);
xsSetHostData(xsThis, i2c);
}
static char *isCueFile(const char *full_path)
{
char *fp = (char *)mc_malloc(strlen(full_path) + strlen(".cue") + 1);
char *cues[] = { ".cue", ".Cue", ".cUe", ".cuE", ".CUe", ".CuE", ".cUE", ".CUE",
NULL
};
int i;
for (i = 0; cues[i] != NULL; i++) {
sprintf(fp, "%s%s", full_path, cues[i]);
FILE *f = fopen(fp, "r");
if (f != NULL) {
fclose(f);
return fp;
}
}
mc_free(fp);
return NULL;
}
void read_in_sizes(const char *from_file) {
FILE *f = fopen(from_file, "rt");
if (f==NULL) {
return;
}
char *line = (char *) mc_malloc(10240*sizeof(char));
if (fgets(line, 10240, f) != NULL) {
char *ln = trim(line);
if (strcmp(ln, VFILESIZE_FILE_TYPE) == 0) {
if (fgets(line, 10240, f) != NULL) {
char *ln1 = trim(line);
if (strcmp(ln1, VFILESIZE_FILE_VERSION) == 0) {
while (fgets(line, 10240, f) != NULL) {
char *ln2 = trim(line);
char *vfile = mc_strdup( ln2 );
fgets(line, 10240, f);
char *ln3 = trim( line );
size_t size = (size_t) strtoul(ln3, NULL, 10);
fgets(line, 10240, f);
char *ln4 = trim (line);
time_t mtime = (time_t) strtoul(ln4, NULL, 10);
put_size( vfile, size, mtime );
mc_free( vfile);
mc_free( ln4 );
mc_free( ln3 );
mc_free( ln2 );
}
}
mc_free( ln1 );
}
}
mc_free( ln );
}
mc_free(line);
fclose(f);
}
void library_view_edit_lyric(GtkToolButton *btn, GObject *lview)
{
library_view_t* view = (library_view_t*) g_object_get_data(lview, "library_view_t");
if (view->current_lyric_track_id != NULL) {
track_t* t = library_get(view->library, view->current_lyric_track_id);
if (t != NULL) {
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_lyr_edit_track"));
char* s = (char*) mc_malloc(strlen(track_get_artist(t))+sizeof(", ")+strlen(track_get_title(t))+200);
sprintf(s,"<span size=\"x-small\"><i><b>%s\n%s</b></i></span>", track_get_artist(t), track_get_title(t));
gtk_label_set_markup(lbl,s);
mc_free(s);
GtkDialog* dlg = GTK_DIALOG(gtk_builder_get_object(view->builder, "dlg_edit_lyric"));
g_object_set_data(G_OBJECT(dlg), "track", (gpointer) t );
GtkTextView* tv = GTK_TEXT_VIEW(gtk_builder_get_object(view->builder, "txt_lyric_edit"));
GtkTextBuffer* buf = gtk_text_view_get_buffer(tv);
const char* lyric = track_get_lyric(t);
gtk_text_buffer_set_text(buf, lyric, -1);
int response = gtk_dialog_run(dlg);
if (response) {
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset(buf, &start, 0);
gtk_text_buffer_get_iter_at_offset(buf, &end, -1);
char* txt = gtk_text_buffer_get_text(buf, &start, &end, FALSE);
write_lyric(t, txt, el_true);
track_set_lyric(t, txt);
char* html = lyric_text_to_html(txt);
webkit_web_view_load_string(view->lyric_view, html, NULL, NULL, "");
mc_free(html);
g_free(txt);
}
gtk_widget_hide(GTK_WIDGET(dlg));
}
}
}
void
xs_env_constructor(xsMachine *the)
{
int ac = xsToInteger(xsArgc);
const char *partname = ac > 0 ? xsToString(xsArg(0)) : MC_ENV_DEFAULT_PATH;
int autosave = ac > 1 && xsTest(xsArg(1));
int encrypt = ac > 2 && xsTest(xsArg(2));
int recovery = ac <= 3 || xsTest(xsArg(3));
mc_env_t *env;
if (mc_env_init())
mc_xs_throw(the, "mc_env: init fail");
if (strcmp(partname, MC_ENV_DEFAULT_PATH) == 0)
env = NULL;
else {
if ((env = mc_malloc(sizeof(mc_env_t))) == NULL)
mc_xs_throw(the, "mc_env: no mem");
if (mc_env_new(env, partname, encrypt, recovery) != 0)
mc_xs_throw(the, "mc_env: new fail");
}
mc_env_autosave(env, autosave);
xsSetHostData(xsThis, env);
}
void
xs_i2c_write(xsMachine *the)
{
wm_i2c *i2c = xsGetHostData(xsThis);
int ac = xsToInteger(xsArgc);
int reg;
uint8_t *data;
int datasize;
uint8_t num;
uint8_t *allocated = NULL;
if (ac < 2)
return;
#if I2C_SUPPORT_CONCURRENCY
if (i2c->slave_addr != i2c_current_slave_addr)
i2c_config(i2c);
#endif
switch (xsTypeOf(xsArg(0))) {
case xsNumberType:
case xsIntegerType:
reg = xsToInteger(xsArg(0));
break;
default:
reg = -1;
break;
}
switch (xsTypeOf(xsArg(1))) {
case xsIntegerType:
case xsNumberType:
num = (uint8_t)xsToInteger(xsArg(1));
data = #
datasize = 1;
break;
case xsReferenceType:
if (xsIsInstanceOf(xsArg(1), xsArrayPrototype)) {
int i;
xsVars(1);
xsGet(xsVar(0), xsArg(1), xsID("length"));
datasize = xsToInteger(xsVar(0));
if ((allocated = mc_malloc(datasize)) == NULL)
mc_xs_throw(the, "no mem");
for (i = 0; i < datasize; i++) {
xsGet(xsVar(0), xsArg(1), (xsIndex)i);
allocated[i] = (uint8_t)xsToInteger(xsVar(0));
}
data = allocated;
}
else {
datasize = xsGetArrayBufferLength(xsArg(1));
data = xsToArrayBuffer(xsArg(1));
}
break;
default:
mc_xs_throw(the, "args");
return; /* NOT REACHED */
}
if (ac > 2) {
int n = xsToInteger(xsArg(2));
if (datasize > n)
datasize = n;
}
if (!i2c_wait_for_ack(i2c, i2c->txtout))
mc_log_debug("I2C: write: no ack!\n");
if (!i2c_write_bytes(i2c, reg, data, datasize))
goto bail;
(void)i2c_wait_tx_fifo(i2c); /* send the stop sequence */
if (allocated != NULL)
mc_free(allocated);
xsSetTrue(xsResult);
bail:
return;
}
static gboolean library_view_update_info(library_view_t* view)
{
if (view->run_timeout) {
// update play buttons
playlist_player_t* player = backtobasics_player(view->btb);
if (view->btn_play == NULL) {
view->btn_play = GTK_WIDGET(gtk_builder_get_object(view->builder, "tbtn_library_play"));
}
if (view->btn_pause == NULL) {
view->btn_pause = GTK_WIDGET(gtk_builder_get_object(view->builder, "tbtn_library_pause"));
}
GtkWidget* btn_play = view->btn_play;
GtkWidget* btn_pause = view->btn_pause;
if (!playlist_player_is_playing(player)) {
if (!gtk_widget_get_visible(btn_play)) gtk_widget_show_all(btn_play);
if (gtk_widget_get_visible(btn_pause)) gtk_widget_hide(btn_pause);
} else if (playlist_player_is_playing(player)) {
if (gtk_widget_get_visible(btn_play)) gtk_widget_hide(btn_play);
if (!gtk_widget_get_visible(btn_pause)) gtk_widget_show_all(btn_pause);
}
// update slider and time
long tr_tm = playlist_player_get_track_position_in_ms(player);
track_t* track = playlist_player_get_track(player);
int index = playlist_player_get_track_index(player);
int a = tr_tm / 1000;
int b = view->time_in_ms / 1000;
if (a != b) {
view->time_in_ms = tr_tm;
int min = tr_tm / 1000 / 60;
int sec = (tr_tm / 1000) % 60;
{
char s[200];
sprintf(s,"<span size=\"x-small\"><b><i>%02d:%02d</i></b></span>", min, sec);
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_time"));
gtk_label_set_markup(lbl, s);
// update presets
reflect_presets(view->btb);
}
GtkScale* sc_playback = GTK_SCALE(gtk_builder_get_object(view->builder, "sc_library_playback"));
double perc = 0.0;
if (track != NULL) {
int len_in_ms = track_get_length_in_ms(track);
if (len_in_ms != view->len_in_ms) {
view->len_in_ms = len_in_ms;
int min = len_in_ms / 1000 / 60;
int sec = (len_in_ms / 1000) % 60;
{
char s[200];
sprintf(s,"<span size=\"x-small\"><b><i>%02d:%02d</i></b></span>", min, sec);
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_total"));
gtk_label_set_markup(lbl, s);
}
}
perc = (((double) tr_tm) / ((double) len_in_ms)) * 100.0;
if (!view->sliding) {
gtk_range_set_value(GTK_RANGE(sc_playback), perc);
}
}
// update track info
if (index != view->track_index ||
(track != NULL && track_get_id(track) != view->track_id)) {
log_debug3("updating track info, index = %d, %p", index, track);
view->track_index = index;
if (track != NULL) {
// fetch lyric if possible
if (strcmp(track_get_lyric(track),"") == 0) {
struct lyric_cb* cb = (struct lyric_cb*) mc_malloc(sizeof(struct lyric_cb));
cb->track_id = mc_strdup(track_get_id(track));
cb->view = view;
fetch_lyric(track, library_view_process_lyric, cb);
} else {
struct lyric_cb* cb = (struct lyric_cb*) mc_malloc(sizeof(struct lyric_cb));
cb->track_id = mc_strdup(track_get_id(track));
cb->view = view;
library_view_process_lyric(mc_strdup(track_get_lyric(track)), cb);
}
// Print artist info
view->track_id = track_get_id(track);
log_debug2("artid = %s", track_get_artid(track));
char s[200];
char c = ',';
char c1 = ',';
char *artist = text_to_html(track_get_artist(track));
char *title = text_to_html(track_get_title(track));
char *piece = text_to_html(track_get_piece(track));
if (strcmp(track_get_artist(track), "") == 0) { c = ' '; }
if (strcmp(track_get_piece(track), "") == 0) { c1 = ' '; }
snprintf(s, 125,
"%s%c %s%c %s",
artist,
c,
piece,
c1,
title
);
mc_free(artist);
mc_free(title);
mc_free(piece);
char ss[400];
log_debug2("s = %s", s);
sprintf(ss,"<span size=\"x-small\"><i><b>%s</b></i></span>",s);
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_song_info"));
gtk_label_set_markup(lbl, ss);
log_debug2("artid = %s", track_get_artid(track));
file_info_t* info = file_info_new(track_get_artid(track));
if (!file_info_is_file(info)) {
file_info_destroy(info);
char *path = backtobasics_logo(view->btb);
info = file_info_new(path);
mc_free(path);
//info = file_info_new(backtobasics_logo(view->btb));
}
if (file_info_is_file(info)) {
GError *err = NULL;
GdkPixbuf* pb = gdk_pixbuf_new_from_file_at_scale(file_info_path(info),
view->img_w, view->img_h,
TRUE,
&err
);
if (pb != NULL) {
GtkImage* img = GTK_IMAGE(gtk_builder_get_object(view->builder, "img_art"));
gtk_image_set_from_pixbuf(img, pb);
g_object_unref(pb);
} else {
log_error3("error loading image art: %d, %s", err->code, err->message);
//g_free(err);
}
}
file_info_destroy(info);
}
log_debug("track hash");
// Select the track in the librarylist if the librarylist is still
// the same
if (playlist_model_tracks_hash(view->playlist_model) == playlist_player_get_hash(player)) {
GtkTreeView* tview = view->tview;
GtkTreePath* path = gtk_tree_path_new();
gtk_tree_path_append_index(path, index);
gtk_tree_view_set_cursor(tview, path, NULL, FALSE);
gtk_tree_path_free(path);
}
log_debug("track hash 2");
}
//log_debug3("lib hash = %lld, pl hash = %lld", view->library_list_hash, playlist_player_get_hash(player));
// TODO
if (playlist_model_tracks_hash(view->playlist_model) == playlist_player_get_hash(player)) {
//view->track_index = -1;
} else {
GtkTreeView* tview = view->tview;
GtkTreeSelection* sel = gtk_tree_view_get_selection(tview);
gtk_tree_selection_unselect_all(sel);
}
}
// update repeat info
playlist_player_repeat_t repeat = playlist_player_get_repeat(player);
if (view->repeat != repeat) {
log_debug3("repeat = %d, view repeat = %d", repeat, view->repeat);
view->repeat = repeat;
GtkWidget* r_btn = GTK_WIDGET(gtk_builder_get_object(view->builder, "tbtn_repeat"));
GtkWidget* r1_btn = GTK_WIDGET(gtk_builder_get_object(view->builder, "tbtn_repeat_one"));
GtkWidget* rlist_btn = GTK_WIDGET(gtk_builder_get_object(view->builder, "tbtn_repeat_all"));
log_debug4("r = %p, r1 = %p, rall = %p", r_btn, r1_btn, rlist_btn);
switch (repeat) {
case PLP_NO_REPEAT: {
gtk_widget_show_all(r_btn);
gtk_widget_hide(rlist_btn);
gtk_widget_hide(r1_btn);
}
break;
case PLP_TRACK_REPEAT: {
gtk_widget_hide(r_btn);
gtk_widget_show_all(r1_btn);
gtk_widget_hide(rlist_btn);
}
break;
case PLP_LIST_REPEAT: {
gtk_widget_hide(r1_btn);
gtk_widget_show_all(rlist_btn);
gtk_widget_hide(r_btn);
}
break;
}
}
return TRUE;
} else {
return FALSE;
}
}
static int
load_elf(const char *path, void **basep, struct mc_module **modp)
{
struct mc_elf elf;
unsigned int i;
uint32_t psize = 0, sz;
uint8_t *base = NULL;
uint8_t *paddr = NULL, *adr;
struct mc_module *mod = NULL;
int err = -1;
mc_log_debug("ELF: loading %s...\n", path);
if (mc_elf_open(path, &elf) != 0) {
mc_log_error("ELF: cannot open %s\n", path);
return -1;
}
/* calculate the entire program size in VM */
for (i = 0; i < NUM_EXT_SECTIONS; i++) {
if (mc_elf_get_section_addr_and_size(&elf, ext_sections[i], &adr, &sz) != 0)
continue;
if (adr >= paddr) {
paddr = adr;
psize = (uint32_t)paddr + sz;
}
}
mc_log_debug("ELF: allocating %d bytes...\n", (unsigned int)psize);
if ((base = mc_malloc(psize)) == NULL)
goto bail;
/* load each section */
for (i = 0; i < NUM_EXT_SECTIONS; i++) {
if (mc_elf_load_section(&elf, ext_sections[i], base) != 0)
mc_log_error("cannot load %s (%d)\n", ext_sections[i], err);
}
#if 0
/* adjust function(?) addresses */
if (mc_elf_get_section_addr_and_size(&elf, ".got", &adr, &sz) == 0) {
uint32_t *gadr = (uint32_t *)(adr + (uint32_t)base), *eadr = (uint32_t *)(adr + (uint32_t)base + sz);
for (; gadr < eadr; gadr++) {
/*
if (*gadr & 0xf0000000) {
*gadr = (*gadr & ~0xf0000000) + (uint32_t)base;
mc_log_debug("adjusted: 0x%lx\n", *gadr);
}
*/
*gadr += (uint32_t)base;
}
}
#endif
/* relocate variables */
if (mc_elf_set_position(&elf, ".rel.dyn") == 0) {
struct elf_rel rel;
while (mc_elf_read(&elf, &rel, sizeof(rel)) == 0) {
switch (ELF32_R_TYPE(rel.info)) {
case 0x17: /* R_ARM_RELATIVE */
*(uint32_t *)(rel.offset + (uint32_t)base) += (uint32_t)base;
// mc_log_debug("RELOC (rel): %x: %x\n", rel.offset, *(uint32_t *)(rel.offset + (uint32_t)base));
break;
case 0x02: { /* R_ARM_ABS32 */
struct elf_sym sym;
if (mc_elf_get(&elf, ".dynsym", &sym, sizeof(sym), ELF32_R_SYM(rel.info)) != 0) {
mc_log_error("cannot read .dynsym %ld\n", ELF32_R_SYM(rel.info));
goto bail;
}
*(uint32_t *)(rel.offset + (uint32_t)base) = sym.value + (uint32_t)base;
// mc_log_debug("RELOC (abs): %x: %x\n", rel.offset, *(uint32_t *)(rel.offset + (uint32_t)base));
break;
}
default:
/* no-op */
mc_log_error("RELOC unknown type: 0x%x\n", ELF32_R_TYPE(rel.info));
break;
}
}
}
paddr = mc_elf_get_entry(&elf);
// mc_log_debug("ELF: entry = 0x%lx, base = 0x%lx\n", (uint32_t)paddr, (uint32_t)base);
paddr += (uint32_t)base;
mod = (struct mc_module *)paddr;
*mod->stubs = (const void **)ext_stubs;
*mod->num_stubs = num_ext_stubs;
*basep = base;
*modp = mod;
err = 0;
bail:
mc_elf_close(&elf);
if (err != 0 && base != NULL)
mc_free(base);
return err;
}
void library_view_init(library_view_t* view)
{
// library view.
GObject* object = gtk_builder_get_object(view->builder,"view_library");
g_object_set_data(object, "library_view_t", (gpointer) view);
// playlists (initially not viewed)
//GtkWidget* scw_playlists = GTK_WIDGET(gtk_builder_get_object(view->builder,"scw_playlists"));
//gtk_widget_hide(scw_playlists);
// library list
GtkTreeView* tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_library"));
view->tview = tview;
GtkTreeViewColumn *col;
GtkCellRenderer* renderer;
renderer = gtk_cell_renderer_text_new();
view->cols = (GtkTreeViewColumn**) mc_malloc(sizeof(GtkTreeViewColumn*) * PLAYLIST_MODEL_N_COLUMNS);
playlist_column_enum e;
for(e = PLAYLIST_MODEL_COL_NR; e < PLAYLIST_MODEL_N_COLUMNS; ++e) {
col = gtk_tree_view_column_new_with_attributes(i18n_column_name(e), renderer, "text", e, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
char path [500];
sprintf(path, "library.column.%s.width", column_id(e));
int width = el_config_get_int(btb_config(view->btb), path, 100);
if (width < 10) { width = 100; }
g_object_set_data(G_OBJECT(col), "column_id", (gpointer) column_id(e));
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(col, "clicked", (GCallback) library_view_library_col_sort, view);
g_signal_connect (col, "notify::width", G_CALLBACK (library_view_col_width_set), view);
view->cols[e] = col;
g_object_ref(view->cols[e]);
gtk_tree_view_append_column(tview, col);
}
gtk_tree_view_set_model(tview, GTK_TREE_MODEL(playlist_model_gtk_model(view->playlist_model)));
// Aspect lists
int width;
// Genres
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_genre_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Genre"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->genre_model));
// Artists
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_artist_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->artist_model));
// Albums
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_album_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->album_model));
// Activate genres
library_view_aspect_page(view, GENRE_ASPECT);
GtkToggleToolButton* g_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_genres"));
gtk_toggle_tool_button_set_active(g_btn, TRUE);
// playback scale, song info
GtkScale* sc_playback = GTK_SCALE(gtk_builder_get_object(view->builder, "sc_library_playback"));
gtk_range_set_range(GTK_RANGE(sc_playback), 0.0, 100.0);
{
char ss[300];
sprintf(ss,"<span size=\"x-small\"><i><b> </b></i></span>");
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_song_info"));
gtk_label_set_markup(lbl, ss);
}
// Set logo
{
char *path = backtobasics_logo(view->btb);
file_info_t* info = file_info_new(path);
mc_free(path);
if (file_info_is_file(info)) {
GError *err = NULL;
GdkPixbuf* pb = gdk_pixbuf_new_from_file_at_scale(file_info_path(info),
view->img_w, view->img_h,
TRUE,
&err
);
GtkImage* img = GTK_IMAGE(gtk_builder_get_object(view->builder, "img_art"));
gtk_widget_set_size_request(GTK_WIDGET(img), view->img_w, view->img_h);
if (pb != NULL) {
gtk_image_set_from_pixbuf(img, pb);
g_object_unref(pb);
} else {
log_error3("error loading image art: %d, %s", err->code, err->message);
//g_free(err);
}
}
file_info_destroy(info);
}
// Playlists
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_playlists"));
col = gtk_tree_view_column_new_with_attributes(_("Playlist"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
width = el_config_get_int(btb_config(view->btb), "library.playlists.column_width", 200);
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, playlists_model_gtk_model(view->playlists_model));
// Lyric view
view->lyric_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
view->lbl_lyric_track = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_lyric_track"));
GtkScrolledWindow* scw_lyric = GTK_SCROLLED_WINDOW(gtk_builder_get_object(view->builder, "scw_lyric"));
gtk_container_add(GTK_CONTAINER(scw_lyric), GTK_WIDGET(view->lyric_view));
// visibility of columns
{
const char* names[] = {
"chk_col_nr", "chk_col_title", "chk_col_artist", "chk_col_composer",
"chk_col_piece", "chk_col_album", "chk_col_albumartist", "chk_col_genre",
"chk_col_year", "chk_col_length", NULL
};
const playlist_column_enum es[] = {
PLAYLIST_MODEL_COL_NR, PLAYLIST_MODEL_COL_TITLE, PLAYLIST_MODEL_COL_ARTIST,
PLAYLIST_MODEL_COL_COMPOSER, PLAYLIST_MODEL_COL_PIECE,
PLAYLIST_MODEL_COL_ALBUM_TITLE, PLAYLIST_MODEL_COL_ALBUM_ARTIST,
PLAYLIST_MODEL_COL_GENRE, PLAYLIST_MODEL_COL_YEAR, PLAYLIST_MODEL_COL_LENGTH,
PLAYLIST_MODEL_N_COLUMNS
};
int i;
for(i = 0;names[i] != NULL; ++i) {
GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(gtk_builder_get_object(view->builder, names[i]));
gtk_widget_set_name(GTK_WIDGET(item), names[i]);
char cfgitem[100];
sprintf(cfgitem, "library.cols.%s", names[i]);
int yes = el_config_get_int(btb_config(view->btb), cfgitem, 1);
gtk_check_menu_item_set_active(item, yes);
gtk_tree_view_column_set_visible(view->cols[es[i]], yes);
}
}
// Start timeout every 250 ms
g_timeout_add(250, (GSourceFunc) library_view_update_info, view);
}
MC_FILE *
mc_fopen(const char *fullpath, const char *mode)
{
MC_FILE *fp;
errno = 0;
if ((fp = mc_malloc(sizeof(MC_FILE))) == NULL) {
errno = ENOMEM;
mc_log_error("mc_fopen: mc_malloc failed\n");
return NULL;
}
fp->ffs = NULL;
fp->mmapped = NULL;
fp->buf = NULL;
fp->bp = fp->bufend = fp->buf;
fp->length = 0;
fp->pos = 0;
#if FTFS || !mxMC
fp->aux = NULL;
#endif
if ((mode[0] == 'r' && mode[1] != '+') && fullpath[0] != '/') {
size_t sz;
const void *p = mc_mmap(fullpath, &sz);
if (p != NULL) {
fp->mmapped = p;
fp->length = sz;
fp->bp = fp->buf = (uint8_t *)p;
fp->bufend = fp->buf + sz;
fp->pos = (long)sz;
}
else {
#if FTFS
if ((fp->aux = mc_ft_fopen(fullpath, mode)) != NULL) {
fp->length = mc_ft_fseek(fp->aux, 0L, SEEK_END);
mc_ft_fseek(fp->aux, 0L, SEEK_SET);
}
else
errno = ENOENT;
#else
errno = ENOENT;
#endif
}
}
else {
uint32_t flags = 0;
#if !mxMC
if (sync_with_native_path(fullpath)) {
const char *path = mc_resolve_path(fullpath, *mode == 'r' ? 0 : 1);
fp->aux = fopen(path, mode);
errno = 0;
}
#endif
if (strlen(mode) > 1) {
switch (mode[1]) {
case '+':
flags |= FFS_ORDWR;
break;
case 'p':
flags |= FFS_OPASSIVE;
break;
case 'a':
flags |= FFS_OACTIVE;
break;
}
}
if (mode[0] == 'w')
flags |= FFS_OTRUNC | FFS_OCREAT;
if ((fp->ffs = mc_ffs_open(fullpath, flags)) != NULL)
fp->length = mc_ffs_position(fp->ffs, 1L << 30, mode[0] == 'a');
else {
/* errno must've been set */
if (errno != ENOENT)
mc_log_error("mc_fopen: ffs_open failed: %d\n", errno);
}
}
if (errno == 0) {
if (fp->mmapped == NULL) {
if ((fp->buf = mc_malloc(MC_STREAM_BUFSIZ)) != NULL)
fp->bufend = fp->bp = fp->buf;
else {
mc_log_error("mc_fopen: mc_malloc failed\n");
errno = ENOMEM;
}
}
}
if (errno != 0) {
if (fp != NULL)
mc_fclose(fp);
fp = NULL;
}
return fp;
}
