gui_main.cpp

网络MPEG4IP流媒体开发源代码

  time_slider_pressed = 1;
  return (FALSE);
}

static int on_time_slider_adjusted (GtkWidget *window, gpointer data)
{
  char errmsg[512];
  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,
				  errmsg, sizeof(errmsg));
  if (ret == 0) 
    adjust_gui_for_play();
  SDL_mutexV(command_mutex);
  if (ret != 0) {
    char buffer[1024];
    close_session();
    snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
	     errmsg);
    ShowMessage("Play error", buffer);
  } 
  return FALSE;
}

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

/*
 * Main timer routine - runs ~every 500 msec
 * Might be able to adjust this to handle just when playing.
 */
static gint main_timer (gpointer raw)
{
  uint64_t play_time;
  char errmsg[512];
  char buffer[1024];
  if (play_state == PLAYING) {
    double max_time = psptr->get_max_time();
    uint64_t pt = psptr->get_playing_time();
    double playtime = ((double)pt) / 1000.0;
    double val;

    val = max_time;
    if (time_slider_pressed == 0 && 
	val > 0.0 &&
	psptr->get_session_state() == SESSION_PLAYING) {
      if (playtime < 0) {
	val = 0.0;
      } else if (playtime > val) {
	val = 100.0;
      } else {
	val = (playtime * 100.0) / val;
      }
#ifdef HAVE_GTK_2_0
      gtk_range_set_value(GTK_RANGE(time_slider), val);
#else
      GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(time_slider));
      adj->value = val;
      gtk_range_set_adjustment(GTK_RANGE(time_slider), adj);
      gtk_range_slider_update(GTK_RANGE(time_slider));
      gtk_range_clear_background(GTK_RANGE(time_slider));
      gtk_range_draw_background(GTK_RANGE(time_slider));
      gtk_widget_show(time_slider);
#endif
    }
    int hr, min, tot;
    tot = (int) playtime;
    hr = tot / 3600;
    tot %= 3600;
    min = tot / 60;
    tot %= 60;
    playtime -= (double)((hr * 3600) + (min * 60));
    if (max_time == 0.0) {
      gchar buffer[30];
      g_snprintf(buffer, 30, "%d:%02d:%04.1f", hr, min, playtime);
      gtk_label_set_text(GTK_LABEL(time_disp), buffer);
    } else {
      int mhr, mmin, msec, mtot;
      mtot = (int)max_time;
      mhr = mtot / 3600;
      mtot %= 3600;
      mmin = mtot / 60;
      msec = mtot % 60;

      gchar buffer[60];
      g_snprintf(buffer, 60, "%d:%02d:%04.1f of %d:%02d:%02d", 
		 hr, min, playtime, mhr, mmin, msec);
      gtk_label_set_text(GTK_LABEL(time_disp), buffer);
    }
    
    for (int ix = 0; ix < 4; ix++) {
      const char *text;
      text = psptr->get_session_desc(ix);
      if (text != NULL) {
	gtk_label_set_text(GTK_LABEL(session_desc[ix]), text);
      } else {
	gtk_label_set_text(GTK_LABEL(session_desc[ix]), "");
      }
    }
  }
  CMsg *newmsg;
  while ((newmsg = master_queue.get_message()) != NULL) {
    switch (newmsg->get_value()) {
    case MSG_RECEIVED_QUIT:
      //player_debug_message("received quit");
      on_main_menu_close(NULL, 0);
      break;
    case MSG_SESSION_FINISHED:
      player_debug_message("gui received finished message");
      if (master_playlist != NULL) {
	SDL_mutexP(command_mutex);
	const char *start;
	do {
	  start = master_playlist->get_next();
	  if (start == NULL) {
	    if (master_looped)
	      start = master_playlist->get_first();
	  }
	  if (start != NULL)
	    create_session_from_name(start);
	} while (start != NULL && psptr == NULL);
	SDL_mutexV(command_mutex);
      } else if (master_looped != 0) {
	if (play_state == PLAYING) {
	  if (psptr == NULL)
	    break;
	  SDL_mutexP(command_mutex);
	  psptr->pause_all_media();
	  if (psptr->play_all_media(TRUE, 0.0, errmsg, sizeof(errmsg)) < 0) {
	    close_session();
	    snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
		     errmsg);
	    ShowMessage("Play error", buffer);
	  } else {
	    adjust_gui_for_play();
	  }
	  SDL_mutexV(command_mutex);
	}
      } else if (psptr != NULL) {
	play_state = STOPPED;
	toggle_button_adjust(play_button, FALSE);
	toggle_button_adjust(stop_button, TRUE);
	psptr->pause_all_media();
	master_fullscreen = 0;
      }

      break;
    case MSG_SDL_KEY_EVENT:
      sdl_event_msg_t *msg;
      uint32_t len;
      msg = (sdl_event_msg_t *)newmsg->get_message(len);
      if (len != sizeof(*msg)) {
	player_error_message("key event message is wrong size %d %d", 
			     len, (int) sizeof(*msg));
	break;
      }
      switch (msg->sym) {
      case SDLK_ESCAPE:
	player_debug_message("Got escape");
	master_fullscreen = 0;
	break;
      case SDLK_RETURN:
	if ((msg->mod & (KMOD_LALT | KMOD_RALT)) != 0) {
	  master_fullscreen = 1;
	}
	break;
      case SDLK_c:
	if ((msg->mod & (KMOD_LCTRL | KMOD_RCTRL)) != 0) {
	  on_main_menu_close(NULL, 0);
	}
	break;
      case SDLK_x:
	if ((msg->mod & (KMOD_LCTRL | KMOD_RCTRL)) != 0) {
	  delete_event(NULL, 0);
	}
	break;
      case SDLK_s:
	if ((msg->mod & (KMOD_LCTRL | KMOD_RCTRL)) != 0) {
	  on_menu_seek(NULL, NULL);
	}
	break;
      case SDLK_UP:
	master_volume += 10;
	if (master_volume > 100) master_volume = 100;
	volume_adjusted(master_volume);
	break;
      case SDLK_DOWN:
	if (master_volume > 10) {
	  master_volume -= 10;
	} else {
	  master_volume = 0;
	}
	volume_adjusted(master_volume);
	break;
	
      case SDLK_SPACE:
	if (play_state == PLAYING) {
	  do_pause();
	} else if (play_state == PAUSED && psptr) {
	  SDL_mutexP(command_mutex);
	  if (psptr->play_all_media(FALSE, 0.0, errmsg, sizeof(errmsg)) == 0) {
	    adjust_gui_for_play();
	    SDL_mutexV(command_mutex);
	  } else {
	    SDL_mutexV(command_mutex);
	    close_session();
	    snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
		     errmsg);
	    ShowMessage("Play error", buffer);
	  }
	}
	break;
      case SDLK_HOME:
	if (psptr && play_state == PLAYING) {
	  psptr->pause_all_media();
	  if (psptr->play_all_media(TRUE, 0.0, errmsg, sizeof(errmsg)) < 0) {
	    close_session();
	    snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
		     errmsg);
	    ShowMessage("Play error", buffer);
	  }
	}
	break;
      case SDLK_RIGHT:
	if (psptr && psptr->session_is_seekable() && play_state == PLAYING) {
	  SDL_mutexP(command_mutex);
	  play_time = psptr->get_playing_time();
	  double ptime, maxtime;
	  play_time += 10 * M_LLU;
	  ptime = (double)play_time;
	  ptime /= 1000.0;
	  maxtime = psptr->get_max_time();
	  if (ptime < maxtime) {
	    psptr->pause_all_media();
	    if (psptr->play_all_media(FALSE, ptime, errmsg, sizeof(errmsg)) == 0) {
	      adjust_gui_for_play();
	    } else {
	      SDL_mutexV(command_mutex);
	      close_session();
	      snprintf(buffer, sizeof(buffer), "Error re-starting session: %s", 
		       errmsg);
	      ShowMessage("Play error", buffer);
	      break;
	    }
	  }
	  SDL_mutexV(command_mutex);
	}
	break;
      case SDLK_LEFT:
	if (psptr && psptr->session_is_seekable() && play_state == PLAYING) {
	  SDL_mutexP(command_mutex);
	  play_time = psptr->get_playing_time();
	  double ptime;
	  if (play_time >= 10 * M_LLU) {
	    play_time -= 10 * M_LLU;
	    ptime = (double)play_time;
	    ptime /= 1000.0;
	    psptr->pause_all_media();
	    if (psptr->play_all_media(FALSE, ptime) == 0) {
	      adjust_gui_for_play();
	    } else {
	      SDL_mutexV(command_mutex);
	      close_session();
	      snprintf(buffer, sizeof(buffer), "Error starting session: %s", 
		       errmsg);
	      ShowMessage("Play error", buffer);
	      break;
	    }
	  }
	  SDL_mutexV(command_mutex);
	}
	break;
      case SDLK_PAGEUP:
	if (master_screen_size < 200) {
	  change_video_size (master_screen_size * 2);
	}
	break;
      case SDLK_PAGEDOWN:
	if (master_screen_size > 50) {
	  change_video_size (master_screen_size / 2);
	}
	break;
      case SDLK_0:
      case SDLK_1:
      case SDLK_2:
      case SDLK_3:
      case SDLK_4:
	if ((msg->mod & (KMOD_LCTRL | KMOD_RCTRL)) != 0) {
	  set_aspect_ratio(msg->sym - SDLK_0);
	}
        break;
      default:
	break;
      }
      break;
    }
  }
  return (TRUE);  // keep timer going
}

