/* GStreamer * * Copyright (C) 2014-2015 Sebastian Dröge * Copyright (C) 2015 Brijesh Singh * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include #include #include #include #include #include #if defined (GDK_WINDOWING_X11) #include #elif defined (GDK_WINDOWING_WIN32) #include #elif defined (GDK_WINDOWING_QUARTZ) #include #endif #include #include #define APP_NAME "gtk-play" typedef GtkApplication GtkPlayApp; typedef GtkApplicationClass GtkPlayAppClass; G_DEFINE_TYPE (GtkPlayApp, gtk_play_app, GTK_TYPE_APPLICATION); typedef struct { GtkApplicationWindow parent; GstPlayer *player; gchar *uri; GList *uris; GList *current_uri; guint inhibit_cookie; GtkWidget *play_pause_button; GtkWidget *prev_button, *next_button; GtkWidget *seekbar; GtkWidget *video_area; GtkWidget *image_area; GtkWidget *volume_button; GtkWidget *media_info_button; GtkWidget *repeat_button; GtkWidget *fullscreen_button; GtkWidget *toolbar; GdkCursor *default_cursor; gulong seekbar_value_changed_signal_id; GdkPixbuf *image_pixbuf; gboolean playing; gboolean loop; gboolean fullscreen; gboolean visual; gint toolbar_hide_timeout; } GtkPlay; typedef GtkApplicationWindowClass GtkPlayClass; G_DEFINE_TYPE (GtkPlay, gtk_play, GTK_TYPE_APPLICATION_WINDOW); enum { PROP_0, PROP_LOOP, PROP_FULLSCREEN, PROP_VISUAL, PROP_URIS, LAST_PROP }; static GParamSpec *gtk_play_properties[LAST_PROP] = { NULL, }; enum { COL_TEXT = 0, COL_NUM }; enum { VIDEO_INFO_START, VIDEO_INFO_RESOLUTION, VIDEO_INFO_FPS, VIDEO_INFO_PAR, VIDEO_INFO_CODEC, VIDEO_INFO_MAX_BITRATE, VIDEO_INFO_END, AUDIO_INFO_START, AUDIO_INFO_CHANNELS, AUDIO_INFO_RATE, AUDIO_INFO_LANGUAGE, AUDIO_INFO_CODEC, AUDIO_INFO_MAX_BITRATE, AUDIO_INFO_END, SUBTITLE_INFO_START, SUBTITLE_INFO_LANGUAGE, SUBTITLE_INFO_CODEC, SUBTITLE_INFO_END, }; static void display_cover_art (GtkPlay * play, GstPlayerMediaInfo * media_info); static void set_title (GtkPlay * play, const gchar * title) { if (title == NULL) { gtk_window_set_title (GTK_WINDOW (play), APP_NAME); } else { gtk_window_set_title (GTK_WINDOW (play), title); } } static void delete_event_cb (GtkWidget * widget, GdkEvent * event, GtkPlay * play) { gst_player_stop (play->player); } static void video_area_realize_cb (GtkWidget * widget, GtkPlay * play) { GdkWindow *window = gtk_widget_get_window (widget); guintptr window_handle; if (!gdk_window_ensure_native (window)) g_error ("Couldn't create native window needed for GstXOverlay!"); #if defined (GDK_WINDOWING_WIN32) window_handle = (guintptr) GDK_WINDOW_HWND (window); #elif defined (GDK_WINDOWING_QUARTZ) window_handle = gdk_quartz_window_get_nsview (window); #elif defined (GDK_WINDOWING_X11) window_handle = GDK_WINDOW_XID (window); #endif g_object_set (play->player, "window-handle", (gpointer) window_handle, NULL); } static void play_pause_clicked_cb (GtkButton * button, GtkPlay * play) { GtkWidget *image; if (play->playing) { gst_player_pause (play->player); image = gtk_image_new_from_icon_name ("media-playback-start", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (play->play_pause_button), image); play->playing = FALSE; if (play->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), play->inhibit_cookie); play->inhibit_cookie = 0; } else { if (play->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), play->inhibit_cookie); play->inhibit_cookie = gtk_application_inhibit (GTK_APPLICATION (g_application_get_default ()), GTK_WINDOW (play), GTK_APPLICATION_INHIBIT_IDLE, "Playing media"); gst_player_play (play->player); image = gtk_image_new_from_icon_name ("media-playback-pause", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (play->play_pause_button), image); play->playing = TRUE; } } static void play_current_uri (GtkPlay * play, GList * uri, const gchar * ext_suburi) { /* reset the button/widget state to default */ if (play->image_pixbuf) g_object_unref (play->image_pixbuf); play->image_pixbuf = NULL; gtk_widget_set_sensitive (play->media_info_button, FALSE); gtk_range_set_range (GTK_RANGE (play->seekbar), 0, 0); gtk_widget_set_sensitive (play->prev_button, g_list_previous (uri) != NULL); gtk_widget_set_sensitive (play->next_button, g_list_next (uri) != NULL); /* set uri or suburi */ if (ext_suburi) gst_player_set_subtitle_uri (play->player, ext_suburi); else gst_player_set_uri (play->player, uri->data); play->current_uri = uri; if (play->playing) { if (play->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), play->inhibit_cookie); play->inhibit_cookie = gtk_application_inhibit (GTK_APPLICATION (g_application_get_default ()), GTK_WINDOW (play), GTK_APPLICATION_INHIBIT_IDLE, "Playing media"); gst_player_play (play->player); } else { gst_player_pause (play->player); if (play->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), play->inhibit_cookie); play->inhibit_cookie = 0; } set_title (play, uri->data); } static void skip_prev_clicked_cb (GtkButton * button, GtkPlay * play) { GList *prev; prev = g_list_previous (play->current_uri); g_return_if_fail (prev != NULL); play_current_uri (play, prev, NULL); } static gboolean color_balance_channel_change_value_cb (GtkRange * range, GtkScrollType scroll, gdouble value, GtkPlay * play) { GstPlayerColorBalanceType type; type = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (range), "type")); value = CLAMP (value, 0.0, 1.0); gst_player_set_color_balance (play->player, type, value); return FALSE; } static gboolean color_balance_channel_button_press_cb (GtkWidget * widget, GdkEventButton * event, GtkPlay * play) { GstPlayerColorBalanceType type; if (event->type != GDK_2BUTTON_PRESS) return FALSE; type = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget), "type")); gtk_range_set_value (GTK_RANGE (widget), 0.5); gst_player_set_color_balance (play->player, type, 0.5); return FALSE; } static void color_balance_dialog (GtkPlay * play) { GtkWidget *dialog; GtkWidget *content; GtkWidget *box; GtkWidget *ctlbox; GtkWidget *label; GtkWidget *scale; gdouble value; guint i; dialog = gtk_dialog_new_with_buttons ("Color Balance", GTK_WINDOW (play), GTK_DIALOG_DESTROY_WITH_PARENT, "_Close", GTK_RESPONSE_CLOSE, NULL); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (play)); content = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_set_homogeneous (GTK_BOX (box), TRUE); gtk_box_pack_start (GTK_BOX (content), box, TRUE, TRUE, 5); for (i = GST_PLAYER_COLOR_BALANCE_BRIGHTNESS; i <= GST_PLAYER_COLOR_BALANCE_HUE; i++) { ctlbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); label = gtk_label_new (gst_player_color_balance_type_get_name (i)); scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, 0, 1, 0.5); gtk_widget_set_size_request (scale, 0, 200); gtk_box_pack_start (GTK_BOX (ctlbox), label, FALSE, TRUE, 2); gtk_box_pack_end (GTK_BOX (ctlbox), scale, TRUE, TRUE, 2); gtk_box_pack_end (GTK_BOX (box), ctlbox, TRUE, TRUE, 2); value = gst_player_get_color_balance (play->player, i); gtk_range_set_value (GTK_RANGE (scale), value); g_object_set_data (G_OBJECT (scale), "type", GUINT_TO_POINTER (i)); g_signal_connect (scale, "change-value", G_CALLBACK (color_balance_channel_change_value_cb), play); g_signal_connect (scale, "button-press-event", G_CALLBACK (color_balance_channel_button_press_cb), play); } gtk_widget_show_all (dialog); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } static void color_balance_clicked_cb (GtkWidget * unused, GtkPlay * play) { if (gst_player_has_color_balance (play->player)) { color_balance_dialog (play); return; } g_warning ("No color balance channels available."); return; } static GList * open_file_dialog (GtkPlay * play, gboolean multi) { int res; GList *uris = NULL; GtkWidget *chooser; GtkWidget *parent; if (play) { parent = GTK_WIDGET (play); } else { parent = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_application_add_window (GTK_APPLICATION (g_application_get_default ()), GTK_WINDOW (parent)); } chooser = gtk_file_chooser_dialog_new ("Select files to play", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, NULL); g_object_set (chooser, "local-only", FALSE, "select-multiple", multi, NULL); gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (parent)); res = gtk_dialog_run (GTK_DIALOG (chooser)); if (res == GTK_RESPONSE_ACCEPT) { GSList *l; l = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (chooser)); while (l) { uris = g_list_append (uris, l->data); l = g_slist_delete_link (l, l); } } gtk_widget_destroy (chooser); if (!play) gtk_widget_destroy (parent); return uris; } static void open_file_clicked_cb (GtkWidget * unused, GtkPlay * play) { GList *uris; uris = open_file_dialog (play, TRUE); if (uris) { /* free existing playlist */ g_list_free_full (play->uris, g_free); play->uris = uris; play_current_uri (play, g_list_first (play->uris), NULL); } } static void skip_next_clicked_cb (GtkButton * button, GtkPlay * play) { GList *next; next = g_list_next (play->current_uri); g_return_if_fail (next != NULL); play_current_uri (play, next, NULL); } static const gchar * audio_channels_string (gint num) { if (num == 1) return "mono"; else if (num == 2) return "stereo"; else if (num > 2) return "surround"; else return "unknown"; } static gchar * stream_info_get_string (GstPlayerStreamInfo * stream, gint type, gboolean label) { switch (type) { case AUDIO_INFO_RATE: { gchar *buffer; GstPlayerAudioInfo *audio = (GstPlayerAudioInfo *) stream; buffer = g_strdup_printf ("%s%d", label ? "Sample rate : " : "", gst_player_audio_info_get_sample_rate (audio)); return buffer; } case AUDIO_INFO_LANGUAGE: { gchar *buffer; GstPlayerAudioInfo *audio = (GstPlayerAudioInfo *) stream; if (!gst_player_audio_info_get_language (audio)) return NULL; buffer = g_strdup_printf ("%s%s", label ? "Language : " : "", gst_player_audio_info_get_language (audio)); return buffer; } case AUDIO_INFO_CHANNELS: { gchar *buffer; GstPlayerAudioInfo *audio = (GstPlayerAudioInfo *) stream; buffer = g_strdup_printf ("%s%s", label ? "Channels : " : "", audio_channels_string (gst_player_audio_info_get_channels (audio))); return buffer; } case SUBTITLE_INFO_CODEC: case VIDEO_INFO_CODEC: case AUDIO_INFO_CODEC: { gchar *buffer; buffer = g_strdup_printf ("%s%s", label ? "Codec : " : "", gst_player_stream_info_get_codec (stream)); return buffer; } case AUDIO_INFO_MAX_BITRATE: { gchar *buffer = NULL; GstPlayerAudioInfo *audio = (GstPlayerAudioInfo *) stream; gint bitrate = gst_player_audio_info_get_max_bitrate (audio); if (bitrate > 0) buffer = g_strdup_printf ("%s%d", label ? "Max bitrate : " : "", bitrate); return buffer; } case VIDEO_INFO_MAX_BITRATE: { gchar *buffer = NULL; GstPlayerVideoInfo *video = (GstPlayerVideoInfo *) stream; gint bitrate = gst_player_video_info_get_max_bitrate (video); if (bitrate > 0) buffer = g_strdup_printf ("%s%d", label ? "Max bitrate : " : "", bitrate); return buffer; } case VIDEO_INFO_PAR: { guint par_d, par_n; gchar *buffer; GstPlayerVideoInfo *video = (GstPlayerVideoInfo *) stream; gst_player_video_info_get_pixel_aspect_ratio (video, &par_n, &par_d); buffer = g_strdup_printf ("%s%u:%u", label ? "pixel-aspect-ratio : " : "", par_n, par_d); return buffer; } case VIDEO_INFO_FPS: { gint fps_d, fps_n; gchar *buffer; GstPlayerVideoInfo *video = (GstPlayerVideoInfo *) stream; gst_player_video_info_get_framerate (video, &fps_n, &fps_d); buffer = g_strdup_printf ("%s%.2f", label ? "Framerate : " : "", (gdouble) fps_n / fps_d); return buffer; } case VIDEO_INFO_RESOLUTION: { gchar *buffer; GstPlayerVideoInfo *video = (GstPlayerVideoInfo *) stream; buffer = g_strdup_printf ("%s%dx%d", label ? "Resolution : " : "", gst_player_video_info_get_width (video), gst_player_video_info_get_height (video)); return buffer; } case SUBTITLE_INFO_LANGUAGE: { gchar *buffer; GstPlayerSubtitleInfo *sub = (GstPlayerSubtitleInfo *) stream; buffer = g_strdup_printf ("%s%s", label ? "Language : " : "", gst_player_subtitle_info_get_language (sub)); return buffer; } default: { return NULL; } } } static gboolean is_current_stream (GtkPlay * play, GstPlayerStreamInfo * stream) { gboolean ret = FALSE; GstPlayerStreamInfo *s; GstPlayerVideoInfo *video = gst_player_get_current_video_track (play->player); GstPlayerAudioInfo *audio = gst_player_get_current_audio_track (play->player); GstPlayerSubtitleInfo *sub = gst_player_get_current_subtitle_track (play->player); if (GST_IS_PLAYER_VIDEO_INFO (stream)) s = (GstPlayerStreamInfo *) video; else if (GST_IS_PLAYER_AUDIO_INFO (stream)) s = (GstPlayerStreamInfo *) audio; else s = (GstPlayerStreamInfo *) sub; if (s) if (gst_player_stream_info_get_index (stream) == gst_player_stream_info_get_index (s)) ret = TRUE; if (audio) g_object_unref (audio); if (video) g_object_unref (video); if (sub) g_object_unref (sub); return ret; } static GtkTreeModel * create_and_fill_model (GtkPlay * play, GstPlayerMediaInfo * info) { GList *l; guint count; GtkTreeStore *tree; GtkTreeIter child, parent; count = 0; tree = gtk_tree_store_new (COL_NUM, G_TYPE_STRING); for (l = gst_player_media_info_get_stream_list (info); l != NULL; l = l->next) { gchar *buffer; gint i, start, end; GstPlayerStreamInfo *stream = (GstPlayerStreamInfo *) l->data; /* define the field range based on stream type */ if (GST_IS_PLAYER_VIDEO_INFO (stream)) { start = VIDEO_INFO_START + 1; end = VIDEO_INFO_END; } else if (GST_IS_PLAYER_AUDIO_INFO (stream)) { start = AUDIO_INFO_START + 1; end = AUDIO_INFO_END; } else { start = SUBTITLE_INFO_START + 1; end = SUBTITLE_INFO_END; } buffer = g_strdup_printf ("Stream %u %s", count++, is_current_stream (play, stream) ? "(current)" : ""); gtk_tree_store_append (tree, &parent, NULL); gtk_tree_store_set (tree, &parent, COL_TEXT, buffer, -1); g_free (buffer); buffer = g_strdup_printf ("Type : %s", gst_player_stream_info_get_stream_type (stream)); gtk_tree_store_append (tree, &child, &parent); gtk_tree_store_set (tree, &child, COL_TEXT, buffer, -1); g_free (buffer); for (i = start; i < end; i++) { buffer = stream_info_get_string (stream, i, TRUE); if (buffer) { gtk_tree_store_append (tree, &child, &parent); gtk_tree_store_set (tree, &child, COL_TEXT, buffer, -1); g_free (buffer); } } } return GTK_TREE_MODEL (tree); } static GtkWidget * create_view_and_model (GtkPlay * play, GstPlayerMediaInfo * info) { GtkWidget *view; GtkTreeModel *model; GtkTreeViewColumn *col; GtkCellRenderer *renderer; view = gtk_tree_view_new (); col = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (view), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", COL_TEXT); model = create_and_fill_model (play, info); gtk_tree_view_set_model (GTK_TREE_VIEW (view), model); g_object_unref (model); return view; } static void delete_media_info_window (GtkWidget * button, GtkWindow * window) { gtk_window_close (window); } static void create_media_info_window (GtkPlay * play, GstPlayerMediaInfo * info) { GtkWidget *sw; GtkWidget *vbox; GtkWidget *label; GtkWidget *view; GtkWidget *hbox; GtkWidget *uri; GtkWidget *loc; GtkTextIter iter; GtkWidget *window; GtkTextBuffer *buffer; GtkWidget *hbox_close; GtkWidget *button_close; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Media information"); gtk_window_set_default_size (GTK_WINDOW (window), 550, 450); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER (window), 10); gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (play)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "Information about all the streams contains in your media. \n" "Current selected streams are marked as (current)."); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 2); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); view = create_view_and_model (play, info); gtk_container_add (GTK_CONTAINER (sw), view); g_signal_connect (view, "realize", G_CALLBACK (gtk_tree_view_expand_all), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2); loc = gtk_label_new ("Location : "); gtk_box_pack_start (GTK_BOX (hbox), loc, FALSE, FALSE, 2); buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_get_start_iter (buffer, &iter); gtk_text_buffer_insert (buffer, &iter, gst_player_media_info_get_uri (info), -1); uri = gtk_text_view_new_with_buffer (buffer); gtk_box_pack_start (GTK_BOX (hbox), uri, FALSE, FALSE, 2); gtk_text_view_set_editable (GTK_TEXT_VIEW (uri), FALSE); g_object_unref (buffer); hbox_close = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox_close, FALSE, FALSE, 2); button_close = gtk_button_new_with_label (" Close "); g_signal_connect (button_close, "clicked", G_CALLBACK (delete_media_info_window), window); gtk_box_pack_end (GTK_BOX (hbox_close), button_close, FALSE, FALSE, 3); gtk_widget_show_all (window); } static void media_info_clicked_cb (GtkButton * button, GtkPlay * play) { GstPlayerMediaInfo *info; info = gst_player_get_media_info (play->player); if (!info) return; create_media_info_window (play, info); g_object_unref (info); } static gboolean toolbar_hide_func (GtkPlay * play) { GdkCursor *cursor; /* TODO: add some animation while hiding the toolbar. */ gtk_widget_hide (play->toolbar); /* hide the mouse pointer */ cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (play)), GDK_BLANK_CURSOR); gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (play->video_area)), cursor); g_object_unref (cursor); play->toolbar_hide_timeout = 0; return FALSE; } static void fullscreen_toggle_cb (GtkToggleButton * widget, GtkPlay * play) { GtkWidget *image; if (gtk_toggle_button_get_active (widget)) { image = gtk_image_new_from_icon_name ("view-restore", GTK_ICON_SIZE_BUTTON); gtk_window_fullscreen (GTK_WINDOW (play)); gtk_button_set_image (GTK_BUTTON (play->fullscreen_button), image); /* start timer to hide toolbar */ if (play->toolbar_hide_timeout) g_source_remove (play->toolbar_hide_timeout); play->toolbar_hide_timeout = g_timeout_add_seconds (5, (GSourceFunc) toolbar_hide_func, play); } else { /* if toolbar hide timer is running then kill it */ if (play->toolbar_hide_timeout) { g_source_remove (play->toolbar_hide_timeout); play->toolbar_hide_timeout = 0; } image = gtk_image_new_from_icon_name ("view-fullscreen", GTK_ICON_SIZE_BUTTON); gtk_window_unfullscreen (GTK_WINDOW (play)); gtk_button_set_image (GTK_BUTTON (play->fullscreen_button), image); } } static void seekbar_value_changed_cb (GtkRange * range, GtkPlay * play) { gdouble value = gtk_range_get_value (GTK_RANGE (play->seekbar)); gst_player_seek (play->player, gst_util_uint64_scale (value, GST_SECOND, 1)); } void volume_changed_cb (GtkScaleButton * button, gdouble value, GtkPlay * play) { gst_player_set_volume (play->player, value); } static gint _get_current_track_index (GtkPlay * play, void *(*func) (GstPlayer * player)) { void *obj; gint index = -1; obj = func (play->player); if (obj) { index = gst_player_stream_info_get_index ((GstPlayerStreamInfo *) obj); g_object_unref (obj); } return index; } static gint get_current_track_index (GtkPlay * play, GType type) { if (type == GST_TYPE_PLAYER_VIDEO_INFO) return _get_current_track_index (play, (void *) gst_player_get_current_video_track); else if (type == GST_TYPE_PLAYER_AUDIO_INFO) return _get_current_track_index (play, (void *) gst_player_get_current_audio_track); else return _get_current_track_index (play, (void *) gst_player_get_current_subtitle_track); } static gchar * get_menu_label (GstPlayerStreamInfo * stream, GType type) { if (type == GST_TYPE_PLAYER_AUDIO_INFO) { gchar *label = NULL; gchar *lang, *codec, *channels; /* label format: [language] */ lang = stream_info_get_string (stream, AUDIO_INFO_LANGUAGE, FALSE); codec = stream_info_get_string (stream, AUDIO_INFO_CODEC, FALSE); channels = stream_info_get_string (stream, AUDIO_INFO_CHANNELS, FALSE); if (lang) { label = g_strdup_printf ("%s %s [%s]", codec ? codec : "", channels ? channels : "", lang); g_free (lang); } else label = g_strdup_printf ("%s %s", codec ? codec : "", channels ? channels : ""); g_free (codec); g_free (channels); return label; } else if (type == GST_TYPE_PLAYER_VIDEO_INFO) { /* label format: */ return stream_info_get_string (stream, VIDEO_INFO_CODEC, FALSE); } else { /* label format: */ return stream_info_get_string (stream, SUBTITLE_INFO_LANGUAGE, FALSE); } return NULL; } static void new_subtitle_clicked_cb (GtkWidget * unused, GtkPlay * play) { GList *uri; uri = open_file_dialog (play, FALSE); if (uri) { play_current_uri (play, play->current_uri, uri->data); g_list_free_full (uri, g_free); } } static void disable_track (GtkPlay * play, GType type) { if (type == GST_TYPE_PLAYER_VIDEO_INFO) { gst_player_set_video_track_enabled (play->player, FALSE); display_cover_art (play, NULL); /* display cover art */ } else if (type == GST_TYPE_PLAYER_AUDIO_INFO) gst_player_set_audio_track_enabled (play->player, FALSE); else gst_player_set_subtitle_track_enabled (play->player, FALSE); } static void change_track (GtkPlay * play, gint index, GType type) { if (type == GST_TYPE_PLAYER_VIDEO_INFO) { gst_player_set_video_track (play->player, index); gst_player_set_video_track_enabled (play->player, TRUE); /* if video area widget is not visible then make it visible */ if (!gtk_widget_is_visible (play->video_area)) { gtk_widget_hide (play->image_area); gtk_widget_show (play->video_area); } } else if (type == GST_TYPE_PLAYER_AUDIO_INFO) { gst_player_set_audio_track (play->player, index); gst_player_set_audio_track_enabled (play->player, TRUE); } else { gst_player_set_subtitle_track (play->player, index); gst_player_set_subtitle_track_enabled (play->player, TRUE); } } static void track_changed_cb (GtkWidget * widget, GtkPlay * play) { GType type; gint index; /* check if button is toggled */ if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) return; index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "index")); type = GPOINTER_TO_SIZE (g_object_get_data (G_OBJECT (widget), "type")); if (index == -1) disable_track (play, type); else change_track (play, index, type); } static void visualization_changed_cb (GtkWidget * widget, GtkPlay * play) { gchar *name; if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) { /* video_area is window-id is shared with playbin hence * video_area widget will be used by visualization elements to * render the visuals. If visualization is enabled then hide * image widget and show video widget and similiarly when visualization * is disabled then hide video widget and show imag widget. */ name = g_object_get_data (G_OBJECT (widget), "name"); if (g_strcmp0 (name, "disable") == 0) { gst_player_set_visualization_enabled (play->player, FALSE); gtk_widget_hide (play->video_area); gtk_widget_show (play->image_area); } else { const gchar *vis_name; gst_player_set_visualization (play->player, name); /* if visualization is not enabled then enable it */ if (!(vis_name = gst_player_get_current_visualization (play->player))) { gst_player_set_visualization_enabled (play->player, TRUE); } gtk_widget_hide (play->image_area); gtk_widget_show (play->video_area); } } } static GtkWidget * create_visualization_menu (GtkPlay * play) { GtkWidget *menu; GtkWidget *item; GtkWidget *sep; GSList *group = NULL; const gchar *cur_vis; GstPlayerVisualization **viss, **p; menu = gtk_menu_new (); cur_vis = gst_player_get_current_visualization (play->player); viss = gst_player_visualizations_get (); p = viss; while (*p) { gchar *label = g_strdup ((*p)->name); item = gtk_radio_menu_item_new_with_label (group, label); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); if (g_strcmp0 (label, cur_vis) == 0) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), True); g_object_set_data_full (G_OBJECT (item), "name", label, (GDestroyNotify) g_free); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect (G_OBJECT (item), "toggled", G_CALLBACK (visualization_changed_cb), play); p++; } gst_player_visualizations_free (viss); sep = gtk_separator_menu_item_new (); item = gtk_radio_menu_item_new_with_label (group, "Disable"); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); g_object_set_data (G_OBJECT (item), "name", "disable"); if (cur_vis == NULL) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), True); g_signal_connect (G_OBJECT (item), "toggled", G_CALLBACK (visualization_changed_cb), play); gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); return menu; } static GtkWidget * create_tracks_menu (GtkPlay * play, GstPlayerMediaInfo * media_info, GType type) { GtkWidget *menu; GtkWidget *item; GtkWidget *sep; GList *list, *l; gint current_index; GSList *group = NULL; if (!media_info) return NULL; current_index = get_current_track_index (play, type); if (type == GST_TYPE_PLAYER_VIDEO_INFO) list = gst_player_get_video_streams (media_info); else if (type == GST_TYPE_PLAYER_AUDIO_INFO) list = gst_player_get_audio_streams (media_info); else list = gst_player_get_subtitle_streams (media_info); menu = gtk_menu_new (); if (type == GST_TYPE_PLAYER_SUBTITLE_INFO) { GtkWidget *ext_subtitle; ext_subtitle = gtk_menu_item_new_with_label ("New File"); sep = gtk_separator_menu_item_new (); g_signal_connect (G_OBJECT (ext_subtitle), "activate", G_CALLBACK (new_subtitle_clicked_cb), play); gtk_menu_shell_append (GTK_MENU_SHELL (menu), ext_subtitle); gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep); } for (l = list; l != NULL; l = l->next) { gint index; gchar *buffer; GstPlayerStreamInfo *s = (GstPlayerStreamInfo *) l->data; buffer = get_menu_label (s, type); item = gtk_radio_menu_item_new_with_label (group, buffer); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); index = gst_player_stream_info_get_index (s); g_object_set_data (G_OBJECT (item), "index", GINT_TO_POINTER (index)); g_object_set_data (G_OBJECT (item), "type", GSIZE_TO_POINTER (type)); if (current_index == index) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), True); g_free (buffer); g_signal_connect (G_OBJECT (item), "toggled", G_CALLBACK (track_changed_cb), play); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } sep = gtk_separator_menu_item_new (); item = gtk_radio_menu_item_new_with_label (group, "Disable"); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); g_object_set_data (G_OBJECT (item), "index", GINT_TO_POINTER (-1)); g_object_set_data (G_OBJECT (item), "type", GSIZE_TO_POINTER (type)); if (current_index == -1) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), True); g_signal_connect (G_OBJECT (item), "toggled", G_CALLBACK (track_changed_cb), play); gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); return menu; } static void player_quit_clicked_cb (GtkButton * button, GtkPlay * play) { gtk_widget_destroy (GTK_WIDGET (play)); } static void gtk_player_popup_menu_create (GtkPlay * play, GdkEventButton * event) { GtkWidget *menu; GtkWidget *info; GtkWidget *audio; GtkWidget *video; GtkWidget *sub; GtkWidget *quit; GtkWidget *next; GtkWidget *prev; GtkWidget *open; GtkWidget *submenu; GtkWidget *vis; GtkWidget *cb; GstPlayerMediaInfo *media_info; menu = gtk_menu_new (); info = gtk_menu_item_new_with_label ("Media Information"); audio = gtk_menu_item_new_with_label ("Audio"); video = gtk_menu_item_new_with_label ("Video"); sub = gtk_menu_item_new_with_label ("Subtitle"); open = gtk_menu_item_new_with_label ("Open"); next = gtk_menu_item_new_with_label ("Next"); prev = gtk_menu_item_new_with_label ("Prev"); quit = gtk_menu_item_new_with_label ("Quit"); vis = gtk_menu_item_new_with_label ("Visualization"); cb = gtk_menu_item_new_with_label ("Color Balance"); media_info = gst_player_get_media_info (play->player); if (media_info && !gst_player_get_video_streams (media_info)) gtk_widget_set_sensitive (video, FALSE); else { submenu = create_tracks_menu (play, media_info, GST_TYPE_PLAYER_VIDEO_INFO); if (submenu) gtk_menu_item_set_submenu (GTK_MENU_ITEM (video), submenu); else gtk_widget_set_sensitive (video, FALSE); } if (media_info && !gst_player_get_audio_streams (media_info)) gtk_widget_set_sensitive (audio, FALSE); else { submenu = create_tracks_menu (play, media_info, GST_TYPE_PLAYER_AUDIO_INFO); if (submenu) gtk_menu_item_set_submenu (GTK_MENU_ITEM (audio), submenu); else gtk_widget_set_sensitive (audio, FALSE); } /* enable visualization menu for audio stream */ if (media_info && gst_player_get_audio_streams (media_info) && !gst_player_get_video_streams (media_info)) { submenu = create_visualization_menu (play); gtk_menu_item_set_submenu (GTK_MENU_ITEM (vis), submenu); } else { gtk_widget_set_sensitive (vis, FALSE); } if (media_info && gst_player_get_video_streams (media_info)) { submenu = create_tracks_menu (play, media_info, GST_TYPE_PLAYER_SUBTITLE_INFO); gtk_menu_item_set_submenu (GTK_MENU_ITEM (sub), submenu); } else { gtk_widget_set_sensitive (sub, FALSE); } gtk_widget_set_sensitive (next, g_list_next (play->current_uri) ? TRUE : FALSE); gtk_widget_set_sensitive (prev, g_list_previous (play->current_uri) ? TRUE : FALSE); gtk_widget_set_sensitive (info, media_info ? TRUE : FALSE); gtk_widget_set_sensitive (cb, gst_player_has_color_balance (play->player) ? TRUE : FALSE); g_signal_connect (G_OBJECT (open), "activate", G_CALLBACK (open_file_clicked_cb), play); g_signal_connect (G_OBJECT (cb), "activate", G_CALLBACK (color_balance_clicked_cb), play); g_signal_connect (G_OBJECT (next), "activate", G_CALLBACK (skip_next_clicked_cb), play); g_signal_connect (G_OBJECT (prev), "activate", G_CALLBACK (skip_prev_clicked_cb), play); g_signal_connect (G_OBJECT (info), "activate", G_CALLBACK (media_info_clicked_cb), play); g_signal_connect (G_OBJECT (quit), "activate", G_CALLBACK (player_quit_clicked_cb), play); gtk_menu_shell_append (GTK_MENU_SHELL (menu), open); gtk_menu_shell_append (GTK_MENU_SHELL (menu), next); gtk_menu_shell_append (GTK_MENU_SHELL (menu), prev); gtk_menu_shell_append (GTK_MENU_SHELL (menu), video); gtk_menu_shell_append (GTK_MENU_SHELL (menu), audio); gtk_menu_shell_append (GTK_MENU_SHELL (menu), vis); gtk_menu_shell_append (GTK_MENU_SHELL (menu), sub); gtk_menu_shell_append (GTK_MENU_SHELL (menu), info); gtk_menu_shell_append (GTK_MENU_SHELL (menu), cb); gtk_menu_shell_append (GTK_MENU_SHELL (menu), quit); gtk_widget_show_all (menu); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time ((GdkEvent *) event)); if (media_info) g_object_unref (media_info); } static void mouse_button_pressed_cb (GtkWidget * unused, GdkEventButton * event, GtkPlay * play) { if (event->type == GDK_2BUTTON_PRESS) { /* toggle fullscreen on double button click */ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (play->fullscreen_button))) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (play->fullscreen_button), FALSE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (play->fullscreen_button), TRUE); } else if ((event->type == GDK_BUTTON_PRESS) && (event->button == 3)) { /* popup menu on right button click */ gtk_player_popup_menu_create (play, event); } } static gboolean image_area_draw_cb (GtkWidget * widget, cairo_t * cr, GtkPlay * play) { if (play->image_pixbuf) { gint width, height; gint pix_width, pix_height; gint x = 0, y = 0; gdouble scalex = 0.0, scaley = 0.0; width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); pix_width = gdk_pixbuf_get_width (play->image_pixbuf); pix_height = gdk_pixbuf_get_height (play->image_pixbuf); /* if image is bigger than widget then scale down otherwise center it. */ if (width <= pix_width) scalex = (gdouble) width / (gdouble) pix_width; else x = (width - pix_width) / 2; if (height <= pix_height) scaley = (gdouble) height / (gdouble) pix_height; else y = (height - pix_height) / 2; /* fill background with black */ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); cairo_rectangle (cr, 0, 0, width, height); cairo_fill (cr); if (scalex > 0.0 && scaley > 0.0) cairo_scale (cr, scalex, scaley); gdk_cairo_set_source_pixbuf (cr, play->image_pixbuf, x, y); cairo_paint (cr); } else { /* fill background with black */ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); cairo_paint (cr); } return FALSE; } static gboolean gtk_show_toolbar_cb (GtkWidget * widget, GdkEvent * event, GtkPlay * play) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (play->fullscreen_button))) { /* if timer is running then kill it */ if (play->toolbar_hide_timeout) { g_source_remove (play->toolbar_hide_timeout); play->toolbar_hide_timeout = 0; } /* show mouse pointer */ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (play->video_area)), play->default_cursor); gtk_widget_show (play->toolbar); play->toolbar_hide_timeout = g_timeout_add_seconds (5, (GSourceFunc) toolbar_hide_func, play); } return TRUE; } static void create_ui (GtkPlay * play) { GtkWidget *image; GtkWidget *controls, *main_hbox, *main_vbox; GstElement *playbin, *video_sink, *gl_sink; gtk_window_set_default_size (GTK_WINDOW (play), 640, 480); g_signal_connect (G_OBJECT (play), "delete-event", G_CALLBACK (delete_event_cb), play); set_title (play, APP_NAME); gtk_application_add_window (GTK_APPLICATION (g_application_get_default ()), GTK_WINDOW (play)); gl_sink = gst_element_factory_make ("gtkglsink", NULL); if (gl_sink) { g_object_get (gl_sink, "widget", &play->video_area, NULL); video_sink = gst_element_factory_make ("glsinkbin", NULL); g_object_set (video_sink, "sink", gl_sink, NULL); playbin = gst_player_get_pipeline (play->player); g_object_set (playbin, "video-sink", video_sink, NULL); gst_object_unref (playbin); } else { play->video_area = gtk_drawing_area_new (); g_signal_connect (play->video_area, "realize", G_CALLBACK (video_area_realize_cb), play); } g_signal_connect (play->video_area, "button-press-event", G_CALLBACK (mouse_button_pressed_cb), play); g_signal_connect (play->video_area, "motion-notify-event", G_CALLBACK (gtk_show_toolbar_cb), play); g_signal_connect (play->video_area, "scroll-event", G_CALLBACK (gtk_show_toolbar_cb), play); gtk_widget_set_events (play->video_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_ENTER_NOTIFY_MASK); play->image_area = gtk_drawing_area_new (); g_signal_connect (play->image_area, "button-press-event", G_CALLBACK (mouse_button_pressed_cb), play); g_signal_connect (play->image_area, "draw", G_CALLBACK (image_area_draw_cb), play); g_signal_connect (play->image_area, "motion-notify-event", G_CALLBACK (gtk_show_toolbar_cb), play); g_signal_connect (play->image_area, "scroll-event", G_CALLBACK (gtk_show_toolbar_cb), play); gtk_widget_set_events (play->image_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_ENTER_NOTIFY_MASK); /* Unified play/pause button */ play->play_pause_button = gtk_button_new_from_icon_name ("media-playback-pause", GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT (play->play_pause_button), "clicked", G_CALLBACK (play_pause_clicked_cb), play); play->seekbar = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1); gtk_scale_set_draw_value (GTK_SCALE (play->seekbar), 0); gtk_range_set_range (GTK_RANGE (play->seekbar), 0, 0); play->seekbar_value_changed_signal_id = g_signal_connect (G_OBJECT (play->seekbar), "value-changed", G_CALLBACK (seekbar_value_changed_cb), play); /* Skip backward button */ play->prev_button = gtk_button_new_from_icon_name ("media-skip-backward", GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT (play->prev_button), "clicked", G_CALLBACK (skip_prev_clicked_cb), play); gtk_widget_set_sensitive (play->prev_button, FALSE); /* Skip forward button */ play->next_button = gtk_button_new_from_icon_name ("media-skip-forward", GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT (play->next_button), "clicked", G_CALLBACK (skip_next_clicked_cb), play); gtk_widget_set_sensitive (play->next_button, FALSE); /* Playlist repeat button */ play->repeat_button = gtk_toggle_button_new (); image = gtk_image_new_from_icon_name ("media-playlist-repeat", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (play->repeat_button), image); if (play->loop) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (play->repeat_button), TRUE); /* Volume control button */ play->volume_button = gtk_volume_button_new (); gtk_scale_button_set_value (GTK_SCALE_BUTTON (play->volume_button), gst_player_get_volume (play->player)); g_signal_connect (G_OBJECT (play->volume_button), "value-changed", G_CALLBACK (volume_changed_cb), play); /* media information button */ play->media_info_button = gtk_button_new_from_icon_name ("dialog-information", GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT (play->media_info_button), "clicked", G_CALLBACK (media_info_clicked_cb), play); gtk_widget_set_sensitive (play->media_info_button, FALSE); /* Full screen button */ play->fullscreen_button = gtk_toggle_button_new (); image = gtk_image_new_from_icon_name ("view-fullscreen", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (play->fullscreen_button), image); g_signal_connect (G_OBJECT (play->fullscreen_button), "toggled", G_CALLBACK (fullscreen_toggle_cb), play); if (play->fullscreen) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (play->fullscreen_button), TRUE); play->toolbar = controls = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (controls), play->prev_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), play->play_pause_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), play->next_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), play->repeat_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), play->seekbar, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (controls), play->volume_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), play->media_info_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), play->fullscreen_button, FALSE, FALSE, 2); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (main_hbox), play->video_area, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (main_hbox), play->image_area, TRUE, TRUE, 0); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (main_vbox), controls, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (play), main_vbox); if (!gl_sink) gtk_widget_realize (play->video_area); gtk_widget_hide (play->video_area); } static void duration_changed_cb (GstPlayer * unused, GstClockTime duration, GtkPlay * play) { gtk_range_set_range (GTK_RANGE (play->seekbar), 0, (gdouble) duration / GST_SECOND); } static void position_updated_cb (GstPlayer * unused, GstClockTime position, GtkPlay * play) { g_signal_handler_block (play->seekbar, play->seekbar_value_changed_signal_id); gtk_range_set_value (GTK_RANGE (play->seekbar), (gdouble) position / GST_SECOND); g_signal_handler_unblock (play->seekbar, play->seekbar_value_changed_signal_id); } static void eos_cb (GstPlayer * unused, GtkPlay * play) { if (play->playing) { GList *next = NULL; next = g_list_next (play->current_uri); if (!next && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (play->repeat_button))) next = g_list_first (play->uris); if (next) { play_current_uri (play, next, NULL); } else { GtkWidget *image; gst_player_pause (play->player); image = gtk_image_new_from_icon_name ("media-playback-start", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (play->play_pause_button), image); play->playing = FALSE; if (play->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), play->inhibit_cookie); play->inhibit_cookie = 0; } } } static gboolean _has_active_stream (GtkPlay * play, void *(*func) (GstPlayer * player)) { void *obj; obj = func (play->player); if (obj) { g_object_unref (obj); return TRUE; } return FALSE; } static GdkPixbuf * gst_sample_to_pixbuf (GtkPlay * play, GstSample * sample) { GdkPixbufLoader *loader; GdkPixbuf *pixbuf = NULL; GError *err = NULL; GstMapInfo info; GstBuffer *buffer; const GstStructure *caps_struct; GstTagImageType type = GST_TAG_IMAGE_TYPE_UNDEFINED; buffer = gst_sample_get_buffer (sample); caps_struct = gst_sample_get_info (sample); /* if sample is retrieved from preview-image tag then caps struct * will not be defined. */ if (caps_struct) gst_structure_get_enum (caps_struct, "image-type", GST_TYPE_TAG_IMAGE_TYPE, &type); /* FIXME: Should we check more type ?? */ if ((type != GST_TAG_IMAGE_TYPE_FRONT_COVER) && (type != GST_TAG_IMAGE_TYPE_UNDEFINED) && (type != GST_TAG_IMAGE_TYPE_NONE)) { g_print ("unsupport type ... %d \n", type); return NULL; } if (!gst_buffer_map (buffer, &info, GST_MAP_READ)) { g_print ("failed to map gst buffer \n"); return NULL; } loader = gdk_pixbuf_loader_new (); if (gdk_pixbuf_loader_write (loader, info.data, info.size, &err) && gdk_pixbuf_loader_close (loader, &err)) { pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf) { g_object_ref (pixbuf); } else { g_print ("failed to convert gst buffer to pixbuf %s \n", err->message); g_error_free (err); } } g_object_unref (loader); gst_buffer_unmap (buffer, &info); return pixbuf; } static void display_cover_art (GtkPlay * play, GstPlayerMediaInfo * media_info) { GstSample *sample; GstPlayerMediaInfo *temp_media_info = NULL; /* hide the video widget and show image widget */ gtk_widget_hide (play->video_area); gtk_widget_show (play->image_area); /* if media information is not passed then get it from player */ if (!media_info) temp_media_info = media_info = gst_player_get_media_info (play->player); sample = gst_player_media_info_get_image_sample (media_info); if (!sample) goto cleanup; if (play->image_pixbuf) g_object_unref (play->image_pixbuf); play->image_pixbuf = gst_sample_to_pixbuf (play, sample); cleanup: gtk_widget_queue_draw (play->image_area); /* send expose event to widget */ if (temp_media_info) g_object_unref (temp_media_info); } static gboolean has_active_stream (GtkPlay * play, GType type) { if (type == GST_TYPE_PLAYER_VIDEO_INFO) return _has_active_stream (play, (void *) gst_player_get_current_video_track); else if (type == GST_TYPE_PLAYER_AUDIO_INFO) return _has_active_stream (play, (void *) gst_player_get_current_audio_track); else return _has_active_stream (play, (void *) gst_player_get_current_subtitle_track); } static void media_info_updated_cb (GstPlayer * player, GstPlayerMediaInfo * media_info, GtkPlay * play) { if (!gtk_widget_is_sensitive (play->media_info_button)) { const gchar *title; const gchar *vis; title = gst_player_media_info_get_title (media_info); if (title) set_title (play, title); gtk_widget_set_sensitive (play->media_info_button, TRUE); /* if we have active video stream then hide image widget * and show video widget otherwise show the cover art. */ if (has_active_stream (play, GST_TYPE_PLAYER_VIDEO_INFO)) { gtk_widget_hide (play->image_area); gtk_widget_show (play->video_area); } else { display_cover_art (play, media_info); } /* if we have audio only stream and visualization is enabled * then show video widget. */ vis = gst_player_get_current_visualization (play->player); if (!has_active_stream (play, GST_TYPE_PLAYER_VIDEO_INFO) && has_active_stream (play, GST_TYPE_PLAYER_AUDIO_INFO) && vis) { gtk_widget_show (play->video_area); gtk_widget_hide (play->image_area); } } } static void player_volume_changed_cb (GstPlayer * player, GtkPlay * play) { gdouble new_val, cur_val; cur_val = gtk_scale_button_get_value (GTK_SCALE_BUTTON (play->volume_button)); new_val = gst_player_get_volume (play->player); if (fabs (cur_val - new_val) > 0.001) { g_signal_handlers_block_by_func (play->volume_button, volume_changed_cb, play); gtk_scale_button_set_value (GTK_SCALE_BUTTON (play->volume_button), new_val); g_signal_handlers_unblock_by_func (play->volume_button, volume_changed_cb, play); } } static void gtk_play_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GtkPlay *self = (GtkPlay *) object; switch (prop_id) { case PROP_LOOP: self->loop = g_value_get_boolean (value); break; case PROP_FULLSCREEN: self->fullscreen = g_value_get_boolean (value); break; case PROP_VISUAL: self->visual = g_value_get_boolean (value); break; case PROP_URIS: self->uris = g_value_get_pointer (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void show_cb (GtkWidget * widget, gpointer user_data) { GtkPlay *self = (GtkPlay *) widget; self->default_cursor = gdk_window_get_cursor (gtk_widget_get_window (GTK_WIDGET (self))); play_current_uri (self, g_list_first (self->uris), NULL); } static GObject * gtk_play_constructor (GType type, guint n_construct_params, GObjectConstructParam * construct_params) { GtkPlay *self; gchar **p; self = (GtkPlay *) G_OBJECT_CLASS (gtk_play_parent_class)->constructor (type, n_construct_params, construct_params); self->player = gst_player_new (); self->playing = TRUE; if (self->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), self->inhibit_cookie); self->inhibit_cookie = gtk_application_inhibit (GTK_APPLICATION (g_application_get_default ()), GTK_WINDOW (self), GTK_APPLICATION_INHIBIT_IDLE, "Playing media"); g_object_set (self->player, "dispatch-to-main-context", TRUE, NULL); create_ui (self); /* if visualization is enabled then use the first element */ if (self->visual) { GstPlayerVisualization **viss; viss = gst_player_visualizations_get (); if (viss && *viss) { gst_player_set_visualization (self->player, (*viss)->name); gst_player_set_visualization_enabled (self->player, TRUE); } if (viss) gst_player_visualizations_free (viss); } g_signal_connect (self->player, "position-updated", G_CALLBACK (position_updated_cb), self); g_signal_connect (self->player, "duration-changed", G_CALLBACK (duration_changed_cb), self); g_signal_connect (self->player, "end-of-stream", G_CALLBACK (eos_cb), self); g_signal_connect (self->player, "media-info-updated", G_CALLBACK (media_info_updated_cb), self); g_signal_connect (self->player, "volume-changed", G_CALLBACK (player_volume_changed_cb), self); g_signal_connect (G_OBJECT (self), "show", G_CALLBACK (show_cb), NULL); return G_OBJECT (self); } static void gtk_play_dispose (GObject * object) { GtkPlay *self = (GtkPlay *) object; if (self->inhibit_cookie) gtk_application_uninhibit (GTK_APPLICATION (g_application_get_default ()), self->inhibit_cookie); self->inhibit_cookie = 0; if (self->uri) g_free (self->uri); self->uri = NULL; if (self->uris) g_list_free_full (self->uris, g_free); self->uris = NULL; if (self->player) { gst_player_stop (self->player); g_object_unref (self->player); } self->player = NULL; G_OBJECT_CLASS (gtk_play_parent_class)->dispose (object); } static void gtk_play_init (GtkPlay * self) { } static void gtk_play_class_init (GtkPlayClass * klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->constructor = gtk_play_constructor; object_class->dispose = gtk_play_dispose; object_class->set_property = gtk_play_set_property; gtk_play_properties[PROP_LOOP] = g_param_spec_boolean ("loop", "Loop", "Loop the playlist", FALSE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); gtk_play_properties[PROP_FULLSCREEN] = g_param_spec_boolean ("fullscreen", "Fullscreen", "Fullscreen mode", FALSE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); gtk_play_properties[PROP_VISUAL] = g_param_spec_boolean ("visual", "Visual", "Use Visualizations", FALSE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); gtk_play_properties[PROP_URIS] = g_param_spec_pointer ("uris", "URIs", "URIs to play", G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (object_class, LAST_PROP, gtk_play_properties); } static gint gtk_play_app_command_line (GApplication * application, GApplicationCommandLine * command_line) { GtkPlayApp *self = (GtkPlayApp *) application; GVariantDict *options; GtkPlay *play; GList *uris = NULL; gboolean loop = FALSE, visual = FALSE, fullscreen = FALSE; gchar **uris_array = NULL; options = g_application_command_line_get_options_dict (command_line); g_variant_dict_lookup (options, "loop", "b", &loop); g_variant_dict_lookup (options, "visual", "b", &visual); g_variant_dict_lookup (options, "fullscreen", "b", &fullscreen); g_variant_dict_lookup (options, G_OPTION_REMAINING, "^a&ay", &uris_array); if (uris_array) { gchar **p; p = uris_array; while (*p) { uris = g_list_prepend (uris, gst_uri_is_valid (*p) ? g_strdup (*p) : gst_filename_to_uri (*p, NULL)); p++; } uris = g_list_reverse (uris); } else { uris = open_file_dialog (NULL, TRUE); } if (!uris) return -1; play = g_object_new (gtk_play_get_type (), "loop", loop, "fullscreen", fullscreen, "visual", visual, "uris", uris, NULL); gtk_widget_show_all (GTK_WIDGET (play)); return G_APPLICATION_CLASS (gtk_play_app_parent_class)->command_line (application, command_line); } static void gtk_play_app_init (GtkPlayApp * self) { } static void gtk_play_app_class_init (GtkPlayAppClass * klass) { GApplicationClass *application_class = G_APPLICATION_CLASS (klass); application_class->command_line = gtk_play_app_command_line; } GtkPlayApp * gtk_play_app_new (void) { GtkPlayApp *self; GOptionEntry options[] = { {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, NULL, "Files to play"}, {"loop", 'l', 0, G_OPTION_ARG_NONE, NULL, "Repeat all"}, {"fullscreen", 'f', 0, G_OPTION_ARG_NONE, NULL, "Show the player in fullscreen"}, {"visual", 'v', 0, G_OPTION_ARG_NONE, NULL, "Show visualization when there is no video stream"}, {NULL} }; g_set_prgname (APP_NAME); g_set_application_name (APP_NAME); self = g_object_new (gtk_play_app_get_type (), "application-id", "org.freedesktop.gstreamer.GTKPlay", "flags", G_APPLICATION_HANDLES_COMMAND_LINE, "register-session", TRUE, NULL); g_application_set_default (G_APPLICATION (self)); g_application_add_main_option_entries (G_APPLICATION (self), options); g_application_add_option_group (G_APPLICATION (self), gst_init_get_option_group ()); return self; } int main (gint argc, gchar ** argv) { GtkPlayApp *app; gint status; #if defined (GDK_WINDOWING_X11) XInitThreads (); #endif app = gtk_play_app_new (); status = g_application_run (G_APPLICATION (app), argc, argv);; g_object_unref (app); return status; }