IMIDIMuteSolo.c revision e5bf0d2c9531a7064eb3ddcafaf93ac1b0974037 
1/*
2 * Copyright (C) 2010 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/* MIDIMuteSolo implementation */
18
19#include "sles_allinclusive.h"
20
21static SLresult IMIDIMuteSolo_SetChannelMute(SLMIDIMuteSoloItf self, SLuint8 channel,
22    SLboolean mute)
23{
24    if (channel > 15)
25        return SL_RESULT_PARAMETER_INVALID;
26    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
27    SLuint16 mask = 1 << channel;
28    interface_lock_exclusive(this);
29    if (mute)
30        this->mChannelMuteMask |= mask;
31    else
32        this->mChannelMuteMask &= ~mask;
33    interface_unlock_exclusive(this);
34    return SL_RESULT_SUCCESS;
35}
36
37static SLresult IMIDIMuteSolo_GetChannelMute(SLMIDIMuteSoloItf self, SLuint8 channel,
38    SLboolean *pMute)
39{
40    if (channel > 15 || (NULL == pMute))
41        return SL_RESULT_PARAMETER_INVALID;
42    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
43    interface_lock_peek(this);
44    SLuint16 mask = this->mChannelMuteMask;
45    interface_unlock_peek(this);
46    *pMute = (mask >> channel) & 1;
47    return SL_RESULT_SUCCESS;
48}
49
50static SLresult IMIDIMuteSolo_SetChannelSolo(SLMIDIMuteSoloItf self, SLuint8 channel,
51    SLboolean solo)
52{
53    if (channel > 15)
54        return SL_RESULT_PARAMETER_INVALID;
55    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
56    SLuint16 mask = 1 << channel;
57    interface_lock_exclusive(this);
58    if (solo)
59        this->mChannelSoloMask |= mask;
60    else
61        this->mChannelSoloMask &= ~mask;
62    interface_unlock_exclusive(this);
63    return SL_RESULT_SUCCESS;
64}
65
66static SLresult IMIDIMuteSolo_GetChannelSolo(SLMIDIMuteSoloItf self, SLuint8 channel,
67    SLboolean *pSolo)
68{
69    if (channel > 15 || (NULL == pSolo))
70        return SL_RESULT_PARAMETER_INVALID;
71    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
72    interface_lock_peek(this);
73    SLuint16 mask = this->mChannelSoloMask;
74    interface_unlock_peek(this);
75    *pSolo = (mask >> channel) & 1;
76    return SL_RESULT_SUCCESS;
77}
78
79static SLresult IMIDIMuteSolo_GetTrackCount(SLMIDIMuteSoloItf self, SLuint16 *pCount)
80{
81    if (NULL == pCount)
82        return SL_RESULT_PARAMETER_INVALID;
83    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
84    // const, so no lock needed
85    SLuint16 trackCount = this->mTrackCount;
86    *pCount = trackCount;
87    return SL_RESULT_SUCCESS;
88}
89
90static SLresult IMIDIMuteSolo_SetTrackMute(SLMIDIMuteSoloItf self, SLuint16 track, SLboolean mute)
91{
92    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
93    // const
94    if (!(track < this->mTrackCount))
95        return SL_RESULT_PARAMETER_INVALID;
96    SLuint32 mask = 1 << track;
97    interface_lock_exclusive(this);
98    if (mute)
99        this->mTrackMuteMask |= mask;
100    else
101        this->mTrackMuteMask &= ~mask;
102    interface_unlock_exclusive(this);
103    return SL_RESULT_SUCCESS;
104}
105
106static SLresult IMIDIMuteSolo_GetTrackMute(SLMIDIMuteSoloItf self, SLuint16 track, SLboolean *pMute)
107{
108    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
109    // const, no lock needed
110    if (!(track < this->mTrackCount) || NULL == pMute)
111        return SL_RESULT_PARAMETER_INVALID;
112    interface_lock_peek(this);
113    SLuint32 mask = this->mTrackMuteMask;
114    interface_unlock_peek(this);
115    *pMute = (mask >> track) & 1;
116    return SL_RESULT_SUCCESS;
117}
118
119static SLresult IMIDIMuteSolo_SetTrackSolo(SLMIDIMuteSoloItf self, SLuint16 track, SLboolean solo)
120{
121    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
122    // const
123    if (!(track < this->mTrackCount))
124        return SL_RESULT_PARAMETER_INVALID;
125    SLuint32 mask = 1 << track;
126    interface_lock_exclusive(this);
127    if (solo)
128        this->mTrackSoloMask |= mask;
129    else
130        this->mTrackSoloMask &= ~mask;
131    interface_unlock_exclusive(this);
132    return SL_RESULT_SUCCESS;
133}
134
135static SLresult IMIDIMuteSolo_GetTrackSolo(SLMIDIMuteSoloItf self, SLuint16 track, SLboolean *pSolo)
136{
137    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
138    // const, no lock needed
139    if (!(track < this->mTrackCount) || NULL == pSolo)
140        return SL_RESULT_PARAMETER_INVALID;
141    interface_lock_peek(this);
142    SLuint32 mask = this->mTrackSoloMask;
143    interface_unlock_peek(this);
144    *pSolo = (mask >> track) & 1;
145    return SL_RESULT_SUCCESS;
146}
147
148static const struct SLMIDIMuteSoloItf_ IMIDIMuteSolo_Itf = {
149    IMIDIMuteSolo_SetChannelMute,
150    IMIDIMuteSolo_GetChannelMute,
151    IMIDIMuteSolo_SetChannelSolo,
152    IMIDIMuteSolo_GetChannelSolo,
153    IMIDIMuteSolo_GetTrackCount,
154    IMIDIMuteSolo_SetTrackMute,
155    IMIDIMuteSolo_GetTrackMute,
156    IMIDIMuteSolo_SetTrackSolo,
157    IMIDIMuteSolo_GetTrackSolo
158};
159
160void IMIDIMuteSolo_init(void *self)
161{
162    IMIDIMuteSolo *this = (IMIDIMuteSolo *) self;
163    this->mItf = &IMIDIMuteSolo_Itf;
164    this->mChannelMuteMask = 0;
165    this->mChannelSoloMask = 0;
166    this->mTrackMuteMask = 0;
167    this->mTrackSoloMask = 0;
168    // const
169    this->mTrackCount = 32; // FIXME
170}
171