/*
 * Main routine - set up window
 */
int main (int argc, char **argv)
{
  gtk_init(&argc, &argv);
printf("%s\n", *argv);
  command_mutex = SDL_CreateMutex();
  
  config.read_config_file();
  initialize_plugins();

  if (config.get_config_value(CONFIG_RTP_BUFFER_TIME) != 2) {
    config.set_config_value(CONFIG_RTP_BUFFER_TIME_MSEC, 
			    config.get_config_value(CONFIG_RTP_BUFFER_TIME) * 1000);
    config.set_config_value(CONFIG_RTP_BUFFER_TIME,
			    config.get_config_default_value(CONFIG_RTP_BUFFER_TIME));
  }
  const char *read;
  playlist = g_list_append(playlist, (void *)"");
  read = config.get_config_string(CONFIG_PREV_FILE_0);
  if (read != NULL) {
    gchar *newone = g_strdup(read);
    playlist = g_list_append(playlist, newone);
  }
  read = config.get_config_string(CONFIG_PREV_FILE_1);
  if (read != NULL) {
    gchar *newone = g_strdup(read);
    playlist = g_list_append(playlist, newone);
  }
  read = config.get_config_string(CONFIG_PREV_FILE_2);
  if (read != NULL) {
    gchar *newone = g_strdup(read);
    playlist = g_list_append(playlist, newone);
  }
  read = config.get_config_string(CONFIG_PREV_FILE_3);
  if (read != NULL) {
    gchar *newone = g_strdup(read);
    playlist = g_list_append(playlist, newone);
  }
  
  last_file = g_strdup(config.get_config_string(CONFIG_PREV_DIRECTORY));
  master_looped = config.get_config_value(CONFIG_LOOPED);
  master_muted = config.get_config_value(CONFIG_MUTED);
  master_volume = config.get_config_value(CONFIG_VOLUME);
  rtsp_set_error_func(player_library_message);
  rtsp_set_loglevel(config.get_config_value(CONFIG_RTSP_DEBUG));
  rtp_set_error_msg_func(player_library_message);
  rtp_set_loglevel(config.get_config_value(CONFIG_RTP_DEBUG));
  sdp_set_error_func(player_library_message);
  sdp_set_loglevel(config.get_config_value(CONFIG_SDP_DEBUG));
  http_set_error_func(player_library_message);
  http_set_loglevel(config.get_config_value(CONFIG_HTTP_DEBUG));
  mpeg2t_set_error_func(player_library_message);
  mpeg2t_set_loglevel(config.get_config_value(CONFIG_MPEG2T_DEBUG));
  /*
   * Set up main window
   */
  main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_policy(GTK_WINDOW(main_window), FALSE, TRUE, FALSE);
  gtk_window_set_title(GTK_WINDOW(main_window), 
		       "cisco Open Source MPEG4 Player");
  gtk_widget_set_uposition(GTK_WIDGET(main_window), 10, 10);
  gtk_widget_set_usize(main_window, 450, 185);
  gtk_window_set_default_size(GTK_WINDOW(main_window), 450, 185);
  gtk_signal_connect(GTK_OBJECT(main_window),
		     "delete_event",
		     GTK_SIGNAL_FUNC(delete_event),
		     NULL);
  main_vbox = gtk_vbox_new(FALSE, 1);
  gtk_widget_show(main_vbox);
  // add stuff
  accel_group = gtk_accel_group_new();
#ifdef HAVE_GTK_2_0
  gtk_window_add_accel_group(GTK_WINDOW(main_window), accel_group);
#else
  gtk_accel_group_attach(accel_group, GTK_OBJECT(main_window));
#endif
  tooltips = gtk_tooltips_new();

  GtkWidget *menubar, *menu, *menuitem;
  
  menubar = gtk_menu_bar_new();
  gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
  gtk_widget_show(menubar);

  menu = CreateBarSubMenu(menubar, "File");
  menuitem = CreateMenuItem(menu,
			    accel_group,
			    tooltips,
			    "Open",
			    "^O",
			    "Open local media file",
			    GTK_SIGNAL_FUNC(on_browse_button_clicked),
			    NULL);

  close_menuitem = CreateMenuItem(menu,
			    accel_group,
			    tooltips,
			    "Close",
			    "^C",
			    "Close file/stream being viewed",
			    GTK_SIGNAL_FUNC(on_main_menu_close),
			    NULL);

  // NULL entry is a seperator
  menuitem = CreateMenuItem(menu, 
			    accel_group, 
			    tooltips, 
			    NULL, NULL, NULL, 
			    NULL, NULL);

  menuitem = CreateMenuItem(menu,
			    accel_group,
			    tooltips,
			    "Exit",
			    "^X",
			    "Exit program",
			    GTK_SIGNAL_FUNC(delete_event),
			    NULL);

  menu = CreateBarSubMenu(menubar, "Media");

  GtkWidget *videosub;
  videosub = CreateSubMenu(menu, "Video");
  GSList *videosizelist = NULL;