sys/v4l2/gstv4l2radio.c

   1 /* GStreamer v4l2 radio tuner element
   2  * Copyright (C) 2010, 2011 Alexey Chernov <4ernov@gmail.com>
   3  *
   4  * gstv4l2radio.c - V4L2 radio tuner element
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 /**
  23  * SECTION:element-v4l2radio
  24  *
  25  * v4l2radio can be used to control radio device
  26  * and to tune it to different radiostations.
  27  *
  28  * <refsect2>
  29  * <title>Example launch lines</title>
  30  * |[
  31  * gst-launch-1.0 v4l2radio device=/dev/radio0 frequency=101200000
  32  * gst-launch-1.0 alsasrc device=hw:1 ! audioconvert ! audioresample ! alsasink
  33  * ]|
  34  * First pipeline tunes the radio device /dev/radio0 to station 101.2 MHz,
  35  * second pipeline connects digital audio out (hw:1) to default sound card.
  36  * </refsect2>
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #include <config.h>
  41 #endif
  42
  43 #include <string.h>
  44
  45 #include "gst/gst-i18n-plugin.h"
  46
  47 #include "gstv4l2object.h"
  48 #include "gstv4l2tuner.h"
  49 #include "gstv4l2radio.h"
  50
  51 GST_DEBUG_CATEGORY_STATIC (v4l2radio_debug);
  52 #define GST_CAT_DEFAULT v4l2radio_debug
  53
  54 #define DEFAULT_PROP_DEVICE "/dev/radio0"
  55 #define MIN_FREQUENCY            87500000
  56 #define DEFAULT_FREQUENCY       100000000
  57 #define MAX_FREQUENCY           108000000
  58
  59 enum
  60 {
  61   ARG_0,
  62   ARG_DEVICE,
  63   ARG_FREQUENCY
  64 };
  65
  66 static gboolean
  67 gst_v4l2radio_fill_channel_list (GstV4l2Radio * radio)
  68 {
  69   int res;
  70   struct v4l2_tuner vtun;
  71   struct v4l2_capability vc;
  72   GstV4l2TunerChannel *v4l2channel;
  73   GstTunerChannel *channel;
  74
  75   GstElement *e;
  76
  77   GstV4l2Object *v4l2object;
  78
  79   e = GST_ELEMENT (radio);
  80   v4l2object = radio->v4l2object;
  81
  82   GST_DEBUG_OBJECT (e, "getting audio enumeration");
  83   GST_V4L2_CHECK_OPEN (v4l2object);
  84
  85   GST_DEBUG_OBJECT (e, "  audio input");
  86
  87   memset (&vc, 0, sizeof (vc));
  88
  89   res = v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP, &vc);
  90   if (res < 0)
  91     goto caps_failed;
  92
  93   if (vc.capabilities & V4L2_CAP_DEVICE_CAPS)
  94     v4l2object->device_caps = vc.device_caps;
  95   else
  96     v4l2object->device_caps = vc.capabilities;
  97
  98   if (!(v4l2object->device_caps & V4L2_CAP_TUNER))
  99     goto not_a_tuner;
 100
 101   /* getting audio input */
 102   memset (&vtun, 0, sizeof (vtun));
 103   vtun.index = 0;
 104
 105   res = v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun);
 106   if (res < 0)
 107     goto tuner_failed;
 108
 109   GST_LOG_OBJECT (e, "   index:     %d", vtun.index);
 110   GST_LOG_OBJECT (e, "   name:      '%s'", vtun.name);
 111   GST_LOG_OBJECT (e, "   type:      %016x", (guint) vtun.type);
 112   GST_LOG_OBJECT (e, "   caps:      %016x", (guint) vtun.capability);
 113   GST_LOG_OBJECT (e, "   rlow:      %016x", (guint) vtun.rangelow);
 114   GST_LOG_OBJECT (e, "   rhigh:     %016x", (guint) vtun.rangehigh);
 115   GST_LOG_OBJECT (e, "   audmode:   %016x", (guint) vtun.audmode);
 116
 117   v4l2channel = g_object_new (GST_TYPE_V4L2_TUNER_CHANNEL, NULL);
 118   channel = GST_TUNER_CHANNEL (v4l2channel);
 119   channel->label = g_strdup ((const gchar *) vtun.name);
 120   channel->flags = GST_TUNER_CHANNEL_FREQUENCY | GST_TUNER_CHANNEL_AUDIO;
 121   v4l2channel->index = 0;
 122   v4l2channel->tuner = 0;
 123
 124   channel->freq_multiplicator =
 125       62.5 * ((vtun.capability & V4L2_TUNER_CAP_LOW) ? 1 : 1000);
 126   channel->min_frequency = vtun.rangelow * channel->freq_multiplicator;
 127   channel->max_frequency = vtun.rangehigh * channel->freq_multiplicator;
 128   channel->min_signal = 0;
 129   channel->max_signal = 0xffff;
 130
 131   v4l2object->channels =
 132       g_list_prepend (v4l2object->channels, (gpointer) channel);
 133
 134   v4l2object->channels = g_list_reverse (v4l2object->channels);
 135
 136   GST_DEBUG_OBJECT (e, "done");
 137   return TRUE;
 138
 139   /* ERRORS */
 140 tuner_failed:
 141   {
 142     GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
 143         (_("Failed to get settings of tuner %d on device '%s'."),
 144             vtun.index, v4l2object->videodev), GST_ERROR_SYSTEM);
 145     return FALSE;
 146   }
 147 caps_failed:
 148   {
 149     GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
 150         (_("Error getting capabilities for device '%s'."),
 151             v4l2object->videodev), GST_ERROR_SYSTEM);
 152     return FALSE;
 153   }
 154 not_a_tuner:
 155   {
 156     GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
 157         (_("Device '%s' is not a tuner."),
 158             v4l2object->videodev), GST_ERROR_SYSTEM);
 159     return FALSE;
 160   }
 161 }
 162
 163 static gboolean
 164 gst_v4l2radio_get_input (GstV4l2Object * v4l2object, gint * input)
 165 {
 166   GST_DEBUG_OBJECT (v4l2object->element, "trying to get radio input");
 167
 168   if (!GST_V4L2_IS_OPEN (v4l2object))
 169     return FALSE;
 170
 171   if (!v4l2object->channels)
 172     goto input_failed;
 173
 174   *input = 0;
 175
 176   GST_DEBUG_OBJECT (v4l2object->element, "input: %d", 0);
 177
 178   return TRUE;
 179
 180   /* ERRORS */
 181 input_failed:
 182   {
 183     GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
 184         (_("Failed to get radio input on device '%s'. "),
 185             v4l2object->videodev), GST_ERROR_SYSTEM);
 186     return FALSE;
 187   }
 188 }
 189
 190 static gboolean
 191 gst_v4l2radio_set_input (GstV4l2Object * v4l2object, gint input)
 192 {
 193   GST_DEBUG_OBJECT (v4l2object->element, "trying to set input to %d", input);
 194
 195   if (!GST_V4L2_IS_OPEN (v4l2object))
 196     return FALSE;
 197
 198   if (!v4l2object->channels)
 199     goto input_failed;
 200
 201   return TRUE;
 202
 203   /* ERRORS */
 204 input_failed:
 205   {
 206     GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
 207         (_("Failed to set input %d on device %s."),
 208             input, v4l2object->videodev), GST_ERROR_SYSTEM);
 209     return FALSE;
 210   }
 211 }
 212
 213 static gboolean
 214 gst_v4l2radio_set_mute_on (GstV4l2Radio * radio, gboolean on)
 215 {
 216   gint res;
 217   struct v4l2_control vctrl;
 218
 219   GST_DEBUG_OBJECT (radio, "setting current tuner mute state: %d", on);
 220
 221   if (!GST_V4L2_IS_OPEN (radio->v4l2object))
 222     return FALSE;
 223
 224   memset (&vctrl, 0, sizeof (vctrl));
 225   vctrl.id = V4L2_CID_AUDIO_MUTE;
 226   vctrl.value = on;
 227
 228   GST_DEBUG_OBJECT (radio, "radio fd: %d", radio->v4l2object->video_fd);
 229
 230   res = ioctl (radio->v4l2object->video_fd, VIDIOC_S_CTRL, &vctrl);
 231   GST_DEBUG_OBJECT (radio, "mute state change result: %d", res);
 232   if (res < 0)
 233     goto freq_failed;
 234
 235   return TRUE;
 236
 237   /* ERRORS */
 238 freq_failed:
 239   {
 240     GST_ELEMENT_WARNING (radio, RESOURCE, SETTINGS,
 241         (_("Failed to change mute state for device '%s'."),
 242             radio->v4l2object->videodev), GST_ERROR_SYSTEM);
 243     return FALSE;
 244   }
 245 }
 246
 247 static gboolean
 248 gst_v4l2radio_set_mute (GstV4l2Radio * radio)
 249 {
 250   return gst_v4l2radio_set_mute_on (radio, TRUE);
 251 }
 252
 253 static gboolean
 254 gst_v4l2radio_set_unmute (GstV4l2Radio * radio)
 255 {
 256   return gst_v4l2radio_set_mute_on (radio, FALSE);
 257 }
 258
 259 GST_IMPLEMENT_V4L2_TUNER_METHODS (GstV4l2Radio, gst_v4l2radio);
 260
 261 static void gst_v4l2radio_uri_handler_init (gpointer g_iface,
 262     gpointer iface_data);
 263
 264 static void
 265 gst_v4l2radio_tuner_interface_reinit (GstTunerInterface * iface)
 266 {
 267   gst_v4l2radio_tuner_interface_init (iface);
 268 }
 269
 270 #define gst_v4l2radio_parent_class parent_class
 271 G_DEFINE_TYPE_WITH_CODE (GstV4l2Radio, gst_v4l2radio, GST_TYPE_ELEMENT,
 272     G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER,
 273         gst_v4l2radio_uri_handler_init);
 274     G_IMPLEMENT_INTERFACE (GST_TYPE_TUNER,
 275         gst_v4l2radio_tuner_interface_reinit));
 276
 277 static void gst_v4l2radio_set_property (GObject * object, guint prop_id,
 278     const GValue * value, GParamSpec * pspec);
 279 static void gst_v4l2radio_get_property (GObject * object, guint prop_id,
 280     GValue * value, GParamSpec * pspec);
 281 static void gst_v4l2radio_finalize (GstV4l2Radio * radio);
 282 static void gst_v4l2radio_dispose (GObject * object);
 283 static GstStateChangeReturn gst_v4l2radio_change_state (GstElement * element,
 284     GstStateChange transition);
 285
 286 static void
 287 gst_v4l2radio_class_init (GstV4l2RadioClass * klass)
 288 {
 289   GObjectClass *gobject_class;
 290   GstElementClass *gstelement_class;
 291
 292   gobject_class = (GObjectClass *) klass;
 293   gstelement_class = (GstElementClass *) klass;
 294
 295   gobject_class->dispose = gst_v4l2radio_dispose;
 296   gobject_class->finalize = (GObjectFinalizeFunc) gst_v4l2radio_finalize;
 297   gobject_class->set_property = gst_v4l2radio_set_property;
 298   gobject_class->get_property = gst_v4l2radio_get_property;
 299
 300   g_object_class_install_property (gobject_class, ARG_DEVICE,
 301       g_param_spec_string ("device", "Radio device location",
 302           "Video4Linux2 radio device location",
 303           DEFAULT_PROP_DEVICE, G_PARAM_READWRITE));
 304
 305   g_object_class_install_property (gobject_class, ARG_FREQUENCY,
 306       g_param_spec_int ("frequency", "Station frequency",
 307           "Station frequency in Hz",
 308           MIN_FREQUENCY, MAX_FREQUENCY, DEFAULT_FREQUENCY, G_PARAM_READWRITE));
 309
 310   gstelement_class->change_state =
 311       GST_DEBUG_FUNCPTR (gst_v4l2radio_change_state);
 312
 313   gst_element_class_set_static_metadata (gstelement_class,
 314       "Radio (video4linux2) Tuner",
 315       "Tuner",
 316       "Controls a Video4Linux2 radio device",
 317       "Alexey Chernov <4ernov@gmail.com>");
 318
 319   klass->v4l2_class_devices = NULL;
 320
 321   GST_DEBUG_CATEGORY_INIT (v4l2radio_debug, "v4l2radio", 0,
 322       "V4l2 radio element");
 323 }
 324
 325 static void
 326 gst_v4l2radio_init (GstV4l2Radio * filter)
 327 {
 328   filter->v4l2object = gst_v4l2_object_new (GST_ELEMENT (filter),
 329       GST_OBJECT (filter), V4L2_BUF_TYPE_VIDEO_CAPTURE, DEFAULT_PROP_DEVICE,
 330       gst_v4l2radio_get_input, gst_v4l2radio_set_input, NULL);
 331
 332   filter->v4l2object->frequency = DEFAULT_FREQUENCY;
 333   g_free (filter->v4l2object->videodev);
 334   filter->v4l2object->videodev = g_strdup (DEFAULT_PROP_DEVICE);
 335 }
 336
 337 static void
 338 gst_v4l2radio_dispose (GObject * object)
 339 {
 340   GstV4l2Radio *radio = GST_V4L2RADIO (object);
 341   gst_v4l2_close (radio->v4l2object);
 342   G_OBJECT_CLASS (parent_class)->dispose (object);
 343 }
 344
 345 static void
 346 gst_v4l2radio_finalize (GstV4l2Radio * radio)
 347 {
 348   gst_v4l2_object_destroy (radio->v4l2object);
 349   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (radio));
 350 }
 351
 352 static gboolean
 353 gst_v4l2radio_open (GstV4l2Radio * radio)
 354 {
 355   GstV4l2Object *v4l2object;
 356
 357   v4l2object = radio->v4l2object;
 358   if (gst_v4l2_open (v4l2object))
 359     return gst_v4l2radio_fill_channel_list (radio);
 360   else
 361     return FALSE;
 362 }
 363
 364 static void
 365 gst_v4l2radio_set_defaults (GstV4l2Radio * radio)
 366 {
 367   GstV4l2Object *v4l2object;
 368   GstTunerChannel *channel = NULL;
 369   GstTuner *tuner;
 370
 371   v4l2object = radio->v4l2object;
 372
 373   if (!GST_IS_TUNER (v4l2object->element))
 374     return;
 375
 376   tuner = GST_TUNER (v4l2object->element);
 377
 378   if (v4l2object->channel)
 379     channel = gst_tuner_find_channel_by_name (tuner, v4l2object->channel);
 380   if (channel) {
 381     gst_tuner_set_channel (tuner, channel);
 382   } else {
 383     channel =
 384         GST_TUNER_CHANNEL (gst_tuner_get_channel (GST_TUNER
 385             (v4l2object->element)));
 386     if (channel) {
 387       g_free (v4l2object->channel);
 388       v4l2object->channel = g_strdup (channel->label);
 389       gst_tuner_channel_changed (tuner, channel);
 390     }
 391   }
 392
 393   if (channel
 394       && GST_TUNER_CHANNEL_HAS_FLAG (channel, GST_TUNER_CHANNEL_FREQUENCY)) {
 395     if (v4l2object->frequency != 0) {
 396       gst_tuner_set_frequency (tuner, channel, v4l2object->frequency);
 397     } else {
 398       v4l2object->frequency = gst_tuner_get_frequency (tuner, channel);
 399       if (v4l2object->frequency == 0) {
 400         /* guess */
 401         gst_tuner_set_frequency (tuner, channel, MIN_FREQUENCY);
 402       } else {
 403       }
 404     }
 405   }
 406 }
 407
 408 static gboolean
 409 gst_v4l2radio_start (GstV4l2Radio * radio)
 410 {
 411   if (!gst_v4l2radio_open (radio))
 412     return FALSE;
 413
 414   gst_v4l2radio_set_defaults (radio);
 415
 416   return TRUE;
 417 }
 418
 419 static gboolean
 420 gst_v4l2radio_stop (GstV4l2Radio * radio)
 421 {
 422   if (!gst_v4l2_object_close (radio->v4l2object))
 423     return FALSE;
 424
 425   return TRUE;
 426 }
 427
 428 static GstStateChangeReturn
 429 gst_v4l2radio_change_state (GstElement * element, GstStateChange transition)
 430 {
 431   GstV4l2Radio *radio;
 432   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 433
 434   radio = GST_V4L2RADIO (element);
 435   switch (transition) {
 436     case GST_STATE_CHANGE_NULL_TO_READY:
 437       /*start radio */
 438       if (!gst_v4l2radio_start (radio))
 439         ret = GST_STATE_CHANGE_FAILURE;
 440       break;
 441     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 442       /*unmute radio */
 443       if (!gst_v4l2radio_set_unmute (radio))
 444         ret = GST_STATE_CHANGE_FAILURE;
 445       break;
 446     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 447       /*mute radio */
 448       if (!gst_v4l2radio_set_mute (radio))
 449         ret = GST_STATE_CHANGE_FAILURE;
 450       break;
 451     case GST_STATE_CHANGE_READY_TO_NULL:
 452       /*stop radio */
 453       if (!gst_v4l2radio_stop (radio))
 454         ret = GST_STATE_CHANGE_FAILURE;
 455       break;
 456     default:
 457       break;
 458   }
 459
 460   return ret;
 461 }
 462
 463 static void
 464 gst_v4l2radio_set_property (GObject * object, guint prop_id,
 465     const GValue * value, GParamSpec * pspec)
 466 {
 467   GstV4l2Radio *radio = GST_V4L2RADIO (object);
 468   gint frequency;
 469   switch (prop_id) {
 470     case ARG_DEVICE:
 471       g_free (radio->v4l2object->videodev);
 472       radio->v4l2object->videodev =
 473           g_strdup ((gchar *) g_value_get_string (value));
 474       break;
 475     case ARG_FREQUENCY:
 476       frequency = g_value_get_int (value);
 477       if (frequency >= MIN_FREQUENCY && frequency <= MAX_FREQUENCY) {
 478         radio->v4l2object->frequency = frequency;
 479         gst_v4l2_set_frequency (radio->v4l2object, 0,
 480             radio->v4l2object->frequency);
 481       }
 482       break;
 483     default:
 484       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 485       break;
 486   }
 487 }
 488
 489 static void
 490 gst_v4l2radio_get_property (GObject * object, guint prop_id,
 491     GValue * value, GParamSpec * pspec)
 492 {
 493   GstV4l2Radio *radio = GST_V4L2RADIO (object);
 494
 495   switch (prop_id) {
 496     case ARG_DEVICE:
 497       g_value_set_string (value, radio->v4l2object->videodev);
 498       break;
 499     case ARG_FREQUENCY:
 500       if (gst_v4l2_get_frequency (radio->v4l2object,
 501               0, &(radio->v4l2object->frequency)))
 502         g_value_set_int (value, radio->v4l2object->frequency);
 503       break;
 504     default:
 505       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 506       break;
 507   }
 508 }
 509
 510 /* GstURIHandler interface */
 511 static GstURIType
 512 gst_v4l2radio_uri_get_type (GType type)
 513 {
 514   return GST_URI_SRC;
 515 }
 516
 517 static const gchar *const *
 518 gst_v4l2radio_uri_get_protocols (GType type)
 519 {
 520   static const gchar *protocols[] = { "radio", NULL };
 521
 522   return protocols;
 523 }
 524
 525 static gchar *
 526 gst_v4l2radio_uri_get_uri (GstURIHandler * handler)
 527 {
 528   GstV4l2Radio *radio = GST_V4L2RADIO (handler);
 529
 530   if (radio->v4l2object->videodev != NULL) {
 531     if (gst_v4l2_get_frequency (radio->v4l2object,
 532             0, &(radio->v4l2object->frequency))) {
 533       return g_strdup_printf ("radio://%4.1f",
 534           radio->v4l2object->frequency / 1e6);
 535     }
 536   }
 537
 538   return g_strdup ("radio://");
 539 }
 540
 541 static gboolean
 542 gst_v4l2radio_uri_set_uri (GstURIHandler * handler, const gchar * uri,
 543     GError ** error)
 544 {
 545   GstV4l2Radio *radio = GST_V4L2RADIO (handler);
 546   gdouble dfreq;
 547   gint ifreq;
 548   const gchar *freq;
 549   gchar *end;
 550
 551   if (strcmp (uri, "radio://") != 0) {
 552     freq = uri + 8;
 553
 554     dfreq = g_ascii_strtod (freq, &end);
 555
 556     if (errno || strlen (end))
 557       goto uri_failed;
 558
 559     ifreq = dfreq * 1e6;
 560     g_object_set (radio, "frequency", ifreq, NULL);
 561
 562   } else
 563     goto uri_failed;
 564
 565   return TRUE;
 566
 567 uri_failed:
 568   g_set_error_literal (error, GST_URI_ERROR, GST_URI_ERROR_BAD_REFERENCE,
 569       "Bad radio URI, could not parse frequency");
 570   return FALSE;
 571 }
 572
 573 static void
 574 gst_v4l2radio_uri_handler_init (gpointer g_iface, gpointer iface_data)
 575 {
 576   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
 577
 578   iface->get_type = gst_v4l2radio_uri_get_type;
 579   iface->get_protocols = gst_v4l2radio_uri_get_protocols;
 580   iface->get_uri = gst_v4l2radio_uri_get_uri;
 581   iface->set_uri = gst_v4l2radio_uri_set_uri;
 582 }