alsa_input.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/audio/alsa/alsa_input.h"
  5. #include <stddef.h>
  6. #include "base/bind.h"
  7. #include "base/location.h"
  8. #include "base/logging.h"
  9. #include "base/task/single_thread_task_runner.h"
  10. #include "media/audio/alsa/alsa_output.h"
  11. #include "media/audio/alsa/alsa_util.h"
  12. #include "media/audio/alsa/alsa_wrapper.h"
  13. #include "media/audio/alsa/audio_manager_alsa.h"
  14. #include "media/audio/audio_manager.h"
  15. namespace media {
  16. static const SampleFormat kSampleFormat = kSampleFormatS16;
  17. static const snd_pcm_format_t kAlsaSampleFormat = SND_PCM_FORMAT_S16;
  18. static const int kNumPacketsInRingBuffer = 3;
  19. static const char kDefaultDevice1[] = "default";
  20. static const char kDefaultDevice2[] = "plug:default";
  21. const char AlsaPcmInputStream::kAutoSelectDevice[] = "";
  22. AlsaPcmInputStream::AlsaPcmInputStream(AudioManagerBase* audio_manager,
  23. const std::string& device_name,
  24. const AudioParameters& params,
  25. AlsaWrapper* wrapper)
  26. : audio_manager_(audio_manager),
  27. device_name_(device_name),
  28. params_(params),
  29. bytes_per_buffer_(params.GetBytesPerBuffer(kSampleFormat)),
  30. wrapper_(wrapper),
  31. buffer_duration_(base::Microseconds(
  32. params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
  33. static_cast<float>(params.sample_rate()))),
  34. callback_(nullptr),
  35. device_handle_(nullptr),
  36. mixer_handle_(nullptr),
  37. mixer_element_handle_(nullptr),
  38. read_callback_behind_schedule_(false),
  39. audio_bus_(AudioBus::Create(params)),
  40. capture_thread_("AlsaInput"),
  41. running_(false) {}
  42. AlsaPcmInputStream::~AlsaPcmInputStream() = default;
  43. AudioInputStream::OpenOutcome AlsaPcmInputStream::Open() {
  44. if (device_handle_)
  45. return OpenOutcome::kAlreadyOpen;
  46. uint32_t packet_us = buffer_duration_.InMicroseconds();
  47. uint32_t buffer_us = packet_us * kNumPacketsInRingBuffer;
  48. // Use the same minimum required latency as output.
  49. buffer_us = std::max(buffer_us, AlsaPcmOutputStream::kMinLatencyMicros);
  50. if (device_name_ == kAutoSelectDevice) {
  51. const char* device_names[] = { kDefaultDevice1, kDefaultDevice2 };
  52. for (size_t i = 0; i < std::size(device_names); ++i) {
  53. device_handle_ = alsa_util::OpenCaptureDevice(
  54. wrapper_, device_names[i], params_.channels(), params_.sample_rate(),
  55. kAlsaSampleFormat, buffer_us, packet_us);
  56. if (device_handle_) {
  57. device_name_ = device_names[i];
  58. break;
  59. }
  60. }
  61. } else {
  62. device_handle_ = alsa_util::OpenCaptureDevice(
  63. wrapper_, device_name_.c_str(), params_.channels(),
  64. params_.sample_rate(), kAlsaSampleFormat, buffer_us, packet_us);
  65. }
  66. if (device_handle_) {
  67. audio_buffer_.reset(new uint8_t[bytes_per_buffer_]);
  68. // Open the microphone mixer.
  69. mixer_handle_ = alsa_util::OpenMixer(wrapper_, device_name_);
  70. if (mixer_handle_) {
  71. mixer_element_handle_ = alsa_util::LoadCaptureMixerElement(
  72. wrapper_, mixer_handle_);
  73. }
  74. }
  75. return device_handle_ != nullptr ? OpenOutcome::kSuccess
  76. : OpenOutcome::kFailed;
  77. }
  78. void AlsaPcmInputStream::Start(AudioInputCallback* callback) {
  79. DCHECK(!callback_ && callback);
  80. callback_ = callback;
  81. StartAgc();
  82. int error = wrapper_->PcmPrepare(device_handle_);
  83. if (error < 0) {
  84. HandleError("PcmPrepare", error);
  85. } else {
  86. error = wrapper_->PcmStart(device_handle_);
  87. if (error < 0)
  88. HandleError("PcmStart", error);
  89. }
  90. if (error < 0) {
  91. callback_ = nullptr;
  92. } else {
  93. CHECK(capture_thread_.StartWithOptions(
  94. base::Thread::Options(base::ThreadType::kRealtimeAudio)));
  95. // We start reading data half |buffer_duration_| later than when the
  96. // buffer might have got filled, to accommodate some delays in the audio
  97. // driver. This could also give us a smooth read sequence going forward.
  98. base::TimeDelta delay = buffer_duration_ + buffer_duration_ / 2;
  99. next_read_time_ = base::TimeTicks::Now() + delay;
  100. running_ = true;
  101. capture_thread_.task_runner()->PostDelayedTaskAt(
  102. base::subtle::PostDelayedTaskPassKey(), FROM_HERE,
  103. base::BindOnce(&AlsaPcmInputStream::ReadAudio, base::Unretained(this)),
  104. next_read_time_, base::subtle::DelayPolicy::kPrecise);
  105. }
  106. }
  107. bool AlsaPcmInputStream::Recover(int original_error) {
  108. DCHECK(capture_thread_.task_runner()->BelongsToCurrentThread());
  109. int error = wrapper_->PcmRecover(device_handle_, original_error, 1);
  110. if (error < 0) {
  111. // Docs say snd_pcm_recover returns the original error if it is not one
  112. // of the recoverable ones, so this log message will probably contain the
  113. // same error twice.
  114. LOG(WARNING) << "Unable to recover from \""
  115. << wrapper_->StrError(original_error) << "\": "
  116. << wrapper_->StrError(error);
  117. return false;
  118. }
  119. if (original_error == -EPIPE) { // Buffer underrun/overrun.
  120. // For capture streams we have to repeat the explicit start() to get
  121. // data flowing again.
  122. error = wrapper_->PcmStart(device_handle_);
  123. if (error < 0) {
  124. HandleError("PcmStart", error);
  125. return false;
  126. }
  127. }
  128. return true;
  129. }
  130. void AlsaPcmInputStream::StopRunningOnCaptureThread() {
  131. DCHECK(capture_thread_.IsRunning());
  132. if (!capture_thread_.task_runner()->BelongsToCurrentThread()) {
  133. capture_thread_.task_runner()->PostTask(
  134. FROM_HERE,
  135. base::BindOnce(&AlsaPcmInputStream::StopRunningOnCaptureThread,
  136. base::Unretained(this)));
  137. return;
  138. }
  139. running_ = false;
  140. }
  141. void AlsaPcmInputStream::ReadAudio() {
  142. DCHECK(capture_thread_.task_runner()->BelongsToCurrentThread());
  143. DCHECK(callback_);
  144. if (!running_)
  145. return;
  146. snd_pcm_sframes_t frames = wrapper_->PcmAvailUpdate(device_handle_);
  147. if (frames < 0) { // Potentially recoverable error?
  148. LOG(WARNING) << "PcmAvailUpdate(): " << wrapper_->StrError(frames);
  149. Recover(frames);
  150. }
  151. if (frames < params_.frames_per_buffer()) {
  152. base::TimeTicks now = base::TimeTicks::Now();
  153. // Not enough data yet or error happened. In both cases wait for a very
  154. // small duration before checking again.
  155. // Even Though read callback was behind schedule, there is no data, so
  156. // reset the next_read_time_.
  157. if (read_callback_behind_schedule_) {
  158. next_read_time_ = now;
  159. read_callback_behind_schedule_ = false;
  160. }
  161. base::TimeTicks next_check_time = now + buffer_duration_ / 2;
  162. capture_thread_.task_runner()->PostDelayedTaskAt(
  163. base::subtle::PostDelayedTaskPassKey(), FROM_HERE,
  164. base::BindOnce(&AlsaPcmInputStream::ReadAudio, base::Unretained(this)),
  165. next_check_time, base::subtle::DelayPolicy::kPrecise);
  166. return;
  167. }
  168. // Update the AGC volume level once every second. Note that, |volume| is
  169. // also updated each time SetVolume() is called through IPC by the
  170. // render-side AGC.
  171. double normalized_volume = 0.0;
  172. GetAgcVolume(&normalized_volume);
  173. int num_buffers = frames / params_.frames_per_buffer();
  174. while (num_buffers--) {
  175. int frames_read = wrapper_->PcmReadi(device_handle_, audio_buffer_.get(),
  176. params_.frames_per_buffer());
  177. if (frames_read == params_.frames_per_buffer()) {
  178. audio_bus_->FromInterleaved<SignedInt16SampleTypeTraits>(
  179. reinterpret_cast<int16_t*>(audio_buffer_.get()),
  180. audio_bus_->frames());
  181. // TODO(dalecurtis): This should probably use snd_pcm_htimestamp() so that
  182. // we can have |capture_time| directly instead of computing it as
  183. // Now() - available frames.
  184. snd_pcm_sframes_t avail_frames = wrapper_->PcmAvailUpdate(device_handle_);
  185. if (avail_frames < 0) {
  186. LOG(WARNING) << "PcmAvailUpdate(): "
  187. << wrapper_->StrError(avail_frames);
  188. avail_frames = 0; // Error getting number of avail frames, set it to 0
  189. }
  190. base::TimeDelta hardware_delay = base::Seconds(
  191. avail_frames / static_cast<double>(params_.sample_rate()));
  192. callback_->OnData(audio_bus_.get(),
  193. base::TimeTicks::Now() - hardware_delay,
  194. normalized_volume);
  195. } else if (frames_read < 0) {
  196. bool success = Recover(frames_read);
  197. LOG(WARNING) << "PcmReadi failed with error "
  198. << wrapper_->StrError(frames_read) << ". "
  199. << (success ? "Successfully" : "Unsuccessfully")
  200. << " recovered.";
  201. } else {
  202. LOG(WARNING) << "PcmReadi returning less than expected frames: "
  203. << frames_read << " vs. " << params_.frames_per_buffer()
  204. << ". Dropping this buffer.";
  205. }
  206. }
  207. next_read_time_ += buffer_duration_;
  208. base::TimeTicks now = base::TimeTicks::Now();
  209. if (next_read_time_ < now) {
  210. base::TimeDelta delay = now - next_read_time_;
  211. DVLOG(1) << "Audio read callback behind schedule by "
  212. << (buffer_duration_ + delay).InMicroseconds() << " (us).";
  213. // Read callback is behind schedule. Assuming there is data pending in
  214. // the soundcard, invoke the read callback immediate in order to catch up.
  215. read_callback_behind_schedule_ = true;
  216. }
  217. // If |next_read_time_| is in the past, it will be scheduled immediately.
  218. capture_thread_.task_runner()->PostDelayedTaskAt(
  219. base::subtle::PostDelayedTaskPassKey(), FROM_HERE,
  220. base::BindOnce(&AlsaPcmInputStream::ReadAudio, base::Unretained(this)),
  221. next_read_time_, base::subtle::DelayPolicy::kPrecise);
  222. }
  223. void AlsaPcmInputStream::Stop() {
  224. if (!device_handle_ || !callback_)
  225. return;
  226. StopAgc();
  227. StopRunningOnCaptureThread();
  228. capture_thread_.Stop();
  229. int error = wrapper_->PcmDrop(device_handle_);
  230. if (error < 0)
  231. HandleError("PcmDrop", error);
  232. callback_ = nullptr;
  233. }
  234. void AlsaPcmInputStream::Close() {
  235. if (device_handle_) {
  236. Stop();
  237. int error = alsa_util::CloseDevice(wrapper_, device_handle_);
  238. if (error < 0)
  239. HandleError("PcmClose", error);
  240. if (mixer_handle_)
  241. alsa_util::CloseMixer(wrapper_, mixer_handle_, device_name_);
  242. audio_buffer_.reset();
  243. device_handle_ = nullptr;
  244. mixer_handle_ = nullptr;
  245. mixer_element_handle_ = nullptr;
  246. }
  247. audio_manager_->ReleaseInputStream(this);
  248. }
  249. double AlsaPcmInputStream::GetMaxVolume() {
  250. if (!mixer_handle_ || !mixer_element_handle_) {
  251. DLOG(WARNING) << "GetMaxVolume is not supported for " << device_name_;
  252. return 0.0;
  253. }
  254. if (!wrapper_->MixerSelemHasCaptureVolume(mixer_element_handle_)) {
  255. DLOG(WARNING) << "Unsupported microphone volume for " << device_name_;
  256. return 0.0;
  257. }
  258. long min = 0;
  259. long max = 0;
  260. if (wrapper_->MixerSelemGetCaptureVolumeRange(mixer_element_handle_,
  261. &min,
  262. &max)) {
  263. DLOG(WARNING) << "Unsupported max microphone volume for " << device_name_;
  264. return 0.0;
  265. }
  266. DCHECK(min == 0);
  267. DCHECK(max > 0);
  268. return static_cast<double>(max);
  269. }
  270. void AlsaPcmInputStream::SetVolume(double volume) {
  271. if (!mixer_handle_ || !mixer_element_handle_) {
  272. DLOG(WARNING) << "SetVolume is not supported for " << device_name_;
  273. return;
  274. }
  275. int error = wrapper_->MixerSelemSetCaptureVolumeAll(
  276. mixer_element_handle_, static_cast<long>(volume));
  277. if (error < 0) {
  278. DLOG(WARNING) << "Unable to set volume for " << device_name_;
  279. }
  280. // Update the AGC volume level based on the last setting above. Note that,
  281. // the volume-level resolution is not infinite and it is therefore not
  282. // possible to assume that the volume provided as input parameter can be
  283. // used directly. Instead, a new query to the audio hardware is required.
  284. // This method does nothing if AGC is disabled.
  285. UpdateAgcVolume();
  286. }
  287. double AlsaPcmInputStream::GetVolume() {
  288. if (!mixer_handle_ || !mixer_element_handle_) {
  289. DLOG(WARNING) << "GetVolume is not supported for " << device_name_;
  290. return 0.0;
  291. }
  292. long current_volume = 0;
  293. int error = wrapper_->MixerSelemGetCaptureVolume(
  294. mixer_element_handle_, static_cast<snd_mixer_selem_channel_id_t>(0),
  295. &current_volume);
  296. if (error < 0) {
  297. DLOG(WARNING) << "Unable to get volume for " << device_name_;
  298. return 0.0;
  299. }
  300. return static_cast<double>(current_volume);
  301. }
  302. bool AlsaPcmInputStream::IsMuted() {
  303. return false;
  304. }
  305. void AlsaPcmInputStream::SetOutputDeviceForAec(
  306. const std::string& output_device_id) {
  307. // Not supported. Do nothing.
  308. }
  309. void AlsaPcmInputStream::HandleError(const char* method, int error) {
  310. LOG(WARNING) << method << ": " << wrapper_->StrError(error);
  311. if (callback_)
  312. callback_->OnError();
  313. }
  314. } // namespace media