git.maemo.org Git - mafwsubrenderer/blob - qmafw-gst-subtitles-renderer/unittests/common/renderer-worker-stub.c

   1 /*
   2  * This file is part of QMAFW
   3  *
   4  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights
   5  * reserved.
   6  *
   7  * Contact: Visa Smolander <visa.smolander@nokia.com>
   8  *
   9  * This software, including documentation, is protected by copyright controlled
  10  * by Nokia Corporation. All rights are reserved. Copying, including
  11  * reproducing, storing, adapting or translating, any or all of this material
  12  * requires the prior written consent of Nokia Corporation. This material also
  13  * contains confidential information which may not be disclosed to others
  14  * without the prior written consent of Nokia.
  15  *
  16  */
  17
  18 #include <string.h> //memset
  19 #include "mafw-gst-renderer-worker.h"
  20 #include "mafw-gst-renderer-utils.h"
  21
  22 GError* global_error = 0;
  23 gint global_position = 0;
  24 gint global_worker_audio_destination = -1;
  25 gint global_worker_video_destination = -1;
  26 gchar *global_worker_uri = 0;
  27 gint global_worker_stop_called = 0;
  28 gint global_worker_seek_request = 0;
  29 GSList *global_worker_destinations = NULL;
  30 guint global_ready_timeout = 99999;
  31
  32 guint m_volume;
  33 gboolean m_mute;
  34 gboolean m_current_frame_on_pause;
  35 gboolean m_force_aspect_ratio;
  36 gfloat m_playback_speed = 1;
  37 XID m_xid;
  38
  39 render_rectangle m_render_rectangle;
  40 configuration *current_worker_conf;
  41
  42
  43 gboolean global_worker_playing = FALSE;
  44
  45 #define UNUSED(x) (void)(x)
  46
  47 void mafw_gst_renderer_worker_set_volume(MafwGstRendererWorker *worker,
  48                                          guint volume)
  49 {
  50     UNUSED(worker);
  51     m_volume = volume;
  52 }
  53
  54 guint mafw_gst_renderer_worker_get_volume(MafwGstRendererWorker *worker)
  55 {
  56     UNUSED(worker);
  57     return m_volume;
  58 }
  59
  60 void mafw_gst_renderer_worker_set_mute(MafwGstRendererWorker *worker,
  61                                        gboolean mute)
  62 {
  63     UNUSED(worker);
  64     m_mute = mute;
  65 }
  66
  67 gboolean mafw_gst_renderer_worker_get_mute(MafwGstRendererWorker *worker)
  68 {
  69     UNUSED(worker);
  70     return m_mute;
  71 }
  72
  73 gint64 mafw_gst_renderer_worker_get_last_known_duration(MafwGstRendererWorker *worker)
  74 {
  75     UNUSED(worker);
  76     return 10;
  77 }
  78
  79 const char* mafw_gst_renderer_worker_get_uri(MafwGstRendererWorker *worker)
  80 {
  81     UNUSED(worker);
  82     return global_worker_uri;
  83 }
  84
  85 gboolean mafw_gst_renderer_worker_get_seekable(MafwGstRendererWorker *worker)
  86 {
  87     UNUSED(worker);
  88     return TRUE;
  89 }
  90
  91 void _free_configuration(configuration *config)
  92 {
  93     if( !config )
  94     {
  95         return;
  96     }
  97
  98     if( config->asink )
  99     {
 100         g_free(config->asink);
 101     }
 102     if( config->vsink )
 103     {
 104         g_free(config->vsink);
 105     }
 106
 107     g_free(config);
 108 }
 109
 110 void mafw_gst_renderer_worker_set_current_frame_on_pause(
 111     MafwGstRendererWorker *worker,
 112     gboolean current_frame_on_pause)
 113 {
 114     UNUSED(worker);
 115     m_current_frame_on_pause = current_frame_on_pause;
 116 }
 117
 118 gboolean mafw_gst_renderer_worker_get_current_frame_on_pause(
 119     MafwGstRendererWorker *worker)
 120 {
 121     UNUSED(worker);
 122     return m_current_frame_on_pause;
 123 }
 124
 125 void mafw_gst_renderer_worker_set_position(MafwGstRendererWorker *worker,
 126                                            GstSeekType seek_type,
 127                                            gint position, GError **error)
 128 {
 129     UNUSED(worker);
 130     UNUSED(seek_type);
 131     global_worker_seek_request = position;
 132     *error = global_error;
 133 }
 134
 135 gint mafw_gst_renderer_worker_get_position(MafwGstRendererWorker *worker)
 136 {
 137     UNUSED(worker);
 138     return global_position;
 139 }
 140
 141 void mafw_gst_renderer_worker_set_xid(MafwGstRendererWorker *worker, XID xid)
 142 {
 143     UNUSED(worker);
 144     m_xid = xid;
 145 }
 146
 147 gboolean mafw_gst_renderer_worker_get_streaming(MafwGstRendererWorker *worker)
 148 {
 149     return uri_is_stream(global_worker_uri);
 150 }
 151
 152 XID mafw_gst_renderer_worker_get_xid(MafwGstRendererWorker *worker)
 153 {
 154     UNUSED(worker);
 155     return m_xid;
 156 }
 157
 158
 159 void mafw_gst_renderer_worker_set_render_rectangle(MafwGstRendererWorker *worker, render_rectangle *rect)
 160 {
 161     UNUSED(worker);
 162     m_render_rectangle.x = rect->x;
 163     m_render_rectangle.y = rect->y;
 164     m_render_rectangle.width = rect->width;
 165     m_render_rectangle.height = rect->height;
 166 }
 167
 168 const render_rectangle* mafw_gst_renderer_worker_get_render_rectangle(MafwGstRendererWorker *worker)
 169 {
 170     UNUSED(worker);
 171     return &m_render_rectangle;
 172 }
 173
 174
 175 gboolean mafw_gst_renderer_worker_get_autopaint(MafwGstRendererWorker *worker)
 176 {
 177     UNUSED(worker);
 178     return TRUE;
 179 }
 180
 181 void mafw_gst_renderer_worker_set_ready_timeout(MafwGstRendererWorker *worker,
 182                                                 guint seconds)
 183 {
 184     UNUSED(worker);
 185     global_ready_timeout = seconds;
 186 }
 187
 188 void mafw_gst_renderer_worker_set_autopaint(MafwGstRendererWorker *worker,
 189                                             gboolean autopaint)
 190 {
 191     UNUSED(worker);
 192     UNUSED(autopaint);
 193 }
 194
 195 gint mafw_gst_renderer_worker_get_colorkey(MafwGstRendererWorker *worker)
 196 {
 197     UNUSED(worker);
 198     return 1;
 199 }
 200
 201 void mafw_gst_renderer_worker_play(MafwGstRendererWorker *worker,
 202                                    const gchar *uri)
 203 {
 204     UNUSED(worker);
 205     UNUSED(uri);
 206     global_worker_playing = TRUE;
 207     g_free(global_worker_uri);
 208     global_worker_uri = g_strdup(uri);
 209     worker->notify_play_handler(worker, worker->owner);
 210 }
 211
 212 void mafw_gst_renderer_worker_stop(MafwGstRendererWorker *worker)
 213 {
 214     UNUSED(worker);
 215     global_worker_playing = FALSE;
 216     ++global_worker_stop_called;
 217
 218     g_free(global_worker_uri);
 219     global_worker_uri = NULL;
 220 }
 221
 222 void mafw_gst_renderer_worker_pause(MafwGstRendererWorker *worker)
 223 {
 224     UNUSED(worker);
 225     global_worker_playing = FALSE;
 226     worker->notify_pause_handler(worker, worker->owner);
 227 }
 228
 229 void mafw_gst_renderer_worker_pause_at(MafwGstRendererWorker *worker, guint position)
 230 {
 231     UNUSED(worker);
 232     UNUSED(position);
 233 }
 234
 235 void mafw_gst_renderer_worker_resume(MafwGstRendererWorker *worker)
 236 {
 237     UNUSED(worker);
 238 }
 239
 240 MafwGstRendererWorker *mafw_gst_renderer_worker_new(gpointer owner)
 241 {
 242     MafwGstRendererWorker *newWorker = g_new0(MafwGstRendererWorker, 1);
 243     newWorker->owner = owner;
 244     newWorker->config = g_new0(configuration, 1);
 245     return newWorker;
 246 }
 247
 248 void mafw_gst_renderer_worker_exit(MafwGstRendererWorker *worker)
 249 {
 250     if( worker )
 251     {
 252         _free_configuration(worker->config);
 253         worker->config = NULL;
 254     }
 255 }
 256
 257 gboolean mafw_gst_renderer_worker_set_playback_speed(MafwGstRendererWorker *worker, gfloat speed)
 258 {
 259     UNUSED(worker);
 260
 261     if(!global_worker_playing)
 262     {
 263         return FALSE;
 264     }
 265
 266     m_playback_speed = speed;
 267
 268     GValue v;
 269     memset(&v, 0, sizeof(GValue));
 270     g_value_init(&v, G_TYPE_FLOAT);
 271     g_value_set_float(&v, m_playback_speed);
 272
 273     worker->notify_property_handler(worker, worker->owner, WORKER_PROPERTY_PLAYBACK_SPEED, &v);
 274     g_value_unset(&v);
 275
 276     return TRUE;
 277 }
 278
 279 gfloat mafw_gst_renderer_worker_get_playback_speed(MafwGstRendererWorker *worker)
 280 {
 281     UNUSED(worker);
 282     return m_playback_speed;
 283 }
 284
 285 void mafw_gst_renderer_worker_set_force_aspect_ratio(MafwGstRendererWorker *worker, gboolean force)
 286 {
 287     UNUSED(worker);
 288     m_force_aspect_ratio = force;
 289 }
 290
 291 gboolean mafw_gst_renderer_worker_get_force_aspect_ratio(MafwGstRendererWorker *worker)
 292 {
 293     UNUSED(worker);
 294     return m_force_aspect_ratio;
 295 }
 296
 297 void mafw_gst_renderer_worker_notify_media_destination(MafwGstRendererWorker *worker,
 298                                                        GSList *destination)
 299 {
 300     UNUSED(worker);
 301     g_slist_free(global_worker_destinations);
 302     global_worker_destinations = g_slist_copy(destination);
 303 }
 304
 305 configuration* mafw_gst_renderer_worker_create_default_configuration(MafwGstRendererWorker *worker)
 306 {
 307     configuration *config = g_malloc0(sizeof(configuration));
 308     config->asink = g_strdup("pulsesink");
 309     config->vsink = g_strdup("omapxvsink");
 310     config->flags = 67;
 311     config->buffer_time = 300000;
 312     config->latency_time = 100000;
 313
 314     /* timers */
 315     config->milliseconds_to_pause_frame = 1000;
 316     config->seconds_to_pause_to_ready = 3;
 317
 318     /* dhmmixer */
 319     config->use_dhmmixer = TRUE;
 320
 321     config->mobile_surround_music.state = 0;
 322     config->mobile_surround_music.room = 2;
 323     config->mobile_surround_music.color = 2;
 324     config->mobile_surround_video.state = 0;
 325     config->mobile_surround_video.room = 2;
 326     config->mobile_surround_video.color = 2;
 327
 328     return config;
 329 }
 330
 331 void mafw_gst_renderer_worker_set_configuration(MafwGstRendererWorker *worker, configuration *config)
 332 {
 333     if( worker->config )
 334     {
 335         _free_configuration(worker->config);
 336     }
 337     worker->config = config;
 338     current_worker_conf = config;
 339 }
 340
 341 void set_dolby_music_property(MafwGstRendererWorker *worker, guint prop)
 342 {
 343     worker->config->mobile_surround_music.state = prop;
 344 }
 345
 346 void set_dolby_music_sound_property(MafwGstRendererWorker *worker, gint prop, gboolean isRoomProperty)
 347 {
 348     if (isRoomProperty)
 349     {
 350         worker->config->mobile_surround_music.room = prop;
 351     }
 352     else
 353     {
 354         worker->config->mobile_surround_music.color = prop;
 355     }
 356 }
 357
 358 void set_dolby_video_property(MafwGstRendererWorker *worker, guint prop)
 359 {
 360     worker->config->mobile_surround_video.state = prop;
 361 }
 362
 363 void set_dolby_video_sound_property(MafwGstRendererWorker *worker, gint prop, gboolean isRoomProperty)
 364 {
 365     if (isRoomProperty)
 366     {
 367         worker->config->mobile_surround_video.room = prop;
 368     }
 369     else
 370     {
 371         worker->config->mobile_surround_video.color = prop;
 372     }
 373 }
 374
 375 gint64 mafw_gst_renderer_worker_get_duration(MafwGstRendererWorker *worker)
 376 {
 377     UNUSED(worker);
 378
 379     return 0;
 380 }