1/*
2 * Copyright (C) 2014 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 "offload_effect_virtualizer"
18//#define LOG_NDEBUG 0
19
20#include <cutils/list.h>
21#include <cutils/log.h>
22#include <tinyalsa/asoundlib.h>
23#include <sound/audio_effects.h>
24#include <audio_effects/effect_virtualizer.h>
25
26#include "effect_api.h"
27#include "virtualizer.h"
28
29/* Offload Virtualizer UUID: 509a4498-561a-4bea-b3b1-0002a5d5c51b */
30const effect_descriptor_t virtualizer_descriptor = {
31        {0x37cc2c00, 0xdddd, 0x11db, 0x8577, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
32        {0x509a4498, 0x561a, 0x4bea, 0xb3b1, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
33        EFFECT_CONTROL_API_VERSION,
34        (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_DEVICE_IND | EFFECT_FLAG_HW_ACC_TUNNEL |
35                EFFECT_FLAG_VOLUME_CTRL),
36        0, /* TODO */
37        1,
38        "MSM offload virtualizer",
39        "The Android Open Source Project",
40};
41
42/*
43 * Virtualizer operations
44 */
45
46int virtualizer_get_strength(virtualizer_context_t *context)
47{
48    ALOGV("%s: strength: %d", __func__, context->strength);
49    return context->strength;
50}
51
52int virtualizer_set_strength(virtualizer_context_t *context, uint32_t strength)
53{
54    ALOGV("%s: strength: %d", __func__, strength);
55    context->strength = strength;
56
57    offload_virtualizer_set_strength(&(context->offload_virt), strength);
58    if (context->ctl)
59        offload_virtualizer_send_params(context->ctl, &context->offload_virt,
60                                        OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG |
61                                        OFFLOAD_SEND_VIRTUALIZER_STRENGTH);
62    return 0;
63}
64
65int virtualizer_get_parameter(effect_context_t *context, effect_param_t *p,
66                              uint32_t *size)
67{
68    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
69    int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
70    int32_t *param_tmp = (int32_t *)p->data;
71    int32_t param = *param_tmp++;
72    void *value = p->data + voffset;
73    int i;
74
75    ALOGV("%s", __func__);
76
77    p->status = 0;
78
79    switch (param) {
80    case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED:
81        if (p->vsize < sizeof(uint32_t))
82           p->status = -EINVAL;
83        p->vsize = sizeof(uint32_t);
84        break;
85    case VIRTUALIZER_PARAM_STRENGTH:
86        if (p->vsize < sizeof(int16_t))
87           p->status = -EINVAL;
88        p->vsize = sizeof(int16_t);
89        break;
90    default:
91        p->status = -EINVAL;
92    }
93
94    *size = sizeof(effect_param_t) + voffset + p->vsize;
95
96    if (p->status != 0)
97        return 0;
98
99    switch (param) {
100    case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED:
101	ALOGV("%s: VIRTUALIZER_PARAM_STRENGTH_SUPPORTED", __func__);
102        *(uint32_t *)value = 1;
103        break;
104
105    case VIRTUALIZER_PARAM_STRENGTH:
106	ALOGV("%s: VIRTUALIZER_PARAM_STRENGTH", __func__);
107        *(int16_t *)value = virtualizer_get_strength(virt_ctxt);
108        break;
109
110    default:
111        p->status = -EINVAL;
112        break;
113    }
114
115    return 0;
116}
117
118int virtualizer_set_parameter(effect_context_t *context, effect_param_t *p,
119                              uint32_t size __unused)
120{
121    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
122    int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
123    void *value = p->data + voffset;
124    int32_t *param_tmp = (int32_t *)p->data;
125    int32_t param = *param_tmp++;
126    uint32_t strength;
127
128    ALOGV("%s", __func__);
129
130    p->status = 0;
131
132    switch (param) {
133    case VIRTUALIZER_PARAM_STRENGTH:
134	ALOGV("%s VIRTUALIZER_PARAM_STRENGTH", __func__);
135        strength = (uint32_t)(*(int16_t *)value);
136        virtualizer_set_strength(virt_ctxt, strength);
137        break;
138    default:
139        p->status = -EINVAL;
140        break;
141    }
142
143    return 0;
144}
145
146int virtualizer_set_device(effect_context_t *context, uint32_t device)
147{
148    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
149
150    ALOGV("%s: device: %d", __func__, device);
151    virt_ctxt->device = device;
152    if ((device == AUDIO_DEVICE_OUT_SPEAKER) ||
153       (device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT) ||
154       (device == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER) ||
155       (device == AUDIO_DEVICE_OUT_AUX_DIGITAL) ||
156       (device == AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET)) {
157        if (!virt_ctxt->temp_disabled) {
158            if (effect_is_active(&virt_ctxt->common)) {
159                offload_virtualizer_set_enable_flag(&(virt_ctxt->offload_virt), false);
160                if (virt_ctxt->ctl)
161                    offload_virtualizer_send_params(virt_ctxt->ctl,
162                                                    &virt_ctxt->offload_virt,
163                                                    OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG);
164            }
165            virt_ctxt->temp_disabled = true;
166        }
167    } else {
168        if (virt_ctxt->temp_disabled) {
169            if (effect_is_active(&virt_ctxt->common)) {
170                offload_virtualizer_set_enable_flag(&(virt_ctxt->offload_virt), true);
171                if (virt_ctxt->ctl)
172                    offload_virtualizer_send_params(virt_ctxt->ctl,
173                                                    &virt_ctxt->offload_virt,
174                                                    OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG);
175            }
176            virt_ctxt->temp_disabled = false;
177        }
178    }
179    offload_virtualizer_set_device(&(virt_ctxt->offload_virt), device);
180    return 0;
181}
182
183int virtualizer_reset(effect_context_t *context)
184{
185    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
186
187    return 0;
188}
189
190int virtualizer_init(effect_context_t *context)
191{
192    ALOGV("%s", __func__);
193    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
194
195    context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
196    context->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
197    context->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
198    context->config.inputCfg.samplingRate = 44100;
199    context->config.inputCfg.bufferProvider.getBuffer = NULL;
200    context->config.inputCfg.bufferProvider.releaseBuffer = NULL;
201    context->config.inputCfg.bufferProvider.cookie = NULL;
202    context->config.inputCfg.mask = EFFECT_CONFIG_ALL;
203    context->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
204    context->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
205    context->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
206    context->config.outputCfg.samplingRate = 44100;
207    context->config.outputCfg.bufferProvider.getBuffer = NULL;
208    context->config.outputCfg.bufferProvider.releaseBuffer = NULL;
209    context->config.outputCfg.bufferProvider.cookie = NULL;
210    context->config.outputCfg.mask = EFFECT_CONFIG_ALL;
211
212    set_config(context, &context->config);
213
214    virt_ctxt->temp_disabled = false;
215    memset(&(virt_ctxt->offload_virt), 0, sizeof(struct virtualizer_params));
216
217    return 0;
218}
219
220int virtualizer_enable(effect_context_t *context)
221{
222    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
223
224    ALOGV("%s", __func__);
225
226    if (!offload_virtualizer_get_enable_flag(&(virt_ctxt->offload_virt)) &&
227        !(virt_ctxt->temp_disabled)) {
228        offload_virtualizer_set_enable_flag(&(virt_ctxt->offload_virt), true);
229        if (virt_ctxt->ctl && virt_ctxt->strength)
230            offload_virtualizer_send_params(virt_ctxt->ctl,
231                                          &virt_ctxt->offload_virt,
232                                          OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG |
233                                          OFFLOAD_SEND_BASSBOOST_STRENGTH);
234    }
235    return 0;
236}
237
238int virtualizer_disable(effect_context_t *context)
239{
240    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
241
242    ALOGV("%s", __func__);
243    if (offload_virtualizer_get_enable_flag(&(virt_ctxt->offload_virt))) {
244        offload_virtualizer_set_enable_flag(&(virt_ctxt->offload_virt), false);
245        if (virt_ctxt->ctl)
246            offload_virtualizer_send_params(virt_ctxt->ctl,
247                                          &virt_ctxt->offload_virt,
248                                          OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG);
249    }
250    return 0;
251}
252
253int virtualizer_start(effect_context_t *context, output_context_t *output)
254{
255    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
256
257    ALOGV("%s", __func__);
258    virt_ctxt->ctl = output->ctl;
259    if (offload_virtualizer_get_enable_flag(&(virt_ctxt->offload_virt)))
260        if (virt_ctxt->ctl)
261            offload_virtualizer_send_params(virt_ctxt->ctl, &virt_ctxt->offload_virt,
262                                          OFFLOAD_SEND_VIRTUALIZER_ENABLE_FLAG |
263                                          OFFLOAD_SEND_VIRTUALIZER_STRENGTH);
264    return 0;
265}
266
267int virtualizer_stop(effect_context_t *context, output_context_t *output __unused)
268{
269    virtualizer_context_t *virt_ctxt = (virtualizer_context_t *)context;
270
271    ALOGV("%s", __func__);
272    virt_ctxt->ctl = NULL;
273    return 0;
274}
275