1/*
2 * Copyright (C) 2011 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 "audio_hw_default"
18//#define LOG_NDEBUG 0
19
20#include <errno.h>
21#include <pthread.h>
22#include <stdint.h>
23#include <sys/time.h>
24
25#include <cutils/log.h>
26
27#include <hardware/hardware.h>
28#include <system/audio.h>
29#include <hardware/audio.h>
30
31struct stub_audio_device {
32    struct audio_hw_device device;
33};
34
35struct stub_stream_out {
36    struct audio_stream_out stream;
37};
38
39struct stub_stream_in {
40    struct audio_stream_in stream;
41};
42
43static uint32_t out_get_sample_rate(const struct audio_stream *stream)
44{
45    return 44100;
46}
47
48static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
49{
50    return 0;
51}
52
53static size_t out_get_buffer_size(const struct audio_stream *stream)
54{
55    return 4096;
56}
57
58static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
59{
60    return AUDIO_CHANNEL_OUT_STEREO;
61}
62
63static audio_format_t out_get_format(const struct audio_stream *stream)
64{
65    return AUDIO_FORMAT_PCM_16_BIT;
66}
67
68static int out_set_format(struct audio_stream *stream, audio_format_t format)
69{
70    return 0;
71}
72
73static int out_standby(struct audio_stream *stream)
74{
75    return 0;
76}
77
78static int out_dump(const struct audio_stream *stream, int fd)
79{
80    return 0;
81}
82
83static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
84{
85    return 0;
86}
87
88static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
89{
90    return strdup("");
91}
92
93static uint32_t out_get_latency(const struct audio_stream_out *stream)
94{
95    return 0;
96}
97
98static int out_set_volume(struct audio_stream_out *stream, float left,
99                          float right)
100{
101    return 0;
102}
103
104static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
105                         size_t bytes)
106{
107    /* XXX: fake timing for audio output */
108    usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) /
109           out_get_sample_rate(&stream->common));
110    return bytes;
111}
112
113static int out_get_render_position(const struct audio_stream_out *stream,
114                                   uint32_t *dsp_frames)
115{
116    return -EINVAL;
117}
118
119static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
120{
121    return 0;
122}
123
124static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
125{
126    return 0;
127}
128
129static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
130                                        int64_t *timestamp)
131{
132    return -EINVAL;
133}
134
135/** audio_stream_in implementation **/
136static uint32_t in_get_sample_rate(const struct audio_stream *stream)
137{
138    return 8000;
139}
140
141static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
142{
143    return 0;
144}
145
146static size_t in_get_buffer_size(const struct audio_stream *stream)
147{
148    return 320;
149}
150
151static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
152{
153    return AUDIO_CHANNEL_IN_MONO;
154}
155
156static audio_format_t in_get_format(const struct audio_stream *stream)
157{
158    return AUDIO_FORMAT_PCM_16_BIT;
159}
160
161static int in_set_format(struct audio_stream *stream, audio_format_t format)
162{
163    return 0;
164}
165
166static int in_standby(struct audio_stream *stream)
167{
168    return 0;
169}
170
171static int in_dump(const struct audio_stream *stream, int fd)
172{
173    return 0;
174}
175
176static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
177{
178    return 0;
179}
180
181static char * in_get_parameters(const struct audio_stream *stream,
182                                const char *keys)
183{
184    return strdup("");
185}
186
187static int in_set_gain(struct audio_stream_in *stream, float gain)
188{
189    return 0;
190}
191
192static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
193                       size_t bytes)
194{
195    /* XXX: fake timing for audio input */
196    usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) /
197           in_get_sample_rate(&stream->common));
198    return bytes;
199}
200
201static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
202{
203    return 0;
204}
205
206static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
207{
208    return 0;
209}
210
211static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
212{
213    return 0;
214}
215
216static int adev_open_output_stream(struct audio_hw_device *dev,
217                                   audio_io_handle_t handle,
218                                   audio_devices_t devices,
219                                   audio_output_flags_t flags,
220                                   struct audio_config *config,
221                                   struct audio_stream_out **stream_out)
222{
223    struct stub_audio_device *ladev = (struct stub_audio_device *)dev;
224    struct stub_stream_out *out;
225    int ret;
226
227    out = (struct stub_stream_out *)calloc(1, sizeof(struct stub_stream_out));
228    if (!out)
229        return -ENOMEM;
230
231    out->stream.common.get_sample_rate = out_get_sample_rate;
232    out->stream.common.set_sample_rate = out_set_sample_rate;
233    out->stream.common.get_buffer_size = out_get_buffer_size;
234    out->stream.common.get_channels = out_get_channels;
235    out->stream.common.get_format = out_get_format;
236    out->stream.common.set_format = out_set_format;
237    out->stream.common.standby = out_standby;
238    out->stream.common.dump = out_dump;
239    out->stream.common.set_parameters = out_set_parameters;
240    out->stream.common.get_parameters = out_get_parameters;
241    out->stream.common.add_audio_effect = out_add_audio_effect;
242    out->stream.common.remove_audio_effect = out_remove_audio_effect;
243    out->stream.get_latency = out_get_latency;
244    out->stream.set_volume = out_set_volume;
245    out->stream.write = out_write;
246    out->stream.get_render_position = out_get_render_position;
247    out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
248
249    *stream_out = &out->stream;
250    return 0;
251
252err_open:
253    free(out);
254    *stream_out = NULL;
255    return ret;
256}
257
258static void adev_close_output_stream(struct audio_hw_device *dev,
259                                     struct audio_stream_out *stream)
260{
261    free(stream);
262}
263
264static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
265{
266    return -ENOSYS;
267}
268
269static char * adev_get_parameters(const struct audio_hw_device *dev,
270                                  const char *keys)
271{
272    return NULL;
273}
274
275static int adev_init_check(const struct audio_hw_device *dev)
276{
277    return 0;
278}
279
280static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
281{
282    return -ENOSYS;
283}
284
285static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
286{
287    return -ENOSYS;
288}
289
290static int adev_get_master_volume(struct audio_hw_device *dev, float *volume)
291{
292    return -ENOSYS;
293}
294
295static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
296{
297    return -ENOSYS;
298}
299
300static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
301{
302    return -ENOSYS;
303}
304
305static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
306{
307    return 0;
308}
309
310static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
311{
312    return -ENOSYS;
313}
314
315static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
316{
317    return -ENOSYS;
318}
319
320static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
321                                         const struct audio_config *config)
322{
323    return 320;
324}
325
326static int adev_open_input_stream(struct audio_hw_device *dev,
327                                  audio_io_handle_t handle,
328                                  audio_devices_t devices,
329                                  struct audio_config *config,
330                                  struct audio_stream_in **stream_in)
331{
332    struct stub_audio_device *ladev = (struct stub_audio_device *)dev;
333    struct stub_stream_in *in;
334    int ret;
335
336    in = (struct stub_stream_in *)calloc(1, sizeof(struct stub_stream_in));
337    if (!in)
338        return -ENOMEM;
339
340    in->stream.common.get_sample_rate = in_get_sample_rate;
341    in->stream.common.set_sample_rate = in_set_sample_rate;
342    in->stream.common.get_buffer_size = in_get_buffer_size;
343    in->stream.common.get_channels = in_get_channels;
344    in->stream.common.get_format = in_get_format;
345    in->stream.common.set_format = in_set_format;
346    in->stream.common.standby = in_standby;
347    in->stream.common.dump = in_dump;
348    in->stream.common.set_parameters = in_set_parameters;
349    in->stream.common.get_parameters = in_get_parameters;
350    in->stream.common.add_audio_effect = in_add_audio_effect;
351    in->stream.common.remove_audio_effect = in_remove_audio_effect;
352    in->stream.set_gain = in_set_gain;
353    in->stream.read = in_read;
354    in->stream.get_input_frames_lost = in_get_input_frames_lost;
355
356    *stream_in = &in->stream;
357    return 0;
358
359err_open:
360    free(in);
361    *stream_in = NULL;
362    return ret;
363}
364
365static void adev_close_input_stream(struct audio_hw_device *dev,
366                                   struct audio_stream_in *in)
367{
368    return;
369}
370
371static int adev_dump(const audio_hw_device_t *device, int fd)
372{
373    return 0;
374}
375
376static int adev_close(hw_device_t *device)
377{
378    free(device);
379    return 0;
380}
381
382static int adev_open(const hw_module_t* module, const char* name,
383                     hw_device_t** device)
384{
385    struct stub_audio_device *adev;
386    int ret;
387
388    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
389        return -EINVAL;
390
391    adev = calloc(1, sizeof(struct stub_audio_device));
392    if (!adev)
393        return -ENOMEM;
394
395    adev->device.common.tag = HARDWARE_DEVICE_TAG;
396    adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
397    adev->device.common.module = (struct hw_module_t *) module;
398    adev->device.common.close = adev_close;
399
400    adev->device.init_check = adev_init_check;
401    adev->device.set_voice_volume = adev_set_voice_volume;
402    adev->device.set_master_volume = adev_set_master_volume;
403    adev->device.get_master_volume = adev_get_master_volume;
404    adev->device.set_master_mute = adev_set_master_mute;
405    adev->device.get_master_mute = adev_get_master_mute;
406    adev->device.set_mode = adev_set_mode;
407    adev->device.set_mic_mute = adev_set_mic_mute;
408    adev->device.get_mic_mute = adev_get_mic_mute;
409    adev->device.set_parameters = adev_set_parameters;
410    adev->device.get_parameters = adev_get_parameters;
411    adev->device.get_input_buffer_size = adev_get_input_buffer_size;
412    adev->device.open_output_stream = adev_open_output_stream;
413    adev->device.close_output_stream = adev_close_output_stream;
414    adev->device.open_input_stream = adev_open_input_stream;
415    adev->device.close_input_stream = adev_close_input_stream;
416    adev->device.dump = adev_dump;
417
418    *device = &adev->device.common;
419
420    return 0;
421}
422
423static struct hw_module_methods_t hal_module_methods = {
424    .open = adev_open,
425};
426
427struct audio_module HAL_MODULE_INFO_SYM = {
428    .common = {
429        .tag = HARDWARE_MODULE_TAG,
430        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
431        .hal_api_version = HARDWARE_HAL_API_VERSION,
432        .id = AUDIO_HARDWARE_MODULE_ID,
433        .name = "Default audio HW HAL",
434        .author = "The Android Open Source Project",
435        .methods = &hal_module_methods,
436    },
437};
438