git.maemo.org Git - mafwsubrenderer/blob - mafw-gst-subtitles-renderer/libmafw-gst-renderer/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 <X11/Xdefs.h>
  28 #include <glib-object.h>
  29 #include <gst/gst.h>
  30 #include "mafw-gst-renderer-worker-volume.h"
  31
  32 #define MAFW_GST_RENDERER_MAX_TMP_FILES 5
  33
  34 typedef struct _MafwGstRendererWorker MafwGstRendererWorker;
  35
  36 typedef void (*MafwGstRendererWorkerNotifySeekCb)(MafwGstRendererWorker *worker, gpointer owner);
  37 typedef void (*MafwGstRendererWorkerNotifyPauseCb)(MafwGstRendererWorker *worker, gpointer owner);
  38 typedef void (*MafwGstRendererWorkerNotifyPlayCb)(MafwGstRendererWorker *worker, gpointer owner);
  39 typedef void (*MafwGstRendererWorkerNotifyBufferStatusCb)(MafwGstRendererWorker *worker, gpointer owner, gdouble percent);
  40 typedef void (*MafwGstRendererWorkerNotifyEOSCb)(MafwGstRendererWorker *worker, gpointer owner);
  41 typedef void (*MafwGstRendererWorkerNotifyErrorCb)(MafwGstRendererWorker *worker,
  42                                                    gpointer owner,
  43                                                    const GError *error);
  44
  45 typedef enum {
  46         WORKER_MODE_SINGLE_PLAY,
  47         WORKER_MODE_PLAYLIST,
  48         WORKER_MODE_REDUNDANT,
  49 } PlaybackMode;
  50
  51 typedef enum {
  52         SEEKABILITY_UNKNOWN = -1,
  53         SEEKABILITY_NO_SEEKABLE,
  54         SEEKABILITY_SEEKABLE,
  55 } SeekabilityType;
  56
  57 /*
  58  * media:        Information about currently selected media.
  59  *   location:           Current media location
  60  *   length_nanos:       Length of the media, in nanoseconds
  61  *   has_visual_content: the clip contains some visual content (video)
  62  *   video_width:        If media contains video, this tells the video width
  63  *   video_height:       If media contains video, this tells the video height
  64  *   seekable:           Tells whether the media can be seeked
  65  *   par_n:              Video pixel aspect ratio numerator
  66  *   par_d:              Video pixel aspect ratio denominator
  67  * subtitles:     Configuration of subtitles.
  68  *   enabled:            Are subtitles enabled
  69  *   font:               Subtitles font description
  70  *   encoding:           Subtitles encoding
  71  * owner:        Owner of the worker; usually a MafwGstRenderer (FIXME USUALLY?)
  72  * pipeline:     Playback pipeline
  73  * bus:          Message bus
  74  * state:        Current playback pipeline state
  75  * is_stream:    Is currently playing media a stream
  76  * muted:        Is the audio muted
  77  * eos:          Has playback reached EOS already
  78  * is_error:     Has there been an error situation
  79  * buffering:    Indicates the buffering state
  80  * prerolling:   Indicates the prerolling state (NULL -> PAUSED)
  81  * report_statechanges: Report state change bus messages
  82  * current_volume:      Current audio volume [0.0 .. 1.0], see playbin:volume
  83  * async_bus_id:        ID handle for GstBus
  84  * buffer_probe_id:     ID of the video renderer buffer probe
  85  * seek_position:       Indicates the pos where to seek, in seconds
  86  * vsink:               Video sink element of the pipeline
  87  * asink:               Audio sink element of the pipeline
  88  * tsink:               Text sink element of the pipeline
  89  * xid:                 XID for video playback
  90  * current_frame_on_pause: whether to emit current frame when pausing
  91  */
  92 struct _MafwGstRendererWorker {
  93         struct {
  94                 gchar *location;
  95                 gint64 length_nanos;
  96                 gboolean has_visual_content;
  97                 gint video_width;
  98                 gint video_height;
  99                 gdouble fps;
 100                 SeekabilityType seekable;
 101                 gint par_n;
 102                 gint par_d;
 103         } media;
 104         struct {
 105                 gboolean enabled;
 106                 gchar *font;
 107                 gchar *encoding;
 108         } subtitles;
 109         PlaybackMode mode;
 110         struct {
 111                 GSList *items;
 112                 gint current;
 113                 gboolean notify_play_pending;
 114         } pl;
 115         gpointer owner;
 116         GstElement *pipeline;
 117         GstBus *bus;
 118         /* GStreamer state we are considering right now */
 119         GstState state;
 120         MafwGstRendererWorkerVolume *wvolume;
 121         gboolean is_stream;
 122         gboolean muted;
 123         /* we are handing eos or we did */
 124         gboolean eos;
 125         /* if we are handling (or handled) and error */
 126         gboolean is_error;
 127         /* pipeline is buffering */
 128         gboolean buffering;
 129         /* pipeline is prerolling */
 130         gboolean prerolling;
 131         /* stream is live and doesn't need prerolling */
 132         gboolean is_live;
 133         /* if we have to stay in paused though a do_play was
 134          * requested. Usually used when pausing in transitioning */
 135         gboolean stay_paused;
 136         /* this variable should be FALSE while we are hiding state
 137          * changed to the UI. This is that GStreamer can perform
 138          * state_changes without us requiring it, for example, then
 139          * seeking, buffering and so on and we have to hide those
 140          * changes */
 141         gboolean report_statechanges;
 142         guint async_bus_id;
 143         gint seek_position;
 144         guint ready_timeout;
 145         guint duration_seek_timeout;
 146         /* After some time PAUSED, we set the pipeline to READY in order to
 147          * save resources. This field states if we are in this special
 148          * situation.
 149          * It is set to TRUE when the state change to READY is requested
 150          * and stays like that until we reach again PLAYING state (not PAUSED).
 151          * The reason for this is that when resuming streams, we have to
 152          * move from READY to PAUSED, then seek to the position where the
 153          * stream had been paused, then wait for buffering to finish, and then
 154          * play (and notify the state change to PLAYING), and we have to
 155          * differentiate this case from the one in which we have entered PAUSED
 156          * silently (when we ran out of buffer while playing, because in that
 157          * case, when we are done buffering we want to resume playback silently
 158          * again.
 159          */
 160         gboolean in_ready;
 161         GstElement *vsink;
 162         GstElement *asink;
 163         GstElement *tsink;
 164         XID xid;
 165         gboolean autopaint;
 166         gint colorkey;
 167         GPtrArray *tag_list;
 168         GHashTable *current_metadata;
 169
 170 #ifdef HAVE_GDKPIXBUF
 171         gboolean current_frame_on_pause;
 172         gchar *tmp_files_pool[MAFW_GST_RENDERER_MAX_TMP_FILES];
 173         guint8 tmp_files_pool_index;
 174 #endif
 175
 176         /* Handlers for notifications */
 177         MafwGstRendererWorkerNotifySeekCb notify_seek_handler;
 178         MafwGstRendererWorkerNotifyPauseCb notify_pause_handler;
 179         MafwGstRendererWorkerNotifyPlayCb notify_play_handler;
 180         MafwGstRendererWorkerNotifyBufferStatusCb notify_buffer_status_handler;
 181         MafwGstRendererWorkerNotifyEOSCb notify_eos_handler;
 182         MafwGstRendererWorkerNotifyErrorCb notify_error_handler;
 183 };
 184
 185 G_BEGIN_DECLS
 186
 187 MafwGstRendererWorker *mafw_gst_renderer_worker_new(gpointer owner);
 188 void mafw_gst_renderer_worker_exit(MafwGstRendererWorker *worker);
 189
 190 void mafw_gst_renderer_worker_set_volume(MafwGstRendererWorker *worker,
 191                                          guint vol);
 192 guint mafw_gst_renderer_worker_get_volume(MafwGstRendererWorker *worker);
 193 void mafw_gst_renderer_worker_set_mute(MafwGstRendererWorker *worker,
 194                                        gboolean mute);
 195 gboolean mafw_gst_renderer_worker_get_mute(MafwGstRendererWorker *worker);
 196 #ifdef HAVE_GDKPIXBUF
 197 void mafw_gst_renderer_worker_set_current_frame_on_pause(MafwGstRendererWorker *worker,
 198                                                          gboolean current_frame_on_pause);
 199 gboolean mafw_gst_renderer_worker_get_current_frame_on_pause(MafwGstRendererWorker *worker);
 200 #endif
 201 void mafw_gst_renderer_worker_set_position(MafwGstRendererWorker *worker,
 202                                            GstSeekType seek_type,
 203                                            gint position,
 204                                            GError **error);
 205 gint mafw_gst_renderer_worker_get_position(MafwGstRendererWorker *worker);
 206 void mafw_gst_renderer_worker_set_xid(MafwGstRendererWorker *worker, XID xid);
 207 XID mafw_gst_renderer_worker_get_xid(MafwGstRendererWorker *worker);
 208 gboolean mafw_gst_renderer_worker_get_autopaint(MafwGstRendererWorker *worker);
 209 void mafw_gst_renderer_worker_set_autopaint(MafwGstRendererWorker *worker, gboolean autopaint);
 210 gint mafw_gst_renderer_worker_get_colorkey(MafwGstRendererWorker *worker);
 211 void mafw_gst_renderer_worker_set_colorkey(MafwGstRendererWorker *worker, gint autopaint);
 212 gboolean mafw_gst_renderer_worker_get_seekable(MafwGstRendererWorker *worker);
 213 GHashTable *mafw_gst_renderer_worker_get_current_metadata(MafwGstRendererWorker *worker);
 214 void mafw_gst_renderer_worker_play(MafwGstRendererWorker *worker, const gchar *uri, GSList *plitems);
 215 void mafw_gst_renderer_worker_play_alternatives(MafwGstRendererWorker *worker, gchar **uris);
 216 void mafw_gst_renderer_worker_stop(MafwGstRendererWorker *worker);
 217 void mafw_gst_renderer_worker_pause(MafwGstRendererWorker *worker);
 218 void mafw_gst_renderer_worker_resume(MafwGstRendererWorker *worker);
 219
 220 G_END_DECLS
 221 #endif
 222 /* vi: set noexpandtab ts=8 sw=8 cino=t0,(0: */