gui_main.cpp

完整的RTP RTSP代码库

				   guint info,
				   guint time)
{
    gchar *temp, *string;

    string = (gchar *)selection_data->data;

    /* remove newline at end of line, and the file:// url header
       at the begining, copied this code from the xmms source */
    temp = strchr(string, '\n');
    if (temp)
    {
        if (*(temp - 1) == '\r')
            *(temp - 1) = '\0';
        *temp = '\0';
    }
    if (!strncasecmp(string, "file:", 5))
        string = string + 5;
    start_session_from_name(string);
}


static void on_filename_selected (GtkFileSelection *selector, 
				  gpointer user_data) 
{
  const gchar *name;

  name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data));
  start_session_from_name(name);
}

/*
 * This is right out of the book...
 */
static void enable_file_select (GtkSignalFunc func,
				const char *header, 
				const char *file)
{
  GtkWidget *ret;
  ret = gtk_file_selection_new(header);
  if (file != NULL) {
    gtk_file_selection_set_filename(GTK_FILE_SELECTION(ret), file);
  }
  gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(ret));
  gtk_signal_connect (GTK_OBJECT(GTK_FILE_SELECTION(ret)->ok_button),
		      "clicked", 
		      GTK_SIGNAL_FUNC(func), 
		      ret);
                             
  /* Ensure that the dialog box is destroyed when the user clicks a button. */
     
  gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(ret)->ok_button),
			    "clicked", 
			    GTK_SIGNAL_FUNC(gtk_widget_destroy),
			    GTK_OBJECT(ret));

  gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(ret)->cancel_button),
			    "clicked", 
			    GTK_SIGNAL_FUNC(gtk_widget_destroy),
			    GTK_OBJECT(ret));
  
  /* Display that dialog */
     
  gtk_widget_show (ret);
  
}

static void on_browse_button_clicked (GtkWidget *window, gpointer data)
{
  enable_file_select(GTK_SIGNAL_FUNC(on_filename_selected),
		     "Open Media File", 
		     last_file);
}

static void on_logfile_selected (GtkFileSelection *selected,
				 gpointer user_data)
{
  const gchar *name;
  name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data));
  config.set_config_string(CONFIG_LOG_FILE, name);
  open_log_file(name);
}

static void on_main_menu_set_log_file (GtkWidget *window, gpointer data)
{
   enable_file_select(GTK_SIGNAL_FUNC(on_logfile_selected),
		     "Select Log File", 
		     config.get_config_string(CONFIG_LOG_FILE));
}

static void on_main_menu_clear_log_file (GtkWidget *window, gpointer data)
{
  if (config.get_config_string(CONFIG_LOG_FILE) != NULL) {
    clear_log_file();
  }
}

static void on_playlist_child_selected (GtkWidget *window, gpointer data)
{
  const gchar *entry = 
    gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
  if (strcmp(entry, "") == 0) 
    return;
  if (last_entry && strcmp(entry, last_entry) == 0) 
    return;
  start_session_from_name(entry);
}

static void on_play_list_selected (GtkWidget *window, gpointer data)
{
  const gchar *entry = gtk_entry_get_text(GTK_ENTRY(window));
  start_session_from_name(entry);
}

static void on_play_clicked (GtkWidget *window, gpointer data)
{
  int ret;
  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(play_button)) == FALSE) {
    if (play_state == PLAYING) {
      toggle_button_adjust(play_button, TRUE);
    }
    return;
  }

  if (psptr == NULL)
    return;
  ret = 0;
  SDL_mutexP(command_mutex);
  switch (play_state) {
  case PAUSED:
    ret = psptr->play_all_media(FALSE, 0.0);
    break;
  case STOPPED:
    ret = psptr->play_all_media(TRUE, 0.0);
    break;
  default:
    break;
  }
  if (ret == 0)
    adjust_gui_for_play();
  SDL_mutexV(command_mutex);
  if (ret != 0) {
    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
	     psptr->get_message());
    ShowMessage("Play error", buffer);
    close_session();
  }
}

