The Tor Browser: media/libcubeb/src/cubeb_wasapi.cpp@44a2da4a2ab2 (annotated)

media/libcubeb/src/cubeb_wasapi.cpp@44a2da4a2ab2 (annotated)

media/libcubeb/src/cubeb_wasapi.cpp

Fri, 16 Jan 2015 04:50:19 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 04:50:19 +0100
branch: TOR_BUG_9701
changeset 13: 44a2da4a2ab2
permissions: -rw-r--r--

Replace accessor implementation with direct member state manipulation, by
request https://trac.torproject.org/projects/tor/ticket/9701#comment:32

 /*
  * Copyright © 2013 Mozilla Foundation
  *
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
 #undef NDEBUG
 #if defined(HAVE_CONFIG_H)
 #include "config.h"
 #endif
 #include <assert.h>
 #include <windows.h>
 #include <mmdeviceapi.h>
 #include <windef.h>
 #include <audioclient.h>
 #include <math.h>
 #include <process.h>
 #include <avrt.h>
 #include "cubeb/cubeb.h"
 #include "cubeb-internal.h"
 #include "cubeb/cubeb-stdint.h"
 #include "cubeb-speex-resampler.h"
 #include <stdio.h>
 #if 0
 #  define LOG(...) do {         \
   fprintf(stderr, __VA_ARGS__); \
   fprintf(stderr, "\n");        \
 } while(0);
 #else
 #  define LOG(...)
 #endif
 #define ARRAY_LENGTH(array_) \
   (sizeof(array_) / sizeof(array_[0]))
 namespace {
 uint32_t
 ms_to_hns(uint32_t ms)
 {
   return ms * 10000;
 }
 uint32_t
 hns_to_ms(uint32_t hns)
 {
   return hns / 10000;
 }
 double
 hns_to_s(uint32_t hns)
 {
   return static_cast<double>(hns) / 10000000;
 }
 long
 frame_count_at_rate(long frame_count, float rate)
 {
   return static_cast<long>(ceilf(rate * frame_count) + 1);
 }
 void
 SafeRelease(HANDLE handle)
 {
   if (handle) {
     CloseHandle(handle);
   }
 }
 template <typename T>
 void SafeRelease(T * ptr)
 {
   if (ptr) {
     ptr->Release();
   }
 }
 typedef void (*refill_function2)(cubeb_stream * stm,
                                 float * data, long frames_needed);
 typedef HANDLE (WINAPI *set_mm_thread_characteristics_function)(
                                       const char* TaskName, LPDWORD TaskIndex);
 typedef BOOL (WINAPI *revert_mm_thread_characteristics_function)(HANDLE handle);
 extern cubeb_ops const wasapi_ops;
 }
 struct cubeb
 {
   cubeb_ops const * ops;
   /* Library dynamically opened to increase the render
    * thread priority, and the two function pointers we need. */
   HMODULE mmcss_module;
   set_mm_thread_characteristics_function set_mm_thread_characteristics;
   revert_mm_thread_characteristics_function revert_mm_thread_characteristics;
 };
 struct cubeb_stream
 {
   cubeb * context;
   /* Mixer pameters. We need to convert the input
    * stream to this samplerate/channel layout, as WASAPI
    * does not resample nor upmix itself. */
   cubeb_stream_params mix_params;
   cubeb_stream_params stream_params;
   cubeb_state_callback state_callback;
   cubeb_data_callback data_callback;
   void * user_ptr;
   /* Main handle on the WASAPI stream. */
   IAudioClient * client;
   /* Interface pointer to use the event-driven interface. */
   IAudioRenderClient * render_client;
   /* Interface pointer to use the clock facilities. */
   IAudioClock * audio_clock;
   /* This event is set by the stream_stop and stream_destroy
    * function, so the render loop can exit properly. */
   HANDLE shutdown_event;
   /* This is set by WASAPI when we should refill the stream. */
   HANDLE refill_event;
   /* Each cubeb_stream has its own thread. */
   HANDLE thread;
   uint64_t clock_freq;
   /* Maximum number of frames we can be requested in a callback. */
   uint32_t buffer_frame_count;
   /* Resampler instance. If this is !NULL, resampling should happen. */
   SpeexResamplerState * resampler;
   /* Buffer to resample from, into the mix buffer or the final buffer. */
   float * resampling_src_buffer;
   /* Pointer to the function used to refill the buffer, depending
    * on the respective samplerate of the stream and the mix. */
   refill_function2 refill_function;
   /* Leftover frames handling, only used when resampling. */
   uint32_t leftover_frame_count;
   uint32_t leftover_frame_size;
   float * leftover_frames_buffer;
   /* Buffer used to downmix or upmix to the number of channels the mixer has.
    * its size is |frames_to_bytes_before_mix(buffer_frame_count)|. */
   float * mix_buffer;
   /* True if the stream is draining. */
   bool draining;
 };
 namespace {
 bool should_upmix(cubeb_stream * stream)
 {
   return stream->mix_params.channels > stream->stream_params.channels;
 }
 bool should_downmix(cubeb_stream * stream)
 {
   return stream->mix_params.channels < stream->stream_params.channels;
 }
 /* Upmix function, copies a mono channel in two interleaved
  * stereo channel. |out| has to be twice as long as |in| */
 template<typename T>
 void
 mono_to_stereo(T * in, long insamples, T * out)
 {
   int j = 0;
   for (int i = 0; i < insamples; ++i, j += 2) {
     out[j] = out[j + 1] = in[i];
   }
 }
 template<typename T>
 void
 upmix(T * in, long inframes, T * out, int32_t in_channels, int32_t out_channels)
 {
   assert(out_channels >= in_channels);
   /* If we are playing a mono stream over stereo speakers, copy the data over. */
   if (in_channels == 1 && out_channels == 2) {
     mono_to_stereo(in, inframes, out);
     return;
   }
   /* Otherwise, put silence in other channels. */
   long out_index = 0;
   for (long i = 0; i < inframes * in_channels; i += in_channels) {
     for (int j = 0; j < in_channels; ++j) {
       out[out_index + j] = in[i + j];
     }
     for (int j = in_channels; j < out_channels; ++j) {
       out[out_index + j] = 0.0;
     }
     out_index += out_channels;
   }
 }
 template<typename T>
 void
 downmix(T * in, long inframes, T * out, int32_t in_channels, int32_t out_channels)
 {
   assert(in_channels >= out_channels);
   /* We could use a downmix matrix here, applying mixing weight based on the
    * channel, but directsound and winmm simply drop the channels that cannot be
    * rendered by the hardware, so we do the same for consistency. */
   long out_index = 0;
   for (long i = 0; i < inframes * in_channels; i += in_channels) {
     for (int j = 0; j < out_channels; ++j) {
       out[out_index + j] = in[i + j];
     }
     out_index += out_channels;
   }
 }
 /* This returns the size of a frame in the stream,
  * before the eventual upmix occurs. */
 static size_t
 frames_to_bytes_before_mix(cubeb_stream * stm, size_t frames)
 {
   size_t stream_frame_size = stm->stream_params.channels * sizeof(float);
   return stream_frame_size * frames;
 }
 void
 refill_with_resampling(cubeb_stream * stm, float * data, long frames_needed)
 {
   /* Use more input frames that strictly necessary, so in the worst case,
    * we have leftover unresampled frames at the end, that we can use
    * during the next iteration. */
   float rate =
     static_cast<float>(stm->stream_params.rate) / stm->mix_params.rate;
   long before_resampling = frame_count_at_rate(frames_needed, rate);
   long frame_requested = before_resampling - stm->leftover_frame_count;
   size_t leftover_bytes =
     frames_to_bytes_before_mix(stm, stm->leftover_frame_count);
   /* Copy the previous leftover frames to the front of the buffer. */
   memcpy(stm->resampling_src_buffer, stm->leftover_frames_buffer, leftover_bytes);
   uint8_t * buffer_start = reinterpret_cast<uint8_t *>(
                                   stm->resampling_src_buffer) + leftover_bytes;
   long got = stm->data_callback(stm, stm->user_ptr, buffer_start, frame_requested);
   if (got != frame_requested) {
     stm->draining = true;
   }
   uint32_t in_frames = before_resampling;
   uint32_t out_frames = frames_needed;
   /* If we need to upmix after resampling, resample into the mix buffer to
    * avoid a copy. */
   float * resample_dest;
   if (should_upmix(stm) || should_downmix(stm)) {
     resample_dest = stm->mix_buffer;
   } else {
     resample_dest = data;
   }
   speex_resampler_process_interleaved_float(stm->resampler,
                                             stm->resampling_src_buffer,
                                             &in_frames,
                                             resample_dest,
                                             &out_frames);
   /* Copy the leftover frames to buffer for the next time. */
   stm->leftover_frame_count = before_resampling - in_frames;
   size_t unresampled_bytes =
     frames_to_bytes_before_mix(stm, stm->leftover_frame_count);
   uint8_t * leftover_frames_start =
     reinterpret_cast<uint8_t *>(stm->resampling_src_buffer);
   leftover_frames_start += frames_to_bytes_before_mix(stm, in_frames);
   assert(stm->leftover_frame_count <= stm->leftover_frame_size);
   memcpy(stm->leftover_frames_buffer, leftover_frames_start, unresampled_bytes);
   /* If this is not true, there will be glitches.
    * It is alright to have produced less frames if we are draining, though. */
   assert(out_frames == frames_needed || stm->draining);
   if (should_upmix(stm)) {
     upmix(resample_dest, out_frames, data,
           stm->stream_params.channels, stm->mix_params.channels);
   } else if (should_downmix(stm)) {
     downmix(resample_dest, out_frames, data,
             stm->stream_params.channels, stm->mix_params.channels);
   }
 }
 void
 refill(cubeb_stream * stm, float * data, long frames_needed)
 {
   /* If we need to upmix/downmix, get the data into the mix buffer to avoid a
    * copy, then do the processing process. */
   float * dest;
   if (should_upmix(stm) || should_downmix(stm)) {
     dest = stm->mix_buffer;
   } else {
     dest = data;
   }
   long got = stm->data_callback(stm, stm->user_ptr, dest, frames_needed);
   assert(got <= frames_needed);
   if (got != frames_needed) {
     LOG("draining.");
     stm->draining = true;
   }
   if (should_upmix(stm)) {
     upmix(dest, got, data,
           stm->stream_params.channels, stm->mix_params.channels);
   } else if (should_downmix(stm)) {
     downmix(dest, got, data,
             stm->stream_params.channels, stm->mix_params.channels);
   }
 }
 static unsigned int __stdcall
 wasapi_stream_render_loop(LPVOID stream)
 {
   cubeb_stream * stm = static_cast<cubeb_stream *>(stream);
   bool is_playing = true;
   HANDLE wait_array[2] = {stm->shutdown_event, stm->refill_event};
   HANDLE mmcss_handle = NULL;
   HRESULT hr;
   bool first = true;
   DWORD mmcss_task_index = 0;
   /* We could consider using "Pro Audio" here for WebAudio and
    * maybe WebRTC. */
   mmcss_handle =
     stm->context->set_mm_thread_characteristics("Audio", &mmcss_task_index);
   if (!mmcss_handle) {
     /* This is not fatal, but we might glitch under heavy load. */
     LOG("Unable to use mmcss to bump the render thread priority: %x", GetLastError());
   }
   hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
   if (FAILED(hr)) {
     LOG("could not initialize COM in render thread: %x", hr);
     return hr;
   }
   while (is_playing) {
     DWORD waitResult = WaitForMultipleObjects(ARRAY_LENGTH(wait_array),
                                               wait_array,
                                               FALSE,
                                               INFINITE);
     switch (waitResult) {
     case WAIT_OBJECT_0: { /* shutdown */
       is_playing = false;
       /* We don't check if the drain is actually finished here, we just want to
        * shutdown. */
       if (stm->draining) {
         stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED);
       }
       continue;
     }
     case WAIT_OBJECT_0 + 1: { /* refill */
       UINT32 padding;
       hr = stm->client->GetCurrentPadding(&padding);
       if (FAILED(hr)) {
         LOG("Failed to get padding");
         is_playing = false;
         continue;
       }
       assert(padding <= stm->buffer_frame_count);
       if (stm->draining) {
         if (padding == 0) {
           stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED);
           is_playing = false;
         }
         continue;
       }
       long available = stm->buffer_frame_count - padding;
       if (available == 0) {
         continue;
       }
       BYTE* data;
       hr = stm->render_client->GetBuffer(available, &data);
       if (SUCCEEDED(hr)) {
         stm->refill_function(stm, reinterpret_cast<float *>(data), available);
         hr = stm->render_client->ReleaseBuffer(available, 0);
         if (FAILED(hr)) {
           LOG("failed to release buffer.");
           is_playing = false;
         }
       } else {
         LOG("failed to get buffer.");
         is_playing = false;
       }
     }
     break;
     default:
       LOG("case %d not handled in render loop.", waitResult);
       abort();
     }
   }
   if (FAILED(hr)) {
     stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED);
   }
   stm->context->revert_mm_thread_characteristics(mmcss_handle);
   CoUninitialize();
   return 0;
 }
 void wasapi_destroy(cubeb * context);
 HANDLE WINAPI set_mm_thread_characteristics_noop(const char *, LPDWORD mmcss_task_index)
 {
   return (HANDLE)1;
 }
 BOOL WINAPI revert_mm_thread_characteristics_noop(HANDLE mmcss_handle)
 {
   return true;
 }
 HRESULT get_default_endpoint(IMMDevice ** device)
 {
   IMMDeviceEnumerator * enumerator;
   HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
                                 NULL, CLSCTX_INPROC_SERVER,
                                 IID_PPV_ARGS(&enumerator));
   if (FAILED(hr)) {
     LOG("Could not get device enumerator.");
     return hr;
   }
   /* eMultimedia is okay for now ("Music, movies, narration, [...]").
    * We will need to change this when we distinguish streams by use-case, other
    * possible values being eConsole ("Games, system notification sounds [...]")
    * and eCommunication ("Voice communication"). */
   hr = enumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, device);
   if (FAILED(hr)) {
     LOG("Could not get default audio endpoint.");
     SafeRelease(enumerator);
     return hr;
   }
   SafeRelease(enumerator);
   return ERROR_SUCCESS;
 }
 } // namespace anonymous
 extern "C" {
 int wasapi_init(cubeb ** context, char const * context_name)
 {
   HRESULT hr;
   hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
   if (FAILED(hr)) {
     LOG("Could not init COM.");
     return CUBEB_ERROR;
   }
   /* We don't use the device yet, but need to make sure we can initialize one
      so that this backend is not incorrectly enabled on platforms that don't
      support WASAPI. */
   IMMDevice * device;
   hr = get_default_endpoint(&device);
   if (FAILED(hr)) {
     LOG("Could not get device.");
     return CUBEB_ERROR;
   }
   SafeRelease(device);
   cubeb * ctx = (cubeb *)calloc(1, sizeof(cubeb));
   ctx->ops = &wasapi_ops;
   ctx->mmcss_module = LoadLibraryA("Avrt.dll");
   if (ctx->mmcss_module) {
     ctx->set_mm_thread_characteristics =
       (set_mm_thread_characteristics_function) GetProcAddress(
           ctx->mmcss_module, "AvSetMmThreadCharacteristicsA");
     ctx->revert_mm_thread_characteristics =
       (revert_mm_thread_characteristics_function) GetProcAddress(
           ctx->mmcss_module, "AvRevertMmThreadCharacteristics");
     if (!(ctx->set_mm_thread_characteristics && ctx->revert_mm_thread_characteristics)) {
       LOG("Could not load AvSetMmThreadCharacteristics or AvRevertMmThreadCharacteristics: %x", GetLastError());
       FreeLibrary(ctx->mmcss_module);
     }
   } else {
     // This is not a fatal error, but we might end up glitching when
     // the system is under high load.
     LOG("Could not load Avrt.dll");
     ctx->set_mm_thread_characteristics = &set_mm_thread_characteristics_noop;
     ctx->revert_mm_thread_characteristics = &revert_mm_thread_characteristics_noop;
   }
   *context = ctx;
   return CUBEB_OK;
 }
 }
 namespace {
 void wasapi_destroy(cubeb * context)
 {
   if (context->mmcss_module) {
     FreeLibrary(context->mmcss_module);
   }
   free(context);
 }
 char const* wasapi_get_backend_id(cubeb * context)
 {
   return "wasapi";
 }
 int
 wasapi_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 {
   IAudioClient * client;
   WAVEFORMATEX * mix_format;
   assert(ctx && max_channels);
   IMMDevice * device;
   HRESULT hr = get_default_endpoint(&device);
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
   hr = device->Activate(__uuidof(IAudioClient),
                         CLSCTX_INPROC_SERVER,
                         NULL, (void **)&client);
   SafeRelease(device);
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
   hr = client->GetMixFormat(&mix_format);
   if (FAILED(hr)) {
     SafeRelease(client);
     return CUBEB_ERROR;
   }
   *max_channels = mix_format->nChannels;
   CoTaskMemFree(mix_format);
   SafeRelease(client);
   return CUBEB_OK;
 }
 int
 wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
 {
   HRESULT hr;
   IAudioClient * client;
   REFERENCE_TIME default_period;
   IMMDevice * device;
   hr = get_default_endpoint(&device);
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
   hr = device->Activate(__uuidof(IAudioClient),
                         CLSCTX_INPROC_SERVER,
                         NULL, (void **)&client);
   SafeRelease(device);
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
   /* The second parameter is for exclusive mode, that we don't use. */
   hr = client->GetDevicePeriod(&default_period, NULL);
   if (FAILED(hr)) {
     SafeRelease(client);
     return CUBEB_ERROR;
   }
   /* According to the docs, the best latency we can achieve is by synchronizing
    * the stream and the engine.
    * http://msdn.microsoft.com/en-us/library/windows/desktop/dd370871%28v=vs.85%29.aspx */
   *latency_ms = hns_to_ms(default_period);
   SafeRelease(client);
   return CUBEB_OK;
 }
 int
 wasapi_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
 {
   HRESULT hr;
   IAudioClient * client;
   WAVEFORMATEX * mix_format;
   IMMDevice * device;
   hr = get_default_endpoint(&device);
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
   hr = device->Activate(__uuidof(IAudioClient),
                         CLSCTX_INPROC_SERVER,
                         NULL, (void **)&client);
   SafeRelease(device);
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
   hr = client->GetMixFormat(&mix_format);
   if (FAILED(hr)) {
     SafeRelease(client);
     return CUBEB_ERROR;
   }
   *rate = mix_format->nSamplesPerSec;
   CoTaskMemFree(mix_format);
   SafeRelease(client);
   return CUBEB_OK;
 }
 void wasapi_stream_destroy(cubeb_stream * stm);
 /* Based on the mix format and the stream format, try to find a way to play what
  * the user requested. */
 static void
 handle_channel_layout(cubeb_stream * stm,  WAVEFORMATEX ** mix_format, const cubeb_stream_params * stream_params)
 {
   /* Common case: the hardware is stereo. Up-mixing and down-mixing will be
    * handled in the callback. */
   if ((*mix_format)->nChannels <= 2) {
     return;
   }
   /* Otherwise, the hardware supports more than two channels. */
   WAVEFORMATEX hw_mixformat = **mix_format;
   /* The docs say that GetMixFormat is always of type WAVEFORMATEXTENSIBLE [1],
    * so the reinterpret_cast below should be safe. In practice, this is not
    * true, and we just want to bail out and let the rest of the code find a good
    * conversion path instead of trying to make WASAPI do it by itself.
    * [1]: http://msdn.microsoft.com/en-us/library/windows/desktop/dd370811%28v=vs.85%29.aspx*/
   if ((*mix_format)->wFormatTag != WAVE_FORMAT_EXTENSIBLE) {
     return;
   }
   /* The hardware is in surround mode, we want to only use front left and front
    * right. Try that, and check if it works. */
   WAVEFORMATEXTENSIBLE * format_pcm = reinterpret_cast<WAVEFORMATEXTENSIBLE *>((*mix_format));
   switch (stream_params->channels) {
     case 1: /* Mono */
       format_pcm->dwChannelMask = KSAUDIO_SPEAKER_MONO;
       break;
     case 2: /* Stereo */
       format_pcm->dwChannelMask = KSAUDIO_SPEAKER_STEREO;
       break;
     default:
       assert(false && "Channel layout not supported.");
       break;
   }
   (*mix_format)->nChannels = stream_params->channels;
   (*mix_format)->nBlockAlign = ((*mix_format)->wBitsPerSample * (*mix_format)->nChannels) / 8;
   (*mix_format)->nAvgBytesPerSec = (*mix_format)->nSamplesPerSec * (*mix_format)->nBlockAlign;
   format_pcm->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
   (*mix_format)->wBitsPerSample = 32;
   format_pcm->Samples.wValidBitsPerSample = (*mix_format)->wBitsPerSample;
   /* Check if wasapi will accept our channel layout request. */
   WAVEFORMATEX * closest;
   HRESULT hr = stm->client->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED,
                                               *mix_format,
                                               &closest);
   if (hr == S_FALSE) {
     /* Not supported, but WASAPI gives us a suggestion. Use it, and handle the
      * eventual upmix/downmix ourselves */
     LOG("Using WASAPI suggested format: channels: %d", closest->nChannels);
     WAVEFORMATEXTENSIBLE * closest_pcm = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(closest);
     assert(closest_pcm->SubFormat == format_pcm->SubFormat);
     CoTaskMemFree(*mix_format);
     *mix_format = closest;
   } else if (hr == AUDCLNT_E_UNSUPPORTED_FORMAT) {
     /* Not supported, no suggestion. This should not happen, but it does in the
      * field with some sound cards. We restore the mix format, and let the rest
      * of the code figure out the right conversion path. */
     **mix_format = hw_mixformat;
   } else if (hr == S_OK) {
     LOG("Requested format accepted by WASAPI.");
   }
 }
 int
 wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
                    char const * stream_name, cubeb_stream_params stream_params,
                    unsigned int latency, cubeb_data_callback data_callback,
                    cubeb_state_callback state_callback, void * user_ptr)
 {
   HRESULT hr;
   WAVEFORMATEX * mix_format;
   assert(context && stream);
   hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
   if (FAILED(hr)) {
     LOG("Could not initialize COM.");
     return CUBEB_ERROR;
   }
   cubeb_stream * stm = (cubeb_stream *)calloc(1, sizeof(cubeb_stream));
   assert(stm);
   stm->context = context;
   stm->data_callback = data_callback;
   stm->state_callback = state_callback;
   stm->user_ptr = user_ptr;
   stm->stream_params = stream_params;
   stm->draining = false;
   stm->shutdown_event = CreateEvent(NULL, 0, 0, NULL);
   stm->refill_event = CreateEvent(NULL, 0, 0, NULL);
   if (!stm->shutdown_event) {
     LOG("Can't create the shutdown event, error: %x.", GetLastError());
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   if (!stm->refill_event) {
     SafeRelease(stm->shutdown_event);
     LOG("Can't create the refill event, error: %x.", GetLastError());
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   IMMDevice * device;
   hr = get_default_endpoint(&device);
   if (FAILED(hr)) {
     LOG("Could not get default endpoint, error: %x", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   /* Get a client. We will get all other interfaces we need from
    * this pointer. */
   hr = device->Activate(__uuidof(IAudioClient),
                         CLSCTX_INPROC_SERVER,
                         NULL, (void **)&stm->client);
   SafeRelease(device);
   if (FAILED(hr)) {
     LOG("Could not activate the device to get an audio client: error: %x", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   /* We have to distinguish between the format the mixer uses,
   * and the format the stream we want to play uses. */
   hr = stm->client->GetMixFormat(&mix_format);
   if (FAILED(hr)) {
     LOG("Could not fetch current mix format from the audio client: error: %x", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   handle_channel_layout(stm, &mix_format, &stream_params);
   /* Shared mode WASAPI always supports float32 sample format, so this
    * is safe. */
   stm->mix_params.format = CUBEB_SAMPLE_FLOAT32NE;
   stm->mix_params.rate = mix_format->nSamplesPerSec;
   stm->mix_params.channels = mix_format->nChannels;
   float resampling_rate = static_cast<float>(stm->stream_params.rate) /
                           stm->mix_params.rate;
   if (resampling_rate != 1.0) {
     /* If we are playing a mono stream, we only resample one channel,
      * and copy it over, so we are always resampling the number
      * of channels of the stream, not the number of channels
      * that WASAPI wants. */
     stm->resampler = speex_resampler_init(stm->stream_params.channels,
                                           stm->stream_params.rate,
                                           stm->mix_params.rate,
                                           SPEEX_RESAMPLER_QUALITY_DESKTOP,
                                           NULL);
     if (!stm->resampler) {
       LOG("Could not get a resampler");
       CoTaskMemFree(mix_format);
       wasapi_stream_destroy(stm);
       return CUBEB_ERROR;
     }
     /* Get a little buffer so we can store the leftover frames,
      * that is, the samples not consumed by the resampler that we will end up
      * using next time the render callback is called. */
     stm->leftover_frame_size = static_cast<uint32_t>(ceilf(1 / resampling_rate * 2) + 1);
     stm->leftover_frames_buffer = (float *)malloc(frames_to_bytes_before_mix(stm, stm->leftover_frame_size));
     stm->refill_function = &refill_with_resampling;
   } else {
     stm->refill_function = &refill;
   }
   hr = stm->client->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
                                AUDCLNT_STREAMFLAGS_NOPERSIST,
                                ms_to_hns(latency),
 ,
                                mix_format,
                                NULL);
   CoTaskMemFree(mix_format);
   if (FAILED(hr)) {
     LOG("Unable to initialize audio client: %x.", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   hr = stm->client->GetBufferSize(&stm->buffer_frame_count);
   if (FAILED(hr)) {
     LOG("Could not get the buffer size from the client %x.", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   if (should_upmix(stm) || should_downmix(stm)) {
     stm->mix_buffer = (float *) malloc(frames_to_bytes_before_mix(stm, stm->buffer_frame_count));
   }
   /* If we are going to resample, we will end up needing a buffer
    * to resample from, because speex's resampler does not do
    * in-place processing. Of course we need to take the resampling
    * factor and the channel layout into account. */
   if (stm->resampler) {
     size_t frames_needed = static_cast<size_t>(frame_count_at_rate(stm->buffer_frame_count, resampling_rate));
     stm->resampling_src_buffer = (float *)malloc(frames_to_bytes_before_mix(stm, frames_needed));
   }
   hr = stm->client->SetEventHandle(stm->refill_event);
   if (FAILED(hr)) {
     LOG("Could set the event handle for the client %x.", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   hr = stm->client->GetService(__uuidof(IAudioRenderClient),
                                (void **)&stm->render_client);
   if (FAILED(hr)) {
     LOG("Could not get the render client %x.", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   hr = stm->client->GetService(__uuidof(IAudioClock),
                                (void **)&stm->audio_clock);
   if (FAILED(hr)) {
     LOG("Could not get the IAudioClock, %x", hr);
     wasapi_stream_destroy(stm);
     return CUBEB_ERROR;
   }
   hr = stm->audio_clock->GetFrequency(&stm->clock_freq);
   if (FAILED(hr)) {
     LOG("failed to get audio clock frequency, %x", hr);
     return CUBEB_ERROR;
   }
   *stream = stm;
   return CUBEB_OK;
 }
 void wasapi_stream_destroy(cubeb_stream * stm)
 {
   assert(stm);
   if (stm->thread) {
     SetEvent(stm->shutdown_event);
     WaitForSingleObject(stm->thread, INFINITE);
     CloseHandle(stm->thread);
     stm->thread = 0;
   }
   SafeRelease(stm->shutdown_event);
   SafeRelease(stm->refill_event);
   SafeRelease(stm->client);
   SafeRelease(stm->render_client);
   SafeRelease(stm->audio_clock);
   if (stm->resampler) {
     speex_resampler_destroy(stm->resampler);
   }
   free(stm->leftover_frames_buffer);
   free(stm->resampling_src_buffer);
   free(stm->mix_buffer);
   free(stm);
   CoUninitialize();
 }
 int wasapi_stream_start(cubeb_stream * stm)
 {
   HRESULT hr;
   assert(stm);
   stm->thread = (HANDLE) _beginthreadex(NULL, 64 * 1024, wasapi_stream_render_loop, stm, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
   if (stm->thread == NULL) {
     LOG("could not create WASAPI render thread.");
     return CUBEB_ERROR;
   }
   hr = stm->client->Start();
   if (FAILED(hr)) {
     LOG("could not start the stream.");
     return CUBEB_ERROR;
   }
   stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STARTED);
   return CUBEB_OK;
 }
 int wasapi_stream_stop(cubeb_stream * stm)
 {
   assert(stm && stm->shutdown_event);
   SetEvent(stm->shutdown_event);
   HRESULT hr = stm->client->Stop();
   if (FAILED(hr)) {
     LOG("could not stop AudioClient");
   }
   if (stm->thread) {
     WaitForSingleObject(stm->thread, INFINITE);
     CloseHandle(stm->thread);
     stm->thread = NULL;
   }
   stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED);
   return CUBEB_OK;
 }
 int wasapi_stream_get_position(cubeb_stream * stm, uint64_t * position)
 {
   assert(stm && position);
   UINT64 pos;
   HRESULT hr;
   hr = stm->audio_clock->GetPosition(&pos, NULL);
   if (FAILED(hr)) {
     LOG("Could not get accurate position: %x\n", hr);
     return CUBEB_ERROR;
   }
   *position = static_cast<uint64_t>(static_cast<double>(pos) / stm->clock_freq * stm->stream_params.rate);
   return CUBEB_OK;
 }
 int wasapi_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 {
   assert(stm && latency);
   /* The GetStreamLatency method only works if the
    * AudioClient has been initialized. */
   if (!stm->client) {
     return CUBEB_ERROR;
   }
   REFERENCE_TIME latency_hns;
   stm->client->GetStreamLatency(&latency_hns);
   double latency_s = hns_to_s(latency_hns);
   *latency = static_cast<uint32_t>(latency_s * stm->stream_params.rate);
   return CUBEB_OK;
 }
 cubeb_ops const wasapi_ops = {
   /*.init =*/ wasapi_init,
   /*.get_backend_id =*/ wasapi_get_backend_id,
   /*.get_max_channel_count =*/ wasapi_get_max_channel_count,
   /*.get_min_latency =*/ wasapi_get_min_latency,
   /*.get_preferred_sample_rate =*/ wasapi_get_preferred_sample_rate,
   /*.destroy =*/ wasapi_destroy,
   /*.stream_init =*/ wasapi_stream_init,
   /*.stream_destroy =*/ wasapi_stream_destroy,
   /*.stream_start =*/ wasapi_stream_start,
   /*.stream_stop =*/ wasapi_stream_stop,
   /*.stream_get_position =*/ wasapi_stream_get_position,
   /*.stream_get_latency =*/ wasapi_stream_get_latency
  };
 } // namespace anonymous

The Tor Browser / annotate

media/libcubeb/src/cubeb_wasapi.cpp@44a2da4a2ab2 (annotated)

media/libcubeb/src/cubeb_wasapi.cpp