sys/oss/gstosshelper.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wim.taymans@chello.be>
   4  *
   5  * gstosshelper.c: OSS helper routines
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "gst/gst-i18n-plugin.h"
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/ioctl.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34 #include <string.h>
  35
  36 #ifdef HAVE_OSS_INCLUDE_IN_SYS
  37 # include <sys/soundcard.h>
  38 #else
  39 # ifdef HAVE_OSS_INCLUDE_IN_ROOT
  40 #  include <soundcard.h>
  41 # else
  42 #  ifdef HAVE_OSS_INCLUDE_IN_MACHINE
  43 #   include <machine/soundcard.h>
  44 #  else
  45 #   error "What to include?"
  46 #  endif /* HAVE_OSS_INCLUDE_IN_MACHINE */
  47 # endif /* HAVE_OSS_INCLUDE_IN_ROOT */
  48 #endif /* HAVE_OSS_INCLUDE_IN_SYS */
  49
  50 #include <gst/interfaces/propertyprobe.h>
  51
  52 #include "gstosshelper.h"
  53 #include "gstossmixer.h"
  54
  55 GST_DEBUG_CATEGORY_EXTERN (oss_debug);
  56 #define GST_CAT_DEFAULT oss_debug
  57
  58 typedef struct _GstOssProbe GstOssProbe;
  59 struct _GstOssProbe
  60 {
  61   int fd;
  62   int format;
  63   int n_channels;
  64   GArray *rates;
  65   int min;
  66   int max;
  67 };
  68
  69 typedef struct _GstOssRange GstOssRange;
  70 struct _GstOssRange
  71 {
  72   int min;
  73   int max;
  74 };
  75
  76 static GstStructure *gst_oss_helper_get_format_structure (unsigned int
  77     format_bit);
  78 static gboolean gst_oss_helper_rate_probe_check (GstOssProbe * probe);
  79 static int gst_oss_helper_rate_check_rate (GstOssProbe * probe, int irate);
  80 static void gst_oss_helper_rate_add_range (GQueue * queue, int min, int max);
  81 static void gst_oss_helper_rate_add_rate (GArray * array, int rate);
  82 static int gst_oss_helper_rate_int_compare (gconstpointer a, gconstpointer b);
  83
  84 GstCaps *
  85 gst_oss_helper_probe_caps (gint fd)
  86 {
  87   GstOssProbe *probe;
  88   int i;
  89   gboolean ret;
  90   GstStructure *structure;
  91   unsigned int format_bit;
  92   unsigned int format_mask;
  93   GstCaps *caps;
  94
  95   /* FIXME test make sure we're not currently playing */
  96   /* FIXME test both mono and stereo */
  97
  98   format_mask = AFMT_U8 | AFMT_S8;
  99
 100   if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
 101     format_mask |= AFMT_S16_LE | AFMT_U16_LE;
 102   else
 103     format_mask |= AFMT_S16_BE | AFMT_U16_BE;
 104
 105   caps = gst_caps_new_empty ();
 106
 107   /* assume that the most significant bit of format_mask is 0 */
 108   for (format_bit = 1 << 31; format_bit > 0; format_bit >>= 1) {
 109     if (format_bit & format_mask) {
 110       GValue rate_value = { 0 };
 111
 112       probe = g_new0 (GstOssProbe, 1);
 113       probe->fd = fd;
 114       probe->format = format_bit;
 115       probe->n_channels = 2;
 116
 117       ret = gst_oss_helper_rate_probe_check (probe);
 118       if (probe->min == -1 || probe->max == -1) {
 119         g_array_free (probe->rates, TRUE);
 120         g_free (probe);
 121         continue;
 122       }
 123
 124       if (ret) {
 125         GValue value = { 0 };
 126
 127         g_array_sort (probe->rates, gst_oss_helper_rate_int_compare);
 128
 129         g_value_init (&rate_value, GST_TYPE_LIST);
 130         g_value_init (&value, G_TYPE_INT);
 131
 132         for (i = 0; i < probe->rates->len; i++) {
 133           g_value_set_int (&value, g_array_index (probe->rates, int, i));
 134
 135           gst_value_list_append_value (&rate_value, &value);
 136         }
 137
 138         g_value_unset (&value);
 139       } else {
 140         /* one big range */
 141         g_value_init (&rate_value, GST_TYPE_INT_RANGE);
 142         gst_value_set_int_range (&rate_value, probe->min, probe->max);
 143       }
 144
 145       g_array_free (probe->rates, TRUE);
 146       g_free (probe);
 147
 148       structure = gst_oss_helper_get_format_structure (format_bit);
 149       gst_structure_set (structure, "channels", GST_TYPE_INT_RANGE, 1, 2, NULL);
 150       gst_structure_set_value (structure, "rate", &rate_value);
 151       g_value_unset (&rate_value);
 152
 153       gst_caps_append_structure (caps, structure);
 154     }
 155   }
 156
 157   if (gst_caps_is_empty (caps)) {
 158     /* fixme: make user-visible */
 159     GST_WARNING ("Your OSS device could not be probed correctly");
 160   }
 161
 162   GST_DEBUG ("probed caps: %" GST_PTR_FORMAT, caps);
 163
 164   return caps;
 165 }
 166
 167 static GstStructure *
 168 gst_oss_helper_get_format_structure (unsigned int format_bit)
 169 {
 170   GstStructure *structure;
 171   int endianness;
 172   gboolean sign;
 173   int width;
 174
 175   switch (format_bit) {
 176     case AFMT_U8:
 177       endianness = 0;
 178       sign = FALSE;
 179       width = 8;
 180       break;
 181     case AFMT_S16_LE:
 182       endianness = G_LITTLE_ENDIAN;
 183       sign = TRUE;
 184       width = 16;
 185       break;
 186     case AFMT_S16_BE:
 187       endianness = G_BIG_ENDIAN;
 188       sign = TRUE;
 189       width = 16;
 190       break;
 191     case AFMT_S8:
 192       endianness = 0;
 193       sign = TRUE;
 194       width = 8;
 195       break;
 196     case AFMT_U16_LE:
 197       endianness = G_LITTLE_ENDIAN;
 198       sign = FALSE;
 199       width = 16;
 200       break;
 201     case AFMT_U16_BE:
 202       endianness = G_BIG_ENDIAN;
 203       sign = FALSE;
 204       width = 16;
 205       break;
 206     default:
 207       g_assert_not_reached ();
 208       return NULL;
 209   }
 210
 211   structure = gst_structure_new ("audio/x-raw-int",
 212       "width", G_TYPE_INT, width,
 213       "depth", G_TYPE_INT, width, "signed", G_TYPE_BOOLEAN, sign, NULL);
 214
 215   if (endianness) {
 216     gst_structure_set (structure, "endianness", G_TYPE_INT, endianness, NULL);
 217   }
 218
 219   return structure;
 220 }
 221
 222 static gboolean
 223 gst_oss_helper_rate_probe_check (GstOssProbe * probe)
 224 {
 225   GstOssRange *range;
 226   GQueue *ranges;
 227   int exact_rates = 0;
 228   gboolean checking_exact_rates = TRUE;
 229   int n_checks = 0;
 230   gboolean result = TRUE;
 231
 232   ranges = g_queue_new ();
 233
 234   probe->rates = g_array_new (FALSE, FALSE, sizeof (int));
 235
 236   probe->min = gst_oss_helper_rate_check_rate (probe, 1000);
 237   n_checks++;
 238   probe->max = gst_oss_helper_rate_check_rate (probe, 100000);
 239   /* a little bug workaround */
 240   {
 241     int max;
 242
 243     max = gst_oss_helper_rate_check_rate (probe, 48000);
 244     if (max > probe->max) {
 245       GST_ERROR
 246           ("Driver bug recognized (driver does not round rates correctly).  Please file a bug report.");
 247       probe->max = max;
 248     }
 249   }
 250   n_checks++;
 251   if (probe->min == -1 || probe->max == -1) {
 252     /* This is a workaround for drivers that return -EINVAL (or another
 253      * error) for rates outside of [8000,48000].  If this fails, the
 254      * driver is seriously buggy, and probably doesn't work with other
 255      * media libraries/apps.  */
 256     probe->min = gst_oss_helper_rate_check_rate (probe, 8000);
 257     probe->max = gst_oss_helper_rate_check_rate (probe, 48000);
 258   }
 259   if (probe->min == -1 || probe->max == -1) {
 260     GST_DEBUG ("unexpected check_rate error");
 261     return FALSE;
 262   }
 263   gst_oss_helper_rate_add_range (ranges, probe->min + 1, probe->max - 1);
 264
 265   while ((range = g_queue_pop_head (ranges))) {
 266     int min1;
 267     int max1;
 268     int mid;
 269     int mid_ret;
 270
 271     GST_DEBUG ("checking [%d,%d]", range->min, range->max);
 272
 273     mid = (range->min + range->max) / 2;
 274     mid_ret = gst_oss_helper_rate_check_rate (probe, mid);
 275     if (mid_ret == -1) {
 276       /* FIXME ioctl returned an error.  do something */
 277       GST_DEBUG ("unexpected check_rate error");
 278     }
 279     n_checks++;
 280
 281     if (mid == mid_ret && checking_exact_rates) {
 282       int max_exact_matches = 20;
 283
 284       exact_rates++;
 285       if (exact_rates > max_exact_matches) {
 286         GST_DEBUG ("got %d exact rates, assuming all are exact",
 287             max_exact_matches);
 288         result = FALSE;
 289         g_free (range);
 290         break;
 291       }
 292     } else {
 293       checking_exact_rates = FALSE;
 294     }
 295
 296     /* Assume that the rate is arithmetically rounded to the nearest
 297      * supported rate. */
 298     if (mid == mid_ret) {
 299       min1 = mid - 1;
 300       max1 = mid + 1;
 301     } else {
 302       if (mid < mid_ret) {
 303         min1 = mid - (mid_ret - mid);
 304         max1 = mid_ret + 1;
 305       } else {
 306         min1 = mid_ret - 1;
 307         max1 = mid + (mid - mid_ret);
 308       }
 309     }
 310
 311     gst_oss_helper_rate_add_range (ranges, range->min, min1);
 312     gst_oss_helper_rate_add_range (ranges, max1, range->max);
 313
 314     g_free (range);
 315   }
 316
 317   while ((range = g_queue_pop_head (ranges))) {
 318     g_free (range);
 319   }
 320   g_queue_free (ranges);
 321
 322   return result;
 323 }
 324
 325 static void
 326 gst_oss_helper_rate_add_range (GQueue * queue, int min, int max)
 327 {
 328   if (min <= max) {
 329     GstOssRange *range = g_new0 (GstOssRange, 1);
 330
 331     range->min = min;
 332     range->max = max;
 333
 334     g_queue_push_tail (queue, range);
 335     /* push_head also works, but has different probing behavior */
 336     /*g_queue_push_head (queue, range); */
 337   }
 338 }
 339
 340 static int
 341 gst_oss_helper_rate_check_rate (GstOssProbe * probe, int irate)
 342 {
 343   int rate;
 344   int format;
 345   int n_channels;
 346   int ret;
 347
 348   rate = irate;
 349   format = probe->format;
 350   n_channels = probe->n_channels;
 351
 352   GST_LOG ("checking format %d, channels %d, rate %d",
 353       format, n_channels, rate);
 354   ret = ioctl (probe->fd, SNDCTL_DSP_SETFMT, &format);
 355   if (ret < 0 || format != probe->format) {
 356     GST_DEBUG ("unsupported format: %d (%d)", probe->format, format);
 357     return -1;
 358   }
 359   ret = ioctl (probe->fd, SNDCTL_DSP_CHANNELS, &n_channels);
 360   if (ret < 0 || n_channels != probe->n_channels) {
 361     GST_DEBUG ("unsupported channels: %d (%d)", probe->n_channels, n_channels);
 362     return -1;
 363   }
 364   ret = ioctl (probe->fd, SNDCTL_DSP_SPEED, &rate);
 365   if (ret < 0) {
 366     GST_DEBUG ("unsupported rate: %d (%d)", irate, rate);
 367     return -1;
 368   }
 369
 370   GST_DEBUG ("rate %d -> %d", irate, rate);
 371
 372   if (rate == irate - 1 || rate == irate + 1) {
 373     rate = irate;
 374   }
 375   gst_oss_helper_rate_add_rate (probe->rates, rate);
 376   return rate;
 377 }
 378
 379 static void
 380 gst_oss_helper_rate_add_rate (GArray * array, int rate)
 381 {
 382   int i;
 383   int val;
 384
 385   for (i = 0; i < array->len; i++) {
 386     val = g_array_index (array, int, i);
 387
 388     if (val == rate)
 389       return;
 390   }
 391   GST_DEBUG ("supported rate: %d", rate);
 392   g_array_append_val (array, rate);
 393 }
 394
 395 static int
 396 gst_oss_helper_rate_int_compare (gconstpointer a, gconstpointer b)
 397 {
 398   const int *va = (const int *) a;
 399   const int *vb = (const int *) b;
 400
 401   if (*va < *vb)
 402     return -1;
 403   if (*va > *vb)
 404     return 1;
 405   return 0;
 406 }