Ejemplo n.º 1
0
/** 
* got command from server, and push them to task queue
* @param   m: the message got 
************************************************************/
static void server_push_command(message_t *message) {
	if( message == NULL ){
		LM_ERR( " server push message is null \n" );
		return;
	}
	connection_t *connection;

	task_thread_t *thread;
	task_queue_item_t *item;
	
	connection = (connection_t*)message->connection;
	
	/*push to the task queue*/
	thread = (task_thread_t *)(connection->thread);
	
	item = task_queue_item_new(thread->ttm,
                            			    SERVER_ITEM_NUMBER);

	if (item == NULL){
		LM_ERR("task_queue_item_new return null\n");
		return ;
	}
	
 	item->task_data.msg = *message;
    task_queue_push(thread->new_task_queue, item);

    if (write(thread->notify_send_fd, "", 1) != 1) {
        LM_DBG("Writing to thread notify pipe\n");
    }

	return ;
	
}
Ejemplo n.º 2
0
void
thread_pool_execute_task(thread_pool_t p, routine_t f, arg_t arg) {
    task_t t=NULL;
    assert(p!=NULL && p->tasks!=NULL);

    /* create the task and add it to the queue */
    t=task_create(f,arg);
    p->tasks=task_queue_push(p->tasks,t);
}
Ejemplo n.º 3
0
bool task_push_netplay_lan_scan_rooms(retro_task_callback_t cb)
{
   retro_task_t *task = (retro_task_t*)calloc(1, sizeof(*task));

   if (!task)
      return false;

   task->type     = TASK_TYPE_BLOCKING;
   task->handler  = task_netplay_lan_scan_handler;
   task->callback = cb;
   task->title    = strdup(msg_hash_to_str(MSG_NETPLAY_LAN_SCANNING));

   task_queue_push(task);

   return true;
}
Ejemplo n.º 4
0
bool input_autoconfigure_disconnect(unsigned i, const char *ident)
{
   char msg[255];
   retro_task_t         *task      = task_init();
   autoconfig_disconnect_t *state  = (autoconfig_disconnect_t*)calloc(1, sizeof(*state));

   if (!state || !task)
      goto error;

   msg[0]      = '\0';

   state->idx  = i;

   snprintf(msg, sizeof(msg), "%s #%u (%s).",
         msg_hash_to_str(MSG_DEVICE_DISCONNECTED_FROM_PORT),
         i, ident);

   state->msg    = strdup(msg);

   input_config_clear_device_name(state->idx);
   input_config_clear_device_display_name(state->idx);
   input_config_clear_device_config_name(state->idx);
   input_config_clear_device_config_path(state->idx);

   task->state   = state;
   task->handler = input_autoconfigure_disconnect_handler;

   task_queue_push(task);

   return true;

error:
   if (state)
   {
      if (!string_is_empty(state->msg))
         free(state->msg);
      free(state);
   }
   if (task)
      free(task);

   return false;
}
Ejemplo n.º 5
0
void task_push_get_powerstate(void)
{
   retro_task_t *task  = task_init();
   powerstate_t *state = NULL;

   if (!task)
      return;
   state = (powerstate_t*)calloc(1, sizeof(*state));
   if (!state)
   {
      free(task);
      return;
   }

   task->type     = TASK_TYPE_NONE;
   task->state    = state;
   task->handler  = task_powerstate_handler;
   task->callback = task_powerstate_cb;
   task->mute     = true;

   task_queue_push(task);
}
Ejemplo n.º 6
0
bool task_push_dbscan(
      const char *playlist_directory,
      const char *content_database,
      const char *fullpath,
      bool directory,
      bool show_hidden_files,
      retro_task_callback_t cb)
{
   retro_task_t *t      = (retro_task_t*)calloc(1, sizeof(*t));
   db_handle_t *db      = (db_handle_t*)calloc(1, sizeof(db_handle_t));

   if (!t || !db)
      goto error;

   t->handler                = task_database_handler;
   t->state                  = db;
   t->callback               = cb;
   t->title                  = strdup(msg_hash_to_str(MSG_PREPARING_FOR_CONTENT_SCAN));

   db->show_hidden_files     = show_hidden_files;
   db->is_directory          = directory;
   db->playlist_directory    = NULL;
   db->fullpath              = strdup(fullpath);
   db->playlist_directory    = strdup(playlist_directory);
   db->content_database_path = strdup(content_database);

   task_queue_push(t);

   return true;

error:
   if (t)
      free(t);
   if (db)
      free(db);
   return false;
}
Ejemplo n.º 7
0
bool input_autoconfigure_connect(
      const char *name,
      const char *display_name,
      const char *driver,
      unsigned idx,
      unsigned vid,
      unsigned pid)
{
   unsigned i;
   retro_task_t         *task = task_init();
   autoconfig_params_t *state = (autoconfig_params_t*)calloc(1, sizeof(*state));
   settings_t       *settings = config_get_ptr();
   const char *dir_autoconf   = settings ? settings->paths.directory_autoconfig : NULL;
   bool autodetect_enable     = settings ? settings->bools.input_autodetect_enable : false;

   if (!task || !state || !autodetect_enable)
      goto error;

   if (!string_is_empty(name))
      state->name                 = strdup(name);

   if (!string_is_empty(dir_autoconf))
      state->autoconfig_directory = strdup(dir_autoconf);

   state->idx                     = idx;
   state->vid                     = vid;
   state->pid                     = pid;
   state->max_users               = *(
         input_driver_get_uint(INPUT_ACTION_MAX_USERS));

   input_autoconfigure_override_handler(state);

   if (!string_is_empty(state->name))
         input_config_set_device_name(state->idx, state->name);
   input_config_set_pid(state->idx, state->pid);
   input_config_set_vid(state->idx, state->vid);

   for (i = 0; i < RARCH_BIND_LIST_END; i++)
   {
      input_autoconf_binds[state->idx][i].joykey           = NO_BTN;
      input_autoconf_binds[state->idx][i].joyaxis          = AXIS_NONE;
      if (
          !string_is_empty(input_autoconf_binds[state->idx][i].joykey_label))
         free(input_autoconf_binds[state->idx][i].joykey_label);
      if (
          !string_is_empty(input_autoconf_binds[state->idx][i].joyaxis_label))
         free(input_autoconf_binds[state->idx][i].joyaxis_label);
      input_autoconf_binds[state->idx][i].joykey_label      = NULL;
      input_autoconf_binds[state->idx][i].joyaxis_label     = NULL;
   }

   input_autoconfigured[state->idx] = false;

   task->state                      = state;
   task->handler                    = input_autoconfigure_connect_handler;

   task_queue_push(task);

   return true;

error:
   if (state)
   {
      input_autoconfigure_params_free(state);
      free(state);
   }
   if (task)
      free(task);

   return false;
}
Ejemplo n.º 8
0
bool task_push_audio_mixer_load(const char *fullpath, retro_task_callback_t cb, void *user_data)
{
   nbio_handle_t             *nbio    = NULL;
   struct audio_mixer_handle   *image = NULL;
   retro_task_t                   *t  = (retro_task_t*)calloc(1, sizeof(*t));

   if (!t)
      goto error;

   nbio               = (nbio_handle_t*)calloc(1, sizeof(*nbio));

   if (!nbio)
      goto error;

   strlcpy(nbio->path, fullpath, sizeof(nbio->path));

   image              = (struct audio_mixer_handle*)calloc(1, sizeof(*image));   
   if (!image)
      goto error;

   image->is_finished = false;

   strlcpy(image->path, fullpath, sizeof(image->path));

   nbio->type         = NBIO_TYPE_NONE;
   image->type        = AUDIO_MIXER_TYPE_NONE;

   if (strstr(fullpath, file_path_str(FILE_PATH_WAV_EXTENSION)))
   {
      image->type     = AUDIO_MIXER_TYPE_WAV;
      nbio->type      = NBIO_TYPE_WAV;
      t->callback     = task_audio_mixer_handle_upload_wav;
   }
   else if (strstr(fullpath, file_path_str(FILE_PATH_OGG_EXTENSION)))
   {
      image->type     = AUDIO_MIXER_TYPE_OGG;
      nbio->type      = NBIO_TYPE_OGG;
      t->callback     = task_audio_mixer_handle_upload_ogg;
   }
   else if (	strstr(fullpath, file_path_str(FILE_PATH_MOD_EXTENSION)) ||
		strstr(fullpath, file_path_str(FILE_PATH_S3M_EXTENSION)) ||
		strstr(fullpath, file_path_str(FILE_PATH_XM_EXTENSION)))
   {
      image->type     = AUDIO_MIXER_TYPE_MOD;
      nbio->type      = NBIO_TYPE_MOD;
      t->callback     = task_audio_mixer_handle_upload_mod;
   }

   nbio->data         = (struct audio_mixer_handle*)image;
   nbio->is_finished  = false;
   nbio->cb           = &cb_nbio_audio_mixer_load;
   nbio->status       = NBIO_STATUS_INIT;

   t->state           = nbio;
   t->handler         = task_file_load_handler;
   t->cleanup         = task_audio_mixer_load_free;
   t->user_data       = user_data;

   task_queue_push(t);

   return true;

error:
   if (nbio)
   {
      if (nbio->data)
         free(nbio->data);
      nbio_free(nbio->handle);
      free(nbio);
   }
   if (t)
      free(t);

   RARCH_ERR("[audio mixer load] Failed to open '%s': %s.\n",
         fullpath, strerror(errno));

   return false;
}
Ejemplo n.º 9
0
static void* task_push_http_transfer_generic(
      struct http_connection_t *conn,
      const char *url, bool mute, const char *type,
      retro_task_callback_t cb, void *user_data)
{
   task_finder_data_t find_data;
   char tmp[255];
   retro_task_t  *t               = NULL;
   http_handle_t *http            = NULL;

   if (string_is_empty(url))
      return NULL;

   tmp[0]             = '\0';

   find_data.func     = task_http_finder;
   find_data.userdata = (void*)url;

   /* Concurrent download of the same file is not allowed */
   if (task_queue_find(&find_data))
   {
      RARCH_LOG("[http] '%s'' is already being downloaded.\n", url);
      return NULL;
   }

   if (!conn)
      return NULL;

   http                    = (http_handle_t*)calloc(1, sizeof(*http));

   if (!http)
      goto error;

   http->connection.handle = conn;
   http->connection.cb     = &cb_http_conn_default;

   if (type)
      strlcpy(http->connection.elem1, type, sizeof(http->connection.elem1));

   strlcpy(http->connection.url, url, sizeof(http->connection.url));

   http->status            = HTTP_STATUS_CONNECTION_TRANSFER;
   t                       = (retro_task_t*)calloc(1, sizeof(*t));

   if (!t)
      goto error;

   t->handler              = task_http_transfer_handler;
   t->state                = http;
   t->mute                 = mute;
   t->callback             = cb;
   t->user_data            = user_data;
   t->progress             = -1;

   snprintf(tmp, sizeof(tmp), "%s '%s'",
         msg_hash_to_str(MSG_DOWNLOADING), path_basename(url));

   t->title                = strdup(tmp);

   task_queue_push(t);

   return t;

error:
   if (conn)
      net_http_connection_free(conn);
   if (http)
      free(http);

   return NULL;
}
Ejemplo n.º 10
0
/* Take frame bottom-up. */
static bool screenshot_dump(
      const char *name_base,
      const void *frame,
      unsigned width,
      unsigned height,
      int pitch, bool bgr24,
      void *userbuf, bool savestate,
      bool is_idle,
      bool is_paused)
{
   char screenshot_path[PATH_MAX_LENGTH];
   uint8_t *buf                   = NULL;
#ifdef _XBOX1
   d3d_video_t *d3d               = (d3d_video_t*)video_driver_get_ptr(true);
#endif
   settings_t *settings           = config_get_ptr();
   retro_task_t *task             = (retro_task_t*)calloc(1, sizeof(*task));
   screenshot_task_state_t *state = (screenshot_task_state_t*)
         calloc(1, sizeof(*state));
   const char *screenshot_dir     = settings->paths.directory_screenshot;

   screenshot_path[0]             = '\0';

   if (string_is_empty(screenshot_dir) || settings->bools.screenshots_in_content_dir)
   {
      fill_pathname_basedir(screenshot_path, name_base,
            sizeof(screenshot_path));
      screenshot_dir = screenshot_path;
   }

   state->is_idle             = is_idle;
   state->is_paused           = is_paused;
   state->bgr24               = bgr24;
   state->height              = height;
   state->width               = width;
   state->pitch               = pitch;
   state->frame               = frame;
   state->userbuf             = userbuf;
   state->silence             = savestate;
   state->history_list_enable = settings->bools.history_list_enable;
   state->pixel_format_type   = video_driver_get_pixel_format();

   if (savestate)
      snprintf(state->filename,
            sizeof(state->filename), "%s.png", name_base);
   else
   {
      if (settings->bools.auto_screenshot_filename)
         fill_str_dated_filename(state->shotname, path_basename(name_base),
               IMG_EXT, sizeof(state->shotname));
      else
         snprintf(state->shotname, sizeof(state->shotname),
               "%s.png", path_basename(name_base));

      fill_pathname_join(state->filename, screenshot_dir,
            state->shotname, sizeof(state->filename));
   }

#ifdef _XBOX1
   d3d->dev->GetBackBuffer(-1, D3DBACKBUFFER_TYPE_MONO, &state->surf);
#elif defined(HAVE_RPNG)
   buf = (uint8_t*)malloc(width * height * 3);
   if (!buf)
   {
      if (task)
         free(task);
      free(state);
      return false;
   }
   state->out_buffer = buf;
#endif

   task->type        = TASK_TYPE_BLOCKING;
   task->state       = state;
   task->handler     = task_screenshot_handler;

   if (!savestate)
      task->title    = strdup(msg_hash_to_str(MSG_TAKING_SCREENSHOT));

   task_queue_push(task);

   return true;
}
Ejemplo n.º 11
0
/* Take frame bottom-up. */
static bool screenshot_dump(
      const char *name_base,
      const void *frame,
      unsigned width,
      unsigned height,
      int pitch, bool bgr24,
      void *userbuf, bool savestate,
      bool is_idle,
      bool is_paused,
      bool fullpath,
      bool use_thread)
{
   char screenshot_path[PATH_MAX_LENGTH];
   uint8_t *buf                   = NULL;
   settings_t *settings           = config_get_ptr();
   retro_task_t *task;
   screenshot_task_state_t *state;
   const char *screenshot_dir     = settings->paths.directory_screenshot;
   struct retro_system_info system_info;

   screenshot_path[0]             = '\0';

   if (!core_get_system_info(&system_info))
      return false;

   task = task_init();
   state = (screenshot_task_state_t*)calloc(1, sizeof(*state));
   state->shotname[0] = '\0';

   /* If fullpath is true, name_base already contains a static path + filename to save the screenshot to. */
   if (fullpath)
      strlcpy(state->filename, name_base, sizeof(state->filename));
   else
   {
      if (string_is_empty(screenshot_dir) || settings->bools.screenshots_in_content_dir)
      {
         fill_pathname_basedir(screenshot_path, name_base,
               sizeof(screenshot_path));
         screenshot_dir = screenshot_path;
      }
   }

   state->is_idle             = is_idle;
   state->is_paused           = is_paused;
   state->bgr24               = bgr24;
   state->height              = height;
   state->width               = width;
   state->pitch               = pitch;
   state->frame               = frame;
   state->userbuf             = userbuf;
   state->silence             = savestate;
   state->history_list_enable = settings->bools.history_list_enable;
   state->pixel_format_type   = video_driver_get_pixel_format();

   if (!fullpath)
   {
      if (savestate)
         snprintf(state->filename,
               sizeof(state->filename), "%s.png", name_base);
      else
      {
         if (settings->bools.auto_screenshot_filename)
         {
            const char *screenshot_name = NULL;

            if (path_is_empty(RARCH_PATH_CONTENT))
            {
               if (string_is_empty(system_info.library_name))
                  screenshot_name = "RetroArch";
               else
                  screenshot_name = system_info.library_name;
            }
            else
               screenshot_name = path_basename(name_base);

            fill_str_dated_filename(state->shotname, screenshot_name,
                  IMG_EXT, sizeof(state->shotname));
         }
         else
            snprintf(state->shotname, sizeof(state->shotname),
                  "%s.png", path_basename(name_base));

         fill_pathname_join(state->filename, screenshot_dir,
               state->shotname, sizeof(state->filename));
      }
   }

#if defined(HAVE_RPNG)
   buf = (uint8_t*)malloc(width * height * 3);
   if (!buf)
   {
      if (task)
         free(task);
      free(state);
      return false;
   }
   state->out_buffer = buf;
#endif

   task->type        = TASK_TYPE_BLOCKING;
   task->state       = state;
   task->handler     = task_screenshot_handler;

   if (use_thread)
   {
      if (!savestate)
         task->title = strdup(msg_hash_to_str(MSG_TAKING_SCREENSHOT));

      if (!task_queue_push(task))
      {
         /* There is already a blocking task going on */
         if (task->title)
            task_free_title(task);

         free(task);

         if (state->out_buffer)
            free(state->out_buffer);

         free(state);

         return false;
      }
   }
   else
   {
      if (task)
         free(task);
      return screenshot_dump_direct(state);
   }

   return true;
}