xbmc/cores/AudioEngine/Sinks/AESinkOSS.cpp

   1 /*
   2  *  Copyright (C) 2010-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "AESinkOSS.h"
  10 #include <stdint.h>
  11 #include <limits.h>
  12 #include <unistd.h>
  13
  14 #include "cores/AudioEngine/AESinkFactory.h"
  15 #include "cores/AudioEngine/Utils/AEUtil.h"
  16 #include "utils/log.h"
  17 #include "threads/SingleLock.h"
  18 #include <sstream>
  19
  20 #include <sys/ioctl.h>
  21 #include <sys/fcntl.h>
  22
  23 #if defined(OSS4) || defined(TARGET_FREEBSD)
  24   #include <sys/soundcard.h>
  25 #else
  26   #include <linux/soundcard.h>
  27 #endif
  28
  29 #define OSS_FRAMES 256
  30
  31 static enum AEChannel OSSChannelMap[9] =
  32   {AE_CH_FL, AE_CH_FR, AE_CH_BL, AE_CH_BR, AE_CH_FC, AE_CH_LFE, AE_CH_SL, AE_CH_SR, AE_CH_NULL};
  33
  34 #if defined(SNDCTL_SYSINFO) && defined(SNDCTL_CARDINFO)
  35 static int OSSSampleRateList[] =
  36 {
  37   5512,
  38   8000,
  39   11025,
  40   16000,
  41   22050,
  42   32000,
  43   44100,
  44   48000,
  45   64000,
  46   88200,
  47   96000,
  48   176400,
  49   192000,
  50   384000,
  51   0
  52 };
  53 #endif
  54
  55 CAESinkOSS::CAESinkOSS()
  56 {
  57   m_fd = 0;
  58 }
  59
  60 CAESinkOSS::~CAESinkOSS()
  61 {
  62   Deinitialize();
  63 }
  64
  65 void CAESinkOSS::Register()
  66 {
  67   AE::AESinkRegEntry entry;
  68   entry.sinkName = "OSS";
  69   entry.createFunc = CAESinkOSS::Create;
  70   entry.enumerateFunc = CAESinkOSS::EnumerateDevicesEx;
  71   AE::CAESinkFactory::RegisterSink(entry);
  72 }
  73
  74 std::unique_ptr<IAESink> CAESinkOSS::Create(std::string& device, AEAudioFormat& desiredFormat)
  75 {
  76   auto sink = std::make_unique<CAESinkOSS>();
  77   if (sink->Initialize(desiredFormat, device))
  78     return sink;
  79
  80   return {};
  81 }
  82
  83 std::string CAESinkOSS::GetDeviceUse(const AEAudioFormat& format, const std::string &device)
  84 {
  85 #ifdef OSS4
  86   if (AE_IS_RAW(format.m_dataFormat))
  87   {
  88     if (device.find_first_of('/') != 0)
  89       return "/dev/dsp_ac3";
  90     return device;
  91   }
  92
  93   if (device.find_first_of('/') != 0)
  94     return "/dev/dsp_multich";
  95 #else
  96   if (device.find_first_of('/') != 0)
  97     return "/dev/dsp";
  98 #endif
  99
 100   return device;
 101 }
 102
 103 bool CAESinkOSS::Initialize(AEAudioFormat &format, std::string &device)
 104 {
 105   m_initFormat = format;
 106   format.m_channelLayout = GetChannelLayout(format);
 107   device = GetDeviceUse(format, device);
 108
 109 #ifdef __linux__
 110   /* try to open in exclusive mode first (no software mixing) */
 111   m_fd = open(device.c_str(), O_WRONLY | O_EXCL, 0);
 112   if (m_fd == -1)
 113 #endif
 114     m_fd = open(device.c_str(), O_WRONLY, 0);
 115   if (m_fd == -1)
 116   {
 117     CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to open the audio device: {}", device);
 118     return false;
 119   }
 120
 121   int format_mask;
 122   if (ioctl(m_fd, SNDCTL_DSP_GETFMTS, &format_mask) == -1)
 123   {
 124     close(m_fd);
 125     CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to get supported formats, assuming AFMT_S16_NE");
 126     return false;
 127   }
 128
 129 #ifdef OSS4
 130   bool useCooked = true;
 131 #endif
 132
 133   int oss_fmt = 0;
 134 #ifdef AFMT_FLOAT
 135   if ((format.m_dataFormat == AE_FMT_FLOAT) && (format_mask & AFMT_FLOAT ))
 136     oss_fmt = AFMT_FLOAT;
 137   else
 138 #endif
 139 #ifdef AFMT_S32_NE
 140   if ((format.m_dataFormat == AE_FMT_S32NE) && (format_mask & AFMT_S32_NE))
 141     oss_fmt = AFMT_S32_NE;
 142   else if ((format.m_dataFormat == AE_FMT_S32BE) && (format_mask & AFMT_S32_BE))
 143     oss_fmt = AFMT_S32_BE;
 144   else if ((format.m_dataFormat == AE_FMT_S32LE) && (format_mask & AFMT_S32_LE))
 145     oss_fmt = AFMT_S32_LE;
 146   else
 147 #endif
 148   if ((format.m_dataFormat == AE_FMT_S16NE) && (format_mask & AFMT_S16_NE))
 149     oss_fmt = AFMT_S16_NE;
 150   else if ((format.m_dataFormat == AE_FMT_S16BE) && (format_mask & AFMT_S16_BE))
 151     oss_fmt = AFMT_S16_BE;
 152   else if ((format.m_dataFormat == AE_FMT_S16LE) && (format_mask & AFMT_S16_LE))
 153     oss_fmt = AFMT_S16_LE;
 154   else if ((format.m_dataFormat == AE_FMT_U8   ) && (format_mask & AFMT_U8    ))
 155     oss_fmt = AFMT_U8;
 156   else if (((format.m_dataFormat == AE_FMT_RAW)     ) && (format_mask & AFMT_AC3   ))
 157   {
 158     oss_fmt = AFMT_AC3;
 159     format.m_dataFormat = AE_FMT_S16NE;
 160   }
 161   else if (format.m_dataFormat == AE_FMT_RAW)
 162   {
 163     close(m_fd);
 164     CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to find a suitable RAW output format");
 165     return false;
 166   }
 167   else
 168   {
 169     CLog::Log(LOGINFO,
 170               "CAESinkOSS::Initialize - Your hardware does not support {}, trying other formats",
 171               CAEUtil::DataFormatToStr(format.m_dataFormat));
 172
 173     /* fallback to the best supported format */
 174 #ifdef AFMT_FLOAT
 175     if (format_mask & AFMT_FLOAT )
 176     {
 177       oss_fmt = AFMT_FLOAT;
 178       format.m_dataFormat = AE_FMT_FLOAT;
 179     }
 180     else
 181 #endif
 182 #ifdef AFMT_S32_NE
 183     if (format_mask & AFMT_S32_NE)
 184     {
 185       oss_fmt = AFMT_S32_NE;
 186       format.m_dataFormat = AE_FMT_S32NE;
 187     }
 188     else if (format_mask & AFMT_S32_BE)
 189     {
 190       oss_fmt = AFMT_S32_BE;
 191       format.m_dataFormat = AE_FMT_S32BE;
 192     }
 193     else if (format_mask & AFMT_S32_LE)
 194     {
 195       oss_fmt = AFMT_S32_LE;
 196       format.m_dataFormat = AE_FMT_S32LE;
 197     }
 198     else
 199 #endif
 200     if (format_mask & AFMT_S16_NE)
 201     {
 202       oss_fmt = AFMT_S16_NE;
 203       format.m_dataFormat = AE_FMT_S16NE;
 204     }
 205     else if (format_mask & AFMT_S16_BE)
 206     {
 207       oss_fmt = AFMT_S16_BE;
 208       format.m_dataFormat = AE_FMT_S16BE;
 209     }
 210     else if (format_mask & AFMT_S16_LE)
 211     {
 212       oss_fmt = AFMT_S16_LE;
 213       format.m_dataFormat = AE_FMT_S16LE;
 214     }
 215     else if (format_mask & AFMT_U8    )
 216     {
 217       oss_fmt = AFMT_U8;
 218       format.m_dataFormat = AE_FMT_U8;
 219     }
 220     else
 221     {
 222       CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to find a suitable native output format, will try to use AE_FMT_S16NE anyway");
 223       oss_fmt             = AFMT_S16_NE;
 224       format.m_dataFormat = AE_FMT_S16NE;
 225 #ifdef OSS4
 226       /* dont use cooked if we did not find a native format, OSS might be able to convert */
 227       useCooked           = false;
 228 #endif
 229     }
 230   }
 231
 232 #ifdef OSS4
 233   if (useCooked)
 234   {
 235     int oss_cooked = 1;
 236     if (ioctl(m_fd, SNDCTL_DSP_COOKEDMODE, &oss_cooked) == -1)
 237       CLog::Log(LOGWARNING, "CAESinkOSS::Initialize - Failed to set cooked mode");
 238   }
 239 #endif
 240
 241   if (ioctl(m_fd, SNDCTL_DSP_SETFMT, &oss_fmt) == -1)
 242   {
 243     close(m_fd);
 244     CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to set the data format ({})",
 245               CAEUtil::DataFormatToStr(format.m_dataFormat));
 246     return false;
 247   }
 248
 249   /* find the number we need to open to access the channels we need */
 250   bool found = false;
 251   int oss_ch = 0;
 252   for (int ch = format.m_channelLayout.Count(); ch < 9; ++ch)
 253   {
 254     oss_ch = ch;
 255     if (ioctl(m_fd, SNDCTL_DSP_CHANNELS, &oss_ch) != -1 && oss_ch >= (int)format.m_channelLayout.Count())
 256     {
 257       found = true;
 258       break;
 259     }
 260   }
 261
 262   if (!found)
 263     CLog::Log(LOGWARNING, "CAESinkOSS::Initialize - Failed to access the number of channels required, falling back");
 264
 265 #if defined(TARGET_FREEBSD)
 266   /* fix hdmi 8 channels order */
 267   if ((oss_fmt != AFMT_AC3) && 8 == oss_ch)
 268   {
 269     unsigned long long order = 0x0000000087346521ULL;
 270
 271     if (ioctl(m_fd, SNDCTL_DSP_SET_CHNORDER, &order) == -1)
 272       CLog::Log(LOGWARNING, "CAESinkOSS::Initialize - Failed to set the channel order");
 273   }
 274 #elif defined(OSS4)
 275   unsigned long long order = 0;
 276
 277   for (unsigned int i = 0; i < format.m_channelLayout.Count(); ++i)
 278     switch (format.m_channelLayout[i])
 279     {
 280       case AE_CH_FL : order = (order << 4) | CHID_L  ; break;
 281       case AE_CH_FR : order = (order << 4) | CHID_R  ; break;
 282       case AE_CH_FC : order = (order << 4) | CHID_C  ; break;
 283       case AE_CH_LFE: order = (order << 4) | CHID_LFE; break;
 284       case AE_CH_SL : order = (order << 4) | CHID_LS ; break;
 285       case AE_CH_SR : order = (order << 4) | CHID_RS ; break;
 286       case AE_CH_BL : order = (order << 4) | CHID_LR ; break;
 287       case AE_CH_BR : order = (order << 4) | CHID_RR ; break;
 288
 289       default:
 290         continue;
 291     }
 292
 293   if (ioctl(m_fd, SNDCTL_DSP_SET_CHNORDER, &order) == -1)
 294   {
 295     if (ioctl(m_fd, SNDCTL_DSP_GET_CHNORDER, &order) == -1)
 296     {
 297       CLog::Log(LOGWARNING, "CAESinkOSS::Initialize - Failed to get the channel order, assuming CHNORDER_NORMAL");
 298     }
 299   }
 300 #endif
 301
 302   int tmp = (CAEUtil::DataFormatToBits(format.m_dataFormat) >> 3) * format.m_channelLayout.Count() * OSS_FRAMES;
 303   int pos = 0;
 304   while ((tmp & 0x1) == 0x0)
 305   {
 306     tmp = tmp >> 1;
 307     ++pos;
 308   }
 309
 310   int oss_frag = (4 << 16) | pos;
 311   if (ioctl(m_fd, SNDCTL_DSP_SETFRAGMENT, &oss_frag) == -1)
 312     CLog::Log(LOGWARNING, "CAESinkOSS::Initialize - Failed to set the fragment size");
 313
 314   int oss_sr = format.m_sampleRate;
 315   if (ioctl(m_fd, SNDCTL_DSP_SPEED, &oss_sr) == -1)
 316   {
 317     close(m_fd);
 318     CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to set the sample rate");
 319     return false;
 320   }
 321
 322   audio_buf_info bi;
 323   if (ioctl(m_fd, SNDCTL_DSP_GETOSPACE, &bi) == -1)
 324   {
 325     close(m_fd);
 326     CLog::Log(LOGERROR, "CAESinkOSS::Initialize - Failed to get the output buffer size");
 327     return false;
 328   }
 329
 330   format.m_sampleRate    = oss_sr;
 331   format.m_frameSize     = (CAEUtil::DataFormatToBits(format.m_dataFormat) >> 3) * format.m_channelLayout.Count();
 332   format.m_frames        = bi.fragsize / format.m_frameSize;
 333
 334   m_device = device;
 335   m_format = format;
 336   return true;
 337 }
 338
 339 void CAESinkOSS::Deinitialize()
 340 {
 341   Stop();
 342
 343   if (m_fd != -1)
 344     close(m_fd);
 345 }
 346
 347 inline CAEChannelInfo CAESinkOSS::GetChannelLayout(const AEAudioFormat& format)
 348 {
 349   unsigned int count = 0;
 350
 351   if (format.m_dataFormat == AE_FMT_RAW)
 352   {
 353     switch (format.m_streamInfo.m_type)
 354     {
 355     case CAEStreamInfo::STREAM_TYPE_DTSHD_MA:
 356     case CAEStreamInfo::STREAM_TYPE_TRUEHD:
 357       count = 8;
 358       break;
 359     case CAEStreamInfo::STREAM_TYPE_DTSHD_CORE:
 360     case CAEStreamInfo::STREAM_TYPE_DTS_512:
 361     case CAEStreamInfo::STREAM_TYPE_DTS_1024:
 362     case CAEStreamInfo::STREAM_TYPE_DTS_2048:
 363     case CAEStreamInfo::STREAM_TYPE_AC3:
 364     case CAEStreamInfo::STREAM_TYPE_EAC3:
 365     case CAEStreamInfo::STREAM_TYPE_DTSHD:
 366       count = 2;
 367       break;
 368     default:
 369       count = 0;
 370       break;
 371     }
 372   }
 373   else
 374   {
 375     for (unsigned int c = 0; c < 8; ++c)
 376       for (unsigned int i = 0; i < format.m_channelLayout.Count(); ++i)
 377         if (format.m_channelLayout[i] == OSSChannelMap[c])
 378         {
 379           count = c + 1;
 380           break;
 381         }
 382   }
 383
 384   CAEChannelInfo info;
 385   for (unsigned int i = 0; i < count; ++i)
 386     info += OSSChannelMap[i];
 387
 388   return info;
 389 }
 390
 391 void CAESinkOSS::Stop()
 392 {
 393 #ifdef SNDCTL_DSP_RESET
 394   if (m_fd != -1)
 395     ioctl(m_fd, SNDCTL_DSP_RESET, NULL);
 396 #endif
 397 }
 398
 399 void CAESinkOSS::GetDelay(AEDelayStatus& status)
 400 {
 401   if (m_fd == -1)
 402   {
 403     status.SetDelay(0);
 404     return;
 405   }
 406
 407   int delay;
 408   if (ioctl(m_fd, SNDCTL_DSP_GETODELAY, &delay) == -1)
 409   {
 410     status.SetDelay(0);
 411     return;
 412   }
 413
 414   status.SetDelay((double)delay / (m_format.m_frameSize * m_format.m_sampleRate));
 415 }
 416
 417 unsigned int CAESinkOSS::AddPackets(uint8_t **data, unsigned int frames, unsigned int offset)
 418 {
 419   int size = frames * m_format.m_frameSize;
 420   if (m_fd == -1)
 421   {
 422     CLog::Log(LOGERROR, "CAESinkOSS::AddPackets - Failed to write");
 423     return INT_MAX;
 424   }
 425
 426   void *buffer = data[0]+offset*m_format.m_frameSize;
 427   int wrote = write(m_fd, buffer, size);
 428   if (wrote < 0)
 429   {
 430     CLog::Log(LOGERROR, "CAESinkOSS::AddPackets - Failed to write");
 431     return INT_MAX;
 432   }
 433
 434   return wrote / m_format.m_frameSize;
 435 }
 436
 437 void CAESinkOSS::Drain()
 438 {
 439   if (m_fd == -1)
 440     return;
 441
 442   if(ioctl(m_fd, SNDCTL_DSP_SYNC, NULL) == -1)
 443   {
 444     CLog::Log(LOGERROR, "CAESinkOSS::Drain - Draining the Sink failed");
 445   }
 446 }
 447
 448 void CAESinkOSS::EnumerateDevicesEx(AEDeviceInfoList &list, bool force)
 449 {
 450   int mixerfd;
 451   const char * mixerdev = "/dev/mixer";
 452
 453   if ((mixerfd = open(mixerdev, O_RDWR, 0)) == -1)
 454   {
 455     CLog::Log(LOGINFO, "CAESinkOSS::EnumerateDevicesEx - No OSS mixer device present: {}",
 456               mixerdev);
 457     return;
 458   }
 459
 460 #if defined(SNDCTL_SYSINFO) && defined(SNDCTL_CARDINFO)
 461   oss_sysinfo sysinfo;
 462   if (ioctl(mixerfd, SNDCTL_SYSINFO, &sysinfo) == -1)
 463   {
 464     // hardware not supported
 465         // OSSv4 required ?
 466     close(mixerfd);
 467     return;
 468   }
 469
 470   for (int i = 0; i < sysinfo.numcards; ++i)
 471   {
 472     std::stringstream devicepath;
 473     std::stringstream devicename;
 474     CAEDeviceInfo info;
 475     oss_card_info cardinfo;
 476
 477     devicepath << "/dev/dsp" << i;
 478     info.m_deviceName = devicepath.str();
 479
 480     cardinfo.card = i;
 481     if (ioctl(mixerfd, SNDCTL_CARDINFO, &cardinfo) == -1)
 482       break;
 483
 484     devicename << cardinfo.shortname << " " << cardinfo.longname;
 485     info.m_displayName = devicename.str();
 486
 487     info.m_dataFormats.push_back(AE_FMT_S16NE);
 488     info.m_dataFormats.push_back(AE_FMT_S32NE);
 489     if (info.m_displayName.find("HDMI") != std::string::npos
 490     ||  info.m_displayName.find("DisplayPort") != std::string::npos)
 491     {
 492       info.m_deviceType = AE_DEVTYPE_HDMI;
 493       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_AC3);
 494       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD_CORE);
 495       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_1024);
 496       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_2048);
 497       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_512);
 498       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_EAC3);
 499       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD);
 500       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD_MA);
 501       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_TRUEHD);
 502       info.m_dataFormats.push_back(AE_FMT_RAW);
 503     }
 504     else if (info.m_displayName.find("Digital") != std::string::npos)
 505     {
 506       info.m_deviceType = AE_DEVTYPE_IEC958;
 507       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_AC3);
 508       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD_CORE);
 509       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_1024);
 510       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_2048);
 511       info.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_512);
 512       info.m_dataFormats.push_back(AE_FMT_RAW);
 513     }
 514     else
 515     {
 516       info.m_deviceType = AE_DEVTYPE_PCM;
 517     }
 518
 519     oss_audioinfo ainfo = {};
 520     ainfo.dev = i;
 521     if (ioctl(mixerfd, SNDCTL_AUDIOINFO, &ainfo) != -1) {
 522 #if 0
 523       if (ainfo.oformats & AFMT_S32_LE)
 524         info.m_dataFormats.push_back(AE_FMT_S32LE);
 525       if (ainfo.oformats & AFMT_S16_LE)
 526         info.m_dataFormats.push_back(AE_FMT_S16LE);
 527 #endif
 528       for (int j = 0;
 529         j < ainfo.max_channels && AE_CH_NULL != OSSChannelMap[j];
 530         ++j)
 531           info.m_channels += OSSChannelMap[j];
 532
 533       for (int *rate = OSSSampleRateList; *rate != 0; ++rate)
 534         if (*rate >= ainfo.min_rate && *rate <= ainfo.max_rate)
 535           info.m_sampleRates.push_back(*rate);
 536     }
 537     info.m_wantsIECPassthrough = true;
 538     list.push_back(info);
 539   }
 540 #endif
 541   close(mixerfd);
 542 }
 543