1/*
2 * Copyright (C) 2015 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#include "sles_allinclusive.h"
18#include <system/audio.h>
19#include <SLES/OpenSLES_Android.h>
20#include "channels.h"
21
22
23/*
24 * Return the default OpenSL ES output channel mask (as used in SLDataFormat_PCM.channelMask)
25 * for the specified channel count.
26 *
27 * OpenSL ES makes no distinction between input and output channel masks, but
28 * Android does. This is the OUTPUT version of this function.
29 */
30SLuint32 sles_channel_out_mask_from_count(unsigned channelCount)
31{
32    // FIXME channel mask is not yet implemented by Stagefright, so use a reasonable default
33    //       that is computed from the channel count
34    if (channelCount > FCC_8) {
35        return SL_ANDROID_UNKNOWN_CHANNELMASK;
36    }
37    switch (channelCount) {
38    case 1:
39        // see explanation in data.c re: default channel mask for mono
40        return SL_SPEAKER_FRONT_LEFT;
41    case 2:
42        return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
43    // Android-specific
44    case 3:
45        return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT | SL_SPEAKER_FRONT_CENTER;
46    case 4:
47        return SL_ANDROID_SPEAKER_QUAD;
48    case 5:
49        return SL_ANDROID_SPEAKER_QUAD | SL_SPEAKER_FRONT_CENTER;
50    case 6:
51        return SL_ANDROID_SPEAKER_5DOT1;
52    case 7:
53        return SL_ANDROID_SPEAKER_5DOT1 | SL_SPEAKER_BACK_CENTER;
54    case 8:
55        return SL_ANDROID_SPEAKER_7DOT1;
56    // FIXME FCC_8
57    default:
58        return SL_ANDROID_UNKNOWN_CHANNELMASK;
59    }
60}
61
62/*
63 * Return the default OpenSL ES input channel mask (as used in SLDataFormat_PCM.channelMask)
64 * for the specified channel count.
65 *
66 * OpenSL ES makes no distinction between input and output channel masks, but
67 * Android does. This is the INPUT version of this function.
68 */
69SLuint32 sles_channel_in_mask_from_count(unsigned channelCount) {
70    switch (channelCount) {
71        case 1:
72            return SL_SPEAKER_FRONT_LEFT;
73        case 2:
74            return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
75        default: {
76            if (channelCount > AUDIO_CHANNEL_COUNT_MAX) {
77                return SL_ANDROID_UNKNOWN_CHANNELMASK;
78            } else {
79                SLuint32 bitfield = (1 << channelCount) - 1;
80                return SL_ANDROID_MAKE_INDEXED_CHANNEL_MASK(bitfield);
81            }
82        }
83
84    }
85}
86
87/*
88 * Get the number of active channels in an OpenSL ES channel mask.
89 *
90 * This function is valid for both input and output
91 * masks.
92 */
93SLuint32 sles_channel_count_from_mask(SLuint32 mask) {
94    audio_channel_representation_t rep
95        = sles_to_audio_channel_mask_representation(mask);
96
97    if (rep == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
98        mask &= SL_ANDROID_INDEXED_SPEAKER_MASK_ALL;
99        return popcount(mask);
100    } else if (rep == AUDIO_CHANNEL_REPRESENTATION_POSITION){
101        mask &= SL_ANDROID_POSITIONAL_SPEAKER_MASK_ALL;
102        return popcount(mask);
103    } else {
104        return 0;
105    }
106}
107
108/*
109 * Helper to determine whether a channel mask is indexed or not.
110 *
111 * This is the OpenSL ES analog to audio_channel_mask_get_representation().
112 */
113audio_channel_representation_t sles_to_audio_channel_mask_representation(SLuint32 mask) {
114    if (mask & SL_ANDROID_SPEAKER_NON_POSITIONAL) {
115        return AUDIO_CHANNEL_REPRESENTATION_INDEX;
116    } else {
117        return AUDIO_CHANNEL_REPRESENTATION_POSITION;
118    }
119}
120
121// helper struct for the two static arrays which follow.
122struct channel_map {
123    SLuint32 sles;
124    audio_channel_mask_t android;
125};
126
127// In practice this map is unnecessary, because the SL definitions just
128// happen to match the android definitions perfectly, but we can't rely
129// on that fact since the two sets of definitions have different API
130// contracts.
131static const struct channel_map output_map[] = {
132    { SL_SPEAKER_FRONT_LEFT, AUDIO_CHANNEL_OUT_FRONT_LEFT },
133    { SL_SPEAKER_FRONT_RIGHT, AUDIO_CHANNEL_OUT_FRONT_RIGHT },
134    { SL_SPEAKER_FRONT_CENTER, AUDIO_CHANNEL_OUT_FRONT_CENTER },
135    { SL_SPEAKER_LOW_FREQUENCY, AUDIO_CHANNEL_OUT_LOW_FREQUENCY },
136    { SL_SPEAKER_BACK_LEFT, AUDIO_CHANNEL_OUT_BACK_LEFT },
137    { SL_SPEAKER_BACK_RIGHT, AUDIO_CHANNEL_OUT_BACK_RIGHT },
138    { SL_SPEAKER_FRONT_LEFT_OF_CENTER, AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER },
139    { SL_SPEAKER_FRONT_RIGHT_OF_CENTER, AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER },
140    { SL_SPEAKER_BACK_CENTER, AUDIO_CHANNEL_OUT_BACK_CENTER },
141    { SL_SPEAKER_SIDE_LEFT, AUDIO_CHANNEL_OUT_SIDE_LEFT },
142    { SL_SPEAKER_SIDE_RIGHT, AUDIO_CHANNEL_OUT_SIDE_RIGHT },
143    { SL_SPEAKER_TOP_CENTER, AUDIO_CHANNEL_OUT_TOP_CENTER },
144    { SL_SPEAKER_TOP_FRONT_LEFT, AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT },
145    { SL_SPEAKER_TOP_FRONT_CENTER, AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER },
146    { SL_SPEAKER_TOP_FRONT_RIGHT, AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT },
147    { SL_SPEAKER_TOP_BACK_LEFT, AUDIO_CHANNEL_OUT_TOP_BACK_LEFT },
148    { SL_SPEAKER_TOP_BACK_CENTER, AUDIO_CHANNEL_OUT_TOP_BACK_CENTER },
149    { SL_SPEAKER_TOP_BACK_RIGHT, AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT },
150};
151static const unsigned int nOutputChannelMappings = sizeof(output_map) / sizeof(output_map[0]);
152
153// This map is quite sparse, because there really isn't a reasonable mapping
154// between most of the SL_SPEAKER bits and the android input map. It's probably
155// best to use channel indices instead.
156static const struct channel_map input_map[] = {
157        { SL_SPEAKER_FRONT_LEFT, AUDIO_CHANNEL_IN_LEFT },
158        { SL_SPEAKER_FRONT_RIGHT, AUDIO_CHANNEL_IN_RIGHT },
159};
160static const unsigned int nInputChannelMappings = sizeof(input_map) / sizeof(input_map[0]);
161
162// Core channel mask mapper; implementation common to both input and output
163static audio_channel_mask_t sles_to_android_mask_helper(
164        SLuint32 mask,
165        const struct channel_map* map,
166        unsigned int nMappings) {
167    if (!sles_is_channel_mask_valid(mask)) {
168        SL_LOGW("Channel mask %#x is invalid because it uses bits that are undefined.", mask);
169        return AUDIO_CHANNEL_INVALID;
170    }
171
172    // determine whether this mask uses positional or indexed representation
173    audio_channel_representation_t rep = sles_to_audio_channel_mask_representation(mask);
174
175    uint32_t bitsOut = 0;
176    uint32_t bitsIn = mask;
177    if (rep == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
178        // Indexed masks need no mapping
179        bitsIn &= SL_ANDROID_INDEXED_SPEAKER_MASK_ALL;
180        bitsOut = bitsIn;
181    } else if (rep == AUDIO_CHANNEL_REPRESENTATION_POSITION){
182        // positional masks get mapped from OpenSLES speaker definitions
183        // to the channel definitions we use internally.
184        bitsIn &= SL_ANDROID_POSITIONAL_SPEAKER_MASK_ALL;
185        for (unsigned int i = 0; i < nMappings; ++i) {
186            if (bitsIn & map[i].sles) {
187                bitsOut |= map[i].android;
188            }
189        }
190    } else {
191        SL_LOGE("Unrecognized channel representation %#x", rep);
192    }
193
194    uint32_t result = audio_channel_mask_from_representation_and_bits(
195            rep,
196            bitsOut);
197
198    if (popcount(bitsIn) != popcount(bitsOut)) {
199        // At this point mask has already been stripped of the
200        // representation bitsOut, so its bitcount should equal the number
201        // of channels requested. If the bitcount of 'bitsOut' isn't
202        // the same, then we're unable to provide the number of
203        // channels that the app requested. That will cause an
204        // error downstream if the app doesn't correct it, so
205        // issue a warning here.
206        SL_LOGW("Conversion from OpenSL ES %s channel mask %#x to Android mask %#x %s channels",
207                (rep == AUDIO_CHANNEL_REPRESENTATION_POSITION) ? "positional" : "indexed",
208                mask,
209                result,
210                (popcount(bitsIn) < popcount(bitsOut)) ? "gains" : "loses");
211    }
212
213    return result;
214}
215
216/*
217 * Return an android output channel mask, as used in the AudioTrack constructor.
218 */
219audio_channel_mask_t sles_to_audio_output_channel_mask(SLuint32 mask) {
220    return sles_to_android_mask_helper(mask, output_map, nOutputChannelMappings);
221}
222
223/*
224 * Return an android input channel mask, as used in the AudioRecord constructor.
225 */
226audio_channel_mask_t sles_to_audio_input_channel_mask(SLuint32 mask) {
227    return sles_to_android_mask_helper(mask, input_map, nInputChannelMappings);
228}
229
230/*
231 * Check the mask for undefined bits (that is, set bits that don't correspond to a channel).
232 *
233 * Returns SL_BOOLEAN_TRUE if no undefined bits are set; SL_BOOLEAN_FALSE otherwise.
234 */
235SLboolean sles_is_channel_mask_valid(SLuint32 mask) {
236    SLuint32 undefinedMask;
237    if (sles_to_audio_channel_mask_representation(mask) == AUDIO_CHANNEL_REPRESENTATION_POSITION) {
238        undefinedMask =  ~SL_ANDROID_POSITIONAL_SPEAKER_MASK_ALL;
239    } else {
240        undefinedMask
241                = ~(SL_ANDROID_MAKE_INDEXED_CHANNEL_MASK(SL_ANDROID_INDEXED_SPEAKER_MASK_ALL));
242    }
243    return (mask & undefinedMask) ? SL_BOOLEAN_FALSE : SL_BOOLEAN_TRUE;
244}
245