void MainWindow::deleteCurrentPlaylistItem()
{
QString playlistPath = getCurrentPlaylistPath();
QByteArray playlistArray;
QHash<QString, QString> contentHash = getCurrentContentHash();
playlist_t *playlist = NULL;
const char *playlistData = NULL;
unsigned index = 0;
bool ok = false;
if (playlistPath.isEmpty())
return;
if (contentHash.isEmpty())
return;
playlistArray = playlistPath.toUtf8();
playlistData = playlistArray.constData();
index = contentHash.value("index").toUInt(&ok);
if (!ok)
return;
if (!showMessageBox(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CONFIRM_DELETE_PLAYLIST_ITEM)).arg(contentHash["label"]), MainWindow::MSGBOX_TYPE_QUESTION_YESNO, Qt::ApplicationModal, false))
return;
playlist = playlist_init(playlistData, COLLECTION_SIZE);
playlist_delete_index(playlist, index);
playlist_write_file(playlist);
playlist_free(playlist);
reloadPlaylists();
}
void
playlist_global_init(void)
{
playlist_init(&g_playlist);
event_pipe_register(PIPE_EVENT_TAG, playlist_tag_event);
event_pipe_register(PIPE_EVENT_PLAYLIST, playlist_event);
}
PyMODINIT_FUNC
init_spotify(void)
{
PyObject *m;
if (PyType_Ready(&SessionType) < 0)
return;
if (PyType_Ready(&ArtistType) < 0)
return;
if (PyType_Ready(&ArtistBrowserType) < 0)
return;
if (PyType_Ready(&LinkType) < 0)
return;
if (PyType_Ready(&PlaylistType) < 0)
return;
if (PyType_Ready(&PlaylistContainerType) < 0)
return;
if (PyType_Ready(&ResultsType) < 0)
return;
if (PyType_Ready(&ToplistBrowserType) < 0)
return;
if (PyType_Ready(&TrackType) < 0)
return;
if (PyType_Ready(&ImageType) < 0)
return;
if (PyType_Ready(&UserType) < 0)
return;
m = Py_InitModule("_spotify", module_methods);
if (m == NULL)
return;
PyObject *spotify = PyImport_ImportModule("spotify");
PyObject *d = PyModule_GetDict(spotify);
PyObject *s = PyUnicode_FromString("SpotifyError");
SpotifyError = PyDict_GetItem(d, s);
Py_INCREF(SpotifyError);
SpotifyApiVersion = Py_BuildValue("i", SPOTIFY_API_VERSION);
Py_INCREF(SpotifyApiVersion);
PyModule_AddObject(m, "api_version", SpotifyApiVersion);
album_init(m);
albumbrowser_init(m);
artist_init(m);
artistbrowser_init(m);
link_init(m);
playlist_init(m);
playlistcontainer_init(m);
session_init(m);
search_init(m);
toplistbrowser_init(m);
track_init(m);
image_init(m);
user_init(m);
}
int main()
{
kr_mkv_t *mkv_output;
kr_mkv_t *mkv_input;
kr_mkv_t *settings;
krad_system_init();
// krad_system_log_on("derp.log");
playlist_t *playlist = playlist_init("test.txt");
mkv_output = kr_mkv_create_stream(argv[1], atoi(argv[2]), argv[3], argv[4]);
if(splice_init(settings, mkv_output, playlist) < 0)
{
perror("splice_init");
}
printf("resolution: %d x %d\n", mkv_output->tracks[VIDEO_TRACK].width,
mkv_output->tracks[VIDEO_TRACK].height);
uint32_t i;
while(1)
{
playlist->current_entry = 0;
for(i = 0; i < playlist_count(playlist); i++)
{
if(playlist_current_video(playlist) > 0)
{
printf("playing: %s\n", playlist_current_video(playlist));
mkv_input = kr_mkv_open_file(playlist_current_video(playlist));
if(!mkv_input)
{
perror(playlist_current_video(playlist));
}
splice(mkv_input, mkv_output);
kr_mkv_destroy(&mkv_input);
playlist_next(playlist);
}
}
}
kr_mkv_destroy(&mkv_output);
playlist_destroy(playlist);
return(0);
}
static int task_database_iterate_playlist_lutro(
db_handle_t *_db,
database_state_handle_t *db_state,
database_info_handle_t *db,
const char *path)
{
char *db_playlist_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
playlist_t *playlist = NULL;
db_playlist_path[0] = '\0';
if (!string_is_empty(_db->playlist_directory))
fill_pathname_join(db_playlist_path,
_db->playlist_directory,
file_path_str(FILE_PATH_LUTRO_PLAYLIST),
PATH_MAX_LENGTH * sizeof(char));
playlist = playlist_init(db_playlist_path, COLLECTION_SIZE);
free(db_playlist_path);
if(!playlist_entry_exists(playlist,
path, file_path_str(FILE_PATH_DETECT)))
{
char *game_title = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
game_title[0] = '\0';
fill_short_pathname_representation_noext(game_title,
path, PATH_MAX_LENGTH * sizeof(char));
playlist_push(playlist, path,
game_title,
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_LUTRO_PLAYLIST));
free(game_title);
}
playlist_write_file(playlist);
playlist_free(playlist);
return 0;
}
static int task_database_iterate_playlist_lutro(
database_state_handle_t *db_state,
database_info_handle_t *db,
const char *path)
{
char db_playlist_path[PATH_MAX_LENGTH];
playlist_t *playlist = NULL;
settings_t *settings = config_get_ptr();
db_playlist_path[0] = '\0';
fill_pathname_join(db_playlist_path,
settings->directory.playlist,
file_path_str(FILE_PATH_LUTRO_PLAYLIST),
sizeof(db_playlist_path));
playlist = playlist_init(db_playlist_path, COLLECTION_SIZE);
if(!playlist_entry_exists(playlist, path, file_path_str(FILE_PATH_DETECT)))
{
char game_title[PATH_MAX_LENGTH];
game_title[0] = '\0';
fill_short_pathname_representation_noext(game_title,
path, sizeof(game_title));
playlist_push(playlist, path,
game_title,
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_LUTRO_PLAYLIST));
}
playlist_write_file(playlist);
playlist_free(playlist);
return 0;
}
static int database_info_list_iterate_found_match(
db_handle_t *_db,
database_state_handle_t *db_state,
database_info_handle_t *db,
const char *archive_name
)
{
char *db_crc = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *db_playlist_base_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *db_playlist_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *entry_path_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
playlist_t *playlist = NULL;
const char *db_path =
database_info_get_current_name(db_state);
const char *entry_path =
database_info_get_current_element_name(db);
database_info_t *db_info_entry =
&db_state->info->list[db_state->entry_index];
char *hash;
db_crc[0] = '\0';
db_playlist_path[0] = '\0';
db_playlist_base_str[0] = '\0';
entry_path_str[0] = '\0';
fill_short_pathname_representation_noext(db_playlist_base_str,
db_path, PATH_MAX_LENGTH * sizeof(char));
strlcat(db_playlist_base_str,
file_path_str(FILE_PATH_LPL_EXTENSION),
PATH_MAX_LENGTH * sizeof(char));
if (!string_is_empty(_db->playlist_directory))
fill_pathname_join(db_playlist_path, _db->playlist_directory,
db_playlist_base_str, PATH_MAX_LENGTH * sizeof(char));
playlist = playlist_init(db_playlist_path, COLLECTION_SIZE);
snprintf(db_crc, PATH_MAX_LENGTH * sizeof(char),
"%08X|crc", db_info_entry->crc32);
if (entry_path)
strlcpy(entry_path_str, entry_path, PATH_MAX_LENGTH * sizeof(char));
if (!string_is_empty(archive_name))
fill_pathname_join_delim(entry_path_str,
entry_path_str, archive_name,
'#', PATH_MAX_LENGTH * sizeof(char));
if (core_info_database_match_archive_member(
db_state->list->elems[db_state->list_index].data) &&
(hash = strchr(entry_path_str, '#')))
*hash = '\0';
#if defined(RARCH_INTERNAL)
#if 0
RARCH_LOG("Found match in database !\n");
RARCH_LOG("Path: %s\n", db_path);
RARCH_LOG("CRC : %s\n", db_crc);
RARCH_LOG("Playlist Path: %s\n", db_playlist_path);
RARCH_LOG("Entry Path: %s\n", entry_path);
RARCH_LOG("Playlist not NULL: %d\n", playlist != NULL);
RARCH_LOG("ZIP entry: %s\n", archive_name);
RARCH_LOG("entry path str: %s\n", entry_path_str);
#endif
#else
fprintf(stderr, "Found match in database !\n");
fprintf(stderr, "Path: %s\n", db_path);
fprintf(stderr, "CRC : %s\n", db_crc);
fprintf(stderr, "Playlist Path: %s\n", db_playlist_path);
fprintf(stderr, "Entry Path: %s\n", entry_path);
fprintf(stderr, "Playlist not NULL: %d\n", playlist != NULL);
fprintf(stderr, "ZIP entry: %s\n", archive_name);
fprintf(stderr, "entry path str: %s\n", entry_path_str);
#endif
if(!playlist_entry_exists(playlist, entry_path_str, db_crc))
{
playlist_push(playlist, entry_path_str,
db_info_entry->name,
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),
db_crc, db_playlist_base_str);
}
playlist_write_file(playlist);
playlist_free(playlist);
database_info_list_free(db_state->info);
free(db_state->info);
db_state->info = NULL;
db_state->crc = 0;
free(entry_path_str);
free(db_playlist_path);
free(db_playlist_base_str);
free(db_crc);
/* Move database to start since we are likely to match against it
again */
if (db_state->list_index != 0)
{
struct string_list_elem entry = db_state->list->elems[db_state->list_index];
memmove(&db_state->list->elems[1],
&db_state->list->elems[0],
sizeof(entry) * db_state->list_index);
db_state->list->elems[0] = entry;
}
return 0;
}
int
main(int argc, char *argv[])
{
int c;
char *configFile = NULL;
char *host = NULL;
unsigned short port = 0;
char *mount = NULL;
shout_t *shout;
extern char *optarg;
extern int optind;
#ifdef HAVE_SIGNALS
struct sigaction act;
unsigned int i;
#endif
#ifdef XALLOC_DEBUG
xalloc_initialize_debug(2, NULL);
#else
xalloc_initialize();
#endif /* XALLOC_DEBUG */
playlist_init();
shout_init();
__progname = getProgname(argv[0]);
pezConfig = getEZConfig();
mFlag = 0;
nFlag = 0;
qFlag = 0;
vFlag = 0;
while ((c = local_getopt(argc, argv, "c:hmnqsVv")) != -1) {
switch (c) {
case 'c':
if (configFile != NULL) {
printf("Error: multiple -c arguments given\n");
usage();
return (ez_shutdown(2));
}
configFile = xstrdup(optarg);
break;
case 'h':
usage();
usageHelp();
return (ez_shutdown(0));
case 'm':
mFlag = 1;
break;
case 'n':
nFlag = 1;
break;
case 'q':
qFlag = 1;
break;
case 's':
sFlag = 1;
break;
case 'V':
printf("%s\n", PACKAGE_STRING);
return (ez_shutdown(0));
case 'v':
vFlag++;
break;
case '?':
usage();
return (ez_shutdown(2));
default:
break;
}
}
argc -= optind;
argv += optind;
if (sFlag) {
playlist_t *pl;
const char *entry;
switch (argc) {
case 0:
pl = playlist_read(NULL);
if (pl == NULL)
return (ez_shutdown(1));
break;
case 1:
pl = playlist_read(argv[0]);
if (pl == NULL)
return (ez_shutdown(1));
break;
default:
printf("Error: Too many arguments.\n");
return (ez_shutdown(2));
}
playlist_shuffle(pl);
while ((entry = playlist_get_next(pl)) != NULL)
printf("%s\n", entry);
playlist_free(&pl);
return (ez_shutdown(0));
}
if (configFile == NULL) {
printf("You must supply a config file with the -c argument.\n");
usage();
return (ez_shutdown(2));
} else {
/*
* Attempt to open configFile here for a more meaningful error
* message. Where possible, do it with stat() and check for
* safe config file permissions.
*/
#ifdef HAVE_STAT
struct stat st;
if (stat(configFile, &st) == -1) {
printf("%s: %s\n", configFile, strerror(errno));
usage();
return (ez_shutdown(2));
}
if (vFlag && (st.st_mode & (S_IRGRP | S_IROTH)))
printf("%s: Warning: %s is group and/or world readable\n",
__progname, configFile);
if (st.st_mode & (S_IWGRP | S_IWOTH)) {
printf("%s: Error: %s is group and/or world writeable\n",
__progname, configFile);
return (ez_shutdown(2));
}
#else
FILE *tmp;
if ((tmp = fopen(configFile, "r")) == NULL) {
printf("%s: %s\n", configFile, strerror(errno));
usage();
return (ez_shutdown(2));
}
fclose(tmp);
#endif /* HAVE_STAT */
}
if (!parseConfig(configFile))
return (ez_shutdown(2));
if (pezConfig->URL == NULL) {
printf("%s: Error: Missing <url>\n", configFile);
return (ez_shutdown(2));
}
if (!urlParse(pezConfig->URL, &host, &port, &mount)) {
printf("Must be of the form ``http://server:port/mountpoint''\n");
return (ez_shutdown(2));
}
if (strlen(host) == 0) {
printf("%s: Error: Invalid <url>: Missing server:\n", configFile);
printf("Must be of the form ``http://server:port/mountpoint''\n");
return (ez_shutdown(2));
}
if (strlen(mount) == 0) {
printf("%s: Error: Invalid <url>: Missing mountpoint:\n", configFile);
printf("Must be of the form ``http://server:port/mountpoint''\n");
return (ez_shutdown(2));
}
if (pezConfig->password == NULL) {
printf("%s: Error: Missing <sourcepassword>\n", configFile);
return (ez_shutdown(2));
}
if (pezConfig->fileName == NULL) {
printf("%s: Error: Missing <filename>\n", configFile);
return (ez_shutdown(2));
}
if (pezConfig->format == NULL) {
printf("%s: Warning: Missing <format>:\n", configFile);
printf("Specify a stream format of either MP3, VORBIS or THEORA\n");
}
xfree(configFile);
if ((shout = stream_setup(host, port, mount)) == NULL)
return (ez_shutdown(1));
if (pezConfig->metadataProgram != NULL)
metadataFromProgram = 1;
else
metadataFromProgram = 0;
#ifdef HAVE_SIGNALS
memset(&act, 0, sizeof(act));
act.sa_handler = sig_handler;
# ifdef SA_RESTART
act.sa_flags = SA_RESTART;
# endif
for (i = 0; i < sizeof(ezstream_signals) / sizeof(int); i++) {
if (sigaction(ezstream_signals[i], &act, NULL) == -1) {
printf("%s: sigaction(): %s\n",
__progname, strerror(errno));
return (ez_shutdown(1));
}
}
/*
* Ignore SIGPIPE, which has been seen to give a long-running ezstream
* process trouble. EOF and/or EPIPE are also easier to handle.
*/
act.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &act, NULL) == -1) {
printf("%s: sigaction(): %s\n",
__progname, strerror(errno));
return (ez_shutdown(1));
}
#endif /* HAVE_SIGNALS */
if (shout_open(shout) == SHOUTERR_SUCCESS) {
int ret;
printf("%s: Connected to http://%s:%hu%s\n", __progname,
host, port, mount);
if (pezConfig->fileNameIsProgram ||
strrcasecmp(pezConfig->fileName, ".m3u") == 0 ||
strrcasecmp(pezConfig->fileName, ".txt") == 0)
playlistMode = 1;
else
playlistMode = 0;
if (vFlag && pezConfig->fileNameIsProgram)
printf("%s: Using program '%s' to get filenames for streaming\n",
__progname, pezConfig->fileName);
do {
if (playlistMode) {
ret = streamPlaylist(shout,
pezConfig->fileName);
} else {
ret = streamFile(shout, pezConfig->fileName);
}
if (quit)
break;
if (pezConfig->streamOnce)
break;
} while (ret);
shout_close(shout);
} else
printf("%s: Connection to http://%s:%hu%s failed: %s\n", __progname,
host, port, mount, shout_get_error(shout));
if (quit)
printf("\r%s: SIGINT or SIGTERM received\n", __progname);
if (vFlag)
printf("%s: Exiting ...\n", __progname);
xfree(host);
xfree(mount);
playlist_free(&playlist);
return (ez_shutdown(0));
}
bool menu_driver_ctl(enum rarch_menu_ctl_state state, void *data)
{
static struct retro_system_info menu_driver_system;
static bool menu_driver_pending_quick_menu = false;
static bool menu_driver_pending_action = false;
static bool menu_driver_prevent_populate = false;
static bool menu_driver_load_no_content = false;
static bool menu_driver_alive = false;
static bool menu_driver_data_own = false;
static bool menu_driver_pending_quit = false;
static bool menu_driver_pending_shutdown = false;
static playlist_t *menu_driver_playlist = NULL;
static struct video_shader *menu_driver_shader = NULL;
static menu_handle_t *menu_driver_data = NULL;
static const menu_ctx_driver_t *menu_driver_ctx = NULL;
static void *menu_userdata = NULL;
settings_t *settings = config_get_ptr();
switch (state)
{
case RARCH_MENU_CTL_IS_PENDING_ACTION:
if (!menu_driver_pending_action)
return false;
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_ACTION, NULL);
break;
case RARCH_MENU_CTL_SET_PENDING_ACTION:
menu_driver_pending_action = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_ACTION:
menu_driver_pending_action = false;
break;
case RARCH_MENU_CTL_DRIVER_DATA_GET:
{
menu_handle_t **driver_data = (menu_handle_t**)data;
if (!driver_data)
return false;
*driver_data = menu_driver_data;
}
break;
case RARCH_MENU_CTL_IS_PENDING_QUICK_MENU:
return menu_driver_pending_quick_menu;
case RARCH_MENU_CTL_SET_PENDING_QUICK_MENU:
menu_driver_pending_quick_menu = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_QUICK_MENU:
menu_driver_pending_quick_menu = false;
break;
case RARCH_MENU_CTL_IS_PENDING_QUIT:
return menu_driver_pending_quit;
case RARCH_MENU_CTL_SET_PENDING_QUIT:
menu_driver_pending_quit = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_QUIT:
menu_driver_pending_quit = false;
break;
case RARCH_MENU_CTL_IS_PENDING_SHUTDOWN:
return menu_driver_pending_shutdown;
case RARCH_MENU_CTL_SET_PENDING_SHUTDOWN:
menu_driver_pending_shutdown = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_SHUTDOWN:
menu_driver_pending_shutdown = false;
break;
case RARCH_MENU_CTL_DESTROY:
menu_driver_pending_quick_menu = false;
menu_driver_pending_action = false;
menu_driver_pending_quit = false;
menu_driver_pending_shutdown = false;
menu_driver_prevent_populate = false;
menu_driver_load_no_content = false;
menu_driver_alive = false;
menu_driver_data_own = false;
menu_driver_ctx = NULL;
menu_userdata = NULL;
break;
case RARCH_MENU_CTL_PLAYLIST_FREE:
if (menu_driver_playlist)
playlist_free(menu_driver_playlist);
menu_driver_playlist = NULL;
break;
case RARCH_MENU_CTL_FIND_DRIVER:
{
int i;
driver_ctx_info_t drv;
settings_t *settings = config_get_ptr();
drv.label = "menu_driver";
drv.s = settings->menu.driver;
driver_ctl(RARCH_DRIVER_CTL_FIND_INDEX, &drv);
i = drv.len;
if (i >= 0)
menu_driver_ctx = (const menu_ctx_driver_t*)
menu_driver_find_handle(i);
else
{
unsigned d;
RARCH_WARN("Couldn't find any menu driver named \"%s\"\n",
settings->menu.driver);
RARCH_LOG_OUTPUT("Available menu drivers are:\n");
for (d = 0; menu_driver_find_handle(d); d++)
RARCH_LOG_OUTPUT("\t%s\n", menu_driver_find_ident(d));
RARCH_WARN("Going to default to first menu driver...\n");
menu_driver_ctx = (const menu_ctx_driver_t*)
menu_driver_find_handle(0);
if (!menu_driver_ctx)
{
retroarch_fail(1, "find_menu_driver()");
return false;
}
}
}
break;
case RARCH_MENU_CTL_PLAYLIST_INIT:
{
const char *path = (const char*)data;
if (string_is_empty(path))
return false;
menu_driver_playlist = playlist_init(path,
COLLECTION_SIZE);
}
break;
case RARCH_MENU_CTL_PLAYLIST_GET:
{
playlist_t **playlist = (playlist_t**)data;
if (!playlist)
return false;
*playlist = menu_driver_playlist;
}
break;
case RARCH_MENU_CTL_SYSTEM_INFO_GET:
{
struct retro_system_info **system =
(struct retro_system_info**)data;
if (!system)
return false;
*system = &menu_driver_system;
}
break;
case RARCH_MENU_CTL_SYSTEM_INFO_DEINIT:
libretro_free_system_info(&menu_driver_system);
memset(&menu_driver_system, 0, sizeof(struct retro_system_info));
break;
case RARCH_MENU_CTL_RENDER_MESSAGEBOX:
if (menu_driver_ctx->render_messagebox)
menu_driver_ctx->render_messagebox(menu_userdata,
menu_driver_data->menu_state.msg);
break;
case RARCH_MENU_CTL_BLIT_RENDER:
if (menu_driver_ctx->render)
menu_driver_ctx->render(menu_userdata);
break;
case RARCH_MENU_CTL_RENDER:
if (!menu_driver_data)
return false;
if (BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_FRAMEBUFFER)
!= BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_MESSAGEBOX))
BIT64_SET(menu_driver_data->state, MENU_STATE_RENDER_FRAMEBUFFER);
if (BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_FRAMEBUFFER))
menu_display_set_framebuffer_dirty_flag();
if (BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_MESSAGEBOX)
&& !string_is_empty(menu_driver_data->menu_state.msg))
{
menu_driver_ctl(RARCH_MENU_CTL_RENDER_MESSAGEBOX, NULL);
if (ui_companion_is_on_foreground())
{
const ui_companion_driver_t *ui = ui_companion_get_ptr();
if (ui->render_messagebox)
ui->render_messagebox(menu_driver_data->menu_state.msg);
}
}
if (BIT64_GET(menu_driver_data->state, MENU_STATE_BLIT))
{
menu_animation_ctl(MENU_ANIMATION_CTL_UPDATE_TIME, NULL);
menu_driver_ctl(RARCH_MENU_CTL_BLIT_RENDER, NULL);
}
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL)
&& !runloop_ctl(RUNLOOP_CTL_IS_IDLE, NULL))
menu_display_libretro();
menu_driver_ctl(RARCH_MENU_CTL_SET_TEXTURE, NULL);
menu_driver_data->state = 0;
break;
case RARCH_MENU_CTL_SHADER_DEINIT:
#ifdef HAVE_SHADER_MANAGER
if (menu_driver_shader)
free(menu_driver_shader);
menu_driver_shader = NULL;
#endif
break;
case RARCH_MENU_CTL_SHADER_INIT:
#ifdef HAVE_SHADER_MANAGER
menu_driver_shader = (struct video_shader*)
calloc(1, sizeof(struct video_shader));
if (!menu_driver_shader)
return false;
#endif
break;
case RARCH_MENU_CTL_SHADER_GET:
{
struct video_shader **shader = (struct video_shader**)data;
if (!shader)
return false;
*shader = menu_driver_shader;
}
break;
case RARCH_MENU_CTL_FRAME:
if (!menu_driver_alive)
return false;
if (menu_driver_ctx->frame)
menu_driver_ctx->frame(menu_userdata);
break;
case RARCH_MENU_CTL_SET_PREVENT_POPULATE:
menu_driver_prevent_populate = true;
break;
case RARCH_MENU_CTL_UNSET_PREVENT_POPULATE:
menu_driver_prevent_populate = false;
break;
case RARCH_MENU_CTL_IS_PREVENT_POPULATE:
return menu_driver_prevent_populate;
case RARCH_MENU_CTL_SET_TOGGLE:
menu_driver_toggle(true);
break;
case RARCH_MENU_CTL_UNSET_TOGGLE:
menu_driver_toggle(false);
break;
case RARCH_MENU_CTL_SET_ALIVE:
menu_driver_alive = true;
break;
case RARCH_MENU_CTL_UNSET_ALIVE:
menu_driver_alive = false;
break;
case RARCH_MENU_CTL_IS_ALIVE:
return menu_driver_alive;
case RARCH_MENU_CTL_SET_OWN_DRIVER:
menu_driver_data_own = true;
break;
case RARCH_MENU_CTL_UNSET_OWN_DRIVER:
if (!content_is_inited())
return false;
menu_driver_data_own = false;
break;
case RARCH_MENU_CTL_SET_TEXTURE:
if (menu_driver_ctx->set_texture)
menu_driver_ctx->set_texture();
break;
case RARCH_MENU_CTL_IS_SET_TEXTURE:
if (!menu_driver_ctx)
return false;
return menu_driver_ctx->set_texture;
case RARCH_MENU_CTL_OWNS_DRIVER:
return menu_driver_data_own;
case RARCH_MENU_CTL_DEINIT:
menu_driver_ctl(RARCH_MENU_CTL_CONTEXT_DESTROY, NULL);
if (menu_driver_ctl(RARCH_MENU_CTL_OWNS_DRIVER, NULL))
return true;
if (menu_driver_data)
{
menu_driver_ctl(RARCH_MENU_CTL_PLAYLIST_FREE, NULL);
menu_shader_free(menu_driver_data);
menu_input_ctl(MENU_INPUT_CTL_DEINIT, NULL);
menu_navigation_ctl(MENU_NAVIGATION_CTL_DEINIT, NULL);
if (menu_driver_ctx && menu_driver_ctx->free)
menu_driver_ctx->free(menu_userdata);
if (menu_userdata)
free(menu_userdata);
menu_userdata = NULL;
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_DEINIT, NULL);
menu_display_deinit();
menu_entries_ctl(MENU_ENTRIES_CTL_DEINIT, NULL);
command_event(CMD_EVENT_HISTORY_DEINIT, NULL);
core_info_deinit_list();
core_info_free_current_core();
free(menu_driver_data);
}
menu_driver_data = NULL;
break;
case RARCH_MENU_CTL_INIT:
if (menu_driver_data)
return true;
menu_driver_data = (menu_handle_t*)
menu_driver_ctx->init(&menu_userdata);
if (!menu_driver_data || !menu_init(menu_driver_data))
{
retroarch_fail(1, "init_menu()");
return false;
}
strlcpy(settings->menu.driver, menu_driver_ctx->ident,
sizeof(settings->menu.driver));
if (menu_driver_ctx->lists_init)
{
if (!menu_driver_ctx->lists_init(menu_driver_data))
{
retroarch_fail(1, "init_menu()");
return false;
}
}
break;
case RARCH_MENU_CTL_LOAD_NO_CONTENT_GET:
{
bool **ptr = (bool**)data;
if (!ptr)
return false;
*ptr = (bool*)&menu_driver_load_no_content;
}
break;
case RARCH_MENU_CTL_HAS_LOAD_NO_CONTENT:
return menu_driver_load_no_content;
case RARCH_MENU_CTL_SET_LOAD_NO_CONTENT:
menu_driver_load_no_content = true;
break;
case RARCH_MENU_CTL_UNSET_LOAD_NO_CONTENT:
menu_driver_load_no_content = false;
break;
case RARCH_MENU_CTL_NAVIGATION_INCREMENT:
if (menu_driver_ctx->navigation_increment)
menu_driver_ctx->navigation_increment(menu_userdata);
break;
case RARCH_MENU_CTL_NAVIGATION_DECREMENT:
if (menu_driver_ctx->navigation_decrement)
menu_driver_ctx->navigation_decrement(menu_userdata);
break;
case RARCH_MENU_CTL_NAVIGATION_SET:
{
bool *scroll = (bool*)data;
if (!scroll)
return false;
if (menu_driver_ctx->navigation_set)
menu_driver_ctx->navigation_set(menu_userdata, *scroll);
}
break;
case RARCH_MENU_CTL_NAVIGATION_SET_LAST:
if (menu_driver_ctx->navigation_set_last)
menu_driver_ctx->navigation_set_last(menu_userdata);
break;
case RARCH_MENU_CTL_NAVIGATION_ASCEND_ALPHABET:
{
size_t *ptr_out = (size_t*)data;
if (!ptr_out)
return false;
if (menu_driver_ctx->navigation_ascend_alphabet)
menu_driver_ctx->navigation_ascend_alphabet(
menu_userdata, ptr_out);
}
case RARCH_MENU_CTL_NAVIGATION_DESCEND_ALPHABET:
{
size_t *ptr_out = (size_t*)data;
if (!ptr_out)
return false;
if (menu_driver_ctx->navigation_descend_alphabet)
menu_driver_ctx->navigation_descend_alphabet(
menu_userdata, ptr_out);
}
break;
case RARCH_MENU_CTL_NAVIGATION_CLEAR:
{
bool *pending_push = (bool*)data;
if (!pending_push)
return false;
if (menu_driver_ctx->navigation_clear)
menu_driver_ctx->navigation_clear(
menu_userdata, pending_push);
}
break;
case RARCH_MENU_CTL_POPULATE_ENTRIES:
{
menu_displaylist_info_t *info = (menu_displaylist_info_t*)data;
if (!info)
return false;
if (menu_driver_ctx->populate_entries)
menu_driver_ctx->populate_entries(
menu_userdata, info->path,
info->label, info->type);
}
break;
case RARCH_MENU_CTL_LIST_GET_ENTRY:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->list_get_entry)
{
list->entry = NULL;
return false;
}
list->entry = menu_driver_ctx->list_get_entry(menu_userdata,
list->type, list->idx);
}
break;
case RARCH_MENU_CTL_LIST_GET_SIZE:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->list_get_size)
{
list->size = 0;
return false;
}
list->size = menu_driver_ctx->list_get_size(menu_userdata, list->type);
}
break;
case RARCH_MENU_CTL_LIST_GET_SELECTION:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->list_get_selection)
{
list->selection = 0;
return false;
}
list->selection = menu_driver_ctx->list_get_selection(menu_userdata);
}
break;
case RARCH_MENU_CTL_LIST_FREE:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (menu_driver_ctx)
{
if (menu_driver_ctx->list_free)
menu_driver_ctx->list_free(list->list, list->idx, list->list_size);
}
if (list->list)
{
file_list_free_userdata (list->list, list->idx);
file_list_free_actiondata(list->list, list->idx);
}
}
break;
case RARCH_MENU_CTL_LIST_PUSH:
{
menu_ctx_displaylist_t *disp_list = (menu_ctx_displaylist_t*)data;
if (menu_driver_ctx->list_push)
if (menu_driver_ctx->list_push(menu_driver_data,
menu_userdata, disp_list->info, disp_list->type) == 0)
return true;
}
return false;
case RARCH_MENU_CTL_LIST_CLEAR:
{
file_list_t *list = (file_list_t*)data;
if (!list)
return false;
if (menu_driver_ctx->list_clear)
menu_driver_ctx->list_clear(list);
}
break;
case RARCH_MENU_CTL_TOGGLE:
{
bool *latch = (bool*)data;
if (!latch)
return false;
if (menu_driver_ctx && menu_driver_ctx->toggle)
menu_driver_ctx->toggle(menu_userdata, *latch);
}
break;
case RARCH_MENU_CTL_REFRESH:
{
#if 0
bool refresh = false;
menu_entries_ctl(MENU_ENTRIES_CTL_LIST_DEINIT, NULL);
menu_entries_ctl(MENU_ENTRIES_CTL_SETTINGS_DEINIT, NULL);
menu_entries_ctl(MENU_ENTRIES_CTL_INIT, NULL);
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
#endif
}
break;
case RARCH_MENU_CTL_CONTEXT_RESET:
if (!menu_driver_ctx || !menu_driver_ctx->context_reset)
return false;
menu_driver_ctx->context_reset(menu_userdata);
break;
case RARCH_MENU_CTL_CONTEXT_DESTROY:
if (!menu_driver_ctx || !menu_driver_ctx->context_destroy)
return false;
menu_driver_ctx->context_destroy(menu_userdata);
break;
case RARCH_MENU_CTL_SHADER_MANAGER_INIT:
menu_shader_manager_init(menu_driver_data);
break;
case RARCH_MENU_CTL_LIST_SET_SELECTION:
{
file_list_t *list = (file_list_t*)data;
if (!list)
return false;
if (!menu_driver_ctx || !menu_driver_ctx->list_set_selection)
return false;
menu_driver_ctx->list_set_selection(menu_userdata, list);
}
break;
case RARCH_MENU_CTL_LIST_CACHE:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!list || !menu_driver_ctx || !menu_driver_ctx->list_cache)
return false;
menu_driver_ctx->list_cache(menu_userdata,
list->type, list->action);
}
break;
case RARCH_MENU_CTL_LIST_INSERT:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!list || !menu_driver_ctx || !menu_driver_ctx->list_insert)
return false;
menu_driver_ctx->list_insert(menu_userdata,
list->list, list->path, list->label, list->idx);
}
break;
case RARCH_MENU_CTL_LOAD_IMAGE:
{
menu_ctx_load_image_t *load_image_info =
(menu_ctx_load_image_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->load_image)
return false;
return menu_driver_ctx->load_image(menu_userdata,
load_image_info->data, load_image_info->type);
}
case RARCH_MENU_CTL_ITERATE:
{
bool retcode = false;
menu_ctx_iterate_t *iterate = (menu_ctx_iterate_t*)data;
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_QUICK_MENU, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_QUICK_MENU, NULL);
menu_entries_flush_stack(NULL, MENU_SETTINGS);
menu_display_set_msg_force(true);
generic_action_ok_displaylist_push("",
"", 0, 0, 0, ACTION_OK_DL_CONTENT_SETTINGS);
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_QUIT, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_QUIT, NULL);
return false;
}
return true;
}
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_QUIT, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_QUIT, NULL);
return false;
}
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_SHUTDOWN, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_SHUTDOWN, NULL);
if (!command_event(CMD_EVENT_QUIT, NULL))
return false;
return true;
}
if (!menu_driver_ctx || !menu_driver_ctx->iterate)
return false;
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_ACTION, &retcode))
{
iterate->action = pending_iter.action;
pending_iter.action = MENU_ACTION_NOOP;
}
if (menu_driver_ctx->iterate(menu_driver_data,
menu_userdata, iterate->action) == -1)
return false;
}
break;
case RARCH_MENU_CTL_ENVIRONMENT:
{
menu_ctx_environment_t *menu_environ =
(menu_ctx_environment_t*)data;
if (menu_driver_ctx->environ_cb)
{
if (menu_driver_ctx->environ_cb(menu_environ->type,
menu_environ->data, menu_userdata) == 0)
return true;
}
}
return false;
case RARCH_MENU_CTL_POINTER_TAP:
{
menu_ctx_pointer_t *point = (menu_ctx_pointer_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->pointer_tap)
{
point->retcode = 0;
return false;
}
point->retcode = menu_driver_ctx->pointer_tap(menu_userdata,
point->x, point->y, point->ptr,
point->cbs, point->entry, point->action);
}
break;
case RARCH_MENU_CTL_BIND_INIT:
{
menu_ctx_bind_t *bind = (menu_ctx_bind_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->bind_init)
{
bind->retcode = 0;
return false;
}
bind->retcode = menu_driver_ctx->bind_init(
bind->cbs,
bind->path,
bind->label,
bind->type,
bind->idx,
bind->elem0,
bind->elem1,
bind->label_hash,
bind->menu_label_hash);
}
break;
case RARCH_MENU_CTL_UPDATE_THUMBNAIL_PATH:
{
size_t selection;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return false;
if (!menu_driver_ctx || !menu_driver_ctx->update_thumbnail_path)
return false;
menu_driver_ctx->update_thumbnail_path(menu_userdata, selection);
}
break;
case RARCH_MENU_CTL_UPDATE_THUMBNAIL_IMAGE:
{
if (!menu_driver_ctx || !menu_driver_ctx->update_thumbnail_image)
return false;
menu_driver_ctx->update_thumbnail_image(menu_userdata);
}
break;
default:
case RARCH_MENU_CTL_NONE:
break;
}
return true;
}
static int database_info_list_iterate_found_match(
db_handle_t *_db,
database_state_handle_t *db_state,
database_info_handle_t *db,
const char *archive_name
)
{
char *db_crc = (char*)malloc(128 * sizeof(char));
char *db_playlist_base_str = (char*)malloc(128 * sizeof(char));
char *db_playlist_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *entry_path_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
playlist_t *playlist = NULL;
const char *db_path =
database_info_get_current_name(db_state);
const char *entry_path =
database_info_get_current_element_name(db);
database_info_t *db_info_entry =
&db_state->info->list[db_state->entry_index];
db_crc[0] = '\0';
db_playlist_path[0] = '\0';
db_playlist_base_str[0] = '\0';
entry_path_str[0] = '\0';
fill_short_pathname_representation_noext(db_playlist_base_str,
db_path, 128 * sizeof(char));
strlcat(db_playlist_base_str,
file_path_str(FILE_PATH_LPL_EXTENSION),
128 * sizeof(char));
fill_pathname_join(db_playlist_path, _db->playlist_directory,
db_playlist_base_str, PATH_MAX_LENGTH * sizeof(char));
playlist = playlist_init(db_playlist_path, COLLECTION_SIZE);
snprintf(db_crc, 128 * sizeof(char),
"%08X|crc", db_info_entry->crc32);
if (entry_path)
strlcpy(entry_path_str, entry_path, 128 * sizeof(char));
if (!string_is_empty(archive_name))
fill_pathname_join_delim(entry_path_str,
entry_path_str, archive_name,
'#', 128 * sizeof(char));
#if 0
RARCH_LOG("Found match in database !\n");
RARCH_LOG("Path: %s\n", db_path);
RARCH_LOG("CRC : %s\n", db_crc);
RARCH_LOG("Playlist Path: %s\n", db_playlist_path);
RARCH_LOG("Entry Path: %s\n", entry_path);
RARCH_LOG("Playlist not NULL: %d\n", playlist != NULL);
RARCH_LOG("ZIP entry: %s\n", archive_name);
RARCH_LOG("entry path str: %s\n", entry_path_str);
#endif
if(!playlist_entry_exists(playlist, entry_path_str, db_crc))
{
playlist_push(playlist, entry_path_str,
db_info_entry->name,
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),
db_crc, db_playlist_base_str);
}
playlist_write_file(playlist);
playlist_free(playlist);
database_info_list_free(db_state->info);
free(db_state->info);
db_state->info = NULL;
db_state->crc = 0;
free(entry_path_str);
free(db_playlist_path);
free(db_playlist_base_str);
free(db_crc);
return 0;
}
static void init(void)
{
int rc;
bool mounted = false;
#if CONFIG_CHARGING && (CONFIG_CPU == SH7034)
/* if nobody initialized ATA before, I consider this a cold start */
bool coldstart = (PACR2 & 0x4000) != 0; /* starting from Flash */
#endif
system_init();
kernel_init();
#ifdef HAVE_ADJUSTABLE_CPU_FREQ
set_cpu_frequency(CPUFREQ_NORMAL);
#ifdef CPU_COLDFIRE
coldfire_set_pllcr_audio_bits(DEFAULT_PLLCR_AUDIO_BITS);
#endif
cpu_boost(true);
#endif
buffer_init();
settings_reset();
i2c_init();
power_init();
enable_irq();
#ifdef CPU_ARM
enable_fiq();
#endif
/* current_tick should be ticking by now */
CHART("ticking");
lcd_init();
#ifdef HAVE_REMOTE_LCD
lcd_remote_init();
#endif
font_init();
CHART(">show_logo");
show_logo();
CHART("<show_logo");
lang_init(core_language_builtin, language_strings,
LANG_LAST_INDEX_IN_ARRAY);
#ifdef DEBUG
debug_init();
#else
#ifdef HAVE_SERIAL
serial_setup();
#endif
#endif
#if CONFIG_RTC
rtc_init();
#endif
#ifdef HAVE_RTC_RAM
CHART(">settings_load(RTC)");
settings_load(SETTINGS_RTC); /* early load parts of global_settings */
CHART("<settings_load(RTC)");
#endif
adc_init();
usb_init();
#if CONFIG_USBOTG == USBOTG_ISP1362
isp1362_init();
#elif CONFIG_USBOTG == USBOTG_M5636
m5636_init();
#endif
backlight_init();
button_init();
powermgmt_init();
#if CONFIG_TUNER
radio_init();
#endif
/* Keep the order of this 3 (viewportmanager handles statusbars)
* Must be done before any code uses the multi-screen API */
CHART(">gui_syncstatusbar_init");
gui_syncstatusbar_init(&statusbars);
CHART("<gui_syncstatusbar_init");
CHART(">sb_skin_init");
sb_skin_init();
CHART("<sb_skin_init");
CHART(">gui_sync_wps_init");
gui_sync_wps_init();
CHART("<gui_sync_wps_init");
CHART(">viewportmanager_init");
viewportmanager_init();
CHART("<viewportmanager_init");
#if CONFIG_CHARGING && (CONFIG_CPU == SH7034)
/* charger_inserted() can't be used here because power_thread()
hasn't checked power_input_status() yet */
if (coldstart && (power_input_status() & POWER_INPUT_MAIN_CHARGER)
&& !global_settings.car_adapter_mode
#ifdef ATA_POWER_PLAYERSTYLE
&& !ide_powered() /* relies on probing result from bootloader */
#endif
)
{
rc = charging_screen(); /* display a "charging" screen */
if (rc == 1) /* charger removed */
power_off();
/* "On" pressed or USB connected: proceed */
show_logo(); /* again, to provide better visual feedback */
}
#endif
CHART(">storage_init");
rc = storage_init();
CHART("<storage_init");
if(rc)
{
#ifdef HAVE_LCD_BITMAP
lcd_clear_display();
lcd_putsf(0, 1, "ATA error: %d", rc);
lcd_puts(0, 3, "Press ON to debug");
lcd_update();
while(!(button_get(true) & BUTTON_REL)); /*DO NOT CHANGE TO ACTION SYSTEM */
dbg_ports();
#endif
panicf("ata: %d", rc);
}
#ifdef HAVE_EEPROM_SETTINGS
CHART(">eeprom_settings_init");
eeprom_settings_init();
CHART("<eeprom_settings_init");
#endif
#ifndef HAVE_USBSTACK
usb_start_monitoring();
while (usb_detect() == USB_INSERTED)
{
#ifdef HAVE_EEPROM_SETTINGS
firmware_settings.disk_clean = false;
#endif
/* enter USB mode early, before trying to mount */
if (button_get_w_tmo(HZ/10) == SYS_USB_CONNECTED)
#if (CONFIG_STORAGE & STORAGE_MMC)
if (!mmc_touched() ||
(mmc_remove_request() == SYS_HOTSWAP_EXTRACTED))
#endif
{
gui_usb_screen_run();
mounted = true; /* mounting done @ end of USB mode */
}
#ifdef HAVE_USB_POWER
if (usb_powered()) /* avoid deadlock */
break;
#endif
}
#endif
if (!mounted)
{
CHART(">disk_mount_all");
rc = disk_mount_all();
CHART("<disk_mount_all");
if (rc<=0)
{
lcd_clear_display();
lcd_puts(0, 0, "No partition");
lcd_puts(0, 1, "found.");
#ifdef HAVE_LCD_BITMAP
lcd_puts(0, 2, "Insert USB cable");
lcd_puts(0, 3, "and fix it.");
#endif
lcd_update();
while(button_get(true) != SYS_USB_CONNECTED) {};
gui_usb_screen_run();
system_reboot();
}
}
#if defined(SETTINGS_RESET) || (CONFIG_KEYPAD == IPOD_4G_PAD) || \
(CONFIG_KEYPAD == IRIVER_H10_PAD)
#ifdef SETTINGS_RESET
/* Reset settings if holding the reset button. (Rec on Archos,
A on Gigabeat) */
if ((button_status() & SETTINGS_RESET) == SETTINGS_RESET)
#else
/* Reset settings if the hold button is turned on */
if (button_hold())
#endif
{
splash(HZ*2, str(LANG_RESET_DONE_CLEAR));
settings_reset();
}
else
#endif
{
CHART(">settings_load(ALL)");
settings_load(SETTINGS_ALL);
CHART("<settings_load(ALL)");
}
CHART(">init_dircache(true)");
rc = init_dircache(true);
CHART("<init_dircache(true)");
if (rc < 0)
{
#ifdef HAVE_TAGCACHE
remove(TAGCACHE_STATEFILE);
#endif
}
CHART(">settings_apply(true)");
settings_apply(true);
CHART("<settings_apply(true)");
CHART(">init_dircache(false)");
init_dircache(false);
CHART("<init_dircache(false)");
#ifdef HAVE_TAGCACHE
CHART(">init_tagcache");
init_tagcache();
CHART("<init_tagcache");
#endif
#ifdef HAVE_EEPROM_SETTINGS
if (firmware_settings.initialized)
{
/* In case we crash. */
firmware_settings.disk_clean = false;
CHART(">eeprom_settings_store");
eeprom_settings_store();
CHART("<eeprom_settings_store");
}
#endif
playlist_init();
tree_mem_init();
filetype_init();
scrobbler_init();
#if CONFIG_CODEC == SWCODEC
tdspeed_init();
#endif /* CONFIG_CODEC == SWCODEC */
#if CONFIG_CODEC != SWCODEC
/* No buffer allocation (see buffer.c) may take place after the call to
audio_init() since the mpeg thread takes the rest of the buffer space */
mp3_init( global_settings.volume,
global_settings.bass,
global_settings.treble,
global_settings.balance,
global_settings.loudness,
global_settings.avc,
global_settings.channel_config,
global_settings.stereo_width,
global_settings.mdb_strength,
global_settings.mdb_harmonics,
global_settings.mdb_center,
global_settings.mdb_shape,
global_settings.mdb_enable,
global_settings.superbass);
/* audio_init must to know the size of voice buffer so init voice first */
talk_init();
#endif /* CONFIG_CODEC != SWCODEC */
CHART(">audio_init");
audio_init();
CHART("<audio_init");
#if (CONFIG_CODEC == SWCODEC) && defined(HAVE_RECORDING) && !defined(SIMULATOR)
pcm_rec_init();
#endif
/* runtime database has to be initialized after audio_init() */
cpu_boost(false);
#if CONFIG_CHARGING
car_adapter_mode_init();
#endif
#ifdef IPOD_ACCESSORY_PROTOCOL
iap_setup(global_settings.serial_bitrate);
#endif
#ifdef HAVE_ACCESSORY_SUPPLY
accessory_supply_set(global_settings.accessory_supply);
#endif
#ifdef HAVE_LINEOUT_POWEROFF
lineout_set(global_settings.lineout_active);
#endif
#ifdef HAVE_HOTSWAP_STORAGE_AS_MAIN
CHART("<check_bootfile(false)");
check_bootfile(false); /* remember write time and filesize */
CHART(">check_bootfile(false)");
#endif
CHART("<settings_apply_skins");
settings_apply_skins();
CHART(">settings_apply_skins");
}
/* Takes a list of files and folders and adds them to the currently selected playlist. Folders will have their contents added recursively. */
void MainWindow::addFilesToPlaylist(QStringList files)
{
QStringList list;
QString currentPlaylistPath;
QListWidgetItem *currentItem = m_listWidget->currentItem();
QByteArray currentPlaylistArray;
QScopedPointer<QProgressDialog> dialog(NULL);
PlaylistEntryDialog *playlistDialog = playlistEntryDialog();
QHash<QString, QString> selectedCore;
QHash<QString, QString> itemToAdd;
QString selectedDatabase;
QString selectedName;
QString selectedPath;
const char *currentPlaylistData = NULL;
playlist_t *playlist = NULL;
int i;
/* Assume a blank list means we will manually enter in all fields. */
if (files.isEmpty())
{
/* Make sure hash isn't blank, that would mean there's multiple entries to add at once. */
itemToAdd["label"] = "";
itemToAdd["path"] = "";
}
else if (files.count() == 1)
{
QString path = files.at(0);
QFileInfo info(path);
if (info.isFile())
{
itemToAdd["label"] = info.completeBaseName();
itemToAdd["path"] = path;
}
}
if (currentItem)
{
currentPlaylistPath = currentItem->data(Qt::UserRole).toString();
if (!currentPlaylistPath.isEmpty())
{
currentPlaylistArray = currentPlaylistPath.toUtf8();
currentPlaylistData = currentPlaylistArray.constData();
}
}
if (currentPlaylistPath == ALL_PLAYLISTS_TOKEN)
{
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CANNOT_ADD_TO_ALL_PLAYLISTS), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
return;
}
/* a blank itemToAdd means there will be multiple */
if (!playlistDialog->showDialog(itemToAdd))
return;
selectedName = m_playlistEntryDialog->getSelectedName();
selectedPath = m_playlistEntryDialog->getSelectedPath();
selectedCore = m_playlistEntryDialog->getSelectedCore();
selectedDatabase = m_playlistEntryDialog->getSelectedDatabase();
if (selectedDatabase.isEmpty())
selectedDatabase = QFileInfo(currentPlaylistPath).fileName();
else
selectedDatabase += file_path_str(FILE_PATH_LPL_EXTENSION);
dialog.reset(new QProgressDialog(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_GATHERING_LIST_OF_FILES), "Cancel", 0, 0, this));
dialog->setWindowModality(Qt::ApplicationModal);
if (selectedName.isEmpty() || selectedPath.isEmpty() ||
selectedDatabase.isEmpty())
{
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_PLEASE_FILL_OUT_REQUIRED_FIELDS), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
return;
}
if (files.isEmpty())
files.append(selectedPath);
for (i = 0; i < files.count(); i++)
{
QString path(files.at(i));
QFileInfo fileInfo(path);
if (dialog->wasCanceled())
return;
if (i % 25 == 0)
{
/* Needed to update progress dialog while doing a lot of stuff on the main thread. */
qApp->processEvents();
}
if (fileInfo.isDir())
{
QDir dir(path);
addDirectoryFilesToList(list, dir);
continue;
}
if (fileInfo.isFile())
list.append(fileInfo.absoluteFilePath());
else if (files.count() == 1)
{
/* If adding a single file, tell user that it doesn't exist. */
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_FILE_DOES_NOT_EXIST), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
return;
}
}
dialog->setLabelText(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADDING_FILES_TO_PLAYLIST));
dialog->setMaximum(list.count());
playlist = playlist_init(currentPlaylistData, COLLECTION_SIZE);
for (i = 0; i < list.count(); i++)
{
QString fileName = list.at(i);
QFileInfo fileInfo;
QByteArray fileBaseNameArray;
QByteArray pathArray;
QByteArray corePathArray;
QByteArray coreNameArray;
QByteArray databaseArray;
const char *pathData = NULL;
const char *fileNameNoExten = NULL;
const char *corePathData = NULL;
const char *coreNameData = NULL;
const char *databaseData = NULL;
if (dialog->wasCanceled())
{
playlist_free(playlist);
return;
}
if (fileName.isEmpty())
continue;
fileInfo = fileName;
if (files.count() == 1 && list.count() == 1 && i == 0)
{
fileBaseNameArray = selectedName.toUtf8();
pathArray = QDir::toNativeSeparators(selectedPath).toUtf8();
}
else
{
fileBaseNameArray = fileInfo.completeBaseName().toUtf8();
pathArray = QDir::toNativeSeparators(fileName).toUtf8();
}
fileNameNoExten = fileBaseNameArray.constData();
/* a modal QProgressDialog calls processEvents() automatically in setValue() */
dialog->setValue(i + 1);
pathData = pathArray.constData();
if (selectedCore.isEmpty())
{
corePathData = "DETECT";
coreNameData = "DETECT";
}
else
{
corePathArray = QDir::toNativeSeparators(selectedCore.value("core_path")).toUtf8();
coreNameArray = selectedCore.value("core_name").toUtf8();
corePathData = corePathArray.constData();
coreNameData = coreNameArray.constData();
}
databaseArray = selectedDatabase.toUtf8();
databaseData = databaseArray.constData();
if (path_is_compressed_file(pathData))
{
struct string_list *list = file_archive_get_file_list(pathData, NULL);
if (list)
{
if (list->size == 1)
{
/* assume archives with one file should have that file loaded directly */
pathArray = QDir::toNativeSeparators(QString(pathData) + "#" + list->elems[0].data).toUtf8();
pathData = pathArray.constData();
}
string_list_free(list);
}
}
playlist_push(playlist, pathData, fileNameNoExten,
corePathData, coreNameData, "00000000|crc", databaseData);
}
playlist_write_file(playlist);
playlist_free(playlist);
reloadPlaylists();
}
bool MainWindow::updateCurrentPlaylistEntry(const QHash<QString, QString> &contentHash)
{
QString playlistPath = getCurrentPlaylistPath();
QString path;
QString label;
QString corePath;
QString coreName;
QString dbName;
QString crc32;
QByteArray playlistPathArray;
QByteArray pathArray;
QByteArray labelArray;
QByteArray corePathArray;
QByteArray coreNameArray;
QByteArray dbNameArray;
QByteArray crc32Array;
const char *playlistPathData = NULL;
const char *pathData = NULL;
const char *labelData = NULL;
const char *corePathData = NULL;
const char *coreNameData = NULL;
const char *dbNameData = NULL;
const char *crc32Data = NULL;
playlist_t *playlist = NULL;
unsigned index = 0;
bool ok = false;
if (playlistPath.isEmpty() || contentHash.isEmpty() || !contentHash.contains("index"))
return false;
index = contentHash.value("index").toUInt(&ok);
if (!ok)
return false;
path = contentHash.value("path");
label = contentHash.value("label");
coreName = contentHash.value("core_name");
corePath = contentHash.value("core_path");
dbName = contentHash.value("db_name");
crc32 = contentHash.value("crc32");
if (path.isEmpty() ||
label.isEmpty() ||
coreName.isEmpty() ||
corePath.isEmpty() ||
dbName.isEmpty() ||
crc32.isEmpty()
)
return false;
playlistPathArray = playlistPath.toUtf8();
pathArray = QDir::toNativeSeparators(path).toUtf8();
labelArray = label.toUtf8();
coreNameArray = coreName.toUtf8();
corePathArray = QDir::toNativeSeparators(corePath).toUtf8();
dbNameArray = (dbName + file_path_str(FILE_PATH_LPL_EXTENSION)).toUtf8();
crc32Array = crc32.toUtf8();
playlistPathData = playlistPathArray.constData();
pathData = pathArray.constData();
labelData = labelArray.constData();
coreNameData = coreNameArray.constData();
corePathData = corePathArray.constData();
dbNameData = dbNameArray.constData();
crc32Data = crc32Array.constData();
if (path_is_compressed_file(pathData))
{
struct string_list *list = file_archive_get_file_list(pathData, NULL);
if (list)
{
if (list->size == 1)
{
/* assume archives with one file should have that file loaded directly */
pathArray = QDir::toNativeSeparators(QString(pathData) + "#" + list->elems[0].data).toUtf8();
pathData = pathArray.constData();
}
string_list_free(list);
}
}
playlist = playlist_init(playlistPathData, COLLECTION_SIZE);
playlist_update(playlist, index, pathData, labelData,
corePathData, coreNameData, crc32Data, dbNameData);
playlist_write_file(playlist);
playlist_free(playlist);
reloadPlaylists();
return true;
}
QVector<QHash<QString, QString> > MainWindow::getPlaylistItems(QString pathString)
{
QByteArray pathArray;
QVector<QHash<QString, QString> > items;
const char *pathData = NULL;
playlist_t *playlist = NULL;
unsigned playlistSize = 0;
unsigned i = 0;
pathArray.append(pathString);
pathData = pathArray.constData();
playlist = playlist_init(pathData, COLLECTION_SIZE);
playlistSize = playlist_get_size(playlist);
for (i = 0; i < playlistSize; i++)
{
const char *path = NULL;
const char *label = NULL;
const char *core_path = NULL;
const char *core_name = NULL;
const char *crc32 = NULL;
const char *db_name = NULL;
QHash<QString, QString> hash;
playlist_get_index(playlist, i,
&path, &label, &core_path,
&core_name, &crc32, &db_name);
if (string_is_empty(path))
continue;
else
hash["path"] = path;
hash["index"] = QString::number(i);
if (string_is_empty(label))
{
hash["label"] = path;
hash["label_noext"] = path;
}
else
{
hash["label"] = label;
hash["label_noext"] = label;
}
if (!string_is_empty(core_path))
hash["core_path"] = core_path;
if (!string_is_empty(core_name))
hash["core_name"] = core_name;
if (!string_is_empty(crc32))
hash["crc32"] = crc32;
if (!string_is_empty(db_name))
{
hash["db_name"] = db_name;
hash["db_name"].remove(file_path_str(FILE_PATH_LPL_EXTENSION));
}
items.append(hash);
}
playlist_free(playlist);
playlist = NULL;
return items;
}
int main(int argc, char *argv[])
{
int i;
char configname[PATH_MAX] = "";
char playername[PATH_MAX] = "";
char scorename[PATH_MAX] = "";
int playernamegiven = 0;
char tmpstr[PATH_MAX + 256];
long subsong = -1;
FILE *listfile = NULL;
int have_modules = 0;
int ret;
char *endptr;
int uadeconf_loaded, songconf_loaded;
char songconfname[PATH_MAX] = "";
char uadeconfname[PATH_MAX];
struct uade_config uc_cmdline;
char songoptions[256] = "";
int have_song_options = 0;
int plistdir;
int scanmode = 0;
struct uade_state state = {};
char *basedir;
enum {
OPT_FIRST = 0x1FFF,
OPT_BASEDIR,
OPT_REPEAT,
OPT_SCAN,
OPT_SCOPE,
OPT_SET,
OPT_STDERR,
OPT_VERSION
};
struct option long_options[] = {
{"ao-option", 1, NULL, UC_AO_OPTION},
{"basedir", 1, NULL, OPT_BASEDIR},
{"buffer-time", 1, NULL, UC_BUFFER_TIME},
{"cygwin", 0, NULL, UC_CYGWIN_DRIVE_WORKAROUND},
{"debug", 0, NULL, 'd'},
{"detect-format-by-content", 0, NULL, UC_CONTENT_DETECTION},
{"disable-timeouts", 0, NULL, UC_DISABLE_TIMEOUTS},
{"enable-timeouts", 0, NULL, UC_ENABLE_TIMEOUTS},
{"ep-option", 1, NULL, 'x'},
{"filter", 2, NULL, UC_FILTER_TYPE},
{"force-led", 1, NULL, UC_FORCE_LED},
{"frequency", 1, NULL, UC_FREQUENCY},
{"gain", 1, NULL, 'G'},
{"get-info", 0, NULL, 'g'},
{"headphones", 0, NULL, UC_HEADPHONES},
{"headphones2", 0, NULL, UC_HEADPHONES2},
{"help", 0, NULL, 'h'},
{"ignore", 0, NULL, 'i'},
{"interpolator", 1, NULL, UC_RESAMPLER},
{"jump", 1, NULL, 'j'},
{"keys", 1, NULL, 'k'},
{"list", 1, NULL, '@'},
{"magic", 0, NULL, UC_CONTENT_DETECTION},
{"no-ep-end-detect", 0, NULL, 'n'},
{"no-song-end", 0, NULL, 'n'},
{"normalise", 2, NULL, UC_NORMALISE},
{"ntsc", 0, NULL, UC_NTSC},
{"one", 0, NULL, '1'},
{"pal", 0, NULL, UC_PAL},
{"panning", 1, NULL, 'p'},
{"recursive", 0, NULL, 'r'},
{"repeat", 0, NULL, OPT_REPEAT},
{"resampler", 1, NULL, UC_RESAMPLER},
{"scan", 0, NULL, OPT_SCAN},
{"scope", 0, NULL, OPT_SCOPE},
{"shuffle", 0, NULL, 'z'},
{"set", 1, NULL, OPT_SET},
{"silence-timeout", 1, NULL, 'y'},
{"speed-hack", 0, NULL, UC_SPEED_HACK},
{"stderr", 0, NULL, OPT_STDERR},
{"stdout", 0, NULL, 'c'},
{"subsong", 1, NULL, 's'},
{"subsong-timeout", 1, NULL, 'w'},
{"timeout", 1, NULL, 't'},
{"verbose", 0, NULL, 'v'},
{"version", 0, NULL, OPT_VERSION},
{NULL, 0, NULL, 0}
};
uade_config_set_defaults(&uc_cmdline);
if (!playlist_init(&uade_playlist))
die("Can not initialize playlist.\n");
#define GET_OPT_STRING(x) if (strlcpy((x), optarg, sizeof(x)) >= sizeof(x)) { die("Too long a string for option %c.\n", ret); }
while ((ret = getopt_long(argc, argv, "@:1cde:f:gG:hij:k:np:P:rs:S:t:u:vw:x:y:z", long_options, 0)) != -1) {
switch (ret) {
case '@':
listfile = fopen(optarg, "r");
if (listfile == NULL)
die("Can not open list file: %s\n", optarg);
break;
case '1':
uade_set_config_option(&uc_cmdline, UC_ONE_SUBSONG, NULL);
break;
case 'c':
strlcpy(uade_output_file_name, "/dev/stdout", sizeof uade_output_file_name);
/* Output sample data to stdout so do not print anything on stdout */
uade_terminal_file = stderr;
break;
case 'd':
debug_mode = 1;
uade_debug_trigger = 1;
break;
case 'e':
GET_OPT_STRING(uade_output_file_format);
break;
case 'f':
GET_OPT_STRING(uade_output_file_name);
break;
case 'g':
uade_info_mode = 1;
uade_no_audio_output = 1;
uade_no_text_output = 1;
uade_set_config_option(&uc_cmdline, UC_ACTION_KEYS, "off");
break;
case 'G':
uade_set_config_option(&uc_cmdline, UC_GAIN, optarg);
break;
case 'h':
print_help();
exit(0);
case 'i':
uade_set_config_option(&uc_cmdline, UC_IGNORE_PLAYER_CHECK, NULL);
break;
case 'j':
uade_jump_pos = strtod(optarg, &endptr);
if (*endptr != 0 || uade_jump_pos < 0.0)
die("Invalid jump position: %s\n", optarg);
break;
case 'k':
uade_set_config_option(&uc_cmdline, UC_ACTION_KEYS, optarg);
break;
case 'n':
uade_set_config_option(&uc_cmdline, UC_NO_EP_END, NULL);
break;
case 'p':
uade_set_config_option(&uc_cmdline, UC_PANNING_VALUE, optarg);
break;
case 'P':
GET_OPT_STRING(playername);
playernamegiven = 1;
have_modules = 1;
break;
case 'r':
uade_set_config_option(&uc_cmdline, UC_RECURSIVE_MODE, NULL);
break;
case 's':
subsong = strtol(optarg, &endptr, 10);
if (*endptr != 0 || subsong < 0 || subsong > 255)
die("Invalid subsong string: %s\n", optarg);
break;
case 'S':
GET_OPT_STRING(scorename);
break;
case 't':
uade_set_config_option(&uc_cmdline, UC_TIMEOUT_VALUE, optarg);
break;
case 'u':
GET_OPT_STRING(uadename);
break;
case 'v':
uade_set_config_option(&uc_cmdline, UC_VERBOSE, NULL);
break;
case 'w':
uade_set_config_option(&uc_cmdline, UC_SUBSONG_TIMEOUT_VALUE, optarg);
break;
case 'x':
uade_set_config_option(&uc_cmdline, UC_EAGLEPLAYER_OPTION, optarg);
break;
case 'y':
uade_set_config_option(&uc_cmdline, UC_SILENCE_TIMEOUT_VALUE, optarg);
break;
case 'z':
uade_set_config_option(&uc_cmdline, UC_RANDOM_PLAY, NULL);
break;
case '?':
case ':':
exit(1);
case OPT_BASEDIR:
uade_set_config_option(&uc_cmdline, UC_BASE_DIR, optarg);
break;
case OPT_REPEAT:
playlist_repeat(&uade_playlist);
break;
case OPT_SCAN:
scanmode = 1;
/* Set recursive mode in scan mode */
uade_set_config_option(&uc_cmdline, UC_RECURSIVE_MODE, NULL);
break;
case OPT_SCOPE:
uade_no_text_output = 1;
uade_set_config_option(&uc_cmdline, UC_USE_TEXT_SCOPE, NULL);
break;
case OPT_SET:
have_song_options = 1;
strlcpy(songoptions, optarg, sizeof songoptions);
break;
case OPT_STDERR:
uade_terminal_file = stderr;
break;
case OPT_VERSION:
printf("uade123 %s\n", UADE_VERSION);
exit(0);
break;
case UC_AO_OPTION:
case UC_BUFFER_TIME:
case UC_FILTER_TYPE:
case UC_FORCE_LED:
case UC_FREQUENCY:
case UC_NORMALISE:
case UC_RESAMPLER:
uade_set_config_option(&uc_cmdline, ret, optarg);
break;
case UC_CONTENT_DETECTION:
case UC_CYGWIN_DRIVE_WORKAROUND:
case UC_DISABLE_TIMEOUTS:
case UC_ENABLE_TIMEOUTS:
case UC_HEADPHONES:
case UC_HEADPHONES2:
case UC_NTSC:
case UC_PAL:
case UC_SPEED_HACK:
uade_set_config_option(&uc_cmdline, ret, NULL);
break;
default:
die("Impossible option.\n");
}
}
basedir = NULL;
if (uc_cmdline.basedir_set) {
basedir = uc_cmdline.basedir.name;
}
uadeconf_loaded = uade_load_initial_config(&state, uadeconfname, sizeof uadeconfname, basedir);
/* Merge loaded configurations and command line options */
uade_merge_configs(&state.config, &uc_cmdline);
if (uadeconf_loaded == 0) {
debug(state.config.verbose, "Not able to load uade.conf from ~/.uade2/ or %s/.\n", state.config.basedir.name);
} else {
debug(state.config.verbose, "Loaded configuration: %s\n", uadeconfname);
}
songconf_loaded = uade_load_initial_song_conf(songconfname, sizeof songconfname, &state.permconfig, &uc_cmdline, &state);
if (songconf_loaded == 0) {
debug(state.config.verbose, "Not able to load song.conf from ~/.uade2/ or %s/.\n", state.config.basedir.name);
} else {
debug(state.config.verbose, "Loaded song.conf: %s\n", songconfname);
}
/* Read play list from file */
if (listfile != NULL) {
while (xfgets(tmpstr, sizeof(tmpstr), listfile) != NULL) {
if (tmpstr[0] == '#')
continue;
if (tmpstr[strlen(tmpstr) - 1] == '\n')
tmpstr[strlen(tmpstr) - 1] = 0;
playlist_add(&uade_playlist, tmpstr, state.config.recursive_mode, state.config.cygwin_drive_workaround);
}
fclose(listfile);
listfile = NULL;
have_modules = 1;
}
/* Read play list from command line parameters */
for (i = optind; i < argc; i++) {
/* Play files */
playlist_add(&uade_playlist, argv[i], uc_eff.recursive_mode, uc_eff.cygwin_drive_workaround);
have_modules = 1;
}
if (scanmode) {
scan_playlist(&state.config);
exit(0);
}
if (have_song_options) {
set_song_options(&songconf_loaded, songoptions, songconfname, sizeof songconfname);
exit(0);
}
load_content_db(&state.config, &state);
if (state.config.random_play)
playlist_randomize(&uade_playlist);
if (have_modules == 0) {
print_help();
exit(0);
}
/* we want to control terminal differently in debug mode */
if (debug_mode)
state.config.action_keys = 0;
if (state.config.action_keys)
setup_terminal();
do {
DIR *bd = opendir(state.config.basedir.name);
if (bd == NULL)
dieerror("Could not access dir %s", state.config.basedir.name);
closedir(bd);
snprintf(configname, sizeof configname, "%s/uaerc", state.config.basedir.name);
if (scorename[0] == 0)
snprintf(scorename, sizeof scorename, "%s/score", state.config.basedir.name);
if (uadename[0] == 0)
strlcpy(uadename, UADE_CONFIG_UADE_CORE, sizeof uadename);
if (access(configname, R_OK))
dieerror("Could not read %s", configname);
if (access(scorename, R_OK))
dieerror("Could not read %s", scorename);
if (access(uadename, X_OK))
dieerror("Could not execute %s", uadename);
} while (0);
setup_sighandlers();
uade_spawn(&state, uadename, configname);
if (!audio_init(&state.config))
goto cleanup;
plistdir = UADE_PLAY_CURRENT;
while (1) {
ssize_t filesize;
/* modulename and songname are a bit different. modulename is the name
of the song from uadecore's point of view and songname is the
name of the song from user point of view. Sound core considers all
custom songs to be players (instead of modules) and therefore modulename
will become a zero-string with custom songs. */
char modulename[PATH_MAX];
char songname[PATH_MAX];
if (!playlist_get(modulename, sizeof modulename, &uade_playlist, plistdir))
break;
plistdir = UADE_PLAY_NEXT;
state.config = state.permconfig;
state.song = NULL;
state.ep = NULL;
if (uc_cmdline.verbose)
state.config.verbose = 1;
if (playernamegiven == 0) {
debug(state.config.verbose, "\n");
if (!uade_is_our_file(modulename, 0, &state)) {
__android_log_print(ANDROID_LOG_VERBOSE, "UADE", "Unknown format: %s\n", modulename);
continue;
}
debug(state.config.verbose, "Player candidate: %s\n", state.ep->playername);
if (strcmp(state.ep->playername, "custom") == 0) {
strlcpy(playername, modulename, sizeof playername);
modulename[0] = 0;
} else {
snprintf(playername, sizeof playername, "%s/players/%s", uc_cmdline.basedir.name, state.ep->playername);
}
}
if (strlen(playername) == 0) {
__android_log_print(ANDROID_LOG_VERBOSE, "UADE", "Error: an empty player name given\n");
goto cleanup;
}
/* If no modulename given, try the playername as it can be a custom song */
strlcpy(songname, modulename[0] ? modulename : playername, sizeof songname);
if (!uade_alloc_song(&state, songname)) {
__android_log_print(ANDROID_LOG_VERBOSE, "UADE", "Can not read %s: %s\n", songname, strerror(errno));
continue;
}
/* The order of parameter processing is important:
* 0. set uade.conf options (done before this)
* 1. set eagleplayer attributes
* 2. set song attributes
* 3. set command line options
*/
if (state.ep != NULL)
uade_set_ep_attributes(&state);
if (uade_set_song_attributes(&state, playername, sizeof playername)) {
debug(state.config.verbose, "Song rejected based on attributes: %s\n",
state.song->module_filename);
uade_unalloc_song(&state);
continue;
}
uade_merge_configs(&state.config, &uc_cmdline);
/* Now we have the final configuration in "uc". */
uade_set_effects(&state);
if ((filesize = stat_file_size(playername)) < 0) {
__android_log_print(ANDROID_LOG_VERBOSE, "UADE", "Can not find player: %s (%s)\n", playername, strerror(errno));
uade_unalloc_song(&state);
continue;
}
debug(state.config.verbose, "Player: %s (%zd bytes)\n", playername, filesize);
__android_log_print(ANDROID_LOG_VERBOSE, "UADE", "Song: %s (%zd bytes)\n", state.song->module_filename, state.song->bufsize);
ret = uade_song_initialization(scorename, playername, modulename, &state);
switch (ret) {
case UADECORE_INIT_OK:
break;
case UADECORE_INIT_ERROR:
uade_unalloc_song(&state);
goto cleanup;
case UADECORE_CANT_PLAY:
debug(state.config.verbose, "Uadecore refuses to play the song.\n");
uade_unalloc_song(&state);
continue; /* jump to the beginning of playlist loop */
default:
die("Unknown error from uade_song_initialization()\n");
}
if (subsong >= 0)
uade_set_subsong(subsong, &state.ipc);
plistdir = play_loop(&state);
uade_unalloc_song(&state);
if (plistdir == UADE_PLAY_FAILURE)
goto cleanup;
else if (plistdir == UADE_PLAY_EXIT)
break;
}
debug(uc_cmdline.verbose || state.permconfig.verbose, "Killing child (%d).\n", uadepid);
cleanup(&state);
return 0;
cleanup:
cleanup(&state);
return 1;
}
int
main (int argc, char **argv)
{
#ifdef USE_GCONF
GConfClient *gconf;
#endif
char *dir;
struct sigaction action;
sigset_t sigset;
main_status = QUARK_STARTING;
/* initialize the locale */
if (!setlocale(LC_ALL, ""))
g_warning("Couldn't set locale from environment.\n");
bindtextdomain(PACKAGE_NAME, LOCALEDIR);
bind_textdomain_codeset(PACKAGE_NAME, "UTF-8");
textdomain(PACKAGE_NAME);
/* set up signal handler */
sigemptyset (&sigset);
action.sa_handler = signal_handler;
action.sa_mask = sigset;
action.sa_flags = SA_NOCLDSTOP;
sigaction (SIGTERM, &action, (struct sigaction *) NULL);
sigaction (SIGINT, &action, (struct sigaction *) NULL);
sigaction (SIGHUP, &action, (struct sigaction *) NULL);
g_type_init ();
gnome_vfs_init ();
#ifdef USE_GCONF
gconf = gconf_client_get_default ();
gconf_client_add_dir (gconf, QUARK_GCONF_ROOT,
GCONF_CLIENT_PRELOAD_RECURSIVE, NULL);
gconf_client_notify_add (gconf, QUARK_GCONF_ROOT, config_changed, NULL,
NULL, NULL);
#endif
/* make the directory we use in ~ */
dir = g_build_filename (g_get_home_dir(), ".quark", NULL);
mkdir (dir, S_IRWXU|S_IRWXG|S_IRWXO);
g_free (dir);
loop = g_main_loop_new (NULL, FALSE);
if (!fifo_open ()) {
g_critical("failed to open fifo");
return 1;
}
music_init ();
g_static_mutex_lock (&main_mutex);
playlist_init ();
#ifdef USE_GCONF
config_load (gconf);
#endif
main_status = QUARK_RUNNING;
g_static_mutex_unlock (&main_mutex);
g_main_loop_run (loop);
g_static_mutex_lock (&main_mutex);
main_status = QUARK_EXITING;
#ifdef USE_GCONF
config_save (gconf);
#endif
playlist_destroy ();
g_static_mutex_unlock (&main_mutex);
music_destroy ();
fifo_destroy ();
g_main_loop_unref (loop);
#ifdef USE_GCONF
g_object_unref (G_OBJECT (gconf));
#endif
gnome_vfs_shutdown ();
return 0;
}
static int database_info_list_iterate_found_match(
database_state_handle_t *db_state,
database_info_handle_t *db,
const char *zip_name
)
{
char db_crc[PATH_MAX_LENGTH] = {0};
char db_playlist_path[PATH_MAX_LENGTH] = {0};
char db_playlist_base_str[PATH_MAX_LENGTH] = {0};
char entry_path_str[PATH_MAX_LENGTH] = {0};
playlist_t *playlist = NULL;
settings_t *settings = config_get_ptr();
const char *db_path = db_state->list->elems[
db_state->list_index].data;
const char *entry_path = db ? db->list->elems[
db->list_ptr].data : NULL;
database_info_t *db_info_entry = &db_state->info->list[
db_state->entry_index];
fill_short_pathname_representation(db_playlist_base_str,
db_path, sizeof(db_playlist_base_str));
path_remove_extension(db_playlist_base_str);
strlcat(db_playlist_base_str, ".lpl", sizeof(db_playlist_base_str));
fill_pathname_join(db_playlist_path, settings->directory.playlist,
db_playlist_base_str, sizeof(db_playlist_path));
playlist = playlist_init(db_playlist_path, COLLECTION_SIZE);
snprintf(db_crc, sizeof(db_crc), "%08X|crc", db_info_entry->crc32);
if (entry_path)
strlcpy(entry_path_str, entry_path, sizeof(entry_path_str));
if (!string_is_empty(zip_name))
fill_pathname_join_delim(entry_path_str, entry_path_str, zip_name,
'#', sizeof(entry_path_str));
#if 0
RARCH_LOG("Found match in database !\n");
RARCH_LOG("Path: %s\n", db_path);
RARCH_LOG("CRC : %s\n", db_crc);
RARCH_LOG("Playlist Path: %s\n", db_playlist_path);
RARCH_LOG("Entry Path: %s\n", entry_path);
RARCH_LOG("Playlist not NULL: %d\n", playlist != NULL);
RARCH_LOG("ZIP entry: %s\n", zip_name);
RARCH_LOG("entry path str: %s\n", entry_path_str);
#endif
if(!playlist_entry_exists(playlist, entry_path_str, db_crc))
{
playlist_push(playlist, entry_path_str,
db_info_entry->name, "DETECT", "DETECT",
db_crc, db_playlist_base_str);
}
playlist_write_file(playlist);
playlist_free(playlist);
database_info_list_free(db_state->info);
db_state->info = NULL;
db_state->crc = 0;
return 0;
}
static void init(void)
{
kernel_init();
buffer_init();
enable_irq();
lcd_init();
#ifdef HAVE_REMOTE_LCD
lcd_remote_init();
#endif
font_init();
show_logo();
button_init();
backlight_init();
sim_tasks_init();
lang_init(core_language_builtin, language_strings,
LANG_LAST_INDEX_IN_ARRAY);
#ifdef DEBUG
debug_init();
#endif
/* Keep the order of this 3 (viewportmanager handles statusbars)
* Must be done before any code uses the multi-screen API */
gui_syncstatusbar_init(&statusbars);
gui_sync_wps_init();
sb_skin_init();
viewportmanager_init();
storage_init();
settings_reset();
settings_load(SETTINGS_ALL);
settings_apply(true);
init_dircache(true);
init_dircache(false);
#ifdef HAVE_TAGCACHE
init_tagcache();
#endif
sleep(HZ/2);
tree_mem_init();
filetype_init();
playlist_init();
#if CONFIG_CODEC != SWCODEC
mp3_init( global_settings.volume,
global_settings.bass,
global_settings.treble,
global_settings.balance,
global_settings.loudness,
global_settings.avc,
global_settings.channel_config,
global_settings.stereo_width,
global_settings.mdb_strength,
global_settings.mdb_harmonics,
global_settings.mdb_center,
global_settings.mdb_shape,
global_settings.mdb_enable,
global_settings.superbass);
/* audio_init must to know the size of voice buffer so init voice first */
talk_init();
#endif /* CONFIG_CODEC != SWCODEC */
scrobbler_init();
#if CONFIG_CODEC == SWCODEC
tdspeed_init();
#endif /* CONFIG_CODEC == SWCODEC */
audio_init();
button_clear_queue(); /* Empty the keyboard buffer */
settings_apply_skins();
}
