git.maemo.org Git - mafwsubrenderer/blob - qmafw-gst-subtitles-renderer/inc/mafw-gst-renderer-worker.h

   1 /*
   2  * This file is a part of MAFW
   3  *
   4  * Copyright (C) 2007, 2008, 2009 Nokia Corporation, all rights reserved.
   5  *
   6  * Contact: Visa Smolander <visa.smolander@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24 #ifndef MAFW_GST_RENDERER_WORKER_H
  25 #define MAFW_GST_RENDERER_WORKER_H
  26
  27 #include <glib.h>
  28 G_BEGIN_DECLS
  29 #include <X11/Xdefs.h>
  30 #include <glib-object.h>
  31 #include <gst/gst.h>
  32
  33 #include "mafw-gst-renderer-seeker.h"
  34
  35 #define MAFW_GST_RENDERER_WORKER_READY_TIMEOUT 3
  36 #define MAFW_GST_RENDERER_MAX_TMP_FILES 5
  37
  38 enum {
  39     WORKER_ERROR_PLAYBACK,
  40     WORKER_ERROR_VIDEO_CODEC_NOT_FOUND,
  41     WORKER_ERROR_AUDIO_CODEC_NOT_FOUND,
  42     WORKER_ERROR_CODEC_NOT_FOUND,
  43     WORKER_ERROR_UNSUPPORTED_TYPE,
  44     WORKER_ERROR_UNABLE_TO_PERFORM,
  45     WORKER_ERROR_CANNOT_SET_POSITION,
  46     WORKER_ERROR_PLAYLIST_PARSING,
  47     WORKER_ERROR_DRM_NO_LICENSE,
  48     WORKER_ERROR_DRM_NOT_ALLOWED,
  49     WORKER_ERROR_DRM_CLOCK_NOT_SET,
  50     WORKER_ERROR_DRM_OTHER,
  51     WORKER_ERROR_STREAM_DISCONNECTED,
  52     WORKER_ERROR_INVALID_URI,
  53     WORKER_ERROR_MEDIA_NOT_FOUND,
  54     WORKER_ERROR_CORRUPTED_FILE,
  55     WORKER_ERROR_TYPE_NOT_AVAILABLE,
  56     WORKER_ERROR_UNKOWN,
  57     WORKER_ERROR_POSSIBLY_PLAYLIST_TYPE = 1000,
  58 };
  59
  60 enum {
  61     WORKER_METADATA_KEY_TITLE = 1, /* 1st must be non-zero! */
  62     WORKER_METADATA_KEY_ARTIST,
  63     WORKER_METADATA_KEY_AUDIO_CODEC,
  64     WORKER_METADATA_KEY_VIDEO_CODEC,
  65     WORKER_METADATA_KEY_BITRATE,
  66     WORKER_METADATA_KEY_ENCODING,
  67     WORKER_METADATA_KEY_ALBUM,
  68     WORKER_METADATA_KEY_GENRE,
  69     WORKER_METADATA_KEY_TRACK,
  70     WORKER_METADATA_KEY_ORGANIZATION,
  71     WORKER_METADATA_KEY_RENDERER_ART_URI,
  72     WORKER_METADATA_KEY_RES_X,
  73     WORKER_METADATA_KEY_RES_Y,
  74     WORKER_METADATA_KEY_VIDEO_FRAMERATE,
  75     WORKER_METADATA_KEY_DURATION,
  76     WORKER_METADATA_KEY_IS_SEEKABLE,
  77     WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI,
  78     WORKER_METADATA_KEY_URI
  79 };
  80
  81 enum {
  82     WORKER_PROPERTY_VOLUME,
  83     WORKER_PROPERTY_MUTE,
  84     WORKER_PROPERTY_AUTOPAINT,
  85     WORKER_PROPERTY_COLORKEY,
  86     WORKER_PROPERTY_XID,
  87     WORKER_PROPERTY_RENDER_RECTANGLE,
  88     WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE,
  89     WORKER_PROPERTY_PLAYBACK_SPEED,
  90     WORKER_PROPERTY_FORCE_ASPECT_RATIO
  91 };
  92
  93 enum {
  94     WORKER_OUTPUT_NULL,
  95     WORKER_OUTPUT_BUILTIN_SPEAKERS,
  96     WORKER_OUTPUT_FM_RADIO,
  97     WORKER_OUTPUT_BLUETOOTH_AUDIO,
  98     WORKER_OUTPUT_HEADPHONE_JACK,
  99     WORKER_OUTPUT_BUILTIN_DISPLAY,
 100     WORKER_OUTPUT_TVOUT
 101 };
 102
 103 typedef struct _MafwGstRendererWorker MafwGstRendererWorker;
 104
 105 typedef void (*MafwGstRendererWorkerNotifySeekCb)(MafwGstRendererWorker *worker, gpointer owner);
 106 typedef void (*MafwGstRendererWorkerNotifyPauseCb)(MafwGstRendererWorker *worker, gpointer owner);
 107 typedef void (*MafwGstRendererWorkerNotifyPlayCb)(MafwGstRendererWorker *worker, gpointer owner);
 108 typedef void (*MafwGstRendererWorkerNotifyReadyStateCb)(MafwGstRendererWorker *worker, gpointer owner);
 109 typedef void (*MafwGstRendererWorkerNotifyBufferStatusCb)(MafwGstRendererWorker *worker, gpointer owner, gdouble percent);
 110 typedef void (*MafwGstRendererWorkerNotifyEOSCb)(MafwGstRendererWorker *worker, gpointer owner);
 111 typedef void (*MafwGstRendererWorkerNotifyMetadataCb)(MafwGstRendererWorker *worker, gpointer owner, gint key, GType type, gpointer value);
 112 typedef void (*MafwGstRendererWorkerNotifyErrorCb)(MafwGstRendererWorker *worker, gpointer owner, const GError *error);
 113 typedef void (*MafwGstRendererWorkerNotifyPropertyCb)(MafwGstRendererWorker *worker, gpointer owner, gint id, GValue *value);
 114 typedef void (*MafwGstRendererWorkerBlankingControlCb)(MafwGstRendererWorker *worker, gpointer owner, gboolean prohibit);
 115 typedef void (*MafwGstRendererWorkerScreenshotCb)(MafwGstRendererWorker *worker, gpointer owner, GstBuffer *buffer, const char *filename, gboolean cancel);
 116
 117 typedef enum {
 118     SEEKABILITY_UNKNOWN = -1,
 119     SEEKABILITY_NO_SEEKABLE,
 120     SEEKABILITY_SEEKABLE,
 121 } SeekabilityType;
 122
 123 typedef enum {
 124     DURATION_UNQUERIED = -2,
 125     DURATION_INDEFINITE = -1
 126     /* other values are actual */
 127 } Duration;
 128
 129 typedef struct {
 130     gint x;
 131     gint y;
 132     gint width;
 133     gint height;
 134 } render_rectangle;
 135
 136 /* This struct contains all configurable settings
 137    update this and the conf file synchronously, plz
 138  */
 139 typedef struct {
 140     /* pipeline */
 141     gchar *asink;
 142     gchar *vsink;
 143     gint flags;
 144     gint64 buffer_time;
 145     gint64 latency_time;
 146     gboolean autoload_subtitles;
 147     gchar *subtitle_encoding;
 148     gchar *subtitle_font;
 149
 150     /* timers */
 151     guint milliseconds_to_pause_frame;
 152     guint seconds_to_pause_to_ready;
 153
 154     /* dhmmixer */
 155     gboolean use_dhmmixer;
 156     struct {
 157         guint state;
 158         gint room;
 159         gint color;
 160     } mobile_surround_music;
 161     struct {
 162         guint state;
 163         gint room;
 164         gint color;
 165     } mobile_surround_video;
 166 } configuration;
 167
 168 /*
 169  * media:        Information about currently selected media.
 170  *   location:           Current media location
 171  *   length_nanos:       Length of the media, in nanoseconds
 172  *   has_visual_content: the clip contains some visual content (video)
 173  *   video_width:        If media contains video, this tells the video width
 174  *   video_height:       If media contains video, this tells the video height
 175  *   seekable:           Tells whether the media can be seeked
 176  *   par_n:              Video pixel aspect ratio numerator
 177  *   par_d:              Video pixel aspect ratio denominator
 178  * owner:        Owner of the worker; usually a MafwGstRenderer (FIXME USUALLY?)
 179  * pipeline:     Playback pipeline
 180  * bus:          Message bus
 181  * state:        Current playback pipeline state
 182  * is_stream:    Is currently playing media a stream
 183  * muted:        Is the audio muted
 184  * eos:          Has playback reached EOS already
 185  * is_error:     Has there been an error situation
 186  * buffering:    Indicates the buffering state
 187  * prerolling:   Indicates the prerolling state (NULL -> PAUSED)
 188  * report_statechanges: Report state change bus messages
 189  * current_volume:      Current audio volume [0.0 .. 1.0], see playbin:volume
 190  * async_bus_id:        ID handle for GstBus
 191  * buffer_probe_id:     ID of the video renderer buffer probe
 192  * seek_position:       Indicates the pos where to seek, in seconds
 193  * vsink:               Video sink element of the pipeline
 194  * asink:               Audio sink element of the pipeline
 195  * tsink:               Text sink element of the pipeline
 196  * xid:                 XID for video playback
 197  * current_frame_on_pause: whether to emit current frame when pausing
 198  */
 199 struct _MafwGstRendererWorker {
 200     struct {
 201         gchar *location;
 202         gint64 length_nanos;
 203         gboolean has_visual_content;
 204         gint video_width;
 205         gint video_height;
 206         gdouble fps;
 207         SeekabilityType seekable;
 208         gint par_n;
 209         gint par_d;
 210     } media;
 211     gpointer owner;
 212     GstElement *pipeline;
 213
 214     // Audio bin for Dolby Headphones Mobile plugin
 215     GstElement *audiobin;
 216
 217     GstBus *bus;
 218     /* GStreamer state we are considering right now */
 219     GstState state;
 220     gboolean is_stream;
 221     gboolean muted;
 222     /* we are handing eos or we did */
 223     gboolean eos;
 224     /* if we are handling (or handled) and error */
 225     gboolean is_error;
 226     /* pipeline is buffering */
 227     gboolean buffering;
 228     /* pipeline is prerolling */
 229     gboolean prerolling;
 230     /* stream is live and doesn't need prerolling */
 231     gboolean is_live;
 232     /* if we have to stay in paused though a do_play was
 233      * requested. Usually used when pausing in transitioning */
 234     gboolean stay_paused;
 235     /* this variable should be FALSE while we are hiding state
 236      * changed to the UI. This is that GStreamer can perform
 237      * state_changes without us requiring it, for example, then
 238      * seeking, buffering and so on and we have to hide those
 239      * changes */
 240     gboolean report_statechanges;
 241     guint async_bus_id;
 242     gint seek_position;
 243     guint ready_timeout;
 244     guint duration_seek_timeout;
 245     guint duration_seek_timeout_loop_count;
 246     /* TRUE when a transition to GST_STATE_READY has been
 247      * requested or we are actually in GST_STATE_READY (requested
 248      * by us) */
 249     gboolean in_ready;
 250     /* Flag indicating whether taking image from pause frame has succeed after pause. */
 251     gboolean pause_frame_taken;
 252     guint pause_frame_timeout;
 253     GstBuffer *pause_frame_buffer;
 254     GstElement *vsink;
 255     GstElement *asink;
 256     GstElement *tsink;
 257
 258     // Dolby Headphones Mobile mixer
 259     GstElement *amixer;
 260
 261     XID xid;
 262     render_rectangle x_overlay_rectangle;
 263     gboolean autopaint;
 264     gfloat playback_speed;
 265     gboolean force_aspect_ratio;
 266     gint colorkey;
 267     GPtrArray *tag_list;
 268     GHashTable *current_metadata;
 269     gpointer context_nowplaying;
 270
 271     gboolean current_frame_on_pause;
 272     gboolean taking_screenshot;
 273     gchar *tmp_files_pool[MAFW_GST_RENDERER_MAX_TMP_FILES];
 274     guint8 tmp_files_pool_index;
 275
 276     GSList *destinations;
 277
 278     GstElement *queue;
 279
 280     configuration *config;
 281
 282     MafwGstRendererSeeker *seeker;
 283
 284     /* Handlers for notifications */
 285     MafwGstRendererWorkerNotifySeekCb notify_seek_handler;
 286     MafwGstRendererWorkerNotifyPauseCb notify_pause_handler;
 287     MafwGstRendererWorkerNotifyPlayCb notify_play_handler;
 288     MafwGstRendererWorkerNotifyBufferStatusCb notify_buffer_status_handler;
 289     MafwGstRendererWorkerNotifyEOSCb notify_eos_handler;
 290     MafwGstRendererWorkerNotifyReadyStateCb notify_ready_state_handler;
 291     MafwGstRendererWorkerNotifyMetadataCb notify_metadata_handler;
 292     MafwGstRendererWorkerNotifyErrorCb notify_error_handler;
 293     MafwGstRendererWorkerNotifyPropertyCb notify_property_handler;
 294
 295     MafwGstRendererWorkerBlankingControlCb blanking__control_handler;
 296     MafwGstRendererWorkerScreenshotCb screenshot_handler;
 297 };
 298
 299
 300 MafwGstRendererWorker *mafw_gst_renderer_worker_new(gpointer owner);
 301
 302 void mafw_gst_renderer_worker_exit(MafwGstRendererWorker *worker);
 303
 304 void mafw_gst_renderer_worker_set_current_frame_on_pause(
 305     MafwGstRendererWorker *worker,
 306     gboolean current_frame_on_pause);
 307
 308 void mafw_gst_renderer_worker_set_ready_timeout(MafwGstRendererWorker *worker,
 309                                                 guint seconds);
 310
 311 gboolean mafw_gst_renderer_worker_get_current_frame_on_pause(
 312     MafwGstRendererWorker *worker);
 313
 314 configuration* mafw_gst_renderer_worker_create_default_configuration(MafwGstRendererWorker *worker);
 315 void mafw_gst_renderer_worker_set_configuration(MafwGstRendererWorker *worker,
 316                                                 configuration *config);
 317
 318 void mafw_gst_renderer_worker_set_position(MafwGstRendererWorker *worker,
 319                                            GstSeekType seek_type,
 320                                            gint position,
 321                                            GError **error);
 322
 323 gint mafw_gst_renderer_worker_get_position(MafwGstRendererWorker *worker);
 324
 325 gint64 mafw_gst_renderer_worker_get_last_known_duration(MafwGstRendererWorker *worker);
 326 gint64 mafw_gst_renderer_worker_get_duration(MafwGstRendererWorker *worker);
 327
 328 void mafw_gst_renderer_worker_set_xid(MafwGstRendererWorker *worker, XID xid);
 329
 330 XID mafw_gst_renderer_worker_get_xid(MafwGstRendererWorker *worker);
 331
 332 void mafw_gst_renderer_worker_set_render_rectangle(MafwGstRendererWorker *worker, render_rectangle *rect);
 333 const render_rectangle* mafw_gst_renderer_worker_get_render_rectangle(MafwGstRendererWorker *worker);
 334
 335 gboolean mafw_gst_renderer_worker_get_autopaint(MafwGstRendererWorker *worker);
 336
 337 void mafw_gst_renderer_worker_set_autopaint(MafwGstRendererWorker *worker,
 338                                             gboolean autopaint);
 339
 340 gboolean mafw_gst_renderer_worker_set_playback_speed(MafwGstRendererWorker *worker, gfloat speed);
 341
 342 gfloat mafw_gst_renderer_worker_get_playback_speed(MafwGstRendererWorker *worker);
 343
 344 void mafw_gst_renderer_worker_set_force_aspect_ratio(MafwGstRendererWorker *worker, gboolean force);
 345
 346 gboolean mafw_gst_renderer_worker_get_force_aspect_ratio(MafwGstRendererWorker *worker);
 347
 348 gint mafw_gst_renderer_worker_get_colorkey(MafwGstRendererWorker *worker);
 349
 350 gboolean mafw_gst_renderer_worker_get_seekable(MafwGstRendererWorker *worker);
 351
 352 gboolean mafw_gst_renderer_worker_get_streaming(MafwGstRendererWorker *worker);
 353
 354 const char* mafw_gst_renderer_worker_get_uri(MafwGstRendererWorker *worker);
 355
 356 GHashTable *mafw_gst_renderer_worker_get_current_metadata(
 357     MafwGstRendererWorker *worker);
 358
 359 void mafw_gst_renderer_worker_play(MafwGstRendererWorker *worker,
 360                                    const gchar *uri);
 361
 362 void mafw_gst_renderer_worker_stop(MafwGstRendererWorker *worker);
 363
 364 void mafw_gst_renderer_worker_pause(MafwGstRendererWorker *worker);
 365
 366 void mafw_gst_renderer_worker_resume(MafwGstRendererWorker *worker);
 367
 368 void mafw_gst_renderer_worker_pause_at(MafwGstRendererWorker *worker, guint position);
 369
 370 guint check_dolby_audioroute(MafwGstRendererWorker *worker, guint prop);
 371
 372 void set_dolby_music_property(MafwGstRendererWorker *worker, guint prop);
 373 void set_dolby_music_sound_property(MafwGstRendererWorker *worker, gint prop, gboolean isRoomProperty);
 374
 375 void set_dolby_video_property(MafwGstRendererWorker *worker, guint prop);
 376 void set_dolby_video_sound_property(MafwGstRendererWorker *worker, gint prop, gboolean isRoomProperty);
 377
 378 void mafw_gst_renderer_worker_notify_media_destination(MafwGstRendererWorker *worker,
 379                                                        GSList *destinations);
 380
 381 G_END_DECLS
 382 #endif