/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % A c q u i r e V i r t u a l M e m o r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % AcquireVirtualMemory() allocates a pointer to a block of memory at least size % bytes suitably aligned for any use. % % The format of the AcquireVirtualMemory method is: % % MemoryInfo *AcquireVirtualMemory(const size_t count,const size_t quantum) % % A description of each parameter follows: % % o count: the number of quantum elements to allocate. % % o quantum: the number of bytes in each quantum. % */ MagickExport MemoryInfo *AcquireVirtualMemory(const size_t count, const size_t quantum) { MemoryInfo *memory_info; size_t length; length=count*quantum; if ((count == 0) || (quantum != (length/count))) { errno=ENOMEM; return((void *) NULL); } memory_info=(MemoryInfo *) MagickAssumeAligned(AcquireAlignedMemory(1, sizeof(*memory_info))); if (memory_info == (MemoryInfo *) NULL) ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); (void) ResetMagickMemory(memory_info,0,sizeof(*memory_info)); memory_info->length=length; memory_info->signature=MagickSignature; memory_info->blob=AcquireMagickMemory(length); if (memory_info->blob == NULL) { /* Heap memory failed, try anonymous memory mapping. */ memory_info->mapped=MagickTrue; memory_info->blob=MapBlob(-1,IOMode,0,length); } if (memory_info->blob == NULL) { int file; /* Anonymous memory mapping failed, try file-backed memory mapping. */ file=AcquireUniqueFileResource(memory_info->filename); file=open_utf8(memory_info->filename,O_RDWR | O_CREAT | O_BINARY | O_EXCL, S_MODE); if (file == -1) file=open_utf8(memory_info->filename,O_RDWR | O_BINARY,S_MODE); if (file != -1) { if ((lseek(file,length-1,SEEK_SET) >= 0) && (write(file,"",1) == 1)) memory_info->blob=MapBlob(file,IOMode,0,length); (void) close(file); } } if (memory_info->blob == NULL) return(RelinquishVirtualMemory(memory_info)); return(memory_info); }
void shortcuts_init(void) { int fd; char buf[512]; struct shortcut *param = NULL; struct shortcut_handle *h; shortcut_count = 0; fd = open_utf8(SHORTCUTS_FILENAME, O_RDONLY); if (fd < 0) return; first_handle = core_alloc("shortcuts_head", sizeof(struct shortcut_handle)); if (first_handle <= 0) return; h = core_get_data(first_handle); h->next_handle = 0; fast_readline(fd, buf, sizeof buf, ¶m, readline_cb); close(fd); if (param && verify_shortcut(param)) shortcut_count++; }
MagickExport int AcquireUniqueFileResource(char *path) { #if !defined(O_NOFOLLOW) #define O_NOFOLLOW 0 #endif #if !defined(TMP_MAX) # define TMP_MAX 238328 #endif int c, file; register char *p; register ssize_t i; static const char portable_filename[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-"; StringInfo *key; unsigned char *datum; assert(path != (char *) NULL); (void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s",path); if (random_info == (RandomInfo *) NULL) random_info=AcquireRandomInfo(); file=(-1); for (i=0; i < (ssize_t) TMP_MAX; i++) { /* Get temporary pathname. */ (void) GetPathTemplate(path); key=GetRandomKey(random_info,2); p=path+strlen(path)-8; datum=GetStringInfoDatum(key); for (i=0; i < (ssize_t) GetStringInfoLength(key); i++) { c=(int) (datum[i] & 0x3f); *p++=portable_filename[c]; } key=DestroyStringInfo(key); #if defined(MAGICKCORE_HAVE_MKSTEMP) file=mkstemp(path); #if defined(__OS2__) setmode(file,O_BINARY); #endif if (file != -1) break; #endif key=GetRandomKey(random_info,6); p=path+strlen(path)-6; datum=GetStringInfoDatum(key); for (i=0; i < (ssize_t) GetStringInfoLength(key); i++) { c=(int) (datum[i] & 0x3f); *p++=portable_filename[c]; } key=DestroyStringInfo(key); file=open_utf8(path,O_RDWR | O_CREAT | O_EXCL | O_BINARY | O_NOFOLLOW,S_MODE); if ((file >= 0) || (errno != EEXIST)) break; } (void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s",path); if (file == -1) return(file); if (resource_semaphore == (SemaphoreInfo *) NULL) AcquireSemaphoreInfo(&resource_semaphore); LockSemaphoreInfo(resource_semaphore); if (temporary_resources == (SplayTreeInfo *) NULL) temporary_resources=NewSplayTree(CompareSplayTreeString, DestroyTemporaryResources,(void *(*)(void *)) NULL); UnlockSemaphoreInfo(resource_semaphore); (void) AddValueToSplayTree(temporary_resources,ConstantString(path), (const void *) NULL); return(file); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e M P E G I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % WriteMPEGImage() writes an image to a file in MPEG video stream format. % Lawrence Livermore National Laboratory (LLNL) contributed code to adjust % the MPEG parameters to correspond to the compression quality setting. % % The format of the WriteMPEGImage method is: % % MagickBooleanType WriteMPEGImage(const ImageInfo *image_info, % Image *image,ExceptionInfo *exception) % % A description of each parameter follows. % % o image_info: the image info. % % o image: The image. % % o exception: return any errors or warnings in this structure. % */ static MagickBooleanType CopyDelegateFile(const char *source, const char *destination) { int destination_file, source_file; MagickBooleanType status; register size_t i; size_t length, quantum; ssize_t count; struct stat attributes; unsigned char *buffer; /* Return if destination file already exists and is not empty. */ assert(source != (const char *) NULL); assert(destination != (char *) NULL); status=GetPathAttributes(destination,&attributes); if ((status != MagickFalse) && (attributes.st_size > 0)) return(MagickTrue); /* Copy source file to destination. */ destination_file=open_utf8(destination,O_WRONLY | O_BINARY | O_CREAT,S_MODE); if (destination_file == -1) return(MagickFalse); source_file=open_utf8(source,O_RDONLY | O_BINARY,0); if (source_file == -1) { (void) close(destination_file); return(MagickFalse); } quantum=(size_t) MagickMaxBufferExtent; if ((fstat(source_file,&attributes) == 0) && (attributes.st_size > 0)) quantum=(size_t) MagickMin((double) attributes.st_size, MagickMaxBufferExtent); buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer)); if (buffer == (unsigned char *) NULL) { (void) close(source_file); (void) close(destination_file); return(MagickFalse); } length=0; for (i=0; ; i+=count) { count=(ssize_t) read(source_file,buffer,quantum); if (count <= 0) break; length=(size_t) count; count=(ssize_t) write(destination_file,buffer,length); if ((size_t) count != length) break; } (void) close(destination_file); (void) close(source_file); buffer=(unsigned char *) RelinquishMagickMemory(buffer); return(i != 0 ? MagickTrue : MagickFalse); }
/* parse cuesheet "file" and store the information in "cue" */ bool parse_cuesheet(char *file, struct cuesheet *cue) { char line[MAX_PATH]; char *s; bool utf8 = false; int fd = open_utf8(file,O_RDONLY); if (fd < 0) { /* couln't open the file */ return false; } if(lseek(fd, 0, SEEK_CUR) > 0) utf8 = true; /* Initialization */ memset(cue, 0, sizeof(struct cuesheet)); strcpy(cue->path, file); cue->curr_track = cue->tracks; while ( read_line(fd,line,MAX_PATH) && cue->track_count < MAX_TRACKS ) { s = skip_whitespace(line); if (!strncmp(s, "TRACK", 5)) { cue->track_count++; } else if (!strncmp(s, "INDEX 01", 8)) { s = strchr(s,' '); s = skip_whitespace(s); s = strchr(s,' '); s = skip_whitespace(s); cue->tracks[cue->track_count-1].offset = 60*1000 * atoi(s); s = strchr(s,':') + 1; cue->tracks[cue->track_count-1].offset += 1000 * atoi(s); s = strchr(s,':') + 1; cue->tracks[cue->track_count-1].offset += 13 * atoi(s); } else if (!strncmp(s, "TITLE", 5) || !strncmp(s, "PERFORMER", 9) || !strncmp(s, "SONGWRITER", 10)) { char *dest = NULL; char *string = get_string(s); if (!string) break; switch (*s) { case 'T': /* TITLE */ dest = (cue->track_count <= 0) ? cue->title : cue->tracks[cue->track_count-1].title; break; case 'P': /* PERFORMER */ dest = (cue->track_count <= 0) ? cue->performer : cue->tracks[cue->track_count-1].performer; break; case 'S': /* SONGWRITER */ dest = (cue->track_count <= 0) ? cue->songwriter : cue->tracks[cue->track_count-1].songwriter; break; } if (dest) { if (!utf8) { dest = iso_decode(string, dest, -1, MIN(strlen(string), MAX_NAME)); *dest = '\0'; } else { strlcpy(dest, string, MAX_NAME*3 + 1); } } } } close(fd); /* If some songs don't have performer info, we copy the cuesheet performer */ int i; for (i = 0; i < cue->track_count; i++) { if (*(cue->tracks[i].performer) == '\0') strlcpy(cue->tracks[i].performer, cue->performer, MAX_NAME*3); if (*(cue->tracks[i].songwriter) == '\0') strlcpy(cue->tracks[i].songwriter, cue->songwriter, MAX_NAME*3); } return true; }
bool settings_load_config(const char* file, bool apply) { int fd; char line[128]; char* name; char* value; int i; fd = open_utf8(file, O_RDONLY); if (fd < 0) return false; while (read_line(fd, line, sizeof line) > 0) { if (!settings_parseline(line, &name, &value)) continue; for(i=0; i<nb_settings; i++) { if (settings[i].cfg_name == NULL) continue; if (!strcasecmp(name,settings[i].cfg_name)) { switch (settings[i].flags&F_T_MASK) { case F_T_CUSTOM: settings[i].custom_setting->load_from_cfg(settings[i].setting, value); break; case F_T_INT: case F_T_UINT: #ifdef HAVE_LCD_COLOR if (settings[i].flags&F_RGB) hex_to_rgb(value, (int*)settings[i].setting); else #endif if (settings[i].cfg_vals == NULL) { *(int*)settings[i].setting = atoi(value); } else { int temp, *v = (int*)settings[i].setting; bool found = cfg_string_to_int(i, &temp, value); if (found) { if (settings[i].flags&F_TABLE_SETTING) *v = settings[i].table_setting->values[temp]; else *v = temp; } else { /* atoi breaks choice settings because they * don't have int-like values, and would * fall back to the first value (i.e. 0) * due to atoi */ if (!(settings[i].flags&F_CHOICE_SETTING)) *v = atoi(value); } } break; case F_T_BOOL: { int temp; if (cfg_string_to_int(i,&temp,value)) *(bool*)settings[i].setting = (temp!=0); if (settings[i].bool_setting->option_callback) settings[i].bool_setting->option_callback(temp!=0); break; } case F_T_CHARPTR: case F_T_UCHARPTR: { char storage[MAX_PATH]; if (settings[i].filename_setting->prefix) { int len = strlen(settings[i].filename_setting->prefix); if (!strncasecmp(value, settings[i].filename_setting->prefix, len)) { strlcpy(storage, &value[len], MAX_PATH); } else strlcpy(storage, value, MAX_PATH); } else strlcpy(storage, value, MAX_PATH); if (settings[i].filename_setting->suffix) { char *s = strcasestr(storage,settings[i].filename_setting->suffix); if (s) *s = '\0'; } strlcpy((char*)settings[i].setting, storage, settings[i].filename_setting->max_len); break; } } break; } /* if (!strcmp(name,settings[i].cfg_name)) */ } /* for(...) */ } /* while(...) */ close(fd); settings_save(); if (apply) settings_apply(true); return true; }
/* Add "sel" file into specified "playlist". How to insert depends on type of file */ static int add_to_playlist(const char* playlist, bool new_playlist, const char* sel, int sel_attr) { int fd; int result = -1; if (new_playlist) fd = open_utf8(playlist, O_CREAT|O_WRONLY|O_TRUNC); else fd = open(playlist, O_CREAT|O_WRONLY|O_APPEND, 0666); if(fd < 0) return result; /* In case we're in the playlist directory */ reload_directory(); if ((sel_attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO) { /* append the selected file */ if (fdprintf(fd, "%s\n", sel) > 0) result = 0; } else if ((sel_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U) { /* append playlist */ int f, fs, i; char buf[1024]; if(strcasecmp(playlist, sel) == 0) goto exit; f = open_utf8(sel, O_RDONLY); if (f < 0) goto exit; i = lseek(f, 0, SEEK_CUR); fs = filesize(f); while (i < fs) { int n; n = read(f, buf, sizeof(buf)); if (n < 0) break; if (write(fd, buf, n) < 0) break; i += n; } if (i >= fs) result = 0; close(f); } else if (sel_attr & ATTR_DIRECTORY) { /* search directory for tracks and append to playlist */ bool recurse = false; const char *lines[] = { ID2P(LANG_RECURSE_DIRECTORY_QUESTION), sel}; const struct text_message message={lines, 2}; struct add_track_context context; if (global_settings.recursive_dir_insert != RECURSE_ASK) recurse = (bool)global_settings.recursive_dir_insert; else { /* Ask if user wants to recurse directory */ recurse = (gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES); } context.fd = fd; context.count = 0; display_insert_count(0); result = playlist_directory_tracksearch(sel, recurse, add_track_to_playlist, &context); display_insert_count(context.count); } exit: close(fd); return result; }
/* to setup up the wps-data from a format-buffer (isfile = false) from a (wps-)file (isfile = true)*/ bool skin_data_load(enum screen_type screen, struct wps_data *wps_data, const char *buf, bool isfile) { char *wps_buffer = NULL; if (!wps_data || !buf) return false; #ifdef HAVE_ALBUMART int status; struct mp3entry *curtrack; long offset; struct skin_albumart old_aa = {.state = WPS_ALBUMART_NONE}; if (wps_data->albumart) { old_aa.state = wps_data->albumart->state; old_aa.height = wps_data->albumart->height; old_aa.width = wps_data->albumart->width; } #endif #ifdef HAVE_LCD_BITMAP int i; for (i=0;i<MAXUSERFONTS;i++) { skinfonts[i].id = -1; skinfonts[i].name = NULL; } #endif #ifdef DEBUG_SKIN_ENGINE if (isfile && debug_wps) { DEBUGF("\n=====================\nLoading '%s'\n=====================\n", buf); } #endif skin_data_reset(wps_data); wps_data->wps_loaded = false; curr_screen = screen; curr_line = NULL; curr_vp = NULL; curr_viewport_element = NULL; if (isfile) { int fd = open_utf8(buf, O_RDONLY); if (fd < 0) return false; /* get buffer space from the plugin buffer */ size_t buffersize = 0; wps_buffer = (char *)plugin_get_buffer(&buffersize); if (!wps_buffer) return false; /* copy the file's content to the buffer for parsing, ensuring that every line ends with a newline char. */ unsigned int start = 0; while(read_line(fd, wps_buffer + start, buffersize - start) > 0) { start += strlen(wps_buffer + start); if (start < buffersize - 1) { wps_buffer[start++] = '\n'; wps_buffer[start] = 0; } } close(fd); if (start <= 0) return false; } else { wps_buffer = (char*)buf; } #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1 wps_data->backdrop = "-"; wps_data->backdrop_id = -1; #endif /* parse the skin source */ #ifndef APPLICATION skin_buffer_save_position(); #endif wps_data->tree = skin_parse(wps_buffer, skin_element_callback, wps_data); if (!wps_data->tree) { skin_data_reset(wps_data); #ifndef APPLICATION skin_buffer_restore_position(); #endif return false; } #ifdef HAVE_LCD_BITMAP char bmpdir[MAX_PATH]; if (isfile) { /* get the bitmap dir */ char *dot = strrchr(buf, '.'); strlcpy(bmpdir, buf, dot - buf + 1); } else { /* fall back to backdrop dir for built-in themes */ /* no get_user_file_path(), assuming we ship bmps for built-in themes */ snprintf(bmpdir, MAX_PATH, "%s", BACKDROP_DIR); } /* load the bitmaps that were found by the parsing */ if (!load_skin_bitmaps(wps_data, bmpdir) || !skin_load_fonts(wps_data)) { skin_data_reset(wps_data); #ifndef APPLICATION skin_buffer_restore_position(); #endif return false; } #endif #if defined(HAVE_ALBUMART) && !defined(__PCTOOL__) status = audio_status(); if (status & AUDIO_STATUS_PLAY) { struct skin_albumart *aa = wps_data->albumart; if (aa && ((aa->state && !old_aa.state) || (aa->state && (((old_aa.height != aa->height) || (old_aa.width != aa->width)))))) { curtrack = audio_current_track(); offset = curtrack->offset; audio_stop(); if (!(status & AUDIO_STATUS_PAUSE)) audio_play(offset); } } #endif wps_data->wps_loaded = true; #ifdef DEBUG_SKIN_ENGINE // if (isfile && debug_wps) // debug_skin_usage(); #endif return true; }