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