git.maemo.org Git - mafwsubrenderer/blob - mafw-gst-subtitles-renderer/tests/mafw-test-player.c

   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
  25 /*
  26  * test.c
  27  *
  28  * Test of the playback system
  29  *
  30  * Copyright (C) 2007 Nokia Corporation
  31  *
  32  */
  33
  34 #include <unistd.h>
  35 #include <stdlib.h>
  36 #include <sys/select.h>
  37 #include <sys/time.h>
  38 #include <sys/types.h>
  39 #include <termios.h>
  40
  41 #include "mafw-gst-renderer.h"
  42 #include <libmafw/mafw-metadata.h>
  43 #include <libmafw/mafw-registry.h>
  44
  45 MafwGstRenderer *gst_renderer;
  46 GMainLoop *loop;
  47 static struct termios tio_orig;
  48 guint seek_delta = 2;
  49 gfloat volume = 0.7;
  50 gboolean muted = FALSE;
  51
  52
  53 /**
  54  *@time: how long to wait, in microsecs
  55  *
  56  */
  57 int kbhit (int time) {
  58         fd_set rfds;
  59         struct timeval tv;
  60         int retval;
  61         char c;
  62
  63         FD_ZERO (&rfds);
  64         FD_SET (0, &rfds);
  65
  66         /* Wait up to 'time' microseconds. */
  67         tv.tv_sec=time / 1000;
  68         tv.tv_usec = (time % 1000)*1000;
  69
  70         retval=select (1, &rfds, NULL, NULL, &tv);
  71         if(retval < 1) return -1;
  72         retval = read (0, &c, 1);
  73         if (retval < 1) return -1;
  74         return (int) c;
  75 }
  76
  77
  78 /**
  79  *
  80  *
  81  */
  82 static void raw_kb_enable (void) {
  83         struct termios tio_new;
  84         tcgetattr(0, &tio_orig);
  85
  86         tio_new = tio_orig;
  87         tio_new.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
  88         tio_new.c_cc[VMIN] = 1;
  89         tio_new.c_cc[VTIME] = 0;
  90         tcsetattr (0, TCSANOW, &tio_new);
  91 }
  92
  93 static void raw_kb_disable (void)
  94 {
  95         tcsetattr (0,TCSANOW, &tio_orig);
  96 }
  97
  98 static void get_position_cb(MafwRenderer* self, gint position, gpointer user_data,
  99                             const GError* error)
 100 {
 101         guint* rpos = (guint*) user_data;
 102         g_return_if_fail(rpos != NULL);
 103
 104         *rpos = position;
 105 }
 106
 107 /**
 108  *
 109  *
 110  */
 111 static gboolean idle_cb (gpointer data)
 112 {
 113         gboolean ret = TRUE;
 114         GError *error = NULL;
 115
 116         int c = kbhit (0);
 117         if (c == -1) {
 118                 usleep (10 * 1000);
 119                 return TRUE;
 120         }
 121
 122         printf ("c = %d\n", c);
 123         /* '.' key */
 124         if (c == 46) {
 125                 printf ("Seeking %d seconds forward\n", seek_delta);
 126                 gint pos = 0;
 127
 128                 mafw_gst_renderer_get_position(MAFW_RENDERER(gst_renderer),
 129                                              get_position_cb, &pos);
 130
 131                 printf ("  Position before seek: %d\n", pos);
 132                 pos += seek_delta;
 133                 mafw_gst_renderer_set_position(MAFW_RENDERER(gst_renderer), pos,
 134                                              NULL, NULL);
 135
 136                 mafw_gst_renderer_get_position(MAFW_RENDERER(gst_renderer),
 137                                              get_position_cb, &pos);
 138
 139                 printf ("  Position after seek: %d\n", pos);
 140         }
 141         /* ',' key */
 142         else if (c == 44) {
 143                 printf ("Seeking %d seconds backwards\n", seek_delta);
 144                 gint pos = 0;
 145
 146                 mafw_gst_renderer_get_position(MAFW_RENDERER(gst_renderer),
 147                                              get_position_cb, &pos);
 148
 149                 printf ("  Position before seek: %d\n", pos);
 150                 pos -= seek_delta;
 151                 mafw_gst_renderer_set_position(MAFW_RENDERER(gst_renderer), pos,
 152                                              NULL, NULL);
 153
 154                 mafw_gst_renderer_get_position(MAFW_RENDERER(gst_renderer),
 155                                              get_position_cb, &pos);
 156
 157                 printf ("  Position after seek: %d\n", pos);
 158         }
 159         /* '' (space) key */
 160         else if (c == 32) {
 161                 if (gst_renderer->current_state == Playing) {
 162                         printf ("Pausing...\n");
 163                         mafw_gst_renderer_pause(MAFW_RENDERER (gst_renderer), NULL, NULL);
 164                 }
 165                 else if (gst_renderer->current_state == Paused) {
 166                         printf ("Resuming...\n");
 167                         mafw_gst_renderer_resume(MAFW_RENDERER (gst_renderer), NULL, NULL);
 168                 }
 169         }
 170         /* 'p' key */
 171         else if (c == 112) {
 172                 printf ("Playing...\n");
 173                 mafw_gst_renderer_play (MAFW_RENDERER (gst_renderer), NULL, NULL);
 174         }
 175         /* 's' key */
 176         else if (c == 115) {
 177                 printf ("Stopping\n");
 178                 mafw_gst_renderer_stop (MAFW_RENDERER (gst_renderer), NULL, NULL);
 179         }
 180         /* 'g' key */
 181         else if (c == 103) {
 182                 printf ("Getting position\n");
 183                 gint pos = 0;
 184
 185                 mafw_gst_renderer_get_position(MAFW_RENDERER(gst_renderer),
 186                                              get_position_cb, &pos);
 187
 188                 printf ("Current position: %d\n", pos);
 189         }
 190         /* '+' key */
 191         else if (c == 43) {
 192                 volume += 0.1;
 193                 printf ("Increasing volume to %lf\n", volume);
 194                 mafw_extension_set_property_float(MAFW_EXTENSION(gst_renderer),
 195                                              "volume", volume);
 196         }
 197         /* '-' key */
 198         else if (c == 45) {
 199                 volume -= 0.1;
 200                 printf ("Decreasing volume to %lf\n", volume);
 201                 mafw_extension_set_property_float(MAFW_EXTENSION(gst_renderer),
 202                                              "volume", volume);
 203         }
 204         /* 'm' key */
 205         else if (c == 109) {
 206                 muted = !muted;
 207                 printf ("(Un)Muting...\n");
 208                 mafw_extension_set_property_boolean(MAFW_EXTENSION(gst_renderer),
 209                                                "mute", muted);
 210         }
 211         /* '?' key */
 212         else if (c == 63) {
 213                 printf ("COMMANDS:\n" \
 214                         "    s\t\tStop\n" \
 215                         "    p\t\tPlay\n" \
 216                         "    space\tPause/Resume\n" \
 217                         "    +\t\tVolume up\n" \
 218                         "    -\t\tVolume down\n" \
 219                         "    m\t\tMute/Unmute\n" \
 220                         "    .\t\tSeek forward 2 sec\n" \
 221                         "    ,\t\tSeek backwards 2 sec\n" \
 222                         "    q\t\tQuit\n");
 223         }
 224         /* 'q' key */
 225         else if (c == 113) {
 226                 printf ("QUIT\n");
 227                 mafw_gst_renderer_stop (MAFW_RENDERER (gst_renderer), NULL, NULL);
 228                 raw_kb_disable ();
 229                 g_main_loop_quit (loop);
 230                 ret = FALSE;
 231         }
 232         if (error) {
 233                 printf ("Error occured during the operation\n");
 234                 g_error_free (error);
 235         }
 236         return ret;
 237 }
 238
 239
 240 /**
 241  *
 242  *
 243  */
 244 static void metadata_changed (MafwGstRenderer *gst_renderer,
 245                               GHashTable *metadata,
 246                               gpointer user_data)
 247 {
 248         g_print("Metadata changed:\n");
 249         mafw_metadata_print (metadata, NULL);
 250 }
 251
 252
 253 /**
 254  *
 255  *
 256  */
 257 static void buffering_cb (MafwGstRenderer *gst_renderer,
 258                           gfloat percentage,
 259                           gpointer user_data)
 260 {
 261         g_print("Buffering: %f\n", percentage);
 262 }
 263
 264 static void play_uri_cb(MafwRenderer* renderer, gpointer user_data, const GError* error)
 265 {
 266         if (error != NULL) {
 267                 printf("Unable to play: %s\n", error->message);
 268                 exit(1);
 269         }
 270 }
 271
 272 /**
 273  *
 274  *
 275  */
 276 gint main(gint argc, gchar ** argv)
 277 {
 278         MafwRegistry *registry;
 279
 280         g_type_init();
 281         gst_init (&argc, &argv);
 282
 283         if (argc != 2) {
 284                 g_print("Usage: mafw-test-player <media-uri>\n");
 285                 exit(1);
 286         }
 287
 288         raw_kb_enable();
 289
 290         registry = MAFW_REGISTRY(mafw_registry_get_instance());
 291         gst_renderer = MAFW_GST_RENDERER(mafw_gst_renderer_new(registry));
 292         g_signal_connect (G_OBJECT (gst_renderer),
 293                           "metadata_changed",
 294                           G_CALLBACK (metadata_changed),
 295                           gst_renderer);
 296
 297         g_signal_connect (G_OBJECT (gst_renderer),
 298                           "buffering_info",
 299                           G_CALLBACK (buffering_cb),
 300                           gst_renderer);
 301
 302         mafw_renderer_play_uri(MAFW_RENDERER (gst_renderer), argv[1], play_uri_cb,
 303                             NULL);
 304
 305         loop = mafw_gst_renderer_get_loop(gst_renderer);
 306
 307         g_idle_add (idle_cb, NULL);
 308         g_main_loop_run (loop);
 309
 310         g_object_unref (G_OBJECT (gst_renderer));
 311         return 0;
 312 }