gui_main.cpp

jpeg and mpeg 编解码技术源代码

  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 == 0) {
    // mute the puppy
    set_speaker_button(xpm_speaker_muted);
    master_muted = 1;
    vol = 0;
  } else {
    set_speaker_button(xpm_speaker);
    master_muted = 0;
    vol  = master_volume;
  }
  config.set_config_value(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);
  gtk_range_slider_update(GTK_RANGE(volume_slider));
  gtk_range_clear_background(GTK_RANGE(volume_slider));
  //gtk_range_draw_background(GTK_RANGE(volume_slider));
   if (master_muted == 0 && 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_mpeg4isoonly (GtkWidget *window, gpointer data)
{
  GtkCheckMenuItem *checkmenu;

  checkmenu = GTK_CHECK_MENU_ITEM(window);

  config.set_config_value(CONFIG_USE_MPEG4_ISO_ONLY,
			  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_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_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 on_video_radio (GtkWidget *window, gpointer data)
{
  int newsize = GPOINTER_TO_INT(data);
  if (newsize != master_screen_size) {
    master_screen_size = newsize;
    if (psptr != NULL) {
      psptr->set_screen_size(newsize / 50);
    }
  }
}

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 void on_time_slider_pressed (GtkWidget *window, gpointer data)
{
  time_slider_pressed = 1;
}

static void on_time_slider_adjusted (GtkWidget *window, gpointer data)
{
  double maxtime, newtime;
  time_slider_pressed = 0;
  if (psptr == NULL) 
    return;
  maxtime = psptr->get_max_time();
  if (maxtime == 0.0)
    return;
  GtkAdjustment *val = gtk_range_get_adjustment(GTK_RANGE(time_slider));
  newtime = (maxtime * val->value) / 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) {
    gtk_range_set_adjustment(GTK_RANGE(time_slider), val);
    gtk_range_slider_update(GTK_RANGE(time_slider));
    gtk_range_clear_background(GTK_RANGE(time_slider));
  //gtk_range_draw_background(GTK_RANGE(vol));
  } else {
    close_session();
  }
}

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;
  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;
      }
      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);
    }
    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();
	  psptr->play_all_media(TRUE, 0.0);
	  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_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) {
	    adjust_gui_for_play();
	    SDL_mutexV(command_mutex);
	  } else {
	    SDL_mutexV(command_mutex);
	    close_session();
	  }
	}
	break;
      case SDLK_HOME:
	if (psptr && play_state == PLAYING) {
	  psptr->pause_all_media();
	  psptr->play_all_media(TRUE, 0.0);
	}
	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) == 0) {
	      adjust_gui_for_play();
	    } else {
	      SDL_mutexV(command_mutex);
	      close_session();
	      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();
	      break;
	    }
	  }
	  SDL_mutexV(command_mutex);
	}
	break;
      case SDLK_PAGEUP:
	if (master_screen_size < 200) {
	  master_screen_size *= 2;
	  psptr->set_screen_size(master_screen_size / 50);
	}
	break;
      case SDLK_PAGEDOWN:
	if (master_screen_size > 50) {
	  master_screen_size /= 2;
	  psptr->set_screen_size(master_screen_size / 50);
	}
	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 *)"");