static int opensl_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate) { /* https://android.googlesource.com/platform/ndk.git/+/master/docs/opensles/index.html * We don't want to deal with JNI here (and we don't have Java on b2g anyways, * so we just dlopen the library and get the two symbols we need. */ int rv; void * libmedia; uint32_t (*get_primary_output_samplingrate)(); uint32_t primary_sampling_rate; libmedia = dlopen("libmedia.so", RTLD_LAZY); if (!libmedia) { return CUBEB_ERROR; } /* uint32_t AudioSystem::getPrimaryOutputSamplingRate(void) */ get_primary_output_samplingrate = dlsym(libmedia, "_ZN7android11AudioSystem28getPrimaryOutputSamplingRateEv"); if (!get_primary_output_samplingrate) { dlclose(libmedia); return CUBEB_ERROR; } *rate = get_primary_output_samplingrate(); dlclose(libmedia); return CUBEB_OK; }
static int opensl_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate) { /* https://android.googlesource.com/platform/ndk.git/+/master/docs/opensles/index.html * We don't want to deal with JNI here (and we don't have Java on b2g anyways), * so we just dlopen the library and get the two symbols we need. */ int rv; void * libmedia; uint32_t (*get_primary_output_samplingrate)(); uint32_t (*get_output_samplingrate)(int * samplingRate, int streamType); uint32_t primary_sampling_rate; libmedia = dlopen("libmedia.so", RTLD_LAZY); if (!libmedia) { return CUBEB_ERROR; } /* uint32_t AudioSystem::getPrimaryOutputSamplingRate(void) */ get_primary_output_samplingrate = dlsym(libmedia, "_ZN7android11AudioSystem28getPrimaryOutputSamplingRateEv"); if (!get_primary_output_samplingrate) { /* fallback to * status_t AudioSystem::getOutputSamplingRate(int* samplingRate, int streamType) * if we cannot find getPrimaryOutputSamplingRate. */ get_output_samplingrate = dlsym(libmedia, "_ZN7android11AudioSystem21getOutputSamplingRateEPj19audio_stream_type_t"); if (!get_output_samplingrate) { /* Another signature exists, with a int instead of an audio_stream_type_t */ get_output_samplingrate = dlsym(libmedia, "_ZN7android11AudioSystem21getOutputSamplingRateEPii"); if (!get_output_samplingrate) { dlclose(libmedia); return CUBEB_ERROR; } } } if (get_primary_output_samplingrate) { *rate = get_primary_output_samplingrate(); } else { /* We don't really know about the type, here, so we just pass music. */ rv = get_output_samplingrate((int *) rate, AUDIO_STREAM_TYPE_MUSIC); if (rv) { dlclose(libmedia); return CUBEB_ERROR; } } dlclose(libmedia); /* Depending on which method we called above, we can get a zero back, yet have * a non-error return value, especially if the audio system is not * ready/shutting down (i.e. when we can't get our hand on the AudioFlinger * thread). */ if (*rate == 0) { return CUBEB_ERROR; } return CUBEB_OK; }
static int opensl_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms) { /* https://android.googlesource.com/platform/ndk.git/+/master/docs/opensles/index.html * We don't want to deal with JNI here (and we don't have Java on b2g anyways), * so we just dlopen the library and get the two symbols we need. */ int rv; void * libmedia; uint32_t (*get_primary_output_samplingrate)(void); size_t (*get_primary_output_frame_count)(void); uint32_t primary_sampling_rate; size_t primary_buffer_size; libmedia = dlopen("libmedia.so", RTLD_LAZY); if (!libmedia) { return CUBEB_ERROR; } /* uint32_t AudioSystem::getPrimaryOutputSamplingRate(void) */ get_primary_output_samplingrate = dlsym(libmedia, "_ZN7android11AudioSystem28getPrimaryOutputSamplingRateEv"); if (!get_primary_output_samplingrate) { dlclose(libmedia); return CUBEB_ERROR; } /* size_t AudioSystem::getPrimaryOutputFrameCount(void) */ get_primary_output_frame_count = dlsym(libmedia, "_ZN7android11AudioSystem26getPrimaryOutputFrameCountEv"); if (!get_primary_output_frame_count) { dlclose(libmedia); return CUBEB_ERROR; } primary_sampling_rate = get_primary_output_samplingrate(); primary_buffer_size = get_primary_output_frame_count(); /* To get a fast track in Android's mixer, we need to be at the native * samplerate, which is device dependant. Some devices might be able to * resample when playing a fast track, but it's pretty rare. */ if (primary_sampling_rate != params.rate) { /* If we don't know what to use, let's say 4 * 20ms buffers will do. */ *latency_ms = NBUFS * 20; } else { *latency_ms = NBUFS * primary_buffer_size / (primary_sampling_rate / 1000); } dlclose(libmedia); return CUBEB_OK; }