static void do_pause (void)
{
  SDL_mutexP(command_mutex);
  if (psptr != NULL && play_state == PLAYING) {
    play_state = PAUSED;
    toggle_button_adjust(play_button, FALSE);
    toggle_button_adjust(pause_button, TRUE);
    psptr->pause_all_media();
  } else {
    toggle_button_adjust(pause_button, play_state == PAUSED);
  }
  SDL_mutexV(command_mutex);
}
static void on_pause_clicked (GtkWidget *window, gpointer data)
{
  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pause_button)) == FALSE) {
    if (play_state == PAUSED) {
      toggle_button_adjust(pause_button, TRUE);
    }
    return;
  }
  do_pause();
}

static void on_stop_clicked (GtkWidget *window, gpointer data)
{
  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_button)) == FALSE) {
    if (play_state == STOPPED) {
      toggle_button_adjust(stop_button, TRUE);
    }
    return;
  }
  SDL_mutexP(command_mutex);
  if (psptr != NULL && play_state == PLAYING) {
    play_state = STOPPED;
    toggle_button_adjust(play_button, FALSE);
    toggle_button_adjust(stop_button, TRUE);
    psptr->pause_all_media();
  } else {
    toggle_button_adjust(stop_button, play_state == STOPPED);
  }
  SDL_mutexV(command_mutex);
}

/*
 * Set the speaker button to either mute or playing
 */
static void set_speaker_button (gchar **xpm_data)
{
  GtkWidget *wid;
  wid = CreateWidgetFromXpm(speaker_button, xpm_data);
  FreeChild(speaker_button);
  gtk_container_add(GTK_CONTAINER(speaker_button), wid);
}

static void on_speaker_clicked (GtkWidget *window, gpointer data)
{
  int vol;
  if (master_muted == false) {
    // mute the puppy
    set_speaker_button(xpm_speaker_muted);
    master_muted = true;
    vol = 0;
  } else {
    set_speaker_button(xpm_speaker);
    master_muted = false;
    vol  = master_volume;
  }
  config.SetBoolValue(CONFIG_MUTED, master_muted);
  if (psptr && psptr->session_has_audio()) {
    psptr->set_audio_volume(vol);
  }
}
static void volume_adjusted (int volume)
{
  GtkAdjustment *val = gtk_range_get_adjustment(GTK_RANGE(volume_slider));
  gtk_adjustment_set_value(val, (gfloat)volume);
  master_volume = volume;
  config.set_config_value(CONFIG_VOLUME, master_volume);
  gtk_range_set_adjustment(GTK_RANGE(volume_slider), val);
#ifndef HAVE_GTK_2_0
  gtk_range_slider_update(GTK_RANGE(volume_slider));
  gtk_range_clear_background(GTK_RANGE(volume_slider));
#endif
   if (master_muted == false && psptr && psptr->session_has_audio()) {
     psptr->set_audio_volume(master_volume);
   }
}

static void on_volume_adjusted (GtkWidget *window, gpointer data)
{
  GtkAdjustment *val = gtk_range_get_adjustment(GTK_RANGE(volume_slider));
  volume_adjusted((int)val->value);
}

static void on_debug_display_status (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  checkmenu = GTK_CHECK_MENU_ITEM(window);
  config.SetBoolValue(CONFIG_DISPLAY_DEBUG,
		      checkmenu->active == FALSE ? false : true);
}

