modules/audio_remote_submix/audio_hw.cpp

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "r_submix"
  18 //#define LOG_NDEBUG 0
  19
  20 #include <errno.h>
  21 #include <pthread.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24 #include <sys/param.h>
  25 #include <sys/time.h>
  26 #include <sys/limits.h>
  27
  28 #include <cutils/compiler.h>
  29 #include <cutils/log.h>
  30 #include <cutils/properties.h>
  31 #include <cutils/str_parms.h>
  32
  33 #include <hardware/audio.h>
  34 #include <hardware/hardware.h>
  35 #include <system/audio.h>
  36
  37 #include <media/AudioParameter.h>
  38 #include <media/AudioBufferProvider.h>
  39 #include <media/nbaio/MonoPipe.h>
  40 #include <media/nbaio/MonoPipeReader.h>
  41
  42 #include <utils/String8.h>
  43
  44 #define LOG_STREAMS_TO_FILES 0
  45 #if LOG_STREAMS_TO_FILES
  46 #include <fcntl.h>
  47 #include <stdio.h>
  48 #include <sys/stat.h>
  49 #endif // LOG_STREAMS_TO_FILES
  50
  51 extern "C" {
  52
  53 namespace android {
  54
  55 // Set to 1 to enable extremely verbose logging in this module.
  56 #define SUBMIX_VERBOSE_LOGGING 0
  57 #if SUBMIX_VERBOSE_LOGGING
  58 #define SUBMIX_ALOGV(...) ALOGV(__VA_ARGS__)
  59 #define SUBMIX_ALOGE(...) ALOGE(__VA_ARGS__)
  60 #else
  61 #define SUBMIX_ALOGV(...)
  62 #define SUBMIX_ALOGE(...)
  63 #endif // SUBMIX_VERBOSE_LOGGING
  64
  65 // NOTE: This value will be rounded up to the nearest power of 2 by MonoPipe().
  66 #define DEFAULT_PIPE_SIZE_IN_FRAMES  (1024*4)
  67 // Value used to divide the MonoPipe() buffer into segments that are written to the source and
  68 // read from the sink.  The maximum latency of the device is the size of the MonoPipe's buffer
  69 // the minimum latency is the MonoPipe buffer size divided by this value.
  70 #define DEFAULT_PIPE_PERIOD_COUNT    4
  71 // The duration of MAX_READ_ATTEMPTS * READ_ATTEMPT_SLEEP_MS must be stricly inferior to
  72 //   the duration of a record buffer at the current record sample rate (of the device, not of
  73 //   the recording itself). Here we have:
  74 //      3 * 5ms = 15ms < 1024 frames * 1000 / 48000 = 21.333ms
  75 #define MAX_READ_ATTEMPTS            3
  76 #define READ_ATTEMPT_SLEEP_MS        5 // 5ms between two read attempts when pipe is empty
  77 #define DEFAULT_SAMPLE_RATE_HZ       48000 // default sample rate
  78 // See NBAIO_Format frameworks/av/include/media/nbaio/NBAIO.h.
  79 #define DEFAULT_FORMAT               AUDIO_FORMAT_PCM_16_BIT
  80 // A legacy user of this device does not close the input stream when it shuts down, which
  81 // results in the application opening a new input stream before closing the old input stream
  82 // handle it was previously using.  Setting this value to 1 allows multiple clients to open
  83 // multiple input streams from this device.  If this option is enabled, each input stream returned
  84 // is *the same stream* which means that readers will race to read data from these streams.
  85 #define ENABLE_LEGACY_INPUT_OPEN     1
  86 // Whether channel conversion (16-bit signed PCM mono->stereo, stereo->mono) is enabled.
  87 #define ENABLE_CHANNEL_CONVERSION    1
  88 // Whether resampling is enabled.
  89 #define ENABLE_RESAMPLING            1
  90 #if LOG_STREAMS_TO_FILES
  91 // Folder to save stream log files to.
  92 #define LOG_STREAM_FOLDER "/data/misc/audioserver"
  93 // Log filenames for input and output streams.
  94 #define LOG_STREAM_OUT_FILENAME LOG_STREAM_FOLDER "/r_submix_out.raw"
  95 #define LOG_STREAM_IN_FILENAME LOG_STREAM_FOLDER "/r_submix_in.raw"
  96 // File permissions for stream log files.
  97 #define LOG_STREAM_FILE_PERMISSIONS (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
  98 #endif // LOG_STREAMS_TO_FILES
  99 // limit for number of read error log entries to avoid spamming the logs
 100 #define MAX_READ_ERROR_LOGS 5
 101
 102 // Common limits macros.
 103 #ifndef min
 104 #define min(a, b) ((a) < (b) ? (a) : (b))
 105 #endif // min
 106 #ifndef max
 107 #define max(a, b) ((a) > (b) ? (a) : (b))
 108 #endif // max
 109
 110 // Set *result_variable_ptr to true if value_to_find is present in the array array_to_search,
 111 // otherwise set *result_variable_ptr to false.
 112 #define SUBMIX_VALUE_IN_SET(value_to_find, array_to_search, result_variable_ptr) \
 113     { \
 114         size_t i; \
 115         *(result_variable_ptr) = false; \
 116         for (i = 0; i < sizeof(array_to_search) / sizeof((array_to_search)[0]); i++) { \
 117           if ((value_to_find) == (array_to_search)[i]) { \
 118                 *(result_variable_ptr) = true; \
 119                 break; \
 120             } \
 121         } \
 122     }
 123
 124 // Configuration of the submix pipe.
 125 struct submix_config {
 126     // Channel mask field in this data structure is set to either input_channel_mask or
 127     // output_channel_mask depending upon the last stream to be opened on this device.
 128     struct audio_config common;
 129     // Input stream and output stream channel masks.  This is required since input and output
 130     // channel bitfields are not equivalent.
 131     audio_channel_mask_t input_channel_mask;
 132     audio_channel_mask_t output_channel_mask;
 133 #if ENABLE_RESAMPLING
 134     // Input stream and output stream sample rates.
 135     uint32_t input_sample_rate;
 136     uint32_t output_sample_rate;
 137 #endif // ENABLE_RESAMPLING
 138     size_t pipe_frame_size;  // Number of bytes in each audio frame in the pipe.
 139     size_t buffer_size_frames; // Size of the audio pipe in frames.
 140     // Maximum number of frames buffered by the input and output streams.
 141     size_t buffer_period_size_frames;
 142 };
 143
 144 #define MAX_ROUTES 10
 145 typedef struct route_config {
 146     struct submix_config config;
 147     char address[AUDIO_DEVICE_MAX_ADDRESS_LEN];
 148     // Pipe variables: they handle the ring buffer that "pipes" audio:
 149     //  - from the submix virtual audio output == what needs to be played
 150     //    remotely, seen as an output for AudioFlinger
 151     //  - to the virtual audio source == what is captured by the component
 152     //    which "records" the submix / virtual audio source, and handles it as needed.
 153     // A usecase example is one where the component capturing the audio is then sending it over
 154     // Wifi for presentation on a remote Wifi Display device (e.g. a dongle attached to a TV, or a
 155     // TV with Wifi Display capabilities), or to a wireless audio player.
 156     sp<MonoPipe> rsxSink;
 157     sp<MonoPipeReader> rsxSource;
 158     // Pointers to the current input and output stream instances.  rsxSink and rsxSource are
 159     // destroyed if both and input and output streams are destroyed.
 160     struct submix_stream_out *output;
 161     struct submix_stream_in *input;
 162 #if ENABLE_RESAMPLING
 163     // Buffer used as temporary storage for resampled data prior to returning data to the output
 164     // stream.
 165     int16_t resampler_buffer[DEFAULT_PIPE_SIZE_IN_FRAMES];
 166 #endif // ENABLE_RESAMPLING
 167 } route_config_t;
 168
 169 struct submix_audio_device {
 170     struct audio_hw_device device;
 171     route_config_t routes[MAX_ROUTES];
 172     // Device lock, also used to protect access to submix_audio_device from the input and output
 173     // streams.
 174     pthread_mutex_t lock;
 175 };
 176
 177 struct submix_stream_out {
 178     struct audio_stream_out stream;
 179     struct submix_audio_device *dev;
 180     int route_handle;
 181     bool output_standby;
 182     uint64_t frames_written;
 183     uint64_t frames_written_since_standby;
 184 #if LOG_STREAMS_TO_FILES
 185     int log_fd;
 186 #endif // LOG_STREAMS_TO_FILES
 187 };
 188
 189 struct submix_stream_in {
 190     struct audio_stream_in stream;
 191     struct submix_audio_device *dev;
 192     int route_handle;
 193     bool input_standby;
 194     bool output_standby_rec_thr; // output standby state as seen from record thread
 195     // wall clock when recording starts
 196     struct timespec record_start_time;
 197     // how many frames have been requested to be read
 198     uint64_t read_counter_frames;
 199
 200 #if ENABLE_LEGACY_INPUT_OPEN
 201     // Number of references to this input stream.
 202     volatile int32_t ref_count;
 203 #endif // ENABLE_LEGACY_INPUT_OPEN
 204 #if LOG_STREAMS_TO_FILES
 205     int log_fd;
 206 #endif // LOG_STREAMS_TO_FILES
 207
 208     volatile int16_t read_error_count;
 209 };
 210
 211 // Determine whether the specified sample rate is supported by the submix module.
 212 static bool sample_rate_supported(const uint32_t sample_rate)
 213 {
 214     // Set of sample rates supported by Format_from_SR_C() frameworks/av/media/libnbaio/NAIO.cpp.
 215     static const unsigned int supported_sample_rates[] = {
 216         8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000,
 217     };
 218     bool return_value;
 219     SUBMIX_VALUE_IN_SET(sample_rate, supported_sample_rates, &return_value);
 220     return return_value;
 221 }
 222
 223 // Determine whether the specified sample rate is supported, if it is return the specified sample
 224 // rate, otherwise return the default sample rate for the submix module.
 225 static uint32_t get_supported_sample_rate(uint32_t sample_rate)
 226 {
 227   return sample_rate_supported(sample_rate) ? sample_rate : DEFAULT_SAMPLE_RATE_HZ;
 228 }
 229
 230 // Determine whether the specified channel in mask is supported by the submix module.
 231 static bool channel_in_mask_supported(const audio_channel_mask_t channel_in_mask)
 232 {
 233     // Set of channel in masks supported by Format_from_SR_C()
 234     // frameworks/av/media/libnbaio/NAIO.cpp.
 235     static const audio_channel_mask_t supported_channel_in_masks[] = {
 236         AUDIO_CHANNEL_IN_MONO, AUDIO_CHANNEL_IN_STEREO,
 237     };
 238     bool return_value;
 239     SUBMIX_VALUE_IN_SET(channel_in_mask, supported_channel_in_masks, &return_value);
 240     return return_value;
 241 }
 242
 243 // Determine whether the specified channel in mask is supported, if it is return the specified
 244 // channel in mask, otherwise return the default channel in mask for the submix module.
 245 static audio_channel_mask_t get_supported_channel_in_mask(
 246         const audio_channel_mask_t channel_in_mask)
 247 {
 248     return channel_in_mask_supported(channel_in_mask) ? channel_in_mask :
 249             static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_IN_STEREO);
 250 }
 251
 252 // Determine whether the specified channel out mask is supported by the submix module.
 253 static bool channel_out_mask_supported(const audio_channel_mask_t channel_out_mask)
 254 {
 255     // Set of channel out masks supported by Format_from_SR_C()
 256     // frameworks/av/media/libnbaio/NAIO.cpp.
 257     static const audio_channel_mask_t supported_channel_out_masks[] = {
 258         AUDIO_CHANNEL_OUT_MONO, AUDIO_CHANNEL_OUT_STEREO,
 259     };
 260     bool return_value;
 261     SUBMIX_VALUE_IN_SET(channel_out_mask, supported_channel_out_masks, &return_value);
 262     return return_value;
 263 }
 264
 265 // Determine whether the specified channel out mask is supported, if it is return the specified
 266 // channel out mask, otherwise return the default channel out mask for the submix module.
 267 static audio_channel_mask_t get_supported_channel_out_mask(
 268         const audio_channel_mask_t channel_out_mask)
 269 {
 270     return channel_out_mask_supported(channel_out_mask) ? channel_out_mask :
 271         static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_OUT_STEREO);
 272 }
 273
 274 // Get a pointer to submix_stream_out given an audio_stream_out that is embedded within the
 275 // structure.
 276 static struct submix_stream_out * audio_stream_out_get_submix_stream_out(
 277         struct audio_stream_out * const stream)
 278 {
 279     ALOG_ASSERT(stream);
 280     return reinterpret_cast<struct submix_stream_out *>(reinterpret_cast<uint8_t *>(stream) -
 281                 offsetof(struct submix_stream_out, stream));
 282 }
 283
 284 // Get a pointer to submix_stream_out given an audio_stream that is embedded within the structure.
 285 static struct submix_stream_out * audio_stream_get_submix_stream_out(
 286         struct audio_stream * const stream)
 287 {
 288     ALOG_ASSERT(stream);
 289     return audio_stream_out_get_submix_stream_out(
 290             reinterpret_cast<struct audio_stream_out *>(stream));
 291 }
 292
 293 // Get a pointer to submix_stream_in given an audio_stream_in that is embedded within the
 294 // structure.
 295 static struct submix_stream_in * audio_stream_in_get_submix_stream_in(
 296         struct audio_stream_in * const stream)
 297 {
 298     ALOG_ASSERT(stream);
 299     return reinterpret_cast<struct submix_stream_in *>(reinterpret_cast<uint8_t *>(stream) -
 300             offsetof(struct submix_stream_in, stream));
 301 }
 302
 303 // Get a pointer to submix_stream_in given an audio_stream that is embedded within the structure.
 304 static struct submix_stream_in * audio_stream_get_submix_stream_in(
 305         struct audio_stream * const stream)
 306 {
 307     ALOG_ASSERT(stream);
 308     return audio_stream_in_get_submix_stream_in(
 309             reinterpret_cast<struct audio_stream_in *>(stream));
 310 }
 311
 312 // Get a pointer to submix_audio_device given a pointer to an audio_device that is embedded within
 313 // the structure.
 314 static struct submix_audio_device * audio_hw_device_get_submix_audio_device(
 315         struct audio_hw_device *device)
 316 {
 317     ALOG_ASSERT(device);
 318     return reinterpret_cast<struct submix_audio_device *>(reinterpret_cast<uint8_t *>(device) -
 319         offsetof(struct submix_audio_device, device));
 320 }
 321
 322 // Compare an audio_config with input channel mask and an audio_config with output channel mask
 323 // returning false if they do *not* match, true otherwise.
 324 static bool audio_config_compare(const audio_config * const input_config,
 325         const audio_config * const output_config)
 326 {
 327 #if !ENABLE_CHANNEL_CONVERSION
 328     const uint32_t input_channels = audio_channel_count_from_in_mask(input_config->channel_mask);
 329     const uint32_t output_channels = audio_channel_count_from_out_mask(output_config->channel_mask);
 330     if (input_channels != output_channels) {
 331         ALOGE("audio_config_compare() channel count mismatch input=%d vs. output=%d",
 332               input_channels, output_channels);
 333         return false;
 334     }
 335 #endif // !ENABLE_CHANNEL_CONVERSION
 336 #if ENABLE_RESAMPLING
 337     if (input_config->sample_rate != output_config->sample_rate &&
 338             audio_channel_count_from_in_mask(input_config->channel_mask) != 1) {
 339 #else
 340     if (input_config->sample_rate != output_config->sample_rate) {
 341 #endif // ENABLE_RESAMPLING
 342         ALOGE("audio_config_compare() sample rate mismatch %ul vs. %ul",
 343               input_config->sample_rate, output_config->sample_rate);
 344         return false;
 345     }
 346     if (input_config->format != output_config->format) {
 347         ALOGE("audio_config_compare() format mismatch %x vs. %x",
 348               input_config->format, output_config->format);
 349         return false;
 350     }
 351     // This purposely ignores offload_info as it's not required for the submix device.
 352     return true;
 353 }
 354
 355 // If one doesn't exist, create a pipe for the submix audio device rsxadev of size
 356 // buffer_size_frames and optionally associate "in" or "out" with the submix audio device.
 357 // Must be called with lock held on the submix_audio_device
 358 static void submix_audio_device_create_pipe_l(struct submix_audio_device * const rsxadev,
 359                                             const struct audio_config * const config,
 360                                             const size_t buffer_size_frames,
 361                                             const uint32_t buffer_period_count,
 362                                             struct submix_stream_in * const in,
 363                                             struct submix_stream_out * const out,
 364                                             const char *address,
 365                                             int route_idx)
 366 {
 367     ALOG_ASSERT(in || out);
 368     ALOG_ASSERT(route_idx > -1);
 369     ALOG_ASSERT(route_idx < MAX_ROUTES);
 370     ALOGD("submix_audio_device_create_pipe_l(addr=%s, idx=%d)", address, route_idx);
 371
 372     // Save a reference to the specified input or output stream and the associated channel
 373     // mask.
 374     if (in) {
 375         in->route_handle = route_idx;
 376         rsxadev->routes[route_idx].input = in;
 377         rsxadev->routes[route_idx].config.input_channel_mask = config->channel_mask;
 378 #if ENABLE_RESAMPLING
 379         rsxadev->routes[route_idx].config.input_sample_rate = config->sample_rate;
 380         // If the output isn't configured yet, set the output sample rate to the maximum supported
 381         // sample rate such that the smallest possible input buffer is created, and put a default
 382         // value for channel count
 383         if (!rsxadev->routes[route_idx].output) {
 384             rsxadev->routes[route_idx].config.output_sample_rate = 48000;
 385             rsxadev->routes[route_idx].config.output_channel_mask = AUDIO_CHANNEL_OUT_STEREO;
 386         }
 387 #endif // ENABLE_RESAMPLING
 388     }
 389     if (out) {
 390         out->route_handle = route_idx;
 391         rsxadev->routes[route_idx].output = out;
 392         rsxadev->routes[route_idx].config.output_channel_mask = config->channel_mask;
 393 #if ENABLE_RESAMPLING
 394         rsxadev->routes[route_idx].config.output_sample_rate = config->sample_rate;
 395 #endif // ENABLE_RESAMPLING
 396     }
 397     // Save the address
 398     strncpy(rsxadev->routes[route_idx].address, address, AUDIO_DEVICE_MAX_ADDRESS_LEN);
 399     ALOGD("  now using address %s for route %d", rsxadev->routes[route_idx].address, route_idx);
 400     // If a pipe isn't associated with the device, create one.
 401     if (rsxadev->routes[route_idx].rsxSink == NULL || rsxadev->routes[route_idx].rsxSource == NULL)
 402     {
 403         struct submix_config * const device_config = &rsxadev->routes[route_idx].config;
 404         uint32_t channel_count;
 405         if (out)
 406             channel_count = audio_channel_count_from_out_mask(config->channel_mask);
 407         else
 408             channel_count = audio_channel_count_from_in_mask(config->channel_mask);
 409 #if ENABLE_CHANNEL_CONVERSION
 410         // If channel conversion is enabled, allocate enough space for the maximum number of
 411         // possible channels stored in the pipe for the situation when the number of channels in
 412         // the output stream don't match the number in the input stream.
 413         const uint32_t pipe_channel_count = max(channel_count, 2);
 414 #else
 415         const uint32_t pipe_channel_count = channel_count;
 416 #endif // ENABLE_CHANNEL_CONVERSION
 417         const NBAIO_Format format = Format_from_SR_C(config->sample_rate, pipe_channel_count,
 418             config->format);
 419         const NBAIO_Format offers[1] = {format};
 420         size_t numCounterOffers = 0;
 421         // Create a MonoPipe with optional blocking set to true.
 422         MonoPipe* sink = new MonoPipe(buffer_size_frames, format, true /*writeCanBlock*/);
 423         // Negotiation between the source and sink cannot fail as the device open operation
 424         // creates both ends of the pipe using the same audio format.
 425         ssize_t index = sink->negotiate(offers, 1, NULL, numCounterOffers);
 426         ALOG_ASSERT(index == 0);
 427         MonoPipeReader* source = new MonoPipeReader(sink);
 428         numCounterOffers = 0;
 429         index = source->negotiate(offers, 1, NULL, numCounterOffers);
 430         ALOG_ASSERT(index == 0);
 431         ALOGV("submix_audio_device_create_pipe_l(): created pipe");
 432
 433         // Save references to the source and sink.
 434         ALOG_ASSERT(rsxadev->routes[route_idx].rsxSink == NULL);
 435         ALOG_ASSERT(rsxadev->routes[route_idx].rsxSource == NULL);
 436         rsxadev->routes[route_idx].rsxSink = sink;
 437         rsxadev->routes[route_idx].rsxSource = source;
 438         // Store the sanitized audio format in the device so that it's possible to determine
 439         // the format of the pipe source when opening the input device.
 440         memcpy(&device_config->common, config, sizeof(device_config->common));
 441         device_config->buffer_size_frames = sink->maxFrames();
 442         device_config->buffer_period_size_frames = device_config->buffer_size_frames /
 443                 buffer_period_count;
 444         if (in) device_config->pipe_frame_size = audio_stream_in_frame_size(&in->stream);
 445         if (out) device_config->pipe_frame_size = audio_stream_out_frame_size(&out->stream);
 446 #if ENABLE_CHANNEL_CONVERSION
 447         // Calculate the pipe frame size based upon the number of channels.
 448         device_config->pipe_frame_size = (device_config->pipe_frame_size * pipe_channel_count) /
 449                 channel_count;
 450 #endif // ENABLE_CHANNEL_CONVERSION
 451         SUBMIX_ALOGV("submix_audio_device_create_pipe_l(): pipe frame size %zd, pipe size %zd, "
 452                      "period size %zd", device_config->pipe_frame_size,
 453                      device_config->buffer_size_frames, device_config->buffer_period_size_frames);
 454     }
 455 }
 456
 457 // Release references to the sink and source.  Input and output threads may maintain references
 458 // to these objects via StrongPointer (sp<MonoPipe> and sp<MonoPipeReader>) which they can use
 459 // before they shutdown.
 460 // Must be called with lock held on the submix_audio_device
 461 static void submix_audio_device_release_pipe_l(struct submix_audio_device * const rsxadev,
 462         int route_idx)
 463 {
 464     ALOG_ASSERT(route_idx > -1);
 465     ALOG_ASSERT(route_idx < MAX_ROUTES);
 466     ALOGD("submix_audio_device_release_pipe_l(idx=%d) addr=%s", route_idx,
 467             rsxadev->routes[route_idx].address);
 468     if (rsxadev->routes[route_idx].rsxSink != 0) {
 469         rsxadev->routes[route_idx].rsxSink.clear();
 470         rsxadev->routes[route_idx].rsxSink = 0;
 471     }
 472     if (rsxadev->routes[route_idx].rsxSource != 0) {
 473         rsxadev->routes[route_idx].rsxSource.clear();
 474         rsxadev->routes[route_idx].rsxSource = 0;
 475     }
 476     memset(rsxadev->routes[route_idx].address, 0, AUDIO_DEVICE_MAX_ADDRESS_LEN);
 477 #ifdef ENABLE_RESAMPLING
 478     memset(rsxadev->routes[route_idx].resampler_buffer, 0,
 479             sizeof(int16_t) * DEFAULT_PIPE_SIZE_IN_FRAMES);
 480 #endif
 481 }
 482
 483 // Remove references to the specified input and output streams.  When the device no longer
 484 // references input and output streams destroy the associated pipe.
 485 // Must be called with lock held on the submix_audio_device
 486 static void submix_audio_device_destroy_pipe_l(struct submix_audio_device * const rsxadev,
 487                                              const struct submix_stream_in * const in,
 488                                              const struct submix_stream_out * const out)
 489 {
 490     MonoPipe* sink;
 491     ALOGV("submix_audio_device_destroy_pipe_l()");
 492     int route_idx = -1;
 493     if (in != NULL) {
 494 #if ENABLE_LEGACY_INPUT_OPEN
 495         const_cast<struct submix_stream_in*>(in)->ref_count--;
 496         route_idx = in->route_handle;
 497         ALOG_ASSERT(rsxadev->routes[route_idx].input == in);
 498         if (in->ref_count == 0) {
 499             rsxadev->routes[route_idx].input = NULL;
 500         }
 501         ALOGV("submix_audio_device_destroy_pipe_l(): input ref_count %d", in->ref_count);
 502 #else
 503         rsxadev->input = NULL;
 504 #endif // ENABLE_LEGACY_INPUT_OPEN
 505     }
 506     if (out != NULL) {
 507         route_idx = out->route_handle;
 508         ALOG_ASSERT(rsxadev->routes[route_idx].output == out);
 509         rsxadev->routes[route_idx].output = NULL;
 510     }
 511     if (route_idx != -1 &&
 512             rsxadev->routes[route_idx].input == NULL && rsxadev->routes[route_idx].output == NULL) {
 513         submix_audio_device_release_pipe_l(rsxadev, route_idx);
 514         ALOGD("submix_audio_device_destroy_pipe_l(): pipe destroyed");
 515     }
 516 }
 517
 518 // Sanitize the user specified audio config for a submix input / output stream.
 519 static void submix_sanitize_config(struct audio_config * const config, const bool is_input_format)
 520 {
 521     config->channel_mask = is_input_format ? get_supported_channel_in_mask(config->channel_mask) :
 522             get_supported_channel_out_mask(config->channel_mask);
 523     config->sample_rate = get_supported_sample_rate(config->sample_rate);
 524     config->format = DEFAULT_FORMAT;
 525 }
 526
 527 // Verify a submix input or output stream can be opened.
 528 // Must be called with lock held on the submix_audio_device
 529 static bool submix_open_validate_l(const struct submix_audio_device * const rsxadev,
 530                                  int route_idx,
 531                                  const struct audio_config * const config,
 532                                  const bool opening_input)
 533 {
 534     bool input_open;
 535     bool output_open;
 536     audio_config pipe_config;
 537
 538     // Query the device for the current audio config and whether input and output streams are open.
 539     output_open = rsxadev->routes[route_idx].output != NULL;
 540     input_open = rsxadev->routes[route_idx].input != NULL;
 541     memcpy(&pipe_config, &rsxadev->routes[route_idx].config.common, sizeof(pipe_config));
 542
 543     // If the stream is already open, don't open it again.
 544     if (opening_input ? !ENABLE_LEGACY_INPUT_OPEN && input_open : output_open) {
 545         ALOGE("submix_open_validate_l(): %s stream already open.", opening_input ? "Input" :
 546                 "Output");
 547         return false;
 548     }
 549
 550     SUBMIX_ALOGV("submix_open_validate_l(): sample rate=%d format=%x "
 551                  "%s_channel_mask=%x", config->sample_rate, config->format,
 552                  opening_input ? "in" : "out", config->channel_mask);
 553
 554     // If either stream is open, verify the existing audio config the pipe matches the user
 555     // specified config.
 556     if (input_open || output_open) {
 557         const audio_config * const input_config = opening_input ? config : &pipe_config;
 558         const audio_config * const output_config = opening_input ? &pipe_config : config;
 559         // Get the channel mask of the open device.
 560         pipe_config.channel_mask =
 561             opening_input ? rsxadev->routes[route_idx].config.output_channel_mask :
 562                 rsxadev->routes[route_idx].config.input_channel_mask;
 563         if (!audio_config_compare(input_config, output_config)) {
 564             ALOGE("submix_open_validate_l(): Unsupported format.");
 565             return false;
 566         }
 567     }
 568     return true;
 569 }
 570
 571 // Must be called with lock held on the submix_audio_device
 572 static status_t submix_get_route_idx_for_address_l(const struct submix_audio_device * const rsxadev,
 573                                                  const char* address, /*in*/
 574                                                  int *idx /*out*/)
 575 {
 576     // Do we already have a route for this address
 577     int route_idx = -1;
 578     int route_empty_idx = -1; // index of an empty route slot that can be used if needed
 579     for (int i=0 ; i < MAX_ROUTES ; i++) {
 580         if (strcmp(rsxadev->routes[i].address, "") == 0) {
 581             route_empty_idx = i;
 582         }
 583         if (strncmp(rsxadev->routes[i].address, address, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
 584             route_idx = i;
 585             break;
 586         }
 587     }
 588
 589     if ((route_idx == -1) && (route_empty_idx == -1)) {
 590         ALOGE("Cannot create new route for address %s, max number of routes reached", address);
 591         return -ENOMEM;
 592     }
 593     if (route_idx == -1) {
 594         route_idx = route_empty_idx;
 595     }
 596     *idx = route_idx;
 597     return OK;
 598 }
 599
 600
 601 // Calculate the maximum size of the pipe buffer in frames for the specified stream.
 602 static size_t calculate_stream_pipe_size_in_frames(const struct audio_stream *stream,
 603                                                    const struct submix_config *config,
 604                                                    const size_t pipe_frames,
 605                                                    const size_t stream_frame_size)
 606 {
 607     const size_t pipe_frame_size = config->pipe_frame_size;
 608     const size_t max_frame_size = max(stream_frame_size, pipe_frame_size);
 609     return (pipe_frames * config->pipe_frame_size) / max_frame_size;
 610 }
 611
 612 /* audio HAL functions */
 613
 614 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
 615 {
 616     const struct submix_stream_out * const out = audio_stream_get_submix_stream_out(
 617             const_cast<struct audio_stream *>(stream));
 618 #if ENABLE_RESAMPLING
 619     const uint32_t out_rate = out->dev->routes[out->route_handle].config.output_sample_rate;
 620 #else
 621     const uint32_t out_rate = out->dev->routes[out->route_handle].config.common.sample_rate;
 622 #endif // ENABLE_RESAMPLING
 623     SUBMIX_ALOGV("out_get_sample_rate() returns %u for addr %s",
 624             out_rate, out->dev->routes[out->route_handle].address);
 625     return out_rate;
 626 }
 627
 628 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 629 {
 630     struct submix_stream_out * const out = audio_stream_get_submix_stream_out(stream);
 631 #if ENABLE_RESAMPLING
 632     // The sample rate of the stream can't be changed once it's set since this would change the
 633     // output buffer size and hence break playback to the shared pipe.
 634     if (rate != out->dev->routes[out->route_handle].config.output_sample_rate) {
 635         ALOGE("out_set_sample_rate() resampling enabled can't change sample rate from "
 636               "%u to %u for addr %s",
 637               out->dev->routes[out->route_handle].config.output_sample_rate, rate,
 638               out->dev->routes[out->route_handle].address);
 639         return -ENOSYS;
 640     }
 641 #endif // ENABLE_RESAMPLING
 642     if (!sample_rate_supported(rate)) {
 643         ALOGE("out_set_sample_rate(rate=%u) rate unsupported", rate);
 644         return -ENOSYS;
 645     }
 646     SUBMIX_ALOGV("out_set_sample_rate(rate=%u)", rate);
 647     out->dev->routes[out->route_handle].config.common.sample_rate = rate;
 648     return 0;
 649 }
 650
 651 static size_t out_get_buffer_size(const struct audio_stream *stream)
 652 {
 653     const struct submix_stream_out * const out = audio_stream_get_submix_stream_out(
 654             const_cast<struct audio_stream *>(stream));
 655     const struct submix_config * const config = &out->dev->routes[out->route_handle].config;
 656     const size_t stream_frame_size =
 657                             audio_stream_out_frame_size((const struct audio_stream_out *)stream);
 658     const size_t buffer_size_frames = calculate_stream_pipe_size_in_frames(
 659         stream, config, config->buffer_period_size_frames, stream_frame_size);
 660     const size_t buffer_size_bytes = buffer_size_frames * stream_frame_size;
 661     SUBMIX_ALOGV("out_get_buffer_size() returns %zu bytes, %zu frames",
 662                  buffer_size_bytes, buffer_size_frames);
 663     return buffer_size_bytes;
 664 }
 665
 666 static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
 667 {
 668     const struct submix_stream_out * const out = audio_stream_get_submix_stream_out(
 669             const_cast<struct audio_stream *>(stream));
 670     uint32_t channel_mask = out->dev->routes[out->route_handle].config.output_channel_mask;
 671     SUBMIX_ALOGV("out_get_channels() returns %08x", channel_mask);
 672     return channel_mask;
 673 }
 674
 675 static audio_format_t out_get_format(const struct audio_stream *stream)
 676 {
 677     const struct submix_stream_out * const out = audio_stream_get_submix_stream_out(
 678             const_cast<struct audio_stream *>(stream));
 679     const audio_format_t format = out->dev->routes[out->route_handle].config.common.format;
 680     SUBMIX_ALOGV("out_get_format() returns %x", format);
 681     return format;
 682 }
 683
 684 static int out_set_format(struct audio_stream *stream, audio_format_t format)
 685 {
 686     const struct submix_stream_out * const out = audio_stream_get_submix_stream_out(stream);
 687     if (format != out->dev->routes[out->route_handle].config.common.format) {
 688         ALOGE("out_set_format(format=%x) format unsupported", format);
 689         return -ENOSYS;
 690     }
 691     SUBMIX_ALOGV("out_set_format(format=%x)", format);
 692     return 0;
 693 }
 694
 695 static int out_standby(struct audio_stream *stream)
 696 {
 697     ALOGI("out_standby()");
 698     struct submix_stream_out * const out = audio_stream_get_submix_stream_out(stream);
 699     struct submix_audio_device * const rsxadev = out->dev;
 700
 701     pthread_mutex_lock(&rsxadev->lock);
 702
 703     out->output_standby = true;
 704     out->frames_written_since_standby = 0;
 705
 706     pthread_mutex_unlock(&rsxadev->lock);
 707
 708     return 0;
 709 }
 710
 711 static int out_dump(const struct audio_stream *stream, int fd)
 712 {
 713     (void)stream;
 714     (void)fd;
 715     return 0;
 716 }
 717
 718 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
 719 {
 720     int exiting = -1;
 721     AudioParameter parms = AudioParameter(String8(kvpairs));
 722     SUBMIX_ALOGV("out_set_parameters() kvpairs='%s'", kvpairs);
 723
 724     // FIXME this is using hard-coded strings but in the future, this functionality will be
 725     //       converted to use audio HAL extensions required to support tunneling
 726     if ((parms.getInt(String8("exiting"), exiting) == NO_ERROR) && (exiting > 0)) {
 727         struct submix_audio_device * const rsxadev =
 728                 audio_stream_get_submix_stream_out(stream)->dev;
 729         pthread_mutex_lock(&rsxadev->lock);
 730         { // using the sink
 731             sp<MonoPipe> sink =
 732                     rsxadev->routes[audio_stream_get_submix_stream_out(stream)->route_handle]
 733                                     .rsxSink;
 734             if (sink == NULL) {
 735                 pthread_mutex_unlock(&rsxadev->lock);
 736                 return 0;
 737             }
 738
 739             ALOGD("out_set_parameters(): shutting down MonoPipe sink");
 740             sink->shutdown(true);
 741         } // done using the sink
 742         pthread_mutex_unlock(&rsxadev->lock);
 743     }
 744     return 0;
 745 }
 746
 747 static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
 748 {
 749     (void)stream;
 750     (void)keys;
 751     return strdup("");
 752 }
 753
 754 static uint32_t out_get_latency(const struct audio_stream_out *stream)
 755 {
 756     const struct submix_stream_out * const out = audio_stream_out_get_submix_stream_out(
 757             const_cast<struct audio_stream_out *>(stream));
 758     const struct submix_config * const config = &out->dev->routes[out->route_handle].config;
 759     const size_t stream_frame_size =
 760                             audio_stream_out_frame_size(stream);
 761     const size_t buffer_size_frames = calculate_stream_pipe_size_in_frames(
 762             &stream->common, config, config->buffer_size_frames, stream_frame_size);
 763     const uint32_t sample_rate = out_get_sample_rate(&stream->common);
 764     const uint32_t latency_ms = (buffer_size_frames * 1000) / sample_rate;
 765     SUBMIX_ALOGV("out_get_latency() returns %u ms, size in frames %zu, sample rate %u",
 766                  latency_ms, buffer_size_frames, sample_rate);
 767     return latency_ms;
 768 }
 769
 770 static int out_set_volume(struct audio_stream_out *stream, float left,
 771                           float right)
 772 {
 773     (void)stream;
 774     (void)left;
 775     (void)right;
 776     return -ENOSYS;
 777 }
 778
 779 static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
 780                          size_t bytes)
 781 {
 782     SUBMIX_ALOGV("out_write(bytes=%zd)", bytes);
 783     ssize_t written_frames = 0;
 784     const size_t frame_size = audio_stream_out_frame_size(stream);
 785     struct submix_stream_out * const out = audio_stream_out_get_submix_stream_out(stream);
 786     struct submix_audio_device * const rsxadev = out->dev;
 787     const size_t frames = bytes / frame_size;
 788
 789     pthread_mutex_lock(&rsxadev->lock);
 790
 791     out->output_standby = false;
 792
 793     sp<MonoPipe> sink = rsxadev->routes[out->route_handle].rsxSink;
 794     if (sink != NULL) {
 795         if (sink->isShutdown()) {
 796             sink.clear();
 797             pthread_mutex_unlock(&rsxadev->lock);
 798             SUBMIX_ALOGV("out_write(): pipe shutdown, ignoring the write.");
 799             // the pipe has already been shutdown, this buffer will be lost but we must
 800             //   simulate timing so we don't drain the output faster than realtime
 801             usleep(frames * 1000000 / out_get_sample_rate(&stream->common));
 802             return bytes;
 803         }
 804     } else {
 805         pthread_mutex_unlock(&rsxadev->lock);
 806         ALOGE("out_write without a pipe!");
 807         ALOG_ASSERT("out_write without a pipe!");
 808         return 0;
 809     }
 810
 811     // If the write to the sink would block when no input stream is present, flush enough frames
 812     // from the pipe to make space to write the most recent data.
 813     {
 814         const size_t availableToWrite = sink->availableToWrite();
 815         sp<MonoPipeReader> source = rsxadev->routes[out->route_handle].rsxSource;
 816         if (rsxadev->routes[out->route_handle].input == NULL && availableToWrite < frames) {
 817             static uint8_t flush_buffer[64];
 818             const size_t flushBufferSizeFrames = sizeof(flush_buffer) / frame_size;
 819             size_t frames_to_flush_from_source = frames - availableToWrite;
 820             SUBMIX_ALOGV("out_write(): flushing %d frames from the pipe to avoid blocking",
 821                          frames_to_flush_from_source);
 822             while (frames_to_flush_from_source) {
 823                 const size_t flush_size = min(frames_to_flush_from_source, flushBufferSizeFrames);
 824                 frames_to_flush_from_source -= flush_size;
 825                 // read does not block
 826                 source->read(flush_buffer, flush_size);
 827             }
 828         }
 829     }
 830
 831     pthread_mutex_unlock(&rsxadev->lock);
 832
 833     written_frames = sink->write(buffer, frames);
 834
 835 #if LOG_STREAMS_TO_FILES
 836     if (out->log_fd >= 0) write(out->log_fd, buffer, written_frames * frame_size);
 837 #endif // LOG_STREAMS_TO_FILES
 838
 839     if (written_frames < 0) {
 840         if (written_frames == (ssize_t)NEGOTIATE) {
 841             ALOGE("out_write() write to pipe returned NEGOTIATE");
 842
 843             pthread_mutex_lock(&rsxadev->lock);
 844             sink.clear();
 845             pthread_mutex_unlock(&rsxadev->lock);
 846
 847             written_frames = 0;
 848             return 0;
 849         } else {
 850             // write() returned UNDERRUN or WOULD_BLOCK, retry
 851             ALOGE("out_write() write to pipe returned unexpected %zd", written_frames);
 852             written_frames = sink->write(buffer, frames);
 853         }
 854     }
 855
 856     pthread_mutex_lock(&rsxadev->lock);
 857     sink.clear();
 858     if (written_frames > 0) {
 859         out->frames_written_since_standby += written_frames;
 860         out->frames_written += written_frames;
 861     }
 862     pthread_mutex_unlock(&rsxadev->lock);
 863
 864     if (written_frames < 0) {
 865         ALOGE("out_write() failed writing to pipe with %zd", written_frames);
 866         return 0;
 867     }
 868     const ssize_t written_bytes = written_frames * frame_size;
 869     SUBMIX_ALOGV("out_write() wrote %zd bytes %zd frames", written_bytes, written_frames);
 870     return written_bytes;
 871 }
 872
 873 static int out_get_presentation_position(const struct audio_stream_out *stream,
 874                                    uint64_t *frames, struct timespec *timestamp)
 875 {
 876     if (stream == NULL || frames == NULL || timestamp == NULL) {
 877         return -EINVAL;
 878     }
 879
 880     const submix_stream_out *out = audio_stream_out_get_submix_stream_out(
 881             const_cast<struct audio_stream_out *>(stream));
 882     struct submix_audio_device * const rsxadev = out->dev;
 883
 884     int ret = -EWOULDBLOCK;
 885     pthread_mutex_lock(&rsxadev->lock);
 886     const ssize_t frames_in_pipe =
 887             rsxadev->routes[out->route_handle].rsxSource->availableToRead();
 888     if (CC_UNLIKELY(frames_in_pipe < 0)) {
 889         *frames = out->frames_written;
 890         ret = 0;
 891     } else if (out->frames_written >= (uint64_t)frames_in_pipe) {
 892         *frames = out->frames_written - frames_in_pipe;
 893         ret = 0;
 894     }
 895     pthread_mutex_unlock(&rsxadev->lock);
 896
 897     if (ret == 0) {
 898         clock_gettime(CLOCK_MONOTONIC, timestamp);
 899     }
 900
 901     SUBMIX_ALOGV("out_get_presentation_position() got frames=%llu timestamp sec=%llu",
 902             frames ? *frames : -1, timestamp ? timestamp->tv_sec : -1);
 903
 904     return ret;
 905 }
 906
 907 static int out_get_render_position(const struct audio_stream_out *stream,
 908                                    uint32_t *dsp_frames)
 909 {
 910     if (stream == NULL || dsp_frames == NULL) {
 911         return -EINVAL;
 912     }
 913
 914     const submix_stream_out *out = audio_stream_out_get_submix_stream_out(
 915             const_cast<struct audio_stream_out *>(stream));
 916     struct submix_audio_device * const rsxadev = out->dev;
 917
 918     pthread_mutex_lock(&rsxadev->lock);
 919     const ssize_t frames_in_pipe =
 920             rsxadev->routes[out->route_handle].rsxSource->availableToRead();
 921     if (CC_UNLIKELY(frames_in_pipe < 0)) {
 922         *dsp_frames = (uint32_t)out->frames_written_since_standby;
 923     } else {
 924         *dsp_frames = out->frames_written_since_standby > (uint64_t) frames_in_pipe ?
 925                 (uint32_t)(out->frames_written_since_standby - frames_in_pipe) : 0;
 926     }
 927     pthread_mutex_unlock(&rsxadev->lock);
 928
 929     return 0;
 930 }
 931
 932 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
 933 {
 934     (void)stream;
 935     (void)effect;
 936     return 0;
 937 }
 938
 939 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
 940 {
 941     (void)stream;
 942     (void)effect;
 943     return 0;
 944 }
 945
 946 static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
 947                                         int64_t *timestamp)
 948 {
 949     (void)stream;
 950     (void)timestamp;
 951     return -EINVAL;
 952 }
 953
 954 /** audio_stream_in implementation **/
 955 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
 956 {
 957     const struct submix_stream_in * const in = audio_stream_get_submix_stream_in(
 958         const_cast<struct audio_stream*>(stream));
 959 #if ENABLE_RESAMPLING
 960     const uint32_t rate = in->dev->routes[in->route_handle].config.input_sample_rate;
 961 #else
 962     const uint32_t rate = in->dev->routes[in->route_handle].config.common.sample_rate;
 963 #endif // ENABLE_RESAMPLING
 964     SUBMIX_ALOGV("in_get_sample_rate() returns %u", rate);
 965     return rate;
 966 }
 967
 968 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 969 {
 970     const struct submix_stream_in * const in = audio_stream_get_submix_stream_in(stream);
 971 #if ENABLE_RESAMPLING
 972     // The sample rate of the stream can't be changed once it's set since this would change the
 973     // input buffer size and hence break recording from the shared pipe.
 974     if (rate != in->dev->routes[in->route_handle].config.input_sample_rate) {
 975         ALOGE("in_set_sample_rate() resampling enabled can't change sample rate from "
 976               "%u to %u", in->dev->routes[in->route_handle].config.input_sample_rate, rate);
 977         return -ENOSYS;
 978     }
 979 #endif // ENABLE_RESAMPLING
 980     if (!sample_rate_supported(rate)) {
 981         ALOGE("in_set_sample_rate(rate=%u) rate unsupported", rate);
 982         return -ENOSYS;
 983     }
 984     in->dev->routes[in->route_handle].config.common.sample_rate = rate;
 985     SUBMIX_ALOGV("in_set_sample_rate() set %u", rate);
 986     return 0;
 987 }
 988
 989 static size_t in_get_buffer_size(const struct audio_stream *stream)
 990 {
 991     const struct submix_stream_in * const in = audio_stream_get_submix_stream_in(
 992             const_cast<struct audio_stream*>(stream));
 993     const struct submix_config * const config = &in->dev->routes[in->route_handle].config;
 994     const size_t stream_frame_size =
 995                             audio_stream_in_frame_size((const struct audio_stream_in *)stream);
 996     size_t buffer_size_frames = calculate_stream_pipe_size_in_frames(
 997         stream, config, config->buffer_period_size_frames, stream_frame_size);
 998 #if ENABLE_RESAMPLING
 999     // Scale the size of the buffer based upon the maximum number of frames that could be returned
1000     // given the ratio of output to input sample rate.
1001     buffer_size_frames = (size_t)(((float)buffer_size_frames *
1002                                    (float)config->input_sample_rate) /
1003                                   (float)config->output_sample_rate);
1004 #endif // ENABLE_RESAMPLING
1005     const size_t buffer_size_bytes = buffer_size_frames * stream_frame_size;
1006     SUBMIX_ALOGV("in_get_buffer_size() returns %zu bytes, %zu frames", buffer_size_bytes,
1007                  buffer_size_frames);
1008     return buffer_size_bytes;
1009 }
1010
1011 static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
1012 {
1013     const struct submix_stream_in * const in = audio_stream_get_submix_stream_in(
1014             const_cast<struct audio_stream*>(stream));
1015     const audio_channel_mask_t channel_mask =
1016             in->dev->routes[in->route_handle].config.input_channel_mask;
1017     SUBMIX_ALOGV("in_get_channels() returns %x", channel_mask);
1018     return channel_mask;
1019 }
1020
1021 static audio_format_t in_get_format(const struct audio_stream *stream)
1022 {
1023     const struct submix_stream_in * const in = audio_stream_get_submix_stream_in(
1024             const_cast<struct audio_stream*>(stream));
1025     const audio_format_t format = in->dev->routes[in->route_handle].config.common.format;
1026     SUBMIX_ALOGV("in_get_format() returns %x", format);
1027     return format;
1028 }
1029
1030 static int in_set_format(struct audio_stream *stream, audio_format_t format)
1031 {
1032     const struct submix_stream_in * const in = audio_stream_get_submix_stream_in(stream);
1033     if (format != in->dev->routes[in->route_handle].config.common.format) {
1034         ALOGE("in_set_format(format=%x) format unsupported", format);
1035         return -ENOSYS;
1036     }
1037     SUBMIX_ALOGV("in_set_format(format=%x)", format);
1038     return 0;
1039 }
1040
1041 static int in_standby(struct audio_stream *stream)
1042 {
1043     ALOGI("in_standby()");
1044     struct submix_stream_in * const in = audio_stream_get_submix_stream_in(stream);
1045     struct submix_audio_device * const rsxadev = in->dev;
1046
1047     pthread_mutex_lock(&rsxadev->lock);
1048
1049     in->input_standby = true;
1050
1051     pthread_mutex_unlock(&rsxadev->lock);
1052
1053     return 0;
1054 }
1055
1056 static int in_dump(const struct audio_stream *stream, int fd)
1057 {
1058     (void)stream;
1059     (void)fd;
1060     return 0;
1061 }
1062
1063 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
1064 {
1065     (void)stream;
1066     (void)kvpairs;
1067     return 0;
1068 }
1069
1070 static char * in_get_parameters(const struct audio_stream *stream,
1071                                 const char *keys)
1072 {
1073     (void)stream;
1074     (void)keys;
1075     return strdup("");
1076 }
1077
1078 static int in_set_gain(struct audio_stream_in *stream, float gain)
1079 {
1080     (void)stream;
1081     (void)gain;
1082     return 0;
1083 }
1084
1085 static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
1086                        size_t bytes)
1087 {
1088     struct submix_stream_in * const in = audio_stream_in_get_submix_stream_in(stream);
1089     struct submix_audio_device * const rsxadev = in->dev;
1090     struct audio_config *format;
1091     const size_t frame_size = audio_stream_in_frame_size(stream);
1092     const size_t frames_to_read = bytes / frame_size;
1093
1094     SUBMIX_ALOGV("in_read bytes=%zu", bytes);
1095     pthread_mutex_lock(&rsxadev->lock);
1096
1097     const bool output_standby = rsxadev->routes[in->route_handle].output == NULL
1098             ? true : rsxadev->routes[in->route_handle].output->output_standby;
1099     const bool output_standby_transition = (in->output_standby_rec_thr != output_standby);
1100     in->output_standby_rec_thr = output_standby;
1101
1102     if (in->input_standby || output_standby_transition) {
1103         in->input_standby = false;
1104         // keep track of when we exit input standby (== first read == start "real recording")
1105         // or when we start recording silence, and reset projected time
1106         int rc = clock_gettime(CLOCK_MONOTONIC, &in->record_start_time);
1107         if (rc == 0) {
1108             in->read_counter_frames = 0;
1109         }
1110     }
1111
1112     in->read_counter_frames += frames_to_read;
1113     size_t remaining_frames = frames_to_read;
1114
1115     {
1116         // about to read from audio source
1117         sp<MonoPipeReader> source = rsxadev->routes[in->route_handle].rsxSource;
1118         if (source == NULL) {
1119             in->read_error_count++;// ok if it rolls over
1120             ALOGE_IF(in->read_error_count < MAX_READ_ERROR_LOGS,
1121                     "no audio pipe yet we're trying to read! (not all errors will be logged)");
1122             pthread_mutex_unlock(&rsxadev->lock);
1123             usleep(frames_to_read * 1000000 / in_get_sample_rate(&stream->common));
1124             memset(buffer, 0, bytes);
1125             return bytes;
1126         }
1127
1128         pthread_mutex_unlock(&rsxadev->lock);
1129
1130         // read the data from the pipe (it's non blocking)
1131         int attempts = 0;
1132         char* buff = (char*)buffer;
1133 #if ENABLE_CHANNEL_CONVERSION
1134         // Determine whether channel conversion is required.
1135         const uint32_t input_channels = audio_channel_count_from_in_mask(
1136             rsxadev->routes[in->route_handle].config.input_channel_mask);
1137         const uint32_t output_channels = audio_channel_count_from_out_mask(
1138             rsxadev->routes[in->route_handle].config.output_channel_mask);
1139         if (input_channels != output_channels) {
1140             SUBMIX_ALOGV("in_read(): %d output channels will be converted to %d "
1141                          "input channels", output_channels, input_channels);
1142             // Only support 16-bit PCM channel conversion from mono to stereo or stereo to mono.
1143             ALOG_ASSERT(rsxadev->routes[in->route_handle].config.common.format ==
1144                     AUDIO_FORMAT_PCM_16_BIT);
1145             ALOG_ASSERT((input_channels == 1 && output_channels == 2) ||
1146                         (input_channels == 2 && output_channels == 1));
1147         }
1148 #endif // ENABLE_CHANNEL_CONVERSION
1149
1150 #if ENABLE_RESAMPLING
1151         const uint32_t input_sample_rate = in_get_sample_rate(&stream->common);
1152         const uint32_t output_sample_rate =
1153                 rsxadev->routes[in->route_handle].config.output_sample_rate;
1154         const size_t resampler_buffer_size_frames =
1155             sizeof(rsxadev->routes[in->route_handle].resampler_buffer) /
1156                 sizeof(rsxadev->routes[in->route_handle].resampler_buffer[0]);
1157         float resampler_ratio = 1.0f;
1158         // Determine whether resampling is required.
1159         if (input_sample_rate != output_sample_rate) {
1160             resampler_ratio = (float)output_sample_rate / (float)input_sample_rate;
1161             // Only support 16-bit PCM mono resampling.
1162             // NOTE: Resampling is performed after the channel conversion step.
1163             ALOG_ASSERT(rsxadev->routes[in->route_handle].config.common.format ==
1164                     AUDIO_FORMAT_PCM_16_BIT);
1165             ALOG_ASSERT(audio_channel_count_from_in_mask(
1166                     rsxadev->routes[in->route_handle].config.input_channel_mask) == 1);
1167         }
1168 #endif // ENABLE_RESAMPLING
1169
1170         while ((remaining_frames > 0) && (attempts < MAX_READ_ATTEMPTS)) {
1171             ssize_t frames_read = -1977;
1172             size_t read_frames = remaining_frames;
1173 #if ENABLE_RESAMPLING
1174             char* const saved_buff = buff;
1175             if (resampler_ratio != 1.0f) {
1176                 // Calculate the number of frames from the pipe that need to be read to generate
1177                 // the data for the input stream read.
1178                 const size_t frames_required_for_resampler = (size_t)(
1179                     (float)read_frames * (float)resampler_ratio);
1180                 read_frames = min(frames_required_for_resampler, resampler_buffer_size_frames);
1181                 // Read into the resampler buffer.
1182                 buff = (char*)rsxadev->routes[in->route_handle].resampler_buffer;
1183             }
1184 #endif // ENABLE_RESAMPLING
1185 #if ENABLE_CHANNEL_CONVERSION
1186             if (output_channels == 1 && input_channels == 2) {
1187                 // Need to read half the requested frames since the converted output
1188                 // data will take twice the space (mono->stereo).
1189                 read_frames /= 2;
1190             }
1191 #endif // ENABLE_CHANNEL_CONVERSION
1192
1193             SUBMIX_ALOGV("in_read(): frames available to read %zd", source->availableToRead());
1194
1195             frames_read = source->read(buff, read_frames);
1196
1197             SUBMIX_ALOGV("in_read(): frames read %zd", frames_read);
1198
1199 #if ENABLE_CHANNEL_CONVERSION
1200             // Perform in-place channel conversion.
1201             // NOTE: In the following "input stream" refers to the data returned by this function
1202             // and "output stream" refers to the data read from the pipe.
1203             if (input_channels != output_channels && frames_read > 0) {
1204                 int16_t *data = (int16_t*)buff;
1205                 if (output_channels == 2 && input_channels == 1) {
1206                     // Offset into the output stream data in samples.
1207                     ssize_t output_stream_offset = 0;
1208                     for (ssize_t input_stream_frame = 0; input_stream_frame < frames_read;
1209                          input_stream_frame++, output_stream_offset += 2) {
1210                         // Average the content from both channels.
1211                         data[input_stream_frame] = ((int32_t)data[output_stream_offset] +
1212                                                     (int32_t)data[output_stream_offset + 1]) / 2;
1213                     }
1214                 } else if (output_channels == 1 && input_channels == 2) {
1215                     // Offset into the input stream data in samples.
1216                     ssize_t input_stream_offset = (frames_read - 1) * 2;
1217                     for (ssize_t output_stream_frame = frames_read - 1; output_stream_frame >= 0;
1218                          output_stream_frame--, input_stream_offset -= 2) {
1219                         const short sample = data[output_stream_frame];
1220                         data[input_stream_offset] = sample;
1221                         data[input_stream_offset + 1] = sample;
1222                     }
1223                 }
1224             }
1225 #endif // ENABLE_CHANNEL_CONVERSION
1226
1227 #if ENABLE_RESAMPLING
1228             if (resampler_ratio != 1.0f) {
1229                 SUBMIX_ALOGV("in_read(): resampling %zd frames", frames_read);
1230                 const int16_t * const data = (int16_t*)buff;
1231                 int16_t * const resampled_buffer = (int16_t*)saved_buff;
1232                 // Resample with *no* filtering - if the data from the ouptut stream was really
1233                 // sampled at a different rate this will result in very nasty aliasing.
1234                 const float output_stream_frames = (float)frames_read;
1235                 size_t input_stream_frame = 0;
1236                 for (float output_stream_frame = 0.0f;
1237                      output_stream_frame < output_stream_frames &&
1238                      input_stream_frame < remaining_frames;
1239                      output_stream_frame += resampler_ratio, input_stream_frame++) {
1240                     resampled_buffer[input_stream_frame] = data[(size_t)output_stream_frame];
1241                 }
1242                 ALOG_ASSERT(input_stream_frame <= (ssize_t)resampler_buffer_size_frames);
1243                 SUBMIX_ALOGV("in_read(): resampler produced %zd frames", input_stream_frame);
1244                 frames_read = input_stream_frame;
1245                 buff = saved_buff;
1246             }
1247 #endif // ENABLE_RESAMPLING
1248
1249             if (frames_read > 0) {
1250 #if LOG_STREAMS_TO_FILES
1251                 if (in->log_fd >= 0) write(in->log_fd, buff, frames_read * frame_size);
1252 #endif // LOG_STREAMS_TO_FILES
1253
1254                 remaining_frames -= frames_read;
1255                 buff += frames_read * frame_size;
1256                 SUBMIX_ALOGV("  in_read (att=%d) got %zd frames, remaining=%zu",
1257                              attempts, frames_read, remaining_frames);
1258             } else {
1259                 attempts++;
1260                 SUBMIX_ALOGE("  in_read read returned %zd", frames_read);
1261                 usleep(READ_ATTEMPT_SLEEP_MS * 1000);
1262             }
1263         }
1264         // done using the source
1265         pthread_mutex_lock(&rsxadev->lock);
1266         source.clear();
1267         pthread_mutex_unlock(&rsxadev->lock);
1268     }
1269
1270     if (remaining_frames > 0) {
1271         const size_t remaining_bytes = remaining_frames * frame_size;
1272         SUBMIX_ALOGV("  clearing remaining_frames = %zu", remaining_frames);
1273         memset(((char*)buffer)+ bytes - remaining_bytes, 0, remaining_bytes);
1274     }
1275
1276     // compute how much we need to sleep after reading the data by comparing the wall clock with
1277     //   the projected time at which we should return.
1278     struct timespec time_after_read;// wall clock after reading from the pipe
1279     struct timespec record_duration;// observed record duration
1280     int rc = clock_gettime(CLOCK_MONOTONIC, &time_after_read);
1281     const uint32_t sample_rate = in_get_sample_rate(&stream->common);
1282     if (rc == 0) {
1283         // for how long have we been recording?
1284         record_duration.tv_sec  = time_after_read.tv_sec - in->record_start_time.tv_sec;
1285         record_duration.tv_nsec = time_after_read.tv_nsec - in->record_start_time.tv_nsec;
1286         if (record_duration.tv_nsec < 0) {
1287             record_duration.tv_sec--;
1288             record_duration.tv_nsec += 1000000000;
1289         }
1290
1291         // read_counter_frames contains the number of frames that have been read since the
1292         // beginning of recording (including this call): it's converted to usec and compared to
1293         // how long we've been recording for, which gives us how long we must wait to sync the
1294         // projected recording time, and the observed recording time.
1295         long projected_vs_observed_offset_us =
1296                 ((int64_t)(in->read_counter_frames
1297                             - (record_duration.tv_sec*sample_rate)))
1298                         * 1000000 / sample_rate
1299                 - (record_duration.tv_nsec / 1000);
1300
1301         SUBMIX_ALOGV("  record duration %5lds %3ldms, will wait: %7ldus",
1302                 record_duration.tv_sec, record_duration.tv_nsec/1000000,
1303                 projected_vs_observed_offset_us);
1304         if (projected_vs_observed_offset_us > 0) {
1305             usleep(projected_vs_observed_offset_us);
1306         }
1307     }
1308
1309     SUBMIX_ALOGV("in_read returns %zu", bytes);
1310     return bytes;
1311
1312 }
1313
1314 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
1315 {
1316     (void)stream;
1317     return 0;
1318 }
1319
1320 static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
1321 {
1322     (void)stream;
1323     (void)effect;
1324     return 0;
1325 }
1326
1327 static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
1328 {
1329     (void)stream;
1330     (void)effect;
1331     return 0;
1332 }
1333
1334 static int adev_open_output_stream(struct audio_hw_device *dev,
1335                                    audio_io_handle_t handle,
1336                                    audio_devices_t devices,
1337                                    audio_output_flags_t flags,
1338                                    struct audio_config *config,
1339                                    struct audio_stream_out **stream_out,
1340                                    const char *address)
1341 {
1342     struct submix_audio_device * const rsxadev = audio_hw_device_get_submix_audio_device(dev);
1343     ALOGD("adev_open_output_stream(address=%s)", address);
1344     struct submix_stream_out *out;
1345     bool force_pipe_creation = false;
1346     (void)handle;
1347     (void)devices;
1348     (void)flags;
1349
1350     *stream_out = NULL;
1351
1352     // Make sure it's possible to open the device given the current audio config.
1353     submix_sanitize_config(config, false);
1354
1355     int route_idx = -1;
1356
1357     pthread_mutex_lock(&rsxadev->lock);
1358
1359     status_t res = submix_get_route_idx_for_address_l(rsxadev, address, &route_idx);
1360     if (res != OK) {
1361         ALOGE("Error %d looking for address=%s in adev_open_output_stream", res, address);
1362         pthread_mutex_unlock(&rsxadev->lock);
1363         return res;
1364     }
1365
1366     if (!submix_open_validate_l(rsxadev, route_idx, config, false)) {
1367         ALOGE("adev_open_output_stream(): Unable to open output stream for address %s", address);
1368         pthread_mutex_unlock(&rsxadev->lock);
1369         return -EINVAL;
1370     }
1371
1372     out = (struct submix_stream_out *)calloc(1, sizeof(struct submix_stream_out));
1373     if (!out) {
1374         pthread_mutex_unlock(&rsxadev->lock);
1375         return -ENOMEM;
1376     }
1377
1378     // Initialize the function pointer tables (v-tables).
1379     out->stream.common.get_sample_rate = out_get_sample_rate;
1380     out->stream.common.set_sample_rate = out_set_sample_rate;
1381     out->stream.common.get_buffer_size = out_get_buffer_size;
1382     out->stream.common.get_channels = out_get_channels;
1383     out->stream.common.get_format = out_get_format;
1384     out->stream.common.set_format = out_set_format;
1385     out->stream.common.standby = out_standby;
1386     out->stream.common.dump = out_dump;
1387     out->stream.common.set_parameters = out_set_parameters;
1388     out->stream.common.get_parameters = out_get_parameters;
1389     out->stream.common.add_audio_effect = out_add_audio_effect;
1390     out->stream.common.remove_audio_effect = out_remove_audio_effect;
1391     out->stream.get_latency = out_get_latency;
1392     out->stream.set_volume = out_set_volume;
1393     out->stream.write = out_write;
1394     out->stream.get_render_position = out_get_render_position;
1395     out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
1396     out->stream.get_presentation_position = out_get_presentation_position;
1397
1398 #if ENABLE_RESAMPLING
1399     // Recreate the pipe with the correct sample rate so that MonoPipe.write() rate limits
1400     // writes correctly.
1401     force_pipe_creation = rsxadev->routes[route_idx].config.common.sample_rate
1402             != config->sample_rate;
1403 #endif // ENABLE_RESAMPLING
1404
1405     // If the sink has been shutdown or pipe recreation is forced (see above), delete the pipe so
1406     // that it's recreated.
1407     if ((rsxadev->routes[route_idx].rsxSink != NULL
1408             && rsxadev->routes[route_idx].rsxSink->isShutdown()) || force_pipe_creation) {
1409         submix_audio_device_release_pipe_l(rsxadev, route_idx);
1410     }
1411
1412     // Store a pointer to the device from the output stream.
1413     out->dev = rsxadev;
1414     // Initialize the pipe.
1415     ALOGV("adev_open_output_stream(): about to create pipe at index %d", route_idx);
1416     submix_audio_device_create_pipe_l(rsxadev, config, DEFAULT_PIPE_SIZE_IN_FRAMES,
1417             DEFAULT_PIPE_PERIOD_COUNT, NULL, out, address, route_idx);
1418 #if LOG_STREAMS_TO_FILES
1419     out->log_fd = open(LOG_STREAM_OUT_FILENAME, O_CREAT | O_TRUNC | O_WRONLY,
1420                        LOG_STREAM_FILE_PERMISSIONS);
1421     ALOGE_IF(out->log_fd < 0, "adev_open_output_stream(): log file open failed %s",
1422              strerror(errno));
1423     ALOGV("adev_open_output_stream(): log_fd = %d", out->log_fd);
1424 #endif // LOG_STREAMS_TO_FILES
1425     // Return the output stream.
1426     *stream_out = &out->stream;
1427
1428     pthread_mutex_unlock(&rsxadev->lock);
1429     return 0;
1430 }
1431
1432 static void adev_close_output_stream(struct audio_hw_device *dev,
1433                                      struct audio_stream_out *stream)
1434 {
1435     struct submix_audio_device * rsxadev = audio_hw_device_get_submix_audio_device(
1436                     const_cast<struct audio_hw_device*>(dev));
1437     struct submix_stream_out * const out = audio_stream_out_get_submix_stream_out(stream);
1438
1439     pthread_mutex_lock(&rsxadev->lock);
1440     ALOGD("adev_close_output_stream() addr = %s", rsxadev->routes[out->route_handle].address);
1441     submix_audio_device_destroy_pipe_l(audio_hw_device_get_submix_audio_device(dev), NULL, out);
1442 #if LOG_STREAMS_TO_FILES
1443     if (out->log_fd >= 0) close(out->log_fd);
1444 #endif // LOG_STREAMS_TO_FILES
1445
1446     pthread_mutex_unlock(&rsxadev->lock);
1447     free(out);
1448 }
1449
1450 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
1451 {
1452     (void)dev;
1453     (void)kvpairs;
1454     return -ENOSYS;
1455 }
1456
1457 static char * adev_get_parameters(const struct audio_hw_device *dev,
1458                                   const char *keys)
1459 {
1460     (void)dev;
1461     (void)keys;
1462     return strdup("");;
1463 }
1464
1465 static int adev_init_check(const struct audio_hw_device *dev)
1466 {
1467     ALOGI("adev_init_check()");
1468     (void)dev;
1469     return 0;
1470 }
1471
1472 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
1473 {
1474     (void)dev;
1475     (void)volume;
1476     return -ENOSYS;
1477 }
1478
1479 static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
1480 {
1481     (void)dev;
1482     (void)volume;
1483     return -ENOSYS;
1484 }
1485
1486 static int adev_get_master_volume(struct audio_hw_device *dev, float *volume)
1487 {
1488     (void)dev;
1489     (void)volume;
1490     return -ENOSYS;
1491 }
1492
1493 static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
1494 {
1495     (void)dev;
1496     (void)muted;
1497     return -ENOSYS;
1498 }
1499
1500 static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
1501 {
1502     (void)dev;
1503     (void)muted;
1504     return -ENOSYS;
1505 }
1506
1507 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
1508 {
1509     (void)dev;
1510     (void)mode;
1511     return 0;
1512 }
1513
1514 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
1515 {
1516     (void)dev;
1517     (void)state;
1518     return -ENOSYS;
1519 }
1520
1521 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
1522 {
1523     (void)dev;
1524     (void)state;
1525     return -ENOSYS;
1526 }
1527
1528 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
1529                                          const struct audio_config *config)
1530 {
1531     if (audio_is_linear_pcm(config->format)) {
1532         size_t max_buffer_period_size_frames = 0;
1533         struct submix_audio_device * rsxadev = audio_hw_device_get_submix_audio_device(
1534                 const_cast<struct audio_hw_device*>(dev));
1535         // look for the largest buffer period size
1536         for (int i = 0 ; i < MAX_ROUTES ; i++) {
1537             if (rsxadev->routes[i].config.buffer_period_size_frames > max_buffer_period_size_frames)
1538             {
1539                 max_buffer_period_size_frames = rsxadev->routes[i].config.buffer_period_size_frames;
1540             }
1541         }
1542         const size_t frame_size_in_bytes = audio_channel_count_from_in_mask(config->channel_mask) *
1543                 audio_bytes_per_sample(config->format);
1544         const size_t buffer_size = max_buffer_period_size_frames * frame_size_in_bytes;
1545         SUBMIX_ALOGV("adev_get_input_buffer_size() returns %zu bytes, %zu frames",
1546                  buffer_size, buffer_period_size_frames);
1547         return buffer_size;
1548     }
1549     return 0;
1550 }
1551
1552 static int adev_open_input_stream(struct audio_hw_device *dev,
1553                                   audio_io_handle_t handle,
1554                                   audio_devices_t devices,
1555                                   struct audio_config *config,
1556                                   struct audio_stream_in **stream_in,
1557                                   audio_input_flags_t flags __unused,
1558                                   const char *address,
1559                                   audio_source_t source __unused)
1560 {
1561     struct submix_audio_device *rsxadev = audio_hw_device_get_submix_audio_device(dev);
1562     struct submix_stream_in *in;
1563     ALOGD("adev_open_input_stream(addr=%s)", address);
1564     (void)handle;
1565     (void)devices;
1566
1567     *stream_in = NULL;
1568
1569     // Do we already have a route for this address
1570     int route_idx = -1;
1571
1572     pthread_mutex_lock(&rsxadev->lock);
1573
1574     status_t res = submix_get_route_idx_for_address_l(rsxadev, address, &route_idx);
1575     if (res != OK) {
1576         ALOGE("Error %d looking for address=%s in adev_open_input_stream", res, address);
1577         pthread_mutex_unlock(&rsxadev->lock);
1578         return res;
1579     }
1580
1581     // Make sure it's possible to open the device given the current audio config.
1582     submix_sanitize_config(config, true);
1583     if (!submix_open_validate_l(rsxadev, route_idx, config, true)) {
1584         ALOGE("adev_open_input_stream(): Unable to open input stream.");
1585         pthread_mutex_unlock(&rsxadev->lock);
1586         return -EINVAL;
1587     }
1588
1589 #if ENABLE_LEGACY_INPUT_OPEN
1590     in = rsxadev->routes[route_idx].input;
1591     if (in) {
1592         in->ref_count++;
1593         sp<MonoPipe> sink = rsxadev->routes[route_idx].rsxSink;
1594         ALOG_ASSERT(sink != NULL);
1595         // If the sink has been shutdown, delete the pipe.
1596         if (sink != NULL) {
1597             if (sink->isShutdown()) {
1598                 ALOGD(" Non-NULL shut down sink when opening input stream, releasing, refcount=%d",
1599                         in->ref_count);
1600                 submix_audio_device_release_pipe_l(rsxadev, in->route_handle);
1601             } else {
1602                 ALOGD(" Non-NULL sink when opening input stream, refcount=%d", in->ref_count);
1603             }
1604         } else {
1605             ALOGE("NULL sink when opening input stream, refcount=%d", in->ref_count);
1606         }
1607     }
1608 #else
1609     in = NULL;
1610 #endif // ENABLE_LEGACY_INPUT_OPEN
1611
1612     if (!in) {
1613         in = (struct submix_stream_in *)calloc(1, sizeof(struct submix_stream_in));
1614         if (!in) return -ENOMEM;
1615         in->ref_count = 1;
1616
1617         // Initialize the function pointer tables (v-tables).
1618         in->stream.common.get_sample_rate = in_get_sample_rate;
1619         in->stream.common.set_sample_rate = in_set_sample_rate;
1620         in->stream.common.get_buffer_size = in_get_buffer_size;
1621         in->stream.common.get_channels = in_get_channels;
1622         in->stream.common.get_format = in_get_format;
1623         in->stream.common.set_format = in_set_format;
1624         in->stream.common.standby = in_standby;
1625         in->stream.common.dump = in_dump;
1626         in->stream.common.set_parameters = in_set_parameters;
1627         in->stream.common.get_parameters = in_get_parameters;
1628         in->stream.common.add_audio_effect = in_add_audio_effect;
1629         in->stream.common.remove_audio_effect = in_remove_audio_effect;
1630         in->stream.set_gain = in_set_gain;
1631         in->stream.read = in_read;
1632         in->stream.get_input_frames_lost = in_get_input_frames_lost;
1633
1634         in->dev = rsxadev;
1635 #if LOG_STREAMS_TO_FILES
1636         in->log_fd = -1;
1637 #endif
1638     }
1639
1640     // Initialize the input stream.
1641     in->read_counter_frames = 0;
1642     in->input_standby = true;
1643     if (rsxadev->routes[route_idx].output != NULL) {
1644         in->output_standby_rec_thr = rsxadev->routes[route_idx].output->output_standby;
1645     } else {
1646         in->output_standby_rec_thr = true;
1647     }
1648
1649     in->read_error_count = 0;
1650     // Initialize the pipe.
1651     ALOGV("adev_open_input_stream(): about to create pipe");
1652     submix_audio_device_create_pipe_l(rsxadev, config, DEFAULT_PIPE_SIZE_IN_FRAMES,
1653                                     DEFAULT_PIPE_PERIOD_COUNT, in, NULL, address, route_idx);
1654 #if LOG_STREAMS_TO_FILES
1655     if (in->log_fd >= 0) close(in->log_fd);
1656     in->log_fd = open(LOG_STREAM_IN_FILENAME, O_CREAT | O_TRUNC | O_WRONLY,
1657                       LOG_STREAM_FILE_PERMISSIONS);
1658     ALOGE_IF(in->log_fd < 0, "adev_open_input_stream(): log file open failed %s",
1659              strerror(errno));
1660     ALOGV("adev_open_input_stream(): log_fd = %d", in->log_fd);
1661 #endif // LOG_STREAMS_TO_FILES
1662     // Return the input stream.
1663     *stream_in = &in->stream;
1664
1665     pthread_mutex_unlock(&rsxadev->lock);
1666     return 0;
1667 }
1668
1669 static void adev_close_input_stream(struct audio_hw_device *dev,
1670                                     struct audio_stream_in *stream)
1671 {
1672     struct submix_audio_device * const rsxadev = audio_hw_device_get_submix_audio_device(dev);
1673
1674     struct submix_stream_in * const in = audio_stream_in_get_submix_stream_in(stream);
1675     ALOGD("adev_close_input_stream()");
1676     pthread_mutex_lock(&rsxadev->lock);
1677     submix_audio_device_destroy_pipe_l(rsxadev, in, NULL);
1678 #if LOG_STREAMS_TO_FILES
1679     if (in->log_fd >= 0) close(in->log_fd);
1680 #endif // LOG_STREAMS_TO_FILES
1681 #if ENABLE_LEGACY_INPUT_OPEN
1682     if (in->ref_count == 0) free(in);
1683 #else
1684     free(in);
1685 #endif // ENABLE_LEGACY_INPUT_OPEN
1686
1687     pthread_mutex_unlock(&rsxadev->lock);
1688 }
1689
1690 static int adev_dump(const audio_hw_device_t *device, int fd)
1691 {
1692     const struct submix_audio_device * rsxadev = //audio_hw_device_get_submix_audio_device(device);
1693             reinterpret_cast<const struct submix_audio_device *>(
1694                     reinterpret_cast<const uint8_t *>(device) -
1695                             offsetof(struct submix_audio_device, device));
1696     char msg[100];
1697     int n = sprintf(msg, "\nReroute submix audio module:\n");
1698     write(fd, &msg, n);
1699     for (int i=0 ; i < MAX_ROUTES ; i++) {
1700         n = sprintf(msg, " route[%d] rate in=%d out=%d, addr=[%s]\n", i,
1701                 rsxadev->routes[i].config.input_sample_rate,
1702                 rsxadev->routes[i].config.output_sample_rate,
1703                 rsxadev->routes[i].address);
1704         write(fd, &msg, n);
1705     }
1706     return 0;
1707 }
1708
1709 static int adev_close(hw_device_t *device)
1710 {
1711     ALOGI("adev_close()");
1712     free(device);
1713     return 0;
1714 }
1715
1716 static int adev_open(const hw_module_t* module, const char* name,
1717                      hw_device_t** device)
1718 {
1719     ALOGI("adev_open(name=%s)", name);
1720     struct submix_audio_device *rsxadev;
1721
1722     if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
1723         return -EINVAL;
1724
1725     rsxadev = (submix_audio_device*) calloc(1, sizeof(struct submix_audio_device));
1726     if (!rsxadev)
1727         return -ENOMEM;
1728
1729     rsxadev->device.common.tag = HARDWARE_DEVICE_TAG;
1730     rsxadev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
1731     rsxadev->device.common.module = (struct hw_module_t *) module;
1732     rsxadev->device.common.close = adev_close;
1733
1734     rsxadev->device.init_check = adev_init_check;
1735     rsxadev->device.set_voice_volume = adev_set_voice_volume;
1736     rsxadev->device.set_master_volume = adev_set_master_volume;
1737     rsxadev->device.get_master_volume = adev_get_master_volume;
1738     rsxadev->device.set_master_mute = adev_set_master_mute;
1739     rsxadev->device.get_master_mute = adev_get_master_mute;
1740     rsxadev->device.set_mode = adev_set_mode;
1741     rsxadev->device.set_mic_mute = adev_set_mic_mute;
1742     rsxadev->device.get_mic_mute = adev_get_mic_mute;
1743     rsxadev->device.set_parameters = adev_set_parameters;
1744     rsxadev->device.get_parameters = adev_get_parameters;
1745     rsxadev->device.get_input_buffer_size = adev_get_input_buffer_size;
1746     rsxadev->device.open_output_stream = adev_open_output_stream;
1747     rsxadev->device.close_output_stream = adev_close_output_stream;
1748     rsxadev->device.open_input_stream = adev_open_input_stream;
1749     rsxadev->device.close_input_stream = adev_close_input_stream;
1750     rsxadev->device.dump = adev_dump;
1751
1752     for (int i=0 ; i < MAX_ROUTES ; i++) {
1753             memset(&rsxadev->routes[i], 0, sizeof(route_config));
1754             strcpy(rsxadev->routes[i].address, "");
1755         }
1756
1757     *device = &rsxadev->device.common;
1758
1759     return 0;
1760 }
1761
1762 static struct hw_module_methods_t hal_module_methods = {
1763     /* open */ adev_open,
1764 };
1765
1766 struct audio_module HAL_MODULE_INFO_SYM = {
1767     /* common */ {
1768         /* tag */                HARDWARE_MODULE_TAG,
1769         /* module_api_version */ AUDIO_MODULE_API_VERSION_0_1,
1770         /* hal_api_version */    HARDWARE_HAL_API_VERSION,
1771         /* id */                 AUDIO_HARDWARE_MODULE_ID,
1772         /* name */               "Wifi Display audio HAL",
1773         /* author */             "The Android Open Source Project",
1774         /* methods */            &hal_module_methods,
1775         /* dso */                NULL,
1776         /* reserved */           { 0 },
1777     },
1778 };
1779
1780 } //namespace android
1781
1782 } //extern "C"