--- /dev/null
+/*
+ * This file is a part of MAFW
+ *
+ * Copyright (C) 2007, 2008, 2009 Nokia Corporation, all rights reserved.
+ *
+ * Contact: Visa Smolander <visa.smolander@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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
+ *
+ */
+#ifndef MAFW_GST_RENDERER_WORKER_H
+#define MAFW_GST_RENDERER_WORKER_H
+
+#include <glib.h>
+G_BEGIN_DECLS
+#include <X11/Xdefs.h>
+#include <glib-object.h>
+#include <gst/gst.h>
+
+#include "mafw-gst-renderer-seeker.h"
+
+#define MAFW_GST_RENDERER_WORKER_READY_TIMEOUT 3
+#define MAFW_GST_RENDERER_MAX_TMP_FILES 5
+
+enum {
+ WORKER_ERROR_PLAYBACK,
+ WORKER_ERROR_VIDEO_CODEC_NOT_FOUND,
+ WORKER_ERROR_AUDIO_CODEC_NOT_FOUND,
+ WORKER_ERROR_CODEC_NOT_FOUND,
+ WORKER_ERROR_UNSUPPORTED_TYPE,
+ WORKER_ERROR_UNABLE_TO_PERFORM,
+ WORKER_ERROR_CANNOT_SET_POSITION,
+ WORKER_ERROR_PLAYLIST_PARSING,
+ WORKER_ERROR_DRM_NO_LICENSE,
+ WORKER_ERROR_DRM_NOT_ALLOWED,
+ WORKER_ERROR_DRM_CLOCK_NOT_SET,
+ WORKER_ERROR_DRM_OTHER,
+ WORKER_ERROR_STREAM_DISCONNECTED,
+ WORKER_ERROR_INVALID_URI,
+ WORKER_ERROR_MEDIA_NOT_FOUND,
+ WORKER_ERROR_CORRUPTED_FILE,
+ WORKER_ERROR_TYPE_NOT_AVAILABLE,
+ WORKER_ERROR_UNKOWN,
+ WORKER_ERROR_POSSIBLY_PLAYLIST_TYPE = 1000,
+};
+
+enum {
+ WORKER_METADATA_KEY_TITLE = 1, /* 1st must be non-zero! */
+ WORKER_METADATA_KEY_ARTIST,
+ WORKER_METADATA_KEY_AUDIO_CODEC,
+ WORKER_METADATA_KEY_VIDEO_CODEC,
+ WORKER_METADATA_KEY_BITRATE,
+ WORKER_METADATA_KEY_ENCODING,
+ WORKER_METADATA_KEY_ALBUM,
+ WORKER_METADATA_KEY_GENRE,
+ WORKER_METADATA_KEY_TRACK,
+ WORKER_METADATA_KEY_ORGANIZATION,
+ WORKER_METADATA_KEY_RENDERER_ART_URI,
+ WORKER_METADATA_KEY_RES_X,
+ WORKER_METADATA_KEY_RES_Y,
+ WORKER_METADATA_KEY_VIDEO_FRAMERATE,
+ WORKER_METADATA_KEY_DURATION,
+ WORKER_METADATA_KEY_IS_SEEKABLE,
+ WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI,
+ WORKER_METADATA_KEY_URI
+};
+
+enum {
+ WORKER_PROPERTY_VOLUME,
+ WORKER_PROPERTY_MUTE,
+ WORKER_PROPERTY_AUTOPAINT,
+ WORKER_PROPERTY_COLORKEY,
+ WORKER_PROPERTY_XID,
+ WORKER_PROPERTY_RENDER_RECTANGLE,
+ WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE,
+ WORKER_PROPERTY_PLAYBACK_SPEED,
+ WORKER_PROPERTY_FORCE_ASPECT_RATIO
+};
+
+enum {
+ WORKER_OUTPUT_NULL,
+ WORKER_OUTPUT_BUILTIN_SPEAKERS,
+ WORKER_OUTPUT_FM_RADIO,
+ WORKER_OUTPUT_BLUETOOTH_AUDIO,
+ WORKER_OUTPUT_HEADPHONE_JACK,
+ WORKER_OUTPUT_BUILTIN_DISPLAY,
+ WORKER_OUTPUT_TVOUT
+};
+
+typedef struct _MafwGstRendererWorker MafwGstRendererWorker;
+
+typedef void (*MafwGstRendererWorkerNotifySeekCb)(MafwGstRendererWorker *worker, gpointer owner);
+typedef void (*MafwGstRendererWorkerNotifyPauseCb)(MafwGstRendererWorker *worker, gpointer owner);
+typedef void (*MafwGstRendererWorkerNotifyPlayCb)(MafwGstRendererWorker *worker, gpointer owner);
+typedef void (*MafwGstRendererWorkerNotifyReadyStateCb)(MafwGstRendererWorker *worker, gpointer owner);
+typedef void (*MafwGstRendererWorkerNotifyBufferStatusCb)(MafwGstRendererWorker *worker, gpointer owner, gdouble percent);
+typedef void (*MafwGstRendererWorkerNotifyEOSCb)(MafwGstRendererWorker *worker, gpointer owner);
+typedef void (*MafwGstRendererWorkerNotifyMetadataCb)(MafwGstRendererWorker *worker, gpointer owner, gint key, GType type, gpointer value);
+typedef void (*MafwGstRendererWorkerNotifyErrorCb)(MafwGstRendererWorker *worker, gpointer owner, const GError *error);
+typedef void (*MafwGstRendererWorkerNotifyPropertyCb)(MafwGstRendererWorker *worker, gpointer owner, gint id, GValue *value);
+typedef void (*MafwGstRendererWorkerBlankingControlCb)(MafwGstRendererWorker *worker, gpointer owner, gboolean prohibit);
+typedef void (*MafwGstRendererWorkerScreenshotCb)(MafwGstRendererWorker *worker, gpointer owner, GstBuffer *buffer, const char *filename, gboolean cancel);
+
+typedef enum {
+ SEEKABILITY_UNKNOWN = -1,
+ SEEKABILITY_NO_SEEKABLE,
+ SEEKABILITY_SEEKABLE,
+} SeekabilityType;
+
+typedef enum {
+ DURATION_UNQUERIED = -2,
+ DURATION_INDEFINITE = -1
+ /* other values are actual */
+} Duration;
+
+typedef struct {
+ gint x;
+ gint y;
+ gint width;
+ gint height;
+} render_rectangle;
+
+/* This struct contains all configurable settings
+ update this and the conf file synchronously, plz
+ */
+typedef struct {
+ /* pipeline */
+ gchar *asink;
+ gchar *vsink;
+ gint flags;
+ gint64 buffer_time;
+ gint64 latency_time;
+ gboolean autoload_subtitles;
+ gchar *subtitle_encoding;
+ gchar *subtitle_font;
+
+ /* timers */
+ guint milliseconds_to_pause_frame;
+ guint seconds_to_pause_to_ready;
+
+ /* dhmmixer */
+ gboolean use_dhmmixer;
+ struct {
+ guint state;
+ gint room;
+ gint color;
+ } mobile_surround_music;
+ struct {
+ guint state;
+ gint room;
+ gint color;
+ } mobile_surround_video;
+} configuration;
+
+/*
+ * media: Information about currently selected media.
+ * location: Current media location
+ * length_nanos: Length of the media, in nanoseconds
+ * has_visual_content: the clip contains some visual content (video)
+ * video_width: If media contains video, this tells the video width
+ * video_height: If media contains video, this tells the video height
+ * seekable: Tells whether the media can be seeked
+ * par_n: Video pixel aspect ratio numerator
+ * par_d: Video pixel aspect ratio denominator
+ * owner: Owner of the worker; usually a MafwGstRenderer (FIXME USUALLY?)
+ * pipeline: Playback pipeline
+ * bus: Message bus
+ * state: Current playback pipeline state
+ * is_stream: Is currently playing media a stream
+ * muted: Is the audio muted
+ * eos: Has playback reached EOS already
+ * is_error: Has there been an error situation
+ * buffering: Indicates the buffering state
+ * prerolling: Indicates the prerolling state (NULL -> PAUSED)
+ * report_statechanges: Report state change bus messages
+ * current_volume: Current audio volume [0.0 .. 1.0], see playbin:volume
+ * async_bus_id: ID handle for GstBus
+ * buffer_probe_id: ID of the video renderer buffer probe
+ * seek_position: Indicates the pos where to seek, in seconds
+ * vsink: Video sink element of the pipeline
+ * asink: Audio sink element of the pipeline
+ * tsink: Text sink element of the pipeline
+ * xid: XID for video playback
+ * current_frame_on_pause: whether to emit current frame when pausing
+ */
+struct _MafwGstRendererWorker {
+ struct {
+ gchar *location;
+ gint64 length_nanos;
+ gboolean has_visual_content;
+ gint video_width;
+ gint video_height;
+ gdouble fps;
+ SeekabilityType seekable;
+ gint par_n;
+ gint par_d;
+ } media;
+ gpointer owner;
+ GstElement *pipeline;
+
+ // Audio bin for Dolby Headphones Mobile plugin
+ GstElement *audiobin;
+
+ GstBus *bus;
+ /* GStreamer state we are considering right now */
+ GstState state;
+ gboolean is_stream;
+ gboolean muted;
+ /* we are handing eos or we did */
+ gboolean eos;
+ /* if we are handling (or handled) and error */
+ gboolean is_error;
+ /* pipeline is buffering */
+ gboolean buffering;
+ /* pipeline is prerolling */
+ gboolean prerolling;
+ /* stream is live and doesn't need prerolling */
+ gboolean is_live;
+ /* if we have to stay in paused though a do_play was
+ * requested. Usually used when pausing in transitioning */
+ gboolean stay_paused;
+ /* this variable should be FALSE while we are hiding state
+ * changed to the UI. This is that GStreamer can perform
+ * state_changes without us requiring it, for example, then
+ * seeking, buffering and so on and we have to hide those
+ * changes */
+ gboolean report_statechanges;
+ guint async_bus_id;
+ gint seek_position;
+ guint ready_timeout;
+ guint duration_seek_timeout;
+ guint duration_seek_timeout_loop_count;
+ /* TRUE when a transition to GST_STATE_READY has been
+ * requested or we are actually in GST_STATE_READY (requested
+ * by us) */
+ gboolean in_ready;
+ /* Flag indicating whether taking image from pause frame has succeed after pause. */
+ gboolean pause_frame_taken;
+ guint pause_frame_timeout;
+ GstBuffer *pause_frame_buffer;
+ GstElement *vsink;
+ GstElement *asink;
+ GstElement *tsink;
+
+ // Dolby Headphones Mobile mixer
+ GstElement *amixer;
+
+ XID xid;
+ render_rectangle x_overlay_rectangle;
+ gboolean autopaint;
+ gfloat playback_speed;
+ gboolean force_aspect_ratio;
+ gint colorkey;
+ GPtrArray *tag_list;
+ GHashTable *current_metadata;
+ gpointer context_nowplaying;
+
+ gboolean current_frame_on_pause;
+ gboolean taking_screenshot;
+ gchar *tmp_files_pool[MAFW_GST_RENDERER_MAX_TMP_FILES];
+ guint8 tmp_files_pool_index;
+
+ GSList *destinations;
+
+ GstElement *queue;
+
+ configuration *config;
+
+ MafwGstRendererSeeker *seeker;
+
+ /* Handlers for notifications */
+ MafwGstRendererWorkerNotifySeekCb notify_seek_handler;
+ MafwGstRendererWorkerNotifyPauseCb notify_pause_handler;
+ MafwGstRendererWorkerNotifyPlayCb notify_play_handler;
+ MafwGstRendererWorkerNotifyBufferStatusCb notify_buffer_status_handler;
+ MafwGstRendererWorkerNotifyEOSCb notify_eos_handler;
+ MafwGstRendererWorkerNotifyReadyStateCb notify_ready_state_handler;
+ MafwGstRendererWorkerNotifyMetadataCb notify_metadata_handler;
+ MafwGstRendererWorkerNotifyErrorCb notify_error_handler;
+ MafwGstRendererWorkerNotifyPropertyCb notify_property_handler;
+
+ MafwGstRendererWorkerBlankingControlCb blanking__control_handler;
+ MafwGstRendererWorkerScreenshotCb screenshot_handler;
+};
+
+
+MafwGstRendererWorker *mafw_gst_renderer_worker_new(gpointer owner);
+
+void mafw_gst_renderer_worker_exit(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_set_current_frame_on_pause(
+ MafwGstRendererWorker *worker,
+ gboolean current_frame_on_pause);
+
+void mafw_gst_renderer_worker_set_ready_timeout(MafwGstRendererWorker *worker,
+ guint seconds);
+
+gboolean mafw_gst_renderer_worker_get_current_frame_on_pause(
+ MafwGstRendererWorker *worker);
+
+configuration* mafw_gst_renderer_worker_create_default_configuration(MafwGstRendererWorker *worker);
+void mafw_gst_renderer_worker_set_configuration(MafwGstRendererWorker *worker,
+ configuration *config);
+
+void mafw_gst_renderer_worker_set_position(MafwGstRendererWorker *worker,
+ GstSeekType seek_type,
+ gint position,
+ GError **error);
+
+gint mafw_gst_renderer_worker_get_position(MafwGstRendererWorker *worker);
+
+gint64 mafw_gst_renderer_worker_get_last_known_duration(MafwGstRendererWorker *worker);
+gint64 mafw_gst_renderer_worker_get_duration(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_set_xid(MafwGstRendererWorker *worker, XID xid);
+
+XID mafw_gst_renderer_worker_get_xid(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_set_render_rectangle(MafwGstRendererWorker *worker, render_rectangle *rect);
+const render_rectangle* mafw_gst_renderer_worker_get_render_rectangle(MafwGstRendererWorker *worker);
+
+gboolean mafw_gst_renderer_worker_get_autopaint(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_set_autopaint(MafwGstRendererWorker *worker,
+ gboolean autopaint);
+
+gboolean mafw_gst_renderer_worker_set_playback_speed(MafwGstRendererWorker *worker, gfloat speed);
+
+gfloat mafw_gst_renderer_worker_get_playback_speed(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_set_force_aspect_ratio(MafwGstRendererWorker *worker, gboolean force);
+
+gboolean mafw_gst_renderer_worker_get_force_aspect_ratio(MafwGstRendererWorker *worker);
+
+gint mafw_gst_renderer_worker_get_colorkey(MafwGstRendererWorker *worker);
+
+gboolean mafw_gst_renderer_worker_get_seekable(MafwGstRendererWorker *worker);
+
+gboolean mafw_gst_renderer_worker_get_streaming(MafwGstRendererWorker *worker);
+
+const char* mafw_gst_renderer_worker_get_uri(MafwGstRendererWorker *worker);
+
+GHashTable *mafw_gst_renderer_worker_get_current_metadata(
+ MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_play(MafwGstRendererWorker *worker,
+ const gchar *uri);
+
+void mafw_gst_renderer_worker_stop(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_pause(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_resume(MafwGstRendererWorker *worker);
+
+void mafw_gst_renderer_worker_pause_at(MafwGstRendererWorker *worker, guint position);
+
+guint check_dolby_audioroute(MafwGstRendererWorker *worker, guint prop);
+
+void set_dolby_music_property(MafwGstRendererWorker *worker, guint prop);
+void set_dolby_music_sound_property(MafwGstRendererWorker *worker, gint prop, gboolean isRoomProperty);
+
+void set_dolby_video_property(MafwGstRendererWorker *worker, guint prop);
+void set_dolby_video_sound_property(MafwGstRendererWorker *worker, gint prop, gboolean isRoomProperty);
+
+void mafw_gst_renderer_worker_notify_media_destination(MafwGstRendererWorker *worker,
+ GSList *destinations);
+
+G_END_DECLS
+#endif
projects / mafwsubrenderer / blobdiff