static void on_debug_mpeg4isoonly (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  config_index_t iso_only = config.FindIndexByName("Mpeg4IsoOnly");

  checkmenu = GTK_CHECK_MENU_ITEM(window);

  if (iso_only != UINT32_MAX) {
    config.SetBoolValue(iso_only,
			checkmenu->active == FALSE ? 0 : 1);
  } else {
    ShowMessage("Error", "Mpeg4IsoOnly config variable not loaded");
  }
}
static void on_debug_oldxvid (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  config_index_t old_xvid = config.FindIndexByName("UseOldXvid");
  if (old_xvid == UINT32_MAX) {
    ShowMessage("Error", "UseOldXvid config variable not loaded");
  } else {
    checkmenu = GTK_CHECK_MENU_ITEM(window);
    config.SetBoolValue(old_xvid, 
			checkmenu->active == FALSE ? 0 : 1);
  }
}
static void on_debug_usempeg3 (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  config_index_t mpeg3 = config.FindIndexByName("UseMpeg3");
  if (mpeg3 == UINT32_MAX) {
    ShowMessage("Error", "UseMpeg3 config variable not loaded");
  } else {
    checkmenu = GTK_CHECK_MENU_ITEM(window);
    config.SetBoolValue(mpeg3, 
			checkmenu->active == FALSE ? 0 : 1);
  }
}

static void on_debug_use_old_mp4_lib (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;

  checkmenu = GTK_CHECK_MENU_ITEM(window);

  config.set_config_value(CONFIG_USE_OLD_MP4_LIB,
			  checkmenu->active == FALSE ? 0 : 1);
}

static void on_debug_http (GtkWidget *window, gpointer data)
{
  int loglevel = GPOINTER_TO_INT(data);

  http_set_loglevel(LOG_PRI(loglevel));
  config.set_config_value(CONFIG_HTTP_DEBUG, LOG_PRI(loglevel));
}

static void on_debug_rtsp (GtkWidget *window, gpointer data)
{
  int loglevel = GPOINTER_TO_INT(data);

  rtsp_set_loglevel(LOG_PRI(loglevel));
  config.set_config_value(CONFIG_RTSP_DEBUG, LOG_PRI(loglevel));
}
  
static void on_debug_rtp (GtkWidget *window, gpointer data)
{
  int loglevel = GPOINTER_TO_INT(data);
  rtp_set_loglevel(LOG_PRI(loglevel));
  config.set_config_value(CONFIG_RTP_DEBUG, LOG_PRI(loglevel));
}

static void on_debug_sdp (GtkWidget *window, gpointer data)
{
  int loglevel = GPOINTER_TO_INT(data);

  sdp_set_loglevel(LOG_PRI(loglevel));
  config.set_config_value(CONFIG_SDP_DEBUG, LOG_PRI(loglevel));
}

static void on_debug_mpeg2t (GtkWidget *window, gpointer data)
{
  int loglevel = GPOINTER_TO_INT(data);

  mpeg2t_set_loglevel(LOG_PRI(loglevel));
  config.set_config_value(CONFIG_MPEG2T_DEBUG, LOG_PRI(loglevel));
}
static void on_debug_mpeg2ps (GtkWidget *window, gpointer data)
{
  int loglevel = GPOINTER_TO_INT(data);

  mpeg2ps_set_loglevel(LOG_PRI(loglevel));
  config.set_config_value(CONFIG_MPEG2PS_DEBUG, LOG_PRI(loglevel));
}

static void on_media_play_audio (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  checkmenu = GTK_CHECK_MENU_ITEM(window);

  config.set_config_value(CONFIG_PLAY_AUDIO, checkmenu->active);
  if (psptr != NULL) {
    ShowMessage("Warning", "Play audio will not take effect until next session");
  }
}

static void on_media_play_text (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  checkmenu = GTK_CHECK_MENU_ITEM(window);

  config.set_config_value(CONFIG_PLAY_TEXT, checkmenu->active);
  if (psptr != NULL) {
    ShowMessage("Warning", "Play text will not take effect until next session");
  }
}
static void on_media_play_video (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;
  checkmenu = GTK_CHECK_MENU_ITEM(window);

  config.set_config_value(CONFIG_PLAY_VIDEO, checkmenu->active);
  if (psptr != NULL) {
    ShowMessage("Warning", "Play video will not take effect until next session");
  }
}

