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., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, 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 v4l2radio device=/dev/radio0 frequency=101200000
  32  * gst-launch 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 "gstv4l2tuner.h"
  48 #include "gstv4l2radio.h"
  49 #include "v4l2_calls.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 = v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP, &vc);
  90   if (res < 0)
  91     goto caps_failed;
  92
  93   if (!(vc.capabilities & V4L2_CAP_TUNER))
  94     goto not_a_tuner;
  95
  96   /* getting audio input */
  97   memset (&vtun, 0, sizeof (vtun));
  98   vtun.index = 0;
  99
 100   res = v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun);
 101   if (res < 0)
 102     goto tuner_failed;
 103
 104   GST_LOG_OBJECT (e, "   index:     %d", vtun.index);
 105   GST_LOG_OBJECT (e, "   name:      '%s'", vtun.name);
 106   GST_LOG_OBJECT (e, "   type:      %016x", (guint) vtun.type);
 107   GST_LOG_OBJECT (e, "   caps:      %016x", (guint) vtun.capability);
 108   GST_LOG_OBJECT (e, "   rlow:      %016x", (guint) vtun.rangelow);
 109   GST_LOG_OBJECT (e, "   rhigh:     %016x", (guint) vtun.rangehigh);
 110   GST_LOG_OBJECT (e, "   audmode:   %016x", (guint) vtun.audmode);
 111
 112   v4l2channel = g_object_new (GST_TYPE_V4L2_TUNER_CHANNEL, NULL);
 113   channel = GST_TUNER_CHANNEL (v4l2channel);
 114   channel->label = g_strdup ((const gchar *) vtun.name);
 115   channel->flags = GST_TUNER_CHANNEL_FREQUENCY | GST_TUNER_CHANNEL_AUDIO;
 116   v4l2channel->index = 0;
 117   v4l2channel->tuner = 0;
 118
 119   channel->freq_multiplicator =
 120       62.5 * ((vtun.capability & V4L2_TUNER_CAP_LOW) ? 1 : 1000);
 121   channel->min_frequency = vtun.rangelow * channel->freq_multiplicator;
 122   channel->max_frequency = vtun.rangehigh * channel->freq_multiplicator;
 123   channel->min_signal = 0;
 124   channel->max_signal = 0xffff;
 125
 126   v4l2object->channels =
 127       g_list_prepend (v4l2object->channels, (gpointer) channel);
 128
 129   v4l2object->channels = g_list_reverse (v4l2object->channels);
 130
 131   GST_DEBUG_OBJECT (e, "done");
 132   return TRUE;
 133
 134   /* ERRORS */
 135 tuner_failed:
 136   {
 137     GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
 138         (_("Failed to get settings of tuner %d on device '%s'."),
 139             vtun.index, v4l2object->videodev), GST_ERROR_SYSTEM);
 140     return FALSE;
 141   }
 142 caps_failed:
 143   {
 144     GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
 145         (_("Error getting capabilities for device '%s'."),
 146             v4l2object->videodev), GST_ERROR_SYSTEM);
 147     return FALSE;
 148   }
 149 not_a_tuner:
 150   {
 151     GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
 152         (_("Device '%s' is not a tuner."),
 153             v4l2object->videodev), GST_ERROR_SYSTEM);
 154     return FALSE;
 155   }
 156 }
 157
 158 static gboolean
 159 gst_v4l2radio_get_input (GstV4l2Object * v4l2object, gint * input)
 160 {
 161   GST_DEBUG_OBJECT (v4l2object->element, "trying to get radio input");
 162
 163   if (!GST_V4L2_IS_OPEN (v4l2object))
 164     return FALSE;
 165
 166   if (!v4l2object->channels)
 167     goto input_failed;
 168
 169   *input = 0;
 170
 171   GST_DEBUG_OBJECT (v4l2object->element, "input: %d", 0);
 172
 173   return TRUE;
 174
 175   /* ERRORS */
 176 input_failed:
 177   {
 178     GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
 179         (_("Failed to get radio input on device '%s'. "),
 180             v4l2object->videodev), GST_ERROR_SYSTEM);
 181     return FALSE;
 182   }
 183 }
 184
 185 static gboolean
 186 gst_v4l2radio_set_input (GstV4l2Object * v4l2object, gint input)
 187 {
 188   GST_DEBUG_OBJECT (v4l2object->element, "trying to set input to %d", input);
 189
 190   if (!GST_V4L2_IS_OPEN (v4l2object))
 191     return FALSE;
 192
 193   if (!v4l2object->channels)
 194     goto input_failed;
 195
 196   return TRUE;
 197
 198   /* ERRORS */
 199 input_failed:
 200   {
 201     GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
 202         (_("Failed to set input %d on device %s."),
 203             input, v4l2object->videodev), GST_ERROR_SYSTEM);
 204     return FALSE;
 205   }
 206 }
 207
 208 static gboolean
 209 gst_v4l2radio_set_mute_on (GstV4l2Radio * radio, gboolean on)
 210 {
 211   gint res;
 212   struct v4l2_control vctrl;
 213
 214   GST_DEBUG_OBJECT (radio, "setting current tuner mute state: %d", on);
 215
 216   if (!GST_V4L2_IS_OPEN (radio->v4l2object))
 217     return FALSE;
 218
 219   memset (&vctrl, 0, sizeof (vctrl));
 220   vctrl.id = V4L2_CID_AUDIO_MUTE;
 221   vctrl.value = on;
 222
 223   GST_DEBUG_OBJECT (radio, "radio fd: %d", radio->v4l2object->video_fd);
 224
 225   res = ioctl (radio->v4l2object->video_fd, VIDIOC_S_CTRL, &vctrl);
 226   GST_DEBUG_OBJECT (radio, "mute state change result: %d", res);
 227   if (res < 0)
 228     goto freq_failed;
 229
 230   return TRUE;
 231
 232   /* ERRORS */
 233 freq_failed:
 234   {
 235     GST_ELEMENT_WARNING (radio, RESOURCE, SETTINGS,
 236         (_("Failed to change mute state for device '%s'."),
 237             radio->v4l2object->videodev), GST_ERROR_SYSTEM);
 238     return FALSE;
 239   }
 240 }
 241
 242 static gboolean
 243 gst_v4l2radio_set_mute (GstV4l2Radio * radio)
 244 {
 245   return gst_v4l2radio_set_mute_on (radio, TRUE);
 246 }
 247
 248 static gboolean
 249 gst_v4l2radio_set_unmute (GstV4l2Radio * radio)
 250 {
 251   return gst_v4l2radio_set_mute_on (radio, FALSE);
 252 }
 253
 254 GST_IMPLEMENT_V4L2_TUNER_METHODS (GstV4l2Radio, gst_v4l2radio);
 255
 256 static void gst_v4l2radio_uri_handler_init (gpointer g_iface,
 257     gpointer iface_data);
 258
 259 static void
 260 gst_v4l2radio_tuner_interface_reinit (GstTunerInterface * iface)
 261 {
 262   gst_v4l2radio_tuner_interface_init (iface);
 263 }
 264
 265 #define gst_v4l2radio_parent_class parent_class
 266 G_DEFINE_TYPE_WITH_CODE (GstV4l2Radio, gst_v4l2radio, GST_TYPE_ELEMENT,
 267     G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER,
 268         gst_v4l2radio_uri_handler_init);
 269     G_IMPLEMENT_INTERFACE (GST_TYPE_TUNER,
 270         gst_v4l2radio_tuner_interface_reinit));
 271
 272 static void gst_v4l2radio_set_property (GObject * object, guint prop_id,
 273     const GValue * value, GParamSpec * pspec);
 274 static void gst_v4l2radio_get_property (GObject * object, guint prop_id,
 275     GValue * value, GParamSpec * pspec);
 276 static void gst_v4l2radio_finalize (GstV4l2Radio * radio);
 277 static void gst_v4l2radio_dispose (GObject * object);
 278 static GstStateChangeReturn gst_v4l2radio_change_state (GstElement * element,
 279     GstStateChange transition);
 280
 281 static void
 282 gst_v4l2radio_class_init (GstV4l2RadioClass * klass)
 283 {
 284   GObjectClass *gobject_class;
 285   GstElementClass *gstelement_class;
 286
 287   gobject_class = (GObjectClass *) klass;
 288   gstelement_class = (GstElementClass *) klass;
 289
 290   gobject_class->dispose = gst_v4l2radio_dispose;
 291   gobject_class->finalize = (GObjectFinalizeFunc) gst_v4l2radio_finalize;
 292   gobject_class->set_property = gst_v4l2radio_set_property;
 293   gobject_class->get_property = gst_v4l2radio_get_property;
 294
 295   g_object_class_install_property (gobject_class, ARG_DEVICE,
 296       g_param_spec_string ("device", "Radio device location",
 297           "Video4Linux2 radio device location",
 298           DEFAULT_PROP_DEVICE, G_PARAM_READWRITE));
 299
 300   g_object_class_install_property (gobject_class, ARG_FREQUENCY,
 301       g_param_spec_int ("frequency", "Station frequency",
 302           "Station frequency in Hz",
 303           MIN_FREQUENCY, MAX_FREQUENCY, DEFAULT_FREQUENCY, G_PARAM_READWRITE));
 304
 305   gstelement_class->change_state =
 306       GST_DEBUG_FUNCPTR (gst_v4l2radio_change_state);
 307
 308   gst_element_class_set_details_simple (gstelement_class,
 309       "Radio (video4linux2) Tuner",
 310       "Tuner",
 311       "Controls a Video4Linux2 radio device",
 312       "Alexey Chernov <4ernov@gmail.com>");
 313
 314   klass->v4l2_class_devices = NULL;
 315
 316   GST_DEBUG_CATEGORY_INIT (v4l2radio_debug, "v4l2radio", 0,
 317       "V4l2 radio element");
 318 }
 319
 320 static void
 321 gst_v4l2radio_init (GstV4l2Radio * filter)
 322 {
 323   filter->v4l2object = gst_v4l2_object_new (GST_ELEMENT (filter),
 324       V4L2_BUF_TYPE_VIDEO_CAPTURE, DEFAULT_PROP_DEVICE,
 325       gst_v4l2radio_get_input, gst_v4l2radio_set_input, NULL);
 326
 327   filter->v4l2object->frequency = DEFAULT_FREQUENCY;
 328   g_free (filter->v4l2object->videodev);
 329   filter->v4l2object->videodev = g_strdup (DEFAULT_PROP_DEVICE);
 330 }
 331
 332 static void
 333 gst_v4l2radio_dispose (GObject * object)
 334 {
 335   GstV4l2Radio *radio = GST_V4L2RADIO (object);
 336   gst_v4l2_close (radio->v4l2object);
 337   G_OBJECT_CLASS (parent_class)->dispose (object);
 338 }
 339
 340 static void
 341 gst_v4l2radio_finalize (GstV4l2Radio * radio)
 342 {
 343   gst_v4l2_object_destroy (radio->v4l2object);
 344   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (radio));
 345 }
 346
 347 static gboolean
 348 gst_v4l2radio_open (GstV4l2Radio * radio)
 349 {
 350   GstV4l2Object *v4l2object;
 351
 352   v4l2object = radio->v4l2object;
 353   if (gst_v4l2_open (v4l2object))
 354     return gst_v4l2radio_fill_channel_list (radio);
 355   else
 356     return FALSE;
 357 }
 358
 359 static void
 360 gst_v4l2radio_set_defaults (GstV4l2Radio * radio)
 361 {
 362   GstV4l2Object *v4l2object;
 363   GstTunerChannel *channel = NULL;
 364   GstTuner *tuner;
 365
 366   v4l2object = radio->v4l2object;
 367
 368   if (!GST_IS_TUNER (v4l2object->element))
 369     return;
 370
 371   tuner = GST_TUNER (v4l2object->element);
 372
 373   if (v4l2object->channel)
 374     channel = gst_tuner_find_channel_by_name (tuner, v4l2object->channel);
 375   if (channel) {
 376     gst_tuner_set_channel (tuner, channel);
 377   } else {
 378     channel =
 379         GST_TUNER_CHANNEL (gst_tuner_get_channel (GST_TUNER
 380             (v4l2object->element)));
 381     if (channel) {
 382       g_free (v4l2object->channel);
 383       v4l2object->channel = g_strdup (channel->label);
 384       gst_tuner_channel_changed (tuner, channel);
 385     }
 386   }
 387
 388   if (channel
 389       && GST_TUNER_CHANNEL_HAS_FLAG (channel, GST_TUNER_CHANNEL_FREQUENCY)) {
 390     if (v4l2object->frequency != 0) {
 391       gst_tuner_set_frequency (tuner, channel, v4l2object->frequency);
 392     } else {
 393       v4l2object->frequency = gst_tuner_get_frequency (tuner, channel);
 394       if (v4l2object->frequency == 0) {
 395         /* guess */
 396         gst_tuner_set_frequency (tuner, channel, MIN_FREQUENCY);
 397       } else {
 398       }
 399     }
 400   }
 401 }
 402
 403 static gboolean
 404 gst_v4l2radio_start (GstV4l2Radio * radio)
 405 {
 406   if (!gst_v4l2radio_open (radio))
 407     return FALSE;
 408
 409   gst_v4l2radio_set_defaults (radio);
 410
 411   return TRUE;
 412 }
 413
 414 static gboolean
 415 gst_v4l2radio_stop (GstV4l2Radio * radio)
 416 {
 417   if (!gst_v4l2_object_close (radio->v4l2object))
 418     return FALSE;
 419
 420   return TRUE;
 421 }
 422
 423 static GstStateChangeReturn
 424 gst_v4l2radio_change_state (GstElement * element, GstStateChange transition)
 425 {
 426   GstV4l2Radio *radio;
 427   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 428
 429   radio = GST_V4L2RADIO (element);
 430   switch (transition) {
 431     case GST_STATE_CHANGE_NULL_TO_READY:
 432       /*start radio */
 433       if (!gst_v4l2radio_start (radio))
 434         ret = GST_STATE_CHANGE_FAILURE;
 435       break;
 436     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 437       /*unmute radio */
 438       if (!gst_v4l2radio_set_unmute (radio))
 439         ret = GST_STATE_CHANGE_FAILURE;
 440       break;
 441     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 442       /*mute radio */
 443       if (!gst_v4l2radio_set_mute (radio))
 444         ret = GST_STATE_CHANGE_FAILURE;
 445       break;
 446     case GST_STATE_CHANGE_READY_TO_NULL:
 447       /*stop radio */
 448       if (!gst_v4l2radio_stop (radio))
 449         ret = GST_STATE_CHANGE_FAILURE;
 450       break;
 451     default:
 452       break;
 453   }
 454
 455   return ret;
 456 }
 457
 458 static void
 459 gst_v4l2radio_set_property (GObject * object, guint prop_id,
 460     const GValue * value, GParamSpec * pspec)
 461 {
 462   GstV4l2Radio *radio = GST_V4L2RADIO (object);
 463   gint frequency;
 464   switch (prop_id) {
 465     case ARG_DEVICE:
 466       g_free (radio->v4l2object->videodev);
 467       radio->v4l2object->videodev =
 468           g_strdup ((gchar *) g_value_get_string (value));
 469       break;
 470     case ARG_FREQUENCY:
 471       frequency = g_value_get_int (value);
 472       if (frequency >= MIN_FREQUENCY && frequency <= MAX_FREQUENCY) {
 473         radio->v4l2object->frequency = frequency;
 474         gst_v4l2_set_frequency (radio->v4l2object, 0,
 475             radio->v4l2object->frequency);
 476       }
 477       break;
 478     default:
 479       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 480       break;
 481   }
 482 }
 483
 484 static void
 485 gst_v4l2radio_get_property (GObject * object, guint prop_id,
 486     GValue * value, GParamSpec * pspec)
 487 {
 488   GstV4l2Radio *radio = GST_V4L2RADIO (object);
 489
 490   switch (prop_id) {
 491     case ARG_DEVICE:
 492       g_value_set_string (value, radio->v4l2object->videodev);
 493       break;
 494     case ARG_FREQUENCY:
 495       if (gst_v4l2_get_frequency (radio->v4l2object,
 496               0, &(radio->v4l2object->frequency)))
 497         g_value_set_int (value, radio->v4l2object->frequency);
 498       break;
 499     default:
 500       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 501       break;
 502   }
 503 }
 504
 505 /* GstURIHandler interface */
 506 static GstURIType
 507 gst_v4l2radio_uri_get_type (GType type)
 508 {
 509   return GST_URI_SRC;
 510 }
 511
 512 static const gchar *const *
 513 gst_v4l2radio_uri_get_protocols (GType type)
 514 {
 515   static const gchar *protocols[] = { "radio", NULL };
 516
 517   return protocols;
 518 }
 519
 520 static gchar *
 521 gst_v4l2radio_uri_get_uri (GstURIHandler * handler)
 522 {
 523   GstV4l2Radio *radio = GST_V4L2RADIO (handler);
 524
 525   if (radio->v4l2object->videodev != NULL) {
 526     if (gst_v4l2_get_frequency (radio->v4l2object,
 527             0, &(radio->v4l2object->frequency))) {
 528       return g_strdup_printf ("radio://%4.1f",
 529           radio->v4l2object->frequency / 1e6);
 530     }
 531   }
 532
 533   return g_strdup ("radio://");
 534 }
 535
 536 static gboolean
 537 gst_v4l2radio_uri_set_uri (GstURIHandler * handler, const gchar * uri,
 538     GError ** error)
 539 {
 540   GstV4l2Radio *radio = GST_V4L2RADIO (handler);
 541   gdouble dfreq;
 542   gint ifreq;
 543   const gchar *freq;
 544   gchar *end;
 545
 546   if (strcmp (uri, "radio://") != 0) {
 547     freq = uri + 8;
 548
 549     dfreq = g_ascii_strtod (freq, &end);
 550
 551     if (errno || strlen (end))
 552       goto uri_failed;
 553
 554     ifreq = dfreq * 1e6;
 555     g_object_set (radio, "frequency", ifreq, NULL);
 556
 557   } else
 558     goto uri_failed;
 559
 560   return TRUE;
 561
 562 uri_failed:
 563   g_set_error_literal (error, GST_URI_ERROR, GST_URI_ERROR_BAD_REFERENCE,
 564       "Bad radio URI, could not parse frequency");
 565   return FALSE;
 566 }
 567
 568 static void
 569 gst_v4l2radio_uri_handler_init (gpointer g_iface, gpointer iface_data)
 570 {
 571   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
 572
 573   iface->get_type = gst_v4l2radio_uri_get_type;
 574   iface->get_protocols = gst_v4l2radio_uri_get_protocols;
 575   iface->get_uri = gst_v4l2radio_uri_get_uri;
 576   iface->set_uri = gst_v4l2radio_uri_set_uri;
 577 }