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