1 /*---------------------------------------------------------------------------*
2 Project: Mixer application for AX
3 File: mix.c
4
5 Copyright (C)1998-2006 Nintendo All Rights Reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Log: mix.c,v $
14 Revision 1.12.4.1 2007/09/13 04:05:14 aka
15 For SDK3.1 patch1.
16
17 Revision 1.14 2007/08/08 02:45:02 aka
18 Modified MIXInitSpecifyMem() to check __init flag.
19
20 Revision 1.13 2007/08/08 00:22:02 aka
21 Modified MIXInit() to check __init flag.
22
23 Revision 1.12 2006/12/22 05:23:36 aka
24 Removed __MIXAIVolumeTable[].
25
26 Revision 1.11 2006/11/13 00:35:11 aka
27 Added initialization of axvpb.
28
29 Revision 1.10 2006/10/23 01:51:45 aka
30 Rolled-back MIXInit().
31 Added MIXInitSpecifyMem().
32
33 Revision 1.9 2006/10/10 05:19:39 aka
34 Removed MIXSetMemory().
35 Revised MIXInit().
36
37 Revision 1.8 2006/10/10 00:56:07 aka
38 Added checking initialization.
39
40 Revision 1.7 2006/10/06 08:07:08 aka
41 Added MIXSetMemory().
42
43 Revision 1.6 2006/07/24 09:11:22 aka
44 Added initialization of remote speaker params.
45
46 Revision 1.5 2006/07/19 07:51:45 aka
47 Modified to support controller speakers.
48
49 Revision 1.4 2006/06/20 00:33:03 aka
50 Revised aux settings when DPL2 mode.
51
52 Revision 1.3 2006/02/01 02:07:17 aka
53 Modified some if statements to remove warning when building.
54
55 Revision 1.2 2005/11/08 01:39:32 aka
56 Changed suiting to Revolution's audio spec.
57
58 Revision 1.1.1.1 2005/05/12 02:15:49 yasuh-to
59 Imported from dolphin tree.
60
61 10 2003/02/10 1:46p Akagi
62 Removed some blank lines at the file end.
63
64 9 2003/02/02 5:53p Akagi
65 Revised attenuation of S buffer from -6dB to -3dB.
66 Added -3dB attenuation of S buffer to MIXInitChannel().
67
68 8 2002/04/11 1:01p Billyjack
69 - changes for DPL2 4 buss AUX send
70 - removed (static) statements, no change in function
71
72 7 2002/01/08 6:42p Billyjack
73 - Added DPL2 support
74
75 6 2001/08/28 4:44p Billyjack
76 added : c->mode &= ~MIX_MODE_UPDATE_INPUT; was missing
77
78
79
80 5 2001/06/04 3:23p Billyjack
81 Changed to init mixer in stereo mode by default.
82
83 4 2001/05/30 3:08p Billyjack
84 - added MIXSetSoundMode() to set mixer in mono or stereo mode
85 - then mixer will initialize into proper mode by calling
86 OSGetSoundMode()
87
88 3 2001/05/21 3:15p Billyjack
89
90 2 2001/05/09 5:05p Billyjack
91 Fixed bug with setting mixerctrl flag for AUX surround... also fixed
92 -6dB for S buffer for MIXInitChannel()
93
94 1 2001/05/09 1:12p Billyjack
95 Created
96
97 $NoKeywords: $
98 *---------------------------------------------------------------------------*/
99
100 #include <string.h>
101 #include <revolution.h>
102 #include <revolution/mix.h>
103 #include "mixprivate.h"
104
105 /*---------------------------------------------------------------------------*
106 Multipliers for DSP audio application in .1 dBs from -90.4 dB to +6 dB,
107 volume expressed in 1.15 fixed point, 0x8000 = 1.0
108 *---------------------------------------------------------------------------*/
109 static u16 __MIXVolumeTable[965] =
110 {
111 0x0000, // -90.4 = inf
112 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
113 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
114 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
115 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
116 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
117 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
118 0x0001, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
119 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
120 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
121 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0003, 0x0003, 0x0003,
122 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
123 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
124 0x0003, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
125 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
126 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
127 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0006, 0x0006, 0x0006, 0x0006,
128 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0007,
129 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007,
130 0x0007, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
131 0x0008, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009,
132 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000b,
133 0x000b, 0x000b, 0x000b, 0x000b, 0x000b, 0x000b, 0x000c, 0x000c, 0x000c, 0x000c,
134 0x000c, 0x000c, 0x000c, 0x000d, 0x000d, 0x000d, 0x000d, 0x000d, 0x000d, 0x000d,
135 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000f, 0x000f, 0x000f, 0x000f,
136 0x000f, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011,
137 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0013, 0x0013, 0x0013, 0x0013,
138 0x0013, 0x0014, 0x0014, 0x0014, 0x0014, 0x0015, 0x0015, 0x0015, 0x0015, 0x0016,
139 0x0016, 0x0016, 0x0016, 0x0017, 0x0017, 0x0017, 0x0018, 0x0018, 0x0018, 0x0018,
140 0x0019, 0x0019, 0x0019, 0x001a, 0x001a, 0x001a, 0x001a, 0x001b, 0x001b, 0x001b,
141 0x001c, 0x001c, 0x001c, 0x001d, 0x001d, 0x001d, 0x001e, 0x001e, 0x001e, 0x001f,
142 0x001f, 0x0020, 0x0020, 0x0020, 0x0021, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023,
143 0x0023, 0x0023, 0x0024, 0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0026, 0x0027,
144 0x0027, 0x0028, 0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b, 0x002c,
145 0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f, 0x0030, 0x0031, 0x0031,
146 0x0032, 0x0032, 0x0033, 0x0033, 0x0034, 0x0035, 0x0035, 0x0036, 0x0037, 0x0037,
147 0x0038, 0x0038, 0x0039, 0x003a, 0x003a, 0x003b, 0x003c, 0x003d, 0x003d, 0x003e,
148 0x003f, 0x003f, 0x0040, 0x0041, 0x0042, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046,
149 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004b, 0x004c, 0x004d, 0x004e,
150 0x004f, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
151 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062,
152 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x006a, 0x006b, 0x006c, 0x006d, 0x006f,
153 0x0070, 0x0071, 0x0072, 0x0074, 0x0075, 0x0076, 0x0078, 0x0079, 0x007b, 0x007c,
154 0x007e, 0x007f, 0x0080, 0x0082, 0x0083, 0x0085, 0x0087, 0x0088, 0x008a, 0x008b,
155 0x008d, 0x008f, 0x0090, 0x0092, 0x0094, 0x0095, 0x0097, 0x0099, 0x009b, 0x009c,
156 0x009e, 0x00a0, 0x00a2, 0x00a4, 0x00a6, 0x00a8, 0x00aa, 0x00ab, 0x00ad, 0x00af,
157 0x00b2, 0x00b4, 0x00b6, 0x00b8, 0x00ba, 0x00bc, 0x00be, 0x00c0, 0x00c3, 0x00c5,
158 0x00c7, 0x00ca, 0x00cc, 0x00ce, 0x00d1, 0x00d3, 0x00d6, 0x00d8, 0x00db, 0x00dd,
159 0x00e0, 0x00e2, 0x00e5, 0x00e7, 0x00ea, 0x00ed, 0x00f0, 0x00f2, 0x00f5, 0x00f8,
160 0x00fb, 0x00fe, 0x0101, 0x0104, 0x0107, 0x010a, 0x010d, 0x0110, 0x0113, 0x0116,
161 0x011a, 0x011d, 0x0120, 0x0124, 0x0127, 0x012a, 0x012e, 0x0131, 0x0135, 0x0138,
162 0x013c, 0x0140, 0x0143, 0x0147, 0x014b, 0x014f, 0x0153, 0x0157, 0x015b, 0x015f,
163 0x0163, 0x0167, 0x016b, 0x016f, 0x0173, 0x0178, 0x017c, 0x0180, 0x0185, 0x0189,
164 0x018e, 0x0193, 0x0197, 0x019c, 0x01a1, 0x01a6, 0x01ab, 0x01af, 0x01b4, 0x01ba,
165 0x01bf, 0x01c4, 0x01c9, 0x01ce, 0x01d4, 0x01d9, 0x01df, 0x01e4, 0x01ea, 0x01ef,
166 0x01f5, 0x01fb, 0x0201, 0x0207, 0x020d, 0x0213, 0x0219, 0x021f, 0x0226, 0x022c,
167 0x0232, 0x0239, 0x0240, 0x0246, 0x024d, 0x0254, 0x025b, 0x0262, 0x0269, 0x0270,
168 0x0277, 0x027e, 0x0286, 0x028d, 0x0295, 0x029d, 0x02a4, 0x02ac, 0x02b4, 0x02bc,
169 0x02c4, 0x02cc, 0x02d5, 0x02dd, 0x02e6, 0x02ee, 0x02f7, 0x0300, 0x0309, 0x0312,
170 0x031b, 0x0324, 0x032d, 0x0337, 0x0340, 0x034a, 0x0354, 0x035d, 0x0367, 0x0371,
171 0x037c, 0x0386, 0x0390, 0x039b, 0x03a6, 0x03b1, 0x03bb, 0x03c7, 0x03d2, 0x03dd,
172 0x03e9, 0x03f4, 0x0400, 0x040c, 0x0418, 0x0424, 0x0430, 0x043d, 0x0449, 0x0456,
173 0x0463, 0x0470, 0x047d, 0x048a, 0x0498, 0x04a5, 0x04b3, 0x04c1, 0x04cf, 0x04dd,
174 0x04ec, 0x04fa, 0x0509, 0x0518, 0x0527, 0x0536, 0x0546, 0x0555, 0x0565, 0x0575,
175 0x0586, 0x0596, 0x05a6, 0x05b7, 0x05c8, 0x05d9, 0x05eb, 0x05fc, 0x060e, 0x0620,
176 0x0632, 0x0644, 0x0657, 0x066a, 0x067d, 0x0690, 0x06a4, 0x06b7, 0x06cb, 0x06df,
177 0x06f4, 0x0708, 0x071d, 0x0732, 0x0748, 0x075d, 0x0773, 0x0789, 0x079f, 0x07b6,
178 0x07cd, 0x07e4, 0x07fb, 0x0813, 0x082b, 0x0843, 0x085c, 0x0874, 0x088e, 0x08a7,
179 0x08c1, 0x08da, 0x08f5, 0x090f, 0x092a, 0x0945, 0x0961, 0x097d, 0x0999, 0x09b5,
180 0x09d2, 0x09ef, 0x0a0d, 0x0a2a, 0x0a48, 0x0a67, 0x0a86, 0x0aa5, 0x0ac5, 0x0ae5,
181 0x0b05, 0x0b25, 0x0b47, 0x0b68, 0x0b8a, 0x0bac, 0x0bcf, 0x0bf2, 0x0c15, 0x0c39,
182 0x0c5d, 0x0c82, 0x0ca7, 0x0ccc, 0x0cf2, 0x0d19, 0x0d3f, 0x0d67, 0x0d8e, 0x0db7,
183 0x0ddf, 0x0e08, 0x0e32, 0x0e5c, 0x0e87, 0x0eb2, 0x0edd, 0x0f09, 0x0f36, 0x0f63,
184 0x0f91, 0x0fbf, 0x0fee, 0x101d, 0x104d, 0x107d, 0x10ae, 0x10df, 0x1111, 0x1144,
185 0x1177, 0x11ab, 0x11df, 0x1214, 0x124a, 0x1280, 0x12b7, 0x12ee, 0x1326, 0x135f,
186 0x1399, 0x13d3, 0x140d, 0x1449, 0x1485, 0x14c2, 0x14ff, 0x153e, 0x157d, 0x15bc,
187 0x15fd, 0x163e, 0x1680, 0x16c3, 0x1706, 0x174a, 0x178f, 0x17d5, 0x181c, 0x1863,
188 0x18ac, 0x18f5, 0x193f, 0x198a, 0x19d5, 0x1a22, 0x1a6f, 0x1abe, 0x1b0d, 0x1b5d,
189 0x1bae, 0x1c00, 0x1c53, 0x1ca7, 0x1cfc, 0x1d52, 0x1da9, 0x1e01, 0x1e5a, 0x1eb4,
190 0x1f0f, 0x1f6b, 0x1fc8, 0x2026, 0x2086, 0x20e6, 0x2148, 0x21aa, 0x220e, 0x2273,
191 0x22d9, 0x2341, 0x23a9, 0x2413, 0x247e, 0x24ea, 0x2557, 0x25c6, 0x2636, 0x26a7,
192 0x271a, 0x278e, 0x2803, 0x287a, 0x28f2, 0x296b, 0x29e6, 0x2a62, 0x2ae0, 0x2b5f,
193 0x2bdf, 0x2c61, 0x2ce5, 0x2d6a, 0x2df1, 0x2e79, 0x2f03, 0x2f8e, 0x301b, 0x30aa,
194 0x313a, 0x31cc, 0x325f, 0x32f5, 0x338c, 0x3425, 0x34bf, 0x355b, 0x35fa, 0x369a,
195 0x373c, 0x37df, 0x3885, 0x392c, 0x39d6, 0x3a81, 0x3b2f, 0x3bde, 0x3c90, 0x3d43,
196 0x3df9, 0x3eb1, 0x3f6a, 0x4026, 0x40e5, 0x41a5, 0x4268, 0x432c, 0x43f4, 0x44bd,
197 0x4589, 0x4657, 0x4727, 0x47fa, 0x48d0, 0x49a8, 0x4a82, 0x4b5f, 0x4c3e, 0x4d20,
198 0x4e05, 0x4eec, 0x4fd6, 0x50c3, 0x51b2, 0x52a4, 0x5399, 0x5491, 0x558c, 0x5689,
199 0x578a, 0x588d, 0x5994, 0x5a9d, 0x5baa, 0x5cba, 0x5dcd, 0x5ee3, 0x5ffc, 0x6119,
200 0x6238, 0x635c, 0x6482, 0x65ac, 0x66d9, 0x680a, 0x693f, 0x6a77, 0x6bb2, 0x6cf2,
201 0x6e35, 0x6f7b, 0x70c6, 0x7214, 0x7366, 0x74bc, 0x7616, 0x7774, 0x78d6, 0x7a3d,
202 0x7ba7, 0x7d16, 0x7e88, 0x7fff, 0x817b, 0x82fb, 0x847f, 0x8608, 0x8795, 0x8927,
203 0x8abe, 0x8c59, 0x8df9, 0x8f9e, 0x9148, 0x92f6, 0x94aa, 0x9663, 0x9820, 0x99e3,
204 0x9bab, 0x9d79, 0x9f4c, 0xa124, 0xa302, 0xa4e5, 0xa6ce, 0xa8bc, 0xaab0, 0xacaa,
205 0xaeaa, 0xb0b0, 0xb2bc, 0xb4ce, 0xb6e5, 0xb904, 0xbb28, 0xbd53, 0xbf84, 0xc1bc,
206 0xc3fa, 0xc63f, 0xc88b, 0xcadd, 0xcd37, 0xcf97, 0xd1fe, 0xd46d, 0xd6e3, 0xd960,
207 0xdbe4, 0xde70, 0xe103, 0xe39e, 0xe641, 0xe8eb, 0xeb9e, 0xee58, 0xf11b, 0xf3e6,
208 0xf6b9, 0xf994, 0xfc78, 0xff64
209 };
210
211
212 // Attenuation table for left panning in .1 dB.
213 static int __MIXPanTable[128] =
214 {
215 0,
216 0, -1, -1, -1, -2, -2, -2, -3, -3, -4,
217 -4, -4, -5, -5, -5, -6, -6, -7, -7, -7,
218 -8, -8, -9, -9, -10, -10, -10, -11, -11, -12,
219 -12, -13, -13, -14, -14, -14, -15, -15, -16, -16,
220 -17, -17, -18, -18, -19, -20, -20, -21, -21, -22,
221 -22, -23, -23, -24, -25, -25, -26, -26, -27, -28,
222 -28, -29, -30, -30, -31, -32, -33, -33, -34, -35,
223 -36, -36, -37, -38, -39, -40, -40, -41, -42, -43,
224 -44, -45, -46, -47, -48, -49, -50, -51, -52, -54,
225 -55, -56, -57, -59, -60, -61, -63, -64, -66, -67,
226 -69, -71, -72, -74, -76, -78, -80, -83, -85, -87,
227 -90, -93, -96, -99, -102, -106, -110, -115, -120, -126,
228 -133, -140, -150, -163, -180, -210, -904
229 };
230
231
232 // Panning tables for Pro Logic 2.
233 // cos(pi/2 * n)
234 static s16 __MIX_DPL2_front[128] =
235 {
236 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
237 0, 0, 0, -1, -1, -1, -1, -1, -2, -2,
238 -2, -2, -3, -3, -3, -4, -4, -4, -5, -5,
239 -6, -6, -6, -7, -7, -8, -8, -9, -9, -10,
240 -11, -11, -12, -12, -13, -14, -14, -15, -16, -17,
241 -17, -18, -19, -20, -21, -21, -22, -23, -24, -25,
242 -26, -27, -28, -29, -30, -31, -32, -34, -35, -36,
243 -37, -38, -40, -41, -42, -44, -45, -47, -48, -50,
244 -52, -53, -55, -57, -58, -60, -62, -64, -66, -68,
245 -70, -73, -75, -77, -80, -82, -85, -88, -90, -93,
246 -96, -100, -103, -106, -110, -114, -118, -122, -126, -131,
247 -136, -141, -146, -152, -159, -166, -173, -181, -190, -201,
248 -212, -225, -241, -261, -286, -321, -381, -960
249 };
250 // cos(pi/2 * (k1 + k2n))
251 static s16 __MIX_DPL2_rear[128] =
252 {
253 -61, -61, -60, -59, -59, -58, -58, -57, -56, -56,
254 -55, -55, -54, -53, -53, -52, -52, -51, -50, -50,
255 -49, -49, -48, -48, -47, -47, -46, -46, -45, -45,
256 -44, -44, -43, -43, -42, -42, -41, -41, -40, -40,
257 -39, -39, -38, -38, -38, -37, -37, -36, -36, -35,
258 -35, -35, -34, -34, -33, -33, -32, -32, -32, -31,
259 -31, -31, -30, -30, -29, -29, -29, -28, -28, -28,
260 -27, -27, -27, -26, -26, -26, -25, -25, -25, -24,
261 -24, -24, -23, -23, -23, -22, -22, -22, -21, -21,
262 -21, -20, -20, -20, -20, -19, -19, -19, -18, -18,
263 -18, -18, -17, -17, -17, -17, -16, -16, -16, -16,
264 -15, -15, -15, -15, -14, -14, -14, -14, -13, -13,
265 -13, -13, -13, -12, -12, -12, -12, -11
266 };
267
268 /*---------------------------------------------------------------------------*
269 Internal variables for the mixer
270 *---------------------------------------------------------------------------*/
271 static u32 __MIXSoundMode;
272 static u32 __MIXMaxVoices;
273 static MIXChannel* __MIXChannel = NULL;
274 static MIXChannel __s_MIXChannel[AX_MAX_VOICES];
275
276 static BOOL __init = FALSE;
277
278 /*---------------------------------------------------------------------------*
279 Private functions
280 *---------------------------------------------------------------------------*/
281
282 /*---------------------------------------------------------------------------*
283 Name: __MIXSetPan
284
285 Description: Set panning dB attenuation for the specified channel.
286
287 Arguments: Channel, pointer to MIXChannel to reset.
288
289 Returns: None
290 *---------------------------------------------------------------------------*/
__MIXSetPan(MIXChannel * channel)291 static void __MIXSetPan(MIXChannel *channel)
292 {
293 int pan, span, ipan, ispan;
294
295 ASSERT((channel->pan <= 127) && (channel->pan >= 0));
296 ASSERT((channel->span <= 127) && (channel->span >= 0));
297
298 pan = channel->pan;
299 ipan = 127 - pan;
300 span = channel->span;
301 ispan = 127 - span;
302
303 if (__MIXSoundMode == MIX_SOUND_MODE_DPL2)
304 {
305 channel->l = __MIX_DPL2_front[pan];
306 channel->r = __MIX_DPL2_front[ipan];
307 channel->f = __MIX_DPL2_front[ispan];
308 channel->b = __MIX_DPL2_front[span];
309 channel->l1= __MIX_DPL2_rear[ipan];
310 channel->r1= __MIX_DPL2_rear[pan];
311 }
312 else
313 {
314 channel->l = __MIXPanTable[pan];
315 channel->r = __MIXPanTable[ipan];
316 channel->f = __MIXPanTable[ispan];
317 channel->b = __MIXPanTable[span];
318 channel->l1= 0;
319 channel->r1= 0;
320 }
321 }
322
323
324 /*---------------------------------------------------------------------------*
325 Name: __MIXResetChannel
326
327 Description: Reset specified channel on the mixer to initial values.
328
329 Arguments: Channel, pointer to MIXChannel to reset.
330
331 Returns: None
332 *---------------------------------------------------------------------------*/
__MIXResetChannel(MIXChannel * channel)333 static void __MIXResetChannel(MIXChannel *channel)
334 {
335 channel->mode = MIX_MODE_UPDATE_MIX | MIX_MODE_UPDATE_INPUT;
336
337 channel->input = 0; // 0 dB atten
338 channel->auxA = -960; // -96.0 dB on AUX A
339 channel->auxB = -960; // -96.0 dB on AUX B
340 channel->auxC = -960; // -96.0 dB on AUX C
341 channel->fader = 0; // Fader at 0.
342
343 channel->pan = 64; // Pan to center.
344 channel->span = 127; // Pan to front.
345
346 channel->v =
347 channel->vL =
348 channel->vR =
349 channel->vS =
350 channel->vAL =
351 channel->vAR =
352 channel->vAS =
353 channel->vBL =
354 channel->vBR =
355 channel->vBS =
356 channel->vCL =
357 channel->vCR =
358 channel->vCS = 0;
359
360 __MIXSetPan(channel);
361 }
362
363
364 /*---------------------------------------------------------------------------*
365 Name: __MIXClampPan
366
367 Description: Clamp user specified pan value to 0 and 127.
368
369 Arguments: Pan value.
370
371 Returns: Clamped pan value.
372 *---------------------------------------------------------------------------*/
__MIXClampPan(int pan)373 static int __MIXClampPan(int pan)
374 {
375 if (pan < 0) return 0;
376 if (pan > 127) return 127;
377 return pan;
378 }
379
380
381 /*---------------------------------------------------------------------------*
382 Exposed functions
383 *---------------------------------------------------------------------------*/
384
385 /*---------------------------------------------------------------------------*
386 Name: __MIXGetVolume
387
388 Description: Returns DSP volume in 1.15 for specified dB attenuation
389 from table. It will clamp for -90.4dB and +6.0dB.
390
391 Arguments: db value in 0.1 dB attenuation (1 = 0.1dB, -1 = -0.1dB).
392
393 Returns: 1.15 volume for DSP volume.
394 *---------------------------------------------------------------------------*/
__MIXGetVolume(int db_)395 u16 __MIXGetVolume(int db_)
396 {
397 int db = db_;
398
399 // Clamp for -90.4 dB - +6.0dB.
400 if (db <= -904) return 0;
401 if (db >= 60) return 0xff64;
402
403 return __MIXVolumeTable[db + 904];
404 }
405
406
407 /*---------------------------------------------------------------------------*
408 Name: MIXInit
409
410 Description: Initialize the mixer, this function must be called prior
411 to any other calls to the mixer APIs.
412
413 Arguments: None
414
415 Returns: None
416 *---------------------------------------------------------------------------*/
MIXInit(void)417 void MIXInit(void)
418 {
419 int i;
420
421 ASSERT(AXIsInit());
422
423 if (!AXIsInit())
424 {
425 return;
426 }
427
428 if (__init)
429 {
430 return;
431 }
432
433 // Set num of max voices.
434 __MIXMaxVoices = AXGetMaxVoices();
435
436 // Set memory.
437 __MIXChannel = __s_MIXChannel;
438 __MIXRmtChannel = __s_MIXRmtChannel;
439
440 // Reset all channels to default setting.
441 for (i = 0; i < __MIXMaxVoices; i++)
442 {
443 __MIXChannel[i].axvpb = NULL;
444 __MIXResetChannel(&__MIXChannel[i]);
445 __MIXRmtResetChannel(i);
446 }
447
448 // Initialize the mixing mode.
449 __MIXSoundMode = MIX_SOUND_MODE_STEREO;
450
451 __init = TRUE;
452 }
453
MIXInitSpecifyMem(void * mem)454 void MIXInitSpecifyMem(void* mem)
455 {
456 int i;
457 u8* ptr;
458
459 ASSERT(AXIsInit());
460 ASSERT(mem);
461
462 if (!AXIsInit() || !mem)
463 {
464 return;
465 }
466
467 if (__init)
468 {
469 return;
470 }
471
472 // Set num of max voices.
473 __MIXMaxVoices = AXGetMaxVoices();
474
475 // Set memory.
476
477 ptr = (u8*)mem;
478
479 __MIXChannel = (MIXChannel*)ptr;
480 ptr += sizeof(MIXChannel) * __MIXMaxVoices;
481
482 __MIXRmtChannel = (MIXRmtChannel*)ptr;
483 ptr += sizeof(MIXRmtChannel) * __MIXMaxVoices;
484
485 // Reset all channels to default setting.
486 for (i = 0; i < __MIXMaxVoices; i++)
487 {
488 __MIXChannel[i].axvpb = NULL;
489 __MIXResetChannel(&__MIXChannel[i]);
490 __MIXRmtResetChannel(i);
491 }
492
493 // Initialize the mixing mode.
494 __MIXSoundMode = MIX_SOUND_MODE_STEREO;
495
496 __init = TRUE;
497 }
498
499
500 /*---------------------------------------------------------------------------*
501 Name: MIXQuit
502
503 Description: Quit the mixer in a graceful manner.
504
505 Arguments: None
506
507 Returns: None
508 *---------------------------------------------------------------------------*/
MIXQuit(void)509 void MIXQuit(void)
510 {
511 __MIXChannel = NULL;
512 __MIXRmtChannel = NULL;
513 __init = FALSE;
514 }
515
516
517 /*---------------------------------------------------------------------------*
518 Name: MIXSetSoundMode
519
520 Description: Runtime interface for changing sound mode.
521
522 Arguments: u32 mode, new mode
523
524 Returns: None
525 *---------------------------------------------------------------------------*/
MIXSetSoundMode(u32 mode)526 void MIXSetSoundMode(u32 mode)
527 {
528 ASSERT( (mode == MIX_SOUND_MODE_MONO) ||
529 (mode == MIX_SOUND_MODE_STEREO) ||
530 (mode == MIX_SOUND_MODE_SURROUND) ||
531 (mode == MIX_SOUND_MODE_DPL2)
532 );
533
534 __MIXSoundMode = mode;
535 }
536
537
538 /*---------------------------------------------------------------------------*
539 Name: MIXGetSoundMode
540
541 Description: Runtime interface to query sound mode.
542
543 Arguments: None
544
545 Returns: MIX mode
546 *---------------------------------------------------------------------------*/
MIXGetSoundMode(void)547 u32 MIXGetSoundMode(void)
548 {
549 return __MIXSoundMode;
550 }
551
552
553 /*---------------------------------------------------------------------------*
554 Name: MIXInitChannel
555
556 Description: Initialize a channel on the mixer to user specified values.
557 Users should call this after a successful call to
558 AXAcquireVoice() to setup initial values on the channel
559 belonging to that voice if the user wishes to use this
560 mixer for that voice.
561
562 Arguments: p Pointer to acquired voice
563 mode Aux A, Aux B, Aux C and mute modes, see mix.h
564 input Attenuation for input control
565 auxA Attenuation for Aux A control
566 auxB Attenuation for Aux B control
567 auxC Attenuation for Aux C control
568 pan Left - right pan control
569 span Front - surround pan control
570 fader Attenuation for fader control
571
572 Returns: None
573 *---------------------------------------------------------------------------*/
MIXInitChannel(AXVPB * axvpb,u32 mode,int input,int auxA,int auxB,int auxC,int pan,int span,int fader)574 void MIXInitChannel(
575 AXVPB *axvpb, // Pointer to voice.
576 u32 mode, // auxA, B, mute modes
577 int input, // initial input atten / gain
578 int auxA, // initial aux A atten / gain
579 int auxB, // initial aux B atten / gain
580 int auxC, // initial aux C atten / gain
581 int pan, // initial pan
582 int span, // initial span
583 int fader // initial fader atten / gain
584 )
585 {
586 int old;
587 MIXChannel *c;
588 u32 mixerCtrl;
589 u16 *p;
590
591 ASSERT(axvpb);
592
593 c = &__MIXChannel[axvpb->index];
594
595 c->axvpb = axvpb;
596 c->mode = mode & (MIX_MODE_AUXA_PREFADER
597 | MIX_MODE_AUXB_PREFADER
598 | MIX_MODE_AUXC_PREFADER
599 | MIX_MODE_MUTE);
600 c->input = input;
601 c->auxA = auxA;
602 c->auxB = auxB;
603 c->auxC = auxC;
604 c->pan = pan;
605 c->span = span;
606 c->fader = fader;
607
608 __MIXSetPan(c);
609
610 // If this channel is muted print 0 into the input.
611 if (c->mode & MIX_MODE_MUTE)
612 c->v = 0;
613 else
614 c->v = __MIXGetVolume(input);
615
616 mixerCtrl = 0;
617
618 switch(__MIXSoundMode)
619 {
620 case MIX_SOUND_MODE_MONO:
621
622 // main buss volume = fader + pan + span
623 c->vL = __MIXGetVolume(c->fader + c->f);
624 c->vR = __MIXGetVolume(c->fader + c->f);
625 c->vS = __MIXGetVolume(c->fader + c->b - 30); // -3dB for S
626
627 if (c->mode & MIX_MODE_AUXA_PREFADER)
628 {
629 // Pre fader does not need fader atten.
630 c->vAL = __MIXGetVolume(c->auxA + c->f);
631 c->vAR = __MIXGetVolume(c->auxA + c->f);
632 c->vAS = __MIXGetVolume(c->auxA + c->b - 30);
633 }
634 else
635 {
636 // Post fader need fader atten.
637 c->vAL = __MIXGetVolume(c->fader + c->auxA + c->f);
638 c->vAR = __MIXGetVolume(c->fader + c->auxA + c->f);
639 c->vAS = __MIXGetVolume(c->fader + c->auxA + c->b - 30);
640 }
641
642 if (c->mode & MIX_MODE_AUXB_PREFADER)
643 {
644 // Pre fader does not need fader atten.
645 c->vBL = __MIXGetVolume(c->auxB + c->f);
646 c->vBR = __MIXGetVolume(c->auxB + c->f);
647 c->vBS = __MIXGetVolume(c->auxB + c->b - 30);
648 }
649 else
650 {
651 // Post fader need fader atten.
652 c->vBL = __MIXGetVolume(c->fader + c->auxB + c->f);
653 c->vBR = __MIXGetVolume(c->fader + c->auxB + c->f);
654 c->vBS = __MIXGetVolume(c->fader + c->auxB + c->b - 30);
655 }
656
657 if (c->mode & MIX_MODE_AUXC_PREFADER)
658 {
659 // Pre fader does not need fader atten.
660 c->vCL = __MIXGetVolume(c->auxC + c->f);
661 c->vCR = __MIXGetVolume(c->auxC + c->f);
662 c->vCS = __MIXGetVolume(c->auxC + c->b - 30);
663 }
664 else
665 {
666 // Post fader need fader atten.
667 c->vCL = __MIXGetVolume(c->fader + c->auxC + c->f);
668 c->vCR = __MIXGetVolume(c->fader + c->auxC + c->f);
669 c->vCS = __MIXGetVolume(c->fader + c->auxC + c->b - 30);
670 }
671
672 break;
673
674 case MIX_SOUND_MODE_STEREO:
675 case MIX_SOUND_MODE_SURROUND:
676
677 // main buss volume = fader + pan + span
678 c->vL = __MIXGetVolume(c->fader + c->l + c->f);
679 c->vR = __MIXGetVolume(c->fader + c->r + c->f);
680 c->vS = __MIXGetVolume(c->fader + c->b - 30); // -3dB for S
681
682 if (c->mode & MIX_MODE_AUXA_PREFADER)
683 {
684 // Pre fader does not need fader atten.
685 c->vAL = __MIXGetVolume(c->auxA + c->l + c->f);
686 c->vAR = __MIXGetVolume(c->auxA + c->r + c->f);
687 c->vAS = __MIXGetVolume(c->auxA + c->b - 30);
688 }
689 else
690 {
691 // Post fader need fader atten.
692 c->vAL = __MIXGetVolume(c->fader + c->auxA + c->l + c->f);
693 c->vAR = __MIXGetVolume(c->fader + c->auxA + c->r + c->f);
694 c->vAS = __MIXGetVolume(c->fader + c->auxA + c->b - 30);
695 }
696
697 if (c->mode & MIX_MODE_AUXB_PREFADER)
698 {
699 // Pre fader does not need fader atten.
700 c->vBL = __MIXGetVolume(c->auxB + c->l + c->f);
701 c->vBR = __MIXGetVolume(c->auxB + c->r + c->f);
702 c->vBS = __MIXGetVolume(c->auxB + c->b - 30);
703 }
704 else
705 {
706 // Post fader need fader atten.
707 c->vBL = __MIXGetVolume(c->fader + c->auxB + c->l + c->f);
708 c->vBR = __MIXGetVolume(c->fader + c->auxB + c->r + c->f);
709 c->vBS = __MIXGetVolume(c->fader + c->auxB + c->b - 30);
710 }
711
712 if (c->mode & MIX_MODE_AUXC_PREFADER)
713 {
714 // Pre fader does not need fader atten.
715 c->vCL = __MIXGetVolume(c->auxC + c->l + c->f);
716 c->vCR = __MIXGetVolume(c->auxC + c->r + c->f);
717 c->vCS = __MIXGetVolume(c->auxC + c->b - 30);
718 }
719 else
720 {
721 // Post fader need fader atten.
722 c->vCL = __MIXGetVolume(c->fader + c->auxC + c->l + c->f);
723 c->vCR = __MIXGetVolume(c->fader + c->auxC + c->r + c->f);
724 c->vCS = __MIXGetVolume(c->fader + c->auxC + c->b - 30);
725 }
726
727 break;
728
729 case MIX_SOUND_MODE_DPL2:
730
731 // main buss volume = fader + pan + span
732 c->vL = __MIXGetVolume(c->fader + c->l + c->f);
733 c->vR = __MIXGetVolume(c->fader + c->r + c->f);
734 c->vS = __MIXGetVolume(c->fader + c->l1 + c->b);
735 c->vCL = __MIXGetVolume(c->fader + c->r1 + c->b);
736
737 if (c->mode & MIX_MODE_AUXA_PREFADER)
738 {
739 // Pre fader does not need fader atten.
740 c->vAL = __MIXGetVolume(c->auxA + c->l + c->f);
741 c->vAR = __MIXGetVolume(c->auxA + c->r + c->f);
742 c->vAS = __MIXGetVolume(c->auxA + c->l1 + c->b);
743 c->vCR = __MIXGetVolume(c->auxA + c->r1 + c->b);
744 }
745 else
746 {
747 // Post fader need fader atten.
748 c->vAL = __MIXGetVolume(c->fader + c->auxA + c->l + c->f);
749 c->vAR = __MIXGetVolume(c->fader + c->auxA + c->r + c->f);
750 c->vAS = __MIXGetVolume(c->fader + c->auxA + c->l1 + c->b);
751 c->vCR = __MIXGetVolume(c->fader + c->auxA + c->r1 + c->b);
752 }
753
754 if (c->mode & MIX_MODE_AUXB_PREFADER)
755 {
756 // Pre fader does not need fader atten.
757 c->vBL = __MIXGetVolume(c->auxB + c->l + c->f);
758 c->vBR = __MIXGetVolume(c->auxB + c->r + c->f);
759 c->vBS = __MIXGetVolume(c->auxB + c->l1 + c->b);
760 c->vCS = __MIXGetVolume(c->auxB + c->r1 + c->b);
761 }
762 else
763 {
764 // Post fader need fader atten.
765 c->vBL = __MIXGetVolume(c->fader + c->auxB + c->l + c->f);
766 c->vBR = __MIXGetVolume(c->fader + c->auxB + c->r + c->f);
767 c->vBS = __MIXGetVolume(c->fader + c->auxB + c->l1 + c->b);
768 c->vCS = __MIXGetVolume(c->fader + c->auxB + c->r1 + c->b);
769 }
770
771 mixerCtrl |= AX_PB_MIXCTRL_C_DPL2;
772
773 break;
774 }
775
776 // Reset remote channel.
777 __MIXRmtResetChannel((s32)axvpb->index);
778
779 old = OSDisableInterrupts();
780
781 // Set the input level.
782 axvpb->pb.ve.currentVolume = c->v;
783 axvpb->pb.ve.currentDelta = 0;
784
785 p = (u16*)&axvpb->pb.mix;
786
787 if((*p++ = c->vL) != 0) mixerCtrl |= AX_PB_MIXCTRL_L;
788 *p++ = 0;
789 if((*p++ = c->vR) != 0) mixerCtrl |= AX_PB_MIXCTRL_R;
790 *p++ = 0;
791 if((*p++ = c->vAL) != 0) mixerCtrl |= AX_PB_MIXCTRL_A_L;
792 *p++ = 0;
793 if((*p++ = c->vAR) != 0) mixerCtrl |= AX_PB_MIXCTRL_A_R;
794 *p++ = 0;
795 if((*p++ = c->vBL) != 0) mixerCtrl |= AX_PB_MIXCTRL_B_L;
796 *p++ = 0;
797 if((*p++ = c->vBR) != 0) mixerCtrl |= AX_PB_MIXCTRL_B_R;
798 *p++ = 0;
799 if((*p++ = c->vCL) != 0) mixerCtrl |= AX_PB_MIXCTRL_C_L;
800 *p++ = 0;
801 if((*p++ = c->vCR) != 0) mixerCtrl |= AX_PB_MIXCTRL_C_R;
802 *p++ = 0;
803 if((*p++ = c->vS) != 0) mixerCtrl |= AX_PB_MIXCTRL_S;
804 *p++ = 0;
805 if((*p++ = c->vAS) != 0) mixerCtrl |= AX_PB_MIXCTRL_A_S;
806 *p++ = 0;
807 if((*p++ = c->vBS) != 0) mixerCtrl |= AX_PB_MIXCTRL_B_S;
808 *p++ = 0;
809 if((*p++ = c->vCS) != 0) mixerCtrl |= AX_PB_MIXCTRL_C_S;
810 *p++ = 0;
811
812 axvpb->pb.mixerCtrl = mixerCtrl;
813 axvpb->sync |= AX_SYNC_USER_MIX | AX_SYNC_USER_VE | AX_SYNC_USER_MIXCTRL;
814
815 p = (u16*)&axvpb->pb.rmtMix;
816 memset(p, 0, sizeof(AXPBRMTMIX));
817 axvpb->pb.rmtMixerCtrl = 0;
818 axvpb->sync |= AX_SYNC_USER_RMTMIX | AX_SYNC_USER_RMTMIXCTRL;
819
820 OSRestoreInterrupts(old);
821 }
822
823
824 /*---------------------------------------------------------------------------*
825 Name: MIXReleaseChannel
826
827 Description: Release the mixer channel, it will no longer be serviced.
828
829 Arguments: axvpb Pointer to voice
830
831 Returns: None
832 *---------------------------------------------------------------------------*/
MIXReleaseChannel(AXVPB * axvpb)833 void MIXReleaseChannel(AXVPB *axvpb)
834 {
835 ASSERT(axvpb);
836
837 __MIXChannel[axvpb->index].axvpb = NULL;
838 }
839
840
841 /*---------------------------------------------------------------------------*
842 Name: MIXResetControls
843
844 Description: Reset mixer controls for mixer channel belonging to user
845 specified voice.
846
847 Arguments: p Pointer to voice
848
849 Returns: None
850 *---------------------------------------------------------------------------*/
MIXResetControls(AXVPB * p)851 void MIXResetControls(AXVPB *p)
852 {
853 __MIXResetChannel(&__MIXChannel[p->index]);
854 __MIXRmtResetChannel((s32)p->index);
855 }
856
857
858 /*---------------------------------------------------------------------------*
859 Name: MIXSetInput
860
861 Description: Set input control to specified attenuation for specified
862 voice.
863
864 Arguments: p Pointer to voice
865 dB Attenuation for input control
866
867 Returns: None
868 *---------------------------------------------------------------------------*/
MIXSetInput(AXVPB * p,int dB)869 void MIXSetInput(AXVPB *p, int dB)
870 {
871 MIXChannel *channel = &__MIXChannel[p->index];
872 channel->input = dB;
873 channel->mode |= MIX_MODE_UPDATE_INPUT;
874 }
875
876
877 /*---------------------------------------------------------------------------*
878 Name: MIXAdjustInput
879
880 Description: Adjust the input control by specified attenuation for
881 specified voice.
882
883 Arguments: p Pointer to voice
884 dB Amount of attenuation to add
885
886 Returns: None
887 *---------------------------------------------------------------------------*/
MIXAdjustInput(AXVPB * p,int dB)888 void MIXAdjustInput(AXVPB *p, int dB)
889 {
890 MIXChannel *channel = &__MIXChannel[p->index];
891 channel->input += dB;
892 channel->mode |= MIX_MODE_UPDATE_INPUT;
893 }
894
895
896 /*---------------------------------------------------------------------------*
897 Name: MIXGetInput
898
899 Description: Returns current attenuation for input control.
900
901 Arguments: p Pointer to voice
902
903 Returns: Attenuation for input.
904 *---------------------------------------------------------------------------*/
MIXGetInput(AXVPB * p)905 int MIXGetInput(AXVPB *p)
906 {
907 MIXChannel *channel = &__MIXChannel[p->index];
908 return channel->input;
909 }
910
911
912 /*---------------------------------------------------------------------------*
913 Name: MIXAuxAPostFader
914
915 Description: Set Aux A control to post fader mode for the specified
916 voice.
917
918 Arguments: p Pointer to voice
919
920 Returns: None
921 *---------------------------------------------------------------------------*/
MIXAuxAPostFader(AXVPB * p)922 void MIXAuxAPostFader(AXVPB *p)
923 {
924 MIXChannel *channel = &__MIXChannel[p->index];
925 channel->mode &= ~MIX_MODE_AUXA_PREFADER;
926 channel->mode |= MIX_MODE_UPDATE_MIX;
927 }
928
929
930 /*---------------------------------------------------------------------------*
931 Name: MIXAuxAPreFader
932
933 Description: Set Aux A control to pre fader mode for the specified
934 voice.
935
936 Arguments: p Pointer to voice
937
938 Returns: None
939 *---------------------------------------------------------------------------*/
MIXAuxAPreFader(AXVPB * p)940 void MIXAuxAPreFader(AXVPB *p)
941 {
942 MIXChannel *channel = &__MIXChannel[p->index];
943 channel->mode |= MIX_MODE_UPDATE_MIX | MIX_MODE_AUXA_PREFADER;
944 }
945
946
947 /*---------------------------------------------------------------------------*
948 Name: MIXAuxAIsPostFader
949
950 Description: Check to see if Aux A is in post fader mode for the
951 specified voice.
952
953 Arguments: p Pointer to voice
954
955 Returns: TRUE if Aux A is in post fader mode, else FALSE.
956 *---------------------------------------------------------------------------*/
MIXAuxAIsPostFader(AXVPB * p)957 BOOL MIXAuxAIsPostFader(AXVPB *p)
958 {
959 MIXChannel *channel = &__MIXChannel[p->index];
960
961 if (channel->mode & MIX_MODE_AUXA_PREFADER)
962 return FALSE;
963
964 return TRUE;
965 }
966
967
968 /*---------------------------------------------------------------------------*
969 Name: MIXSetAuxA
970
971 Description: Set the attenuation for the Aux A control for the
972 specified voice.
973
974 Arguments: p Pointer to voice
975 dB Attenuation to set
976
977 Returns: None
978 *---------------------------------------------------------------------------*/
MIXSetAuxA(AXVPB * p,int dB)979 void MIXSetAuxA(AXVPB *p, int dB)
980 {
981 MIXChannel *channel = &__MIXChannel[p->index];
982 channel->auxA = dB;
983 channel->mode |= MIX_MODE_UPDATE_MIX;
984 }
985
986
987 /*---------------------------------------------------------------------------*
988 Name: MIXAdjustAuxA
989
990 Description: Add the specified amount of attenuation to the Aux A
991 control for the specified voice.
992
993 Arguments: p Pointer to voice
994 dB Attenuation to add
995
996 Returns: None
997 *---------------------------------------------------------------------------*/
MIXAdjustAuxA(AXVPB * p,int dB)998 void MIXAdjustAuxA(AXVPB *p, int dB)
999 {
1000 MIXChannel *channel = &__MIXChannel[p->index];
1001 channel->auxA += dB;
1002 channel->mode |= MIX_MODE_UPDATE_MIX;
1003 }
1004
1005
1006 /*---------------------------------------------------------------------------*
1007 Name: MIXGetAuxA
1008
1009 Description: Returns attenuation for the Aux A control for the
1010 specified voice.
1011
1012 Arguments: p Pointer to voice
1013
1014 Returns: Attenuation for Aux A.
1015 *---------------------------------------------------------------------------*/
MIXGetAuxA(AXVPB * p)1016 int MIXGetAuxA(AXVPB *p)
1017 {
1018 MIXChannel *channel = &__MIXChannel[p->index];
1019 return channel->auxA;
1020 }
1021
1022
1023 /*---------------------------------------------------------------------------*
1024 Name: MIXAuxBPostFader
1025
1026 Description: Set Aux B control to post fader mode for the specified
1027 voice.
1028
1029 Arguments: p Pointer to voice
1030
1031 Returns: None
1032 *---------------------------------------------------------------------------*/
MIXAuxBPostFader(AXVPB * p)1033 void MIXAuxBPostFader(AXVPB *p)
1034 {
1035 MIXChannel *channel = &__MIXChannel[p->index];
1036 channel->mode &= ~MIX_MODE_AUXB_PREFADER;
1037 channel->mode |= MIX_MODE_UPDATE_MIX;
1038 }
1039
1040
1041 /*---------------------------------------------------------------------------*
1042 Name: MIXAuxBPreFader
1043
1044 Description: Set Aux B control to pre fader mode for the specified
1045 voice.
1046
1047 Arguments: p Pointer to voice
1048
1049 Returns: None
1050 *---------------------------------------------------------------------------*/
MIXAuxBPreFader(AXVPB * p)1051 void MIXAuxBPreFader(AXVPB *p)
1052 {
1053 MIXChannel *channel = &__MIXChannel[p->index];
1054 channel->mode |= MIX_MODE_UPDATE_MIX | MIX_MODE_AUXB_PREFADER;
1055 }
1056
1057
1058 /*---------------------------------------------------------------------------*
1059 Name: MIXAuxBIsPostFader
1060
1061 Description: Check to see if Aux B is in post fader mode for the
1062 specified voice.
1063
1064 Arguments: p Pointer to voice
1065
1066 Returns: TRUE if Aux A is in post fader mode, else FALSE.
1067 *---------------------------------------------------------------------------*/
MIXAuxBIsPostFader(AXVPB * p)1068 BOOL MIXAuxBIsPostFader(AXVPB *p)
1069 {
1070 MIXChannel *channel = &__MIXChannel[p->index];
1071
1072 if (channel->mode & MIX_MODE_AUXB_PREFADER)
1073 return FALSE;
1074
1075 return TRUE;
1076 }
1077
1078
1079 /*---------------------------------------------------------------------------*
1080 Name: MIXSetAuxB
1081
1082 Description: Set the attenuation for the Aux B control for the
1083 specified voice.
1084
1085 Arguments: p Pointer to voice
1086 dB Attenuation to set
1087
1088 Returns: None
1089 *---------------------------------------------------------------------------*/
MIXSetAuxB(AXVPB * p,int dB)1090 void MIXSetAuxB(AXVPB *p, int dB)
1091 {
1092 MIXChannel *channel = &__MIXChannel[p->index];
1093 channel->auxB = dB;
1094 channel->mode |= MIX_MODE_UPDATE_MIX;
1095 }
1096
1097
1098 /*---------------------------------------------------------------------------*
1099 Name: MIXAdjustAuxB
1100
1101 Description: Add the specified amount of attenuation to the Aux B
1102 control for the specified voice.
1103
1104 Arguments: p Pointer to voice
1105 dB Attenuation to add
1106
1107 Returns: None
1108 *---------------------------------------------------------------------------*/
MIXAdjustAuxB(AXVPB * p,int dB)1109 void MIXAdjustAuxB(AXVPB *p, int dB)
1110 {
1111 MIXChannel *channel = &__MIXChannel[p->index];
1112 channel->auxB += dB;
1113 channel->mode |= MIX_MODE_UPDATE_MIX;
1114 }
1115
1116
1117 /*---------------------------------------------------------------------------*
1118 Name: MIXGetAuxB
1119
1120 Description: Returns attenuation for the Aux B control for the
1121 specified voice.
1122
1123 Arguments: p Pointer to voice
1124
1125 Returns: Attenuation for Aux B.
1126 *---------------------------------------------------------------------------*/
MIXGetAuxB(AXVPB * p)1127 int MIXGetAuxB(AXVPB *p)
1128 {
1129 MIXChannel *channel = &__MIXChannel[p->index];
1130 return channel->auxB;
1131 }
1132
1133
1134 /*---------------------------------------------------------------------------*
1135 Name: MIXAuxCPostFader
1136
1137 Description: Set Aux C control to post fader mode for the specified
1138 voice.
1139
1140 Arguments: p Pointer to voice
1141
1142 Returns: None
1143 *---------------------------------------------------------------------------*/
MIXAuxCPostFader(AXVPB * p)1144 void MIXAuxCPostFader(AXVPB *p)
1145 {
1146 MIXChannel *channel = &__MIXChannel[p->index];
1147 channel->mode &= ~MIX_MODE_AUXC_PREFADER;
1148 channel->mode |= MIX_MODE_UPDATE_MIX;
1149 }
1150
1151
1152 /*---------------------------------------------------------------------------*
1153 Name: MIXAuxCPreFader
1154
1155 Description: Set Aux C control to pre fader mode for the specified
1156 voice.
1157
1158 Arguments: p Pointer to voice
1159
1160 Returns: None
1161 *---------------------------------------------------------------------------*/
MIXAuxCPreFader(AXVPB * p)1162 void MIXAuxCPreFader(AXVPB *p)
1163 {
1164 MIXChannel *channel = &__MIXChannel[p->index];
1165 channel->mode |= MIX_MODE_UPDATE_MIX | MIX_MODE_AUXC_PREFADER;
1166 }
1167
1168
1169 /*---------------------------------------------------------------------------*
1170 Name: MIXAuxCIsPostFader
1171
1172 Description: Check to see if Aux C is in post fader mode for the
1173 specified voice.
1174
1175 Arguments: p Pointer to voice
1176
1177 Returns: TRUE if Aux C is in post fader mode, else FALSE.
1178 *---------------------------------------------------------------------------*/
MIXAuxCIsPostFader(AXVPB * p)1179 BOOL MIXAuxCIsPostFader(AXVPB *p)
1180 {
1181 MIXChannel *channel = &__MIXChannel[p->index];
1182
1183 if (channel->mode & MIX_MODE_AUXC_PREFADER)
1184 return FALSE;
1185
1186 return TRUE;
1187 }
1188
1189
1190 /*---------------------------------------------------------------------------*
1191 Name: MIXSetAuxC
1192
1193 Description: Set the attenuation for the Aux C control for the
1194 specified voice.
1195
1196 Arguments: p Pointer to voice
1197 dB Attenuation to set
1198
1199 Returns: None
1200 *---------------------------------------------------------------------------*/
MIXSetAuxC(AXVPB * p,int dB)1201 void MIXSetAuxC(AXVPB *p, int dB)
1202 {
1203 MIXChannel *channel;
1204
1205 if (__MIXSoundMode == MIX_SOUND_MODE_DPL2)
1206 return;
1207
1208 channel = &__MIXChannel[p->index];
1209 channel->auxC = dB;
1210 channel->mode |= MIX_MODE_UPDATE_MIX;
1211 }
1212
1213
1214 /*---------------------------------------------------------------------------*
1215 Name: MIXAdjustAuxC
1216
1217 Description: Add the specified amount of attenuation to the Aux C
1218 control for the specified voice.
1219
1220 Arguments: p Pointer to voice
1221 dB Attenuation to add
1222
1223 Returns: None
1224 *---------------------------------------------------------------------------*/
MIXAdjustAuxC(AXVPB * p,int dB)1225 void MIXAdjustAuxC(AXVPB *p, int dB)
1226 {
1227 MIXChannel *channel;
1228
1229 if (__MIXSoundMode == MIX_SOUND_MODE_DPL2)
1230 return;
1231
1232 channel = &__MIXChannel[p->index];
1233 channel->auxC += dB;
1234 channel->mode |= MIX_MODE_UPDATE_MIX;
1235 }
1236
1237
1238 /*---------------------------------------------------------------------------*
1239 Name: MIXGetAuxC
1240
1241 Description: Returns attenuation for the Aux C control for the
1242 specified voice.
1243
1244 Arguments: p Pointer to voice
1245
1246 Returns: Attenuation for Aux C.
1247 *---------------------------------------------------------------------------*/
MIXGetAuxC(AXVPB * p)1248 int MIXGetAuxC(AXVPB *p)
1249 {
1250 MIXChannel *channel;
1251
1252 if (__MIXSoundMode == MIX_SOUND_MODE_DPL2)
1253 return -960;
1254
1255 channel = &__MIXChannel[p->index];
1256 return channel->auxC;
1257 }
1258
1259
1260 /*---------------------------------------------------------------------------*
1261 Name: MIXSetPan
1262
1263 Description: Set pan value for specified voice.
1264
1265 Arguments: p Pointer to voice
1266 pan Pan value to set
1267
1268 Returns: None
1269 *---------------------------------------------------------------------------*/
MIXSetPan(AXVPB * p,int pan)1270 void MIXSetPan(AXVPB *p, int pan)
1271 {
1272 MIXChannel *channel = &__MIXChannel[p->index];
1273 channel->pan = __MIXClampPan(pan);
1274 __MIXSetPan(channel);
1275 channel->mode |= MIX_MODE_UPDATE_MIX;
1276 }
1277
1278
1279 /*---------------------------------------------------------------------------*
1280 Name: MIXAdjustPan
1281
1282 Description: Adjust pan value for specified voice.
1283
1284 Arguments: p Pointer to voice
1285 pan Pan value to add
1286
1287 Returns: None
1288 *---------------------------------------------------------------------------*/
MIXAdjustPan(AXVPB * p,int pan)1289 void MIXAdjustPan(AXVPB *p, int pan)
1290 {
1291 MIXChannel *channel = &__MIXChannel[p->index];
1292 channel->pan = __MIXClampPan(channel->pan + pan);
1293 __MIXSetPan(channel);
1294 channel->mode |= MIX_MODE_UPDATE_MIX;
1295 }
1296
1297
1298 /*---------------------------------------------------------------------------*
1299 Name: MIXGetPan
1300
1301 Description: Return pan value for the specified voice.
1302
1303 Arguments: p Pointer to voice
1304
1305 Returns: Pan value for voice.
1306 *---------------------------------------------------------------------------*/
MIXGetPan(AXVPB * p)1307 int MIXGetPan(AXVPB *p)
1308 {
1309 MIXChannel *channel = &__MIXChannel[p->index];
1310 return channel->pan;
1311 }
1312
1313
1314 /*---------------------------------------------------------------------------*
1315 Name: MIXSetSPan
1316
1317 Description: Set surround pan value for specified voice.
1318
1319 Arguments: p Pointer to voice
1320 span Surround pan value to set
1321
1322 Returns: None
1323 *---------------------------------------------------------------------------*/
MIXSetSPan(AXVPB * p,int span)1324 void MIXSetSPan(AXVPB *p, int span)
1325 {
1326 MIXChannel *channel = &__MIXChannel[p->index];
1327 channel->span = __MIXClampPan(span);
1328 __MIXSetPan(channel);
1329 channel->mode |= MIX_MODE_UPDATE_MIX;
1330 }
1331
1332
1333 /*---------------------------------------------------------------------------*
1334 Name: MIXAdjustSPan
1335
1336 Description: Adjust surround pan value for specified voice.
1337
1338 Arguments: p Pointer to voice
1339 span Surround pan value to add
1340
1341 Returns: None
1342 *---------------------------------------------------------------------------*/
MIXAdjustSPan(AXVPB * p,int span)1343 void MIXAdjustSPan(AXVPB *p, int span)
1344 {
1345 MIXChannel *channel = &__MIXChannel[p->index];
1346 channel->span = __MIXClampPan(channel->span + span);
1347 __MIXSetPan(channel);
1348 channel->mode |= MIX_MODE_UPDATE_MIX;
1349 }
1350
1351
1352 /*---------------------------------------------------------------------------*
1353 Name: MIXGetSPan
1354
1355 Description: Return surround pan value for the specified voice.
1356
1357 Arguments: p Pointer to voice
1358
1359 Returns: Surround pan value for voice.
1360 *---------------------------------------------------------------------------*/
MIXGetSPan(AXVPB * p)1361 int MIXGetSPan(AXVPB *p)
1362 {
1363 MIXChannel *channel = &__MIXChannel[p->index];
1364 return channel->span;
1365 }
1366
1367
1368 /*---------------------------------------------------------------------------*
1369 Name: MIXMute
1370
1371 Description: Mute specified voice.
1372
1373 Arguments: p Pointer to voice
1374
1375 Returns: None
1376 *---------------------------------------------------------------------------*/
MIXMute(AXVPB * p)1377 void MIXMute(AXVPB *p)
1378 {
1379 MIXChannel *channel = &__MIXChannel[p->index];
1380 channel->mode |= MIX_MODE_MUTE | MIX_MODE_UPDATE_INPUT;
1381 }
1382
1383
1384 /*---------------------------------------------------------------------------*
1385 Name: MIXUnMute
1386
1387 Description: Un mute specified voice.
1388
1389 Arguments: p Pointer to voice
1390
1391 Returns: None
1392 *---------------------------------------------------------------------------*/
MIXUnMute(AXVPB * p)1393 void MIXUnMute(AXVPB *p)
1394 {
1395 MIXChannel *channel = &__MIXChannel[p->index];
1396 channel->mode &= ~MIX_MODE_MUTE;
1397 channel->mode |= MIX_MODE_UPDATE_INPUT;
1398 }
1399
1400
1401 /*---------------------------------------------------------------------------*
1402 Name: MIXIsMute
1403
1404 Description: Return mute setting for specified voice.
1405
1406 Arguments: p Pointer to voice.
1407
1408 Returns: TRUE if voice is mute, else FALSE.
1409 *---------------------------------------------------------------------------*/
MIXIsMute(AXVPB * p)1410 BOOL MIXIsMute(AXVPB *p)
1411 {
1412 MIXChannel *channel = &__MIXChannel[p->index];
1413
1414 if (channel->mode & MIX_MODE_MUTE)
1415 return TRUE;
1416
1417 return FALSE;
1418 }
1419
1420
1421 /*---------------------------------------------------------------------------*
1422 Name: MIXSetFader
1423
1424 Description: Set fader attenuation for specified voice.
1425
1426 Arguments: p Pointer to voice
1427 dB Attenuation to set
1428
1429 Returns: None
1430 *---------------------------------------------------------------------------*/
MIXSetFader(AXVPB * p,int dB)1431 void MIXSetFader(AXVPB *p, int dB)
1432 {
1433 MIXChannel *channel = &__MIXChannel[p->index];
1434 channel->fader = dB;
1435 channel->mode |= MIX_MODE_UPDATE_MIX;
1436 }
1437
1438
1439 /*---------------------------------------------------------------------------*
1440 Name: MIXAdjustFader
1441
1442 Description: Adjust fader for specified voice
1443
1444 Arguments: p Pointer to voice
1445 dB Attenuation to add
1446
1447 Returns: None
1448 *---------------------------------------------------------------------------*/
MIXAdjustFader(AXVPB * p,int dB)1449 void MIXAdjustFader(AXVPB *p, int dB)
1450 {
1451 MIXChannel *channel = &__MIXChannel[p->index];
1452 channel->fader += dB;
1453 channel->mode |= MIX_MODE_UPDATE_MIX;
1454 }
1455
1456
1457 /*---------------------------------------------------------------------------*
1458 Name: MIXGetFader
1459
1460 Description: Returns fader attenuation for the specified voice.
1461
1462 Arguments: p Pointer to voice
1463
1464 Returns: Attenuation for fader.
1465 *---------------------------------------------------------------------------*/
MIXGetFader(AXVPB * p)1466 int MIXGetFader(AXVPB *p)
1467 {
1468 MIXChannel *channel = &__MIXChannel[p->index];
1469 return channel->fader;
1470 }
1471
1472
1473 /*---------------------------------------------------------------------------*
1474 Name: MIXUpdateSettings
1475
1476 Description: Updates user settings to AX, this function should be
1477 called from the audio frame callback for AX to update the
1478 mixer settings every audio frame.
1479
1480 Arguments: None
1481
1482 Returns: None
1483 *---------------------------------------------------------------------------*/
MIXUpdateSettings(void)1484 void MIXUpdateSettings(void)
1485 {
1486 int i;
1487
1488 if (!__init)
1489 {
1490 return;
1491 }
1492
1493 for (i = 0; i < __MIXMaxVoices; i++)
1494 {
1495 BOOL setNewMixLevel;
1496 BOOL setNewInputLevel;
1497 MIXChannel *c;
1498 AXVPB *axvpb;
1499
1500 setNewInputLevel = FALSE;
1501 setNewMixLevel = FALSE;
1502
1503 // Get pointer to mixer channel.
1504 c = &__MIXChannel[i];
1505 axvpb = c->axvpb;
1506
1507 if (axvpb)
1508 {
1509 u32 mixerCtrl = 0;
1510
1511 // Take care of input volume ramp that might have been set for last frame.
1512 if (c->mode & MIX_MODE_UPDATE_INPUT1)
1513 {
1514 c->v = c->v1;
1515
1516 // Clear the update flag for next frame.
1517 c->mode &= ~MIX_MODE_UPDATE_INPUT1;
1518
1519 // Flag to set new level.
1520 setNewInputLevel = TRUE;
1521 }
1522
1523 if (c->mode & MIX_MODE_UPDATE_INPUT)
1524 {
1525 // If this channel is muted set the input to 0.
1526 if (c->mode & MIX_MODE_MUTE)
1527 c->v1 = 0;
1528 else
1529 c->v1 = __MIXGetVolume(c->input);
1530
1531 // Clear the update flag for next frame.
1532 c->mode &= ~MIX_MODE_UPDATE_INPUT;
1533
1534 // Assert the update for next frame.
1535 c->mode |= MIX_MODE_UPDATE_INPUT1;
1536
1537 // Flag to set new level.
1538 setNewInputLevel = TRUE;
1539 }
1540
1541 // Take care of mix ramp that might have been set for last frame.
1542 if (c->mode & MIX_MODE_UPDATE_MIX1)
1543 {
1544 // Set the vX1 values to vX.
1545 c->vL = c->vL1; c->vR = c->vR1; c->vS = c->vS1;
1546 c->vAL = c->vAL1; c->vAR = c->vAR1; c->vAS = c->vAS1;
1547 c->vBL = c->vBL1; c->vBR = c->vBR1; c->vBS = c->vBS1;
1548 c->vCL = c->vCL1; c->vCR = c->vCR1; c->vCS = c->vCS1;
1549
1550 // Clear the mix1 update flag for next frame.
1551 c->mode &= ~MIX_MODE_UPDATE_MIX1;
1552
1553 // Flag to set new level.
1554 setNewMixLevel = TRUE;
1555 }
1556
1557 // See if any mixer settings need to be updated.
1558 if (c->mode & MIX_MODE_UPDATE_MIX)
1559 {
1560 // Volume updates in the DSP will always happen over 1 audio frame.
1561 // This is so we can ramp differences larger than AX_IN_SAMPLES_PER_FRAME ...
1562 // To do this we place the new target value in vX1 and assert
1563 // the bit for that buss in the ramp, on the following frame the
1564 // vX1 value will be places into vX.
1565 switch(__MIXSoundMode)
1566 {
1567 case MIX_SOUND_MODE_MONO:
1568
1569 // main buss volume = fader + pan + span
1570 c->vL1 = __MIXGetVolume(c->fader + c->f);
1571 c->vR1 = __MIXGetVolume(c->fader + c->f);
1572 c->vS1 = __MIXGetVolume(c->fader + c->b - 30); // -3dB for S
1573
1574 if (c->mode & MIX_MODE_AUXA_PREFADER)
1575 {
1576 // Pre fader does not need fader atten.
1577 c->vAL1 = __MIXGetVolume(c->auxA + c->f);
1578 c->vAR1 = __MIXGetVolume(c->auxA + c->f);
1579 c->vAS1 = __MIXGetVolume(c->auxA + c->b - 30);
1580 }
1581 else
1582 {
1583 // Post fader need fader atten.
1584 c->vAL1 = __MIXGetVolume(c->fader + c->auxA + c->f);
1585 c->vAR1 = __MIXGetVolume(c->fader + c->auxA + c->f);
1586 c->vAS1 = __MIXGetVolume(c->fader + c->auxA + c->b - 30);
1587 }
1588
1589 if (c->mode & MIX_MODE_AUXB_PREFADER)
1590 {
1591 // Pre fader does not need fader atten.
1592 c->vBL1 = __MIXGetVolume(c->auxB + c->f);
1593 c->vBR1 = __MIXGetVolume(c->auxB + c->f);
1594 c->vBS1 = __MIXGetVolume(c->auxB + c->b - 30);
1595 }
1596 else
1597 {
1598 // Post fader need fader atten.
1599 c->vBL1 = __MIXGetVolume(c->fader + c->auxB + c->f);
1600 c->vBR1 = __MIXGetVolume(c->fader + c->auxB + c->f);
1601 c->vBS1 = __MIXGetVolume(c->fader + c->auxB + c->b - 30);
1602 }
1603
1604 if (c->mode & MIX_MODE_AUXC_PREFADER)
1605 {
1606 // Pre fader does not need fader atten.
1607 c->vCL1 = __MIXGetVolume(c->auxC + c->f);
1608 c->vCR1 = __MIXGetVolume(c->auxC + c->f);
1609 c->vCS1 = __MIXGetVolume(c->auxC + c->b - 30);
1610 }
1611 else
1612 {
1613 // Post fader need fader atten.
1614 c->vCL1 = __MIXGetVolume(c->fader + c->auxC + c->f);
1615 c->vCR1 = __MIXGetVolume(c->fader + c->auxC + c->f);
1616 c->vCS1 = __MIXGetVolume(c->fader + c->auxC + c->b - 30);
1617 }
1618
1619 break;
1620
1621 case MIX_SOUND_MODE_STEREO:
1622 case MIX_SOUND_MODE_SURROUND:
1623
1624 // main buss volume = fader + pan + span
1625 c->vL1 = __MIXGetVolume(c->fader + c->l + c->f);
1626 c->vR1 = __MIXGetVolume(c->fader + c->r + c->f);
1627 c->vS1 = __MIXGetVolume(c->fader + c->b - 30); // -3dB for S
1628
1629 if (c->mode & MIX_MODE_AUXA_PREFADER)
1630 {
1631 // Pre fader does not need fader atten.
1632 c->vAL1 = __MIXGetVolume(c->auxA + c->l + c->f);
1633 c->vAR1 = __MIXGetVolume(c->auxA + c->r + c->f);
1634 c->vAS1 = __MIXGetVolume(c->auxA + c->b - 30);
1635 }
1636 else
1637 {
1638 // Post fader need fader atten.
1639 c->vAL1 = __MIXGetVolume(c->fader + c->auxA + c->l + c->f);
1640 c->vAR1 = __MIXGetVolume(c->fader + c->auxA + c->r + c->f);
1641 c->vAS1 = __MIXGetVolume(c->fader + c->auxA + c->b - 30);
1642 }
1643
1644 if (c->mode & MIX_MODE_AUXB_PREFADER)
1645 {
1646 // Pre fader does not need fader atten.
1647 c->vBL1 = __MIXGetVolume(c->auxB + c->l + c->f);
1648 c->vBR1 = __MIXGetVolume(c->auxB + c->r + c->f);
1649 c->vBS1 = __MIXGetVolume(c->auxB + c->b - 30);
1650 }
1651 else
1652 {
1653 // Post fader need fader atten.
1654 c->vBL1 = __MIXGetVolume(c->fader + c->auxB + c->l + c->f);
1655 c->vBR1 = __MIXGetVolume(c->fader + c->auxB + c->r + c->f);
1656 c->vBS1 = __MIXGetVolume(c->fader + c->auxB + c->b - 30);
1657 }
1658
1659 if (c->mode & MIX_MODE_AUXC_PREFADER)
1660 {
1661 // Pre fader does not need fader atten.
1662 c->vCL1 = __MIXGetVolume(c->auxC + c->l + c->f);
1663 c->vCR1 = __MIXGetVolume(c->auxC + c->r + c->f);
1664 c->vCS1 = __MIXGetVolume(c->auxC + c->b - 30);
1665 }
1666 else
1667 {
1668 // Post fader need fader atten.
1669 c->vCL1 = __MIXGetVolume(c->fader + c->auxC + c->l + c->f);
1670 c->vCR1 = __MIXGetVolume(c->fader + c->auxC + c->r + c->f);
1671 c->vCS1 = __MIXGetVolume(c->fader + c->auxC + c->b - 30);
1672 }
1673
1674 break;
1675
1676 case MIX_SOUND_MODE_DPL2:
1677
1678 // main buss volume = fader + pan + span
1679 c->vL1 = __MIXGetVolume(c->fader + c->l + c->f);
1680 c->vR1 = __MIXGetVolume(c->fader + c->r + c->f);
1681 c->vS1 = __MIXGetVolume(c->fader + c->l1 + c->b);
1682 c->vCL1 = __MIXGetVolume(c->fader + c->r1 + c->b);
1683
1684 if (c->mode & MIX_MODE_AUXA_PREFADER)
1685 {
1686 // Pre fader does not need fader atten.
1687 c->vAL1 = __MIXGetVolume(c->auxA + c->l + c->f);
1688 c->vAR1 = __MIXGetVolume(c->auxA + c->r + c->f);
1689 c->vAS1 = __MIXGetVolume(c->auxA + c->l1 + c->b);
1690 c->vCR1 = __MIXGetVolume(c->auxA + c->r1 + c->b);
1691 }
1692 else
1693 {
1694 // Post fader need fader atten.
1695 c->vAL1 = __MIXGetVolume(c->fader + c->auxA + c->l + c->f);
1696 c->vAR1 = __MIXGetVolume(c->fader + c->auxA + c->r + c->f);
1697 c->vAS1 = __MIXGetVolume(c->fader + c->auxA + c->l1 + c->b);
1698 c->vCR1 = __MIXGetVolume(c->fader + c->auxA + c->r1 + c->b);
1699 }
1700
1701 if (c->mode & MIX_MODE_AUXB_PREFADER)
1702 {
1703 // Pre fader does not need fader atten.
1704 c->vBL1 = __MIXGetVolume(c->auxB + c->l + c->f);
1705 c->vBR1 = __MIXGetVolume(c->auxB + c->r + c->f);
1706 c->vBS1 = __MIXGetVolume(c->auxB + c->l1 + c->b);
1707 c->vCS1 = __MIXGetVolume(c->auxB + c->r1 + c->b);
1708 }
1709 else
1710 {
1711 // Post fader need fader atten.
1712 c->vBL1 = __MIXGetVolume(c->fader + c->auxB + c->l + c->f);
1713 c->vBR1 = __MIXGetVolume(c->fader + c->auxB + c->r + c->f);
1714 c->vBS1 = __MIXGetVolume(c->fader + c->auxB + c->l1 + c->b);
1715 c->vCS1 = __MIXGetVolume(c->fader + c->auxB + c->r1 + c->b);
1716 }
1717
1718 mixerCtrl |= AX_PB_MIXCTRL_C_DPL2;
1719
1720 break;
1721 }
1722
1723 // Clear the update mix bit and set the update mix1 for the next frame.
1724 c->mode &= ~MIX_MODE_UPDATE_MIX;
1725 c->mode |= MIX_MODE_UPDATE_MIX1;
1726
1727 // Must update new mix to AX.
1728 setNewMixLevel = TRUE;
1729 }
1730
1731 // Update the input level.
1732 if (setNewInputLevel)
1733 {
1734 axvpb->pb.ve.currentVolume = c->v;
1735 axvpb->pb.ve.currentDelta = (s16)((c->v1 - c->v) / AX_IN_SAMPLES_PER_FRAME);
1736 axvpb->sync |= AX_SYNC_USER_VE;
1737 }
1738
1739 // Update the new levels to the AX.
1740 if (setNewMixLevel)
1741 {
1742 u16 *p = (u16*)&axvpb->pb.mix;
1743
1744 if((*p++ = c->vL) != 0)
1745 mixerCtrl |= AX_PB_MIXCTRL_L;
1746 if((*p++ = (u16)((c->vL1 - c->vL) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1747 mixerCtrl |= AX_PB_MIXCTRL_LR_RAMP;
1748 if((*p++ = c->vR) != 0)
1749 mixerCtrl |= AX_PB_MIXCTRL_R;
1750 if((*p++ = (u16)((c->vR1 - c->vR) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1751 mixerCtrl |= AX_PB_MIXCTRL_LR_RAMP;
1752
1753 if((*p++ = c->vAL) != 0)
1754 mixerCtrl |= AX_PB_MIXCTRL_A_L;
1755 if((*p++ = (u16)((c->vAL1 - c->vAL) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1756 mixerCtrl |= AX_PB_MIXCTRL_A_LR_RAMP;
1757 if((*p++ = c->vAR) != 0)
1758 mixerCtrl |= AX_PB_MIXCTRL_A_R;
1759 if((*p++ = (u16)((c->vAR1 - c->vAR) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1760 mixerCtrl |= AX_PB_MIXCTRL_A_LR_RAMP;
1761
1762 if((*p++ = c->vBL) != 0)
1763 mixerCtrl |= AX_PB_MIXCTRL_B_L;
1764 if((*p++ = (u16)((c->vBL1 - c->vBL) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1765 mixerCtrl |= AX_PB_MIXCTRL_B_LR_RAMP;
1766 if((*p++ = c->vBR) != 0)
1767 mixerCtrl |= AX_PB_MIXCTRL_B_R;
1768 if((*p++ = (u16)((c->vBR1 - c->vBR) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1769 mixerCtrl |= AX_PB_MIXCTRL_B_LR_RAMP;
1770
1771 if((*p++ = c->vCL) != 0)
1772 mixerCtrl |= AX_PB_MIXCTRL_C_L;
1773 if((*p++ = (u16)((c->vCL1 - c->vCL) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1774 mixerCtrl |= AX_PB_MIXCTRL_C_LR_RAMP;
1775 if((*p++ = c->vCR) != 0)
1776 mixerCtrl |= AX_PB_MIXCTRL_C_R;
1777 if((*p++ = (u16)((c->vCR1 - c->vCR) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1778 mixerCtrl |= AX_PB_MIXCTRL_C_LR_RAMP;
1779
1780 if((*p++ = c->vS) != 0)
1781 mixerCtrl |= AX_PB_MIXCTRL_S;
1782 if((*p++ = (u16)((c->vS1 - c->vS) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1783 mixerCtrl |= AX_PB_MIXCTRL_S_RAMP;
1784
1785 if((*p++ = c->vAS) != 0)
1786 mixerCtrl |= AX_PB_MIXCTRL_A_S;
1787 if((*p++ = (u16)((c->vAS1 - c->vAS) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1788 mixerCtrl |= AX_PB_MIXCTRL_A_S_RAMP;
1789
1790 if((*p++ = c->vBS) != 0)
1791 mixerCtrl |= AX_PB_MIXCTRL_B_S;
1792 if((*p++ = (u16)((c->vBS1 - c->vBS) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1793 mixerCtrl |= AX_PB_MIXCTRL_B_S_RAMP;
1794
1795 if((*p++ = c->vCS) != 0)
1796 mixerCtrl |= AX_PB_MIXCTRL_C_S;
1797 if((*p++ = (u16)((c->vCS1 - c->vCS) / AX_IN_SAMPLES_PER_FRAME)) != 0)
1798 mixerCtrl |= AX_PB_MIXCTRL_C_S_RAMP;
1799
1800 axvpb->pb.mixerCtrl = mixerCtrl;
1801 axvpb->sync |= AX_SYNC_USER_MIX | AX_SYNC_USER_MIXCTRL;
1802 }
1803
1804 __MIXRmtUpdateSettings(i, axvpb);
1805 }
1806 }
1807 }
1808