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; }