static void on_network_rtp_over_rtsp (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;

  checkmenu = GTK_CHECK_MENU_ITEM(window);


  config.set_config_value(CONFIG_USE_RTP_OVER_RTSP,
			  checkmenu->active);
}
  
static void change_video_size (int newsize)
{
  if (master_screen_size == newsize) return;

  master_screen_size = newsize;
  if (psptr != NULL) {
    psptr->set_screen_size(newsize / 50);
  }
  int index;
  if (newsize == 50) index = 0;
  else if (newsize == 100) index = 1;
  else index = 2;
#ifdef HAVE_GTK_2_0
  if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(videoradio[index])))
#else
    if (!(GTK_CHECK_MENU_ITEM(videoradio[index])->active)) 
#endif
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(videoradio[index]), TRUE);

}

static void on_video_radio (GtkWidget *window, gpointer data)
{
#ifdef HAVE_GTK_2_0
  if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(window)))
#else
    if (!(GTK_CHECK_MENU_ITEM(window)->active)) 
#endif
    return;

  int newsize = GPOINTER_TO_INT(data);
  if (newsize != master_screen_size) {
    change_video_size(newsize);
  }
}

static void on_aspect_ratio (GtkWidget *window, gpointer data)
{
#ifdef HAVE_GTK_2_0
  if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(window)))
#else
    if (!(GTK_CHECK_MENU_ITEM(window)->active)) 
#endif
    return;
  int newaspect = GPOINTER_TO_INT(data);
  if (psptr != NULL) set_aspect_ratio(newaspect);
}

static void on_video_fullscreen (GtkWidget *window, gpointer data)
{
  if (psptr != NULL) {
    master_fullscreen = 1;
    psptr->set_screen_size(master_screen_size / 50, 1);
  }
}

static int on_time_slider_pressed (GtkWidget *window, gpointer data)
{
  time_slider_pressed = 1;
  return (FALSE);
}

static int on_time_slider_adjusted (GtkWidget *window, gpointer data)
{
  double maxtime, newtime;
  time_slider_pressed = 0;
  if (psptr == NULL) 
    return FALSE;
  maxtime = psptr->get_max_time();
  if (maxtime == 0.0)
    return FALSE;
  gdouble val;
#ifdef HAVE_GTK_2_0
  val = gtk_range_get_value(GTK_RANGE(time_slider));
#else
  GtkAdjustment *adj_val = gtk_range_get_adjustment(GTK_RANGE(time_slider));
  val = adj_val->value;
#endif
  newtime = (maxtime * val) / 100.0;
  SDL_mutexP(command_mutex);
  if (play_state == PLAYING) {
    psptr->pause_all_media();
  }
  // If we're going all the way back to the beginning, indicate that
  int ret = psptr->play_all_media(newtime == 0.0 ? TRUE : FALSE, newtime);
  if (ret == 0) 
    adjust_gui_for_play();
  SDL_mutexV(command_mutex);
  if (ret != 0) {
    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
	     psptr->get_message());
    ShowMessage("Play error", buffer);
    close_session();
  } 
  return FALSE;
}

static void on_loop_enabled_button (GtkWidget *widget, gpointer *data)
{
  master_looped = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  config.SetBoolValue(CONFIG_LOOPED, master_looped);
}

/*
 * Main timer routine - runs ~every 500 msec
 * Might be able to adjust this to handle just when playing.
 */
static bool one_sec = false;
static gint main_timer (gpointer raw)
{
  uint64_t play_time;
  char buffer[1024];
  if (play_state == PLAYING) {
    flush_log_file();

    if (one_sec == false) {
      one_sec = true;
    } else {
      if (config.GetBoolValue(CONFIG_DISPLAY_DEBUG))
	psptr->display_status();
      one_sec = false;
    }
    double max_time = psptr->get_max_time();
    uint64_t pt = psptr->get_playing_time();
    double playtime = ((double)pt) / 1000.0;