source: svn/newcon3bcm2_21bu/nexus/modules/audio/7552/src/nexus_studio_sound.c

Last change on this file was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 29.3 KB
Line 
1/***************************************************************************
2*     (c)2004-2011 Broadcom Corporation
3* 
4*  This program is the proprietary software of Broadcom Corporation and/or its licensors,
5*  and may only be used, duplicated, modified or distributed pursuant to the terms and
6*  conditions of a separate, written license agreement executed between you and Broadcom
7*  (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
8*  no license (express or implied), right to use, or waiver of any kind with respect to the
9*  Software, and Broadcom expressly reserves all rights in and to the Software and all
10*  intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
11*  HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
12*  NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE. 
13*   
14*  Except as expressly set forth in the Authorized License,
15*   
16*  1.     This program, including its structure, sequence and organization, constitutes the valuable trade
17*  secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
18*  and to use this information only in connection with your use of Broadcom integrated circuit products.
19*   
20*  2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
21*  AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
22*  WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
23*  THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
24*  OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
25*  LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
26*  OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
27*  USE OR PERFORMANCE OF THE SOFTWARE.
28* 
29*  3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
30*  LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
31*  EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
32*  USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
33*  THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
34*  ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
35*  LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
36*  ANY LIMITED REMEDY.
37*
38* $brcm_Workfile: nexus_studio_sound.c $
39* $brcm_Revision: 2 $
40* $brcm_Date: 8/24/11 4:04p $
41*
42* API Description:
43*   API name: StudioSound
44*    Specific APIs related to SRS StudioSound processing
45*
46* Revision History:
47*
48* $brcm_Log: /nexus/modules/audio/7422/src/nexus_studio_sound.c $
49*
50* 2   8/24/11 4:04p jgarrett
51* SW7344-179: Coverity CID 290390,290391
52*
53* 1   8/18/11 5:51p jgarrett
54* SWDTV-6306: Merge DTV APE changes to main branch
55*
56* Nexus_APE_Integration/2   8/8/11 5:38p jgarrett
57* SWDTV-6761: Adding StudioSound
58*
59* Nexus_APE_Integration/1   7/1/11 5:50p jgarrett
60* SWDTV-6306: Integrated to latest 7422 baseline and nexus audio
61*  directory structure
62*
63* 1   4/11/11 5:52p jgarrett
64* SWDTV-6306: Adding preliminary Nexus APE support for DTV
65*
66***************************************************************************/
67#include "nexus_audio_module.h"
68
69BDBG_MODULE(nexus_studio_sound);
70
71/* This is a very large structure (> 1k).  Don't use the stack */
72static BAPE_StudioSoundSettings g_NEXUS_StudioSoundSettings;
73
74BDBG_OBJECT_ID(NEXUS_StudioSound);
75typedef struct NEXUS_StudioSound
76{
77    BDBG_OBJECT(NEXUS_StudioSound)
78    NEXUS_AudioInputObject connector;
79    NEXUS_StudioSoundSettings settings;
80    NEXUS_AudioInput input;
81    BAPE_StudioSoundHandle apeHandle;
82} NEXUS_StudioSound;
83
84
85void NEXUS_StudioSound_GetDefaultSettings(
86    NEXUS_StudioSoundSettings *pSettings   /* [out] default settings */
87    )
88{
89    unsigned i, j;
90   
91    BDBG_ASSERT(NULL != pSettings);
92   
93    BAPE_StudioSound_GetDefaultSettings(&g_NEXUS_StudioSoundSettings);
94   
95    /* Top-level Settings */
96    pSettings->enabled = g_NEXUS_StudioSoundSettings.enabled;
97    BDBG_CASSERT((int)NEXUS_StudioSoundMode_eMode1 == (int)BAPE_StudioSoundMode_eMode1);
98    BDBG_CASSERT((int)NEXUS_StudioSoundMode_eMode2 == (int)BAPE_StudioSoundMode_eMode2);
99    BDBG_CASSERT((int)NEXUS_StudioSoundMode_eMax == (int)BAPE_StudioSoundMode_eMax);
100    pSettings->mode = (NEXUS_StudioSoundMode)g_NEXUS_StudioSoundSettings.mode;
101    pSettings->inputGain = g_NEXUS_StudioSoundSettings.inputGain;
102    pSettings->outputGain = g_NEXUS_StudioSoundSettings.outputGain;
103    pSettings->headroomGain = g_NEXUS_StudioSoundSettings.headroomGain;
104    BDBG_CASSERT((int)NEXUS_StudioSoundInputMode_eMono == (int)BAPE_StudioSoundInputMode_eMono);
105    BDBG_CASSERT((int)NEXUS_StudioSoundInputMode_eStereo == (int)BAPE_StudioSoundInputMode_eStereo);           
106    BDBG_CASSERT((int)NEXUS_StudioSoundInputMode_eMultiChannel == (int)BAPE_StudioSoundInputMode_eMultichannel);           
107    BDBG_CASSERT((int)NEXUS_StudioSoundInputMode_eLtRt == (int)BAPE_StudioSoundInputMode_eLtRt);
108    BDBG_CASSERT((int)NEXUS_StudioSoundInputMode_eMax == (int)BAPE_StudioSoundInputMode_eMax);
109    pSettings->inputMode = (NEXUS_StudioSoundInputMode)g_NEXUS_StudioSoundSettings.inputMode;
110   
111    /* Circle Surround */
112    pSettings->circleSurround.enabled = g_NEXUS_StudioSoundSettings.circleSurround.enabled;
113    pSettings->circleSurround.inputGain = g_NEXUS_StudioSoundSettings.circleSurround.inputGain;
114    BDBG_CASSERT((int)NEXUS_CircleSurroundMode_eCinema == (int)BAPE_CircleSurroundMode_eCinema);
115    BDBG_CASSERT((int)NEXUS_CircleSurroundMode_eMusic == (int)BAPE_CircleSurroundMode_eMusic);
116    BDBG_CASSERT((int)NEXUS_CircleSurroundMode_eMax == (int)BAPE_CircleSurroundMode_eMax);
117    pSettings->circleSurround.mode = (NEXUS_CircleSurroundMode)g_NEXUS_StudioSoundSettings.circleSurround.mode;
118    pSettings->circleSurround.outputMode = g_NEXUS_StudioSoundSettings.circleSurround.outputMode;
119    pSettings->circleSurround.outputGainFront = g_NEXUS_StudioSoundSettings.circleSurround.outputGainFront;
120    pSettings->circleSurround.outputGainRear = g_NEXUS_StudioSoundSettings.circleSurround.outputGainRear;
121    pSettings->circleSurround.outputGainCenter = g_NEXUS_StudioSoundSettings.circleSurround.outputGainCenter;
122    pSettings->circleSurround.outputGainSubwoofer = g_NEXUS_StudioSoundSettings.circleSurround.outputGainSubwoofer;
123   
124    /* TruDialog */
125    pSettings->truDialog.enabled = g_NEXUS_StudioSoundSettings.truDialog.enabled;
126    pSettings->truDialog.inputGain = g_NEXUS_StudioSoundSettings.truDialog.inputGain;
127    pSettings->truDialog.outputGain = g_NEXUS_StudioSoundSettings.truDialog.outputGain;
128    pSettings->truDialog.processGain = g_NEXUS_StudioSoundSettings.truDialog.processGain;
129    pSettings->truDialog.bypassGain = g_NEXUS_StudioSoundSettings.truDialog.bypassGain;
130    pSettings->truDialog.enhancementGain = g_NEXUS_StudioSoundSettings.truDialog.enhancementGain;
131 
132    /* TS HD */   
133    NEXUS_TruSurroundHd_GetDefaultSettings(&pSettings->truSurroundHd);
134
135    /* TruVolume */
136    NEXUS_TruVolume_GetDefaultSettings(&pSettings->truVolume);
137
138    /* GEQ */
139    pSettings->graphicEq.leftEnabled = g_NEXUS_StudioSoundSettings.graphicEq.leftEnabled;   
140    pSettings->graphicEq.rightEnabled = g_NEXUS_StudioSoundSettings.graphicEq.rightEnabled;   
141    BDBG_CASSERT((int)NEXUS_SrsGraphicEqBandMode_eFiveBand == (int)BAPE_SrsGraphicEqBandMode_eFiveBand);
142    BDBG_CASSERT((int)NEXUS_SrsGraphicEqBandMode_eTenBand == (int)BAPE_SrsGraphicEqBandMode_eTenBand);
143    BDBG_CASSERT((int)NEXUS_SrsGraphicEqBandMode_eSpeakerCompensation == (int)BAPE_SrsGraphicEqBandMode_eSpeakerCompensation);
144    BDBG_CASSERT((int)NEXUS_SrsGraphicEqBandMode_eMax == (int)BAPE_SrsGraphicEqBandMode_eMax);
145    BDBG_CASSERT(NEXUS_SRS_SS_MAX_GEQ_BANDS == BAPE_STUDIO_SOUND_MAX_GEQ_BANDS);
146    for ( i = 0; i < BAPE_STUDIO_SOUND_MAX_GEQ_BANDS; i++ )
147    {
148        pSettings->graphicEq.leftBandGain[i] = g_NEXUS_StudioSoundSettings.graphicEq.leftBandGain[i];
149        pSettings->graphicEq.rightBandGain[i] = g_NEXUS_StudioSoundSettings.graphicEq.rightBandGain[i];
150    }
151    pSettings->graphicEq.inputGain = g_NEXUS_StudioSoundSettings.graphicEq.inputGain;
152    pSettings->graphicEq.outputGain = g_NEXUS_StudioSoundSettings.graphicEq.outputGain;
153    pSettings->graphicEq.bypassGain = g_NEXUS_StudioSoundSettings.graphicEq.bypassGain;
154   
155    /* TruEq */
156    pSettings->truEq.leftEnabled = g_NEXUS_StudioSoundSettings.truEq.leftEnabled;   
157    pSettings->truEq.rightEnabled = g_NEXUS_StudioSoundSettings.truEq.rightEnabled;
158    BDBG_CASSERT(NEXUS_SRS_SS_MAX_PEQ_BANDS == BAPE_STUDIO_SOUND_MAX_PEQ_BANDS);
159    for ( i = 0; i < BAPE_STUDIO_SOUND_MAX_PEQ_BANDS; i++ )
160    {
161        pSettings->truEq.leftBandEnabled[i] = g_NEXUS_StudioSoundSettings.truEq.leftBandEnabled[i];
162        pSettings->truEq.rightBandEnabled[i] = g_NEXUS_StudioSoundSettings.truEq.rightBandEnabled[i];
163    }
164    pSettings->truEq.inputGain = g_NEXUS_StudioSoundSettings.truEq.inputGain;
165    pSettings->truEq.outputGain = g_NEXUS_StudioSoundSettings.truEq.outputGain;
166    pSettings->truEq.bypassGain = g_NEXUS_StudioSoundSettings.truEq.bypassGain;
167
168    BDBG_CASSERT((int)NEXUS_SrsFilterCoefGenMode_eFilterUser == (int)BAPE_SrsFilterCoefficientMode_eUser);
169    BDBG_CASSERT((int)NEXUS_SrsFilterCoefGenMode_eFilterSpec == (int)BAPE_SrsFilterCoefficientMode_eSpecification);
170    BDBG_CASSERT((int)NEXUS_SrsFilterCoefGenMode_eMax == (int)BAPE_SrsFilterCoefficientMode_eMax);
171    pSettings->truEq.coefGenMode = g_NEXUS_StudioSoundSettings.truEq.coefficientMode;
172   
173    BDBG_CASSERT((int)NEXUS_SrsFilterOrder_eOrder0 == (int)BAPE_SrsFilterOrder_e0);
174    BDBG_CASSERT((int)NEXUS_SrsFilterOrder_eOrder2 == (int)BAPE_SrsFilterOrder_e2);
175    BDBG_CASSERT((int)NEXUS_SrsFilterOrder_eOrder4 == (int)BAPE_SrsFilterOrder_e4);
176    BDBG_CASSERT((int)NEXUS_SrsFilterOrder_eOrder6 == (int)BAPE_SrsFilterOrder_e6);
177    BDBG_CASSERT((int)NEXUS_SrsFilterOrder_eMax == (int)BAPE_SrsFilterOrder_eMax);
178    /* Nexus uses a union here because of legacy RAP settings that also used a union.  APE/FW use a struct instead. */
179    if ( pSettings->truEq.coefGenMode == NEXUS_SrsFilterCoefGenMode_eFilterUser )
180    {
181        for ( i = 0; i < 3; i++ )
182        {
183            for ( j = 0; j < BAPE_STUDIO_SOUND_MAX_PEQ_BANDS; j++ )
184            {
185                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].filterOrder = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].filterOrder;
186                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].scale = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].scale;
187                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientB0 = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientB0;
188                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientA1 = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientA1;
189                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientB1 = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientB1;
190                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientA2 = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientA2;
191                pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientB2 = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientB2;
192            }
193        }
194    }
195    else
196    {
197        for ( i = 0; i < BAPE_STUDIO_SOUND_MAX_PEQ_BANDS; i++ )
198        {
199            pSettings->truEq.coefParam.truEqFilterCoefSpec[i].bandGain = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.specification[i].bandGain;
200            pSettings->truEq.coefParam.truEqFilterCoefSpec[i].bandFrequency = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.specification[i].bandFrequency;
201            pSettings->truEq.coefParam.truEqFilterCoefSpec[i].qFactor = g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.specification[i].qFactor;
202        }
203    }
204   
205    /* HPF */
206    pSettings->highPassFilter.enabled = g_NEXUS_StudioSoundSettings.highPassFilter.enabled;
207    BDBG_CASSERT((int)NEXUS_SrsFilterCoefGenMode_eFilterUser == (int)BAPE_SrsFilterCoefficientMode_eUser);
208    BDBG_CASSERT((int)NEXUS_SrsFilterCoefGenMode_eFilterSpec == (int)BAPE_SrsFilterCoefficientMode_eSpecification);
209    BDBG_CASSERT((int)NEXUS_SrsFilterCoefGenMode_eMax == (int)BAPE_SrsFilterCoefficientMode_eMax);
210    pSettings->highPassFilter.coefGenMode = (NEXUS_SrsFilterCoefGenMode)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientMode;
211    if ( pSettings->highPassFilter.coefGenMode == NEXUS_SrsFilterCoefGenMode_eFilterUser )
212    {
213        for ( i = 0; i < 3; i++ )
214        {
215            pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].filterOrder = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].filterOrder;
216            for ( j = 0; j < 3; j++ )
217            {
218                pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].scale = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].scale;
219                pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientB0 = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientB0;
220                pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientB1 = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientB1;
221                pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientB2 = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientB2;
222                pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientA1 = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientA1;
223                pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientA2 = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientA2;
224            }
225        }
226    }
227    else
228    {
229        pSettings->highPassFilter.coefParam.highPassFilterCoefSpec.cutOffFrequency = g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.specification.cutoffFrequency;
230        pSettings->highPassFilter.coefParam.highPassFilterCoefSpec.filterOrder = (NEXUS_SrsFilterOrder)g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.specification.filterOrder;
231    }   
232       
233    /* Hard Limiter */
234    pSettings->hardLimiter.enabled = g_NEXUS_StudioSoundSettings.hardLimiter.enabled;
235    BDBG_CASSERT((int)NEXUS_SrsHardLimiterBlockSize_e256 == (int)BAPE_SrsHardLimiterBlockSize_e256);
236    BDBG_CASSERT((int)NEXUS_SrsHardLimiterBlockSize_e512 == (int)BAPE_SrsHardLimiterBlockSize_e512);
237    BDBG_CASSERT((int)NEXUS_SrsHardLimiterBlockSize_e768 == (int)BAPE_SrsHardLimiterBlockSize_e768);
238    BDBG_CASSERT((int)NEXUS_SrsHardLimiterBlockSize_e1024 == (int)BAPE_SrsHardLimiterBlockSize_e1024);
239    pSettings->hardLimiter.blockSize = (NEXUS_SrsHardLimiterBlockSize)g_NEXUS_StudioSoundSettings.hardLimiter.blockSize;
240    pSettings->hardLimiter.inputGain = g_NEXUS_StudioSoundSettings.hardLimiter.inputGain;
241    pSettings->hardLimiter.outputGain = g_NEXUS_StudioSoundSettings.hardLimiter.outputGain;
242    pSettings->hardLimiter.bypassGain = g_NEXUS_StudioSoundSettings.hardLimiter.bypassGain;
243    pSettings->hardLimiter.boost = g_NEXUS_StudioSoundSettings.hardLimiter.boost;
244    pSettings->hardLimiter.level = g_NEXUS_StudioSoundSettings.hardLimiter.level;
245    pSettings->hardLimiter.delay = g_NEXUS_StudioSoundSettings.hardLimiter.delay;
246}
247
248NEXUS_StudioSoundHandle NEXUS_StudioSound_Open( /* attr{destructor=NEXUS_StudioSound_Close}  */
249    const NEXUS_StudioSoundSettings *pSettings     /* Pass NULL for default settings */
250    )
251{
252    NEXUS_StudioSoundHandle handle;
253    BAPE_Connector connector;
254    BERR_Code errCode;
255    handle = BKNI_Malloc(sizeof(NEXUS_StudioSound));
256    if ( NULL == handle )
257    {
258        (void)BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
259        return NULL;
260    }
261    BKNI_Memset(handle, 0, sizeof(NEXUS_StudioSound));
262    BDBG_OBJECT_SET(handle, NEXUS_StudioSound);
263    NEXUS_AUDIO_INPUT_INIT(&handle->connector, NEXUS_AudioInputType_eStudioSound, handle);
264    handle->connector.format = NEXUS_AudioInputFormat_eNone;    /* Determined by inputs */
265    BAPE_StudioSound_GetDefaultSettings(&g_NEXUS_StudioSoundSettings);
266    errCode = BAPE_StudioSound_Create(NEXUS_AUDIO_DEVICE_HANDLE, &g_NEXUS_StudioSoundSettings, &handle->apeHandle);
267    if ( errCode )
268    {
269        (void)BERR_TRACE(errCode);
270        BDBG_OBJECT_DESTROY(handle, NEXUS_StudioSound);
271        BKNI_Free(handle);
272        return NULL;
273    }
274    handle->connector.format = NEXUS_AudioInputFormat_ePcmStereo;
275    BAPE_StudioSound_GetConnector(handle->apeHandle, &connector);
276    handle->connector.port = (uint32_t)connector;
277    if ( NULL == pSettings )
278    {
279        NEXUS_StudioSound_GetDefaultSettings(&handle->settings);
280    }
281    else
282    {
283        (void)NEXUS_StudioSound_SetSettings(handle, pSettings);
284    }
285
286    return handle;
287}
288
289void NEXUS_StudioSound_Close(
290    NEXUS_StudioSoundHandle handle
291    )
292{
293    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
294    NEXUS_AudioInput_Shutdown(&handle->connector);
295    BAPE_StudioSound_Destroy(handle->apeHandle);
296    BDBG_OBJECT_DESTROY(handle, NEXUS_StudioSound);
297    BKNI_Free(handle);
298}
299
300void NEXUS_StudioSound_GetSettings(
301    NEXUS_StudioSoundHandle handle,
302    NEXUS_StudioSoundSettings *pSettings    /* [out] Settings */
303    )
304{
305    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
306    BDBG_ASSERT(NULL != pSettings);
307   
308    BKNI_Memcpy(pSettings, &handle->settings, sizeof(NEXUS_StudioSoundSettings));
309}
310
311NEXUS_Error NEXUS_StudioSound_SetSettings(
312    NEXUS_StudioSoundHandle handle,
313    const NEXUS_StudioSoundSettings *pSettings
314    )
315{
316    unsigned i, j;
317    BERR_Code errCode;
318   
319    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
320    BDBG_ASSERT(NULL != pSettings);
321   
322    BAPE_StudioSound_GetSettings(handle->apeHandle, &g_NEXUS_StudioSoundSettings);
323   
324    /* Top-level Settings */
325    g_NEXUS_StudioSoundSettings.enabled = pSettings->enabled;
326    g_NEXUS_StudioSoundSettings.mode = (BAPE_StudioSoundMode)pSettings->mode;
327    g_NEXUS_StudioSoundSettings.inputGain = pSettings->inputGain;
328    g_NEXUS_StudioSoundSettings.outputGain = pSettings->outputGain;
329    g_NEXUS_StudioSoundSettings.headroomGain = pSettings->headroomGain;
330    g_NEXUS_StudioSoundSettings.inputMode = (BAPE_StudioSoundInputMode)pSettings->inputMode;
331   
332    /* Circle Surround */
333    g_NEXUS_StudioSoundSettings.circleSurround.enabled = pSettings->circleSurround.enabled;
334    g_NEXUS_StudioSoundSettings.circleSurround.inputGain = pSettings->circleSurround.inputGain;
335    g_NEXUS_StudioSoundSettings.circleSurround.mode = (BAPE_CircleSurroundMode)pSettings->circleSurround.mode;
336    g_NEXUS_StudioSoundSettings.circleSurround.outputMode = pSettings->circleSurround.outputMode;
337    g_NEXUS_StudioSoundSettings.circleSurround.outputGainFront = pSettings->circleSurround.outputGainFront;
338    g_NEXUS_StudioSoundSettings.circleSurround.outputGainRear = pSettings->circleSurround.outputGainRear;
339    g_NEXUS_StudioSoundSettings.circleSurround.outputGainCenter = pSettings->circleSurround.outputGainCenter;
340    g_NEXUS_StudioSoundSettings.circleSurround.outputGainSubwoofer = pSettings->circleSurround.outputGainSubwoofer;
341   
342    /* TruDialog */
343    g_NEXUS_StudioSoundSettings.truDialog.enabled = pSettings->truDialog.enabled;
344    g_NEXUS_StudioSoundSettings.truDialog.inputGain = pSettings->truDialog.inputGain;
345    g_NEXUS_StudioSoundSettings.truDialog.outputGain = pSettings->truDialog.outputGain;
346    g_NEXUS_StudioSoundSettings.truDialog.processGain = pSettings->truDialog.processGain;
347    g_NEXUS_StudioSoundSettings.truDialog.bypassGain = pSettings->truDialog.bypassGain;
348    g_NEXUS_StudioSoundSettings.truDialog.enhancementGain = pSettings->truDialog.enhancementGain;
349 
350    /* TS HD */   
351    NEXUS_TruSurroundHd_P_ConvertSettings(&pSettings->truSurroundHd, &g_NEXUS_StudioSoundSettings.truSurroundHd);
352   
353    /* TruVolume */
354    NEXUS_TruVolume_P_ConvertSettings(&pSettings->truVolume, &g_NEXUS_StudioSoundSettings.truVolume);
355
356    /* GEQ */
357    g_NEXUS_StudioSoundSettings.graphicEq.leftEnabled = pSettings->graphicEq.leftEnabled;   
358    g_NEXUS_StudioSoundSettings.graphicEq.rightEnabled = pSettings->graphicEq.rightEnabled;   
359    for ( i = 0; i < BAPE_STUDIO_SOUND_MAX_GEQ_BANDS; i++ )
360    {
361        g_NEXUS_StudioSoundSettings.graphicEq.leftBandGain[i] = pSettings->graphicEq.leftBandGain[i];
362        g_NEXUS_StudioSoundSettings.graphicEq.rightBandGain[i] = pSettings->graphicEq.rightBandGain[i];
363    }
364    g_NEXUS_StudioSoundSettings.graphicEq.inputGain = pSettings->graphicEq.inputGain;
365    g_NEXUS_StudioSoundSettings.graphicEq.outputGain = pSettings->graphicEq.outputGain;
366    g_NEXUS_StudioSoundSettings.graphicEq.bypassGain = pSettings->graphicEq.bypassGain;
367   
368    /* TruEq */
369    g_NEXUS_StudioSoundSettings.truEq.leftEnabled = pSettings->truEq.leftEnabled;   
370    g_NEXUS_StudioSoundSettings.truEq.rightEnabled = pSettings->truEq.rightEnabled;
371    for ( i = 0; i < BAPE_STUDIO_SOUND_MAX_PEQ_BANDS; i++ )
372    {
373        g_NEXUS_StudioSoundSettings.truEq.leftBandEnabled[i] = pSettings->truEq.leftBandEnabled[i];
374        g_NEXUS_StudioSoundSettings.truEq.rightBandEnabled[i] = pSettings->truEq.rightBandEnabled[i];
375    }
376    g_NEXUS_StudioSoundSettings.truEq.inputGain = pSettings->truEq.inputGain;
377    g_NEXUS_StudioSoundSettings.truEq.outputGain = pSettings->truEq.outputGain;
378    g_NEXUS_StudioSoundSettings.truEq.bypassGain = pSettings->truEq.bypassGain;
379
380    g_NEXUS_StudioSoundSettings.truEq.coefficientMode = pSettings->truEq.coefGenMode;
381   
382    /* Nexus uses a union here because of legacy RAP settings that also used a union.  APE/FW use a struct instead. */
383    if ( pSettings->truEq.coefGenMode == NEXUS_SrsFilterCoefGenMode_eFilterUser )
384    {
385        for ( i = 0; i < 3; i++ )
386        {
387            for ( j = 0; j < BAPE_STUDIO_SOUND_MAX_PEQ_BANDS; j++ )
388            {
389                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].filterOrder = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].filterOrder;
390                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].scale = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].scale;
391                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientB0 = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientB0;
392                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientA1 = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientA1;
393                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientB1 = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientB1;
394                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientA2 = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientA2;
395                g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.user[i][j].coefficientB2 = pSettings->truEq.coefParam.truEqFilterCoefUser[i][j].coefficientB2;
396            }
397        }
398    }
399    else
400    {
401        for ( i = 0; i < BAPE_STUDIO_SOUND_MAX_PEQ_BANDS; i++ )
402        {
403            g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.specification[i].bandGain = pSettings->truEq.coefParam.truEqFilterCoefSpec[i].bandGain;
404            g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.specification[i].bandFrequency = pSettings->truEq.coefParam.truEqFilterCoefSpec[i].bandFrequency;
405            g_NEXUS_StudioSoundSettings.truEq.coefficientSettings.specification[i].qFactor = pSettings->truEq.coefParam.truEqFilterCoefSpec[i].qFactor;
406        }
407    }
408               
409    /* HPF */
410    g_NEXUS_StudioSoundSettings.highPassFilter.enabled = pSettings->highPassFilter.enabled;
411    BDBG_CASSERT((int)BAPE_SrsFilterCoefficientMode_eUser == (int)NEXUS_SrsFilterCoefGenMode_eFilterUser);
412    BDBG_CASSERT((int)BAPE_SrsFilterCoefficientMode_eSpecification == (int)NEXUS_SrsFilterCoefGenMode_eFilterSpec);
413    BDBG_CASSERT((int)BAPE_SrsFilterCoefficientMode_eMax == (int)NEXUS_SrsFilterCoefGenMode_eMax);
414    g_NEXUS_StudioSoundSettings.highPassFilter.coefficientMode = (BAPE_SrsFilterCoefficientMode)pSettings->highPassFilter.coefGenMode;
415    if ( pSettings->highPassFilter.coefGenMode == NEXUS_SrsFilterCoefGenMode_eFilterUser )
416    {
417        for ( i = 0; i < 3; i++ )
418        {
419            g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].filterOrder = (BAPE_SrsFilterOrder)pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].filterOrder;   
420            for ( j = 0; j < 3; j++ )
421            {
422                g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].scale = pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].scale;   
423                g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientB0 = pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientB0;   
424                g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientB1 = pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientB1;   
425                g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientB2 = pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientB2;   
426                g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientA1 = pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientA1;   
427                g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.user[i].coefficients[j].coefficientA2 = pSettings->highPassFilter.coefParam.highPassFilterCoefUser[i].coefficients[j].coefficientA2;   
428            }
429        }       
430    }
431    else
432    {
433        g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.specification.cutoffFrequency = pSettings->highPassFilter.coefParam.highPassFilterCoefSpec.cutOffFrequency;
434        g_NEXUS_StudioSoundSettings.highPassFilter.coefficientSettings.specification.filterOrder = (BAPE_SrsFilterOrder)pSettings->highPassFilter.coefParam.highPassFilterCoefSpec.filterOrder;
435    }
436   
437    /* Hard Limiter */
438    g_NEXUS_StudioSoundSettings.hardLimiter.enabled = pSettings->hardLimiter.enabled;
439    g_NEXUS_StudioSoundSettings.hardLimiter.blockSize = (BAPE_SrsHardLimiterBlockSize)pSettings->hardLimiter.blockSize;
440    g_NEXUS_StudioSoundSettings.hardLimiter.inputGain = pSettings->hardLimiter.inputGain;
441    g_NEXUS_StudioSoundSettings.hardLimiter.outputGain = pSettings->hardLimiter.outputGain;
442    g_NEXUS_StudioSoundSettings.hardLimiter.bypassGain = pSettings->hardLimiter.bypassGain;
443    g_NEXUS_StudioSoundSettings.hardLimiter.boost = pSettings->hardLimiter.boost;
444    g_NEXUS_StudioSoundSettings.hardLimiter.level = pSettings->hardLimiter.level;
445    g_NEXUS_StudioSoundSettings.hardLimiter.delay = pSettings->hardLimiter.delay;
446
447    errCode = BAPE_StudioSound_SetSettings(handle->apeHandle, &g_NEXUS_StudioSoundSettings);
448    if ( errCode )
449    {
450        return BERR_TRACE(errCode);       
451    }
452   
453    handle->settings = *pSettings;
454   
455    return BERR_SUCCESS;
456}
457
458NEXUS_AudioInput NEXUS_StudioSound_GetConnector( /* attr{shutdown=NEXUS_AudioInput_Shutdown} */
459    NEXUS_StudioSoundHandle handle
460    )
461{
462    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
463    return &handle->connector;
464}
465
466NEXUS_Error NEXUS_StudioSound_AddInput(
467    NEXUS_StudioSoundHandle handle,
468    NEXUS_AudioInput input
469    )
470{
471    NEXUS_Error errCode;
472    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
473    BDBG_ASSERT(NULL != input);
474    if ( NULL != handle->input )
475    {
476        BDBG_ERR(("Only one input can be added"));
477        return BERR_TRACE(BERR_NOT_SUPPORTED);
478    }
479    errCode = BAPE_StudioSound_AddInput(handle->apeHandle, (BAPE_Connector)input->port);
480    if ( errCode )
481    {
482        return BERR_TRACE(errCode);
483    }
484    errCode = NEXUS_AudioInput_P_AddInput(&handle->connector, input);
485    if ( errCode )
486    {
487        (void)BAPE_StudioSound_RemoveInput(handle->apeHandle, (BAPE_Connector)input->port);
488        return BERR_TRACE(errCode);
489    }
490    handle->input = input;
491    return BERR_SUCCESS;
492}
493
494NEXUS_Error NEXUS_StudioSound_RemoveInput(
495    NEXUS_StudioSoundHandle handle,
496    NEXUS_AudioInput input
497    )
498{
499    NEXUS_Error errCode;
500    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
501    BDBG_ASSERT(NULL != handle->input);
502    if ( input != handle->input )
503    {
504        BDBG_ERR(("Input not connected"));
505        return BERR_TRACE(BERR_NOT_SUPPORTED);
506    }
507    errCode = BAPE_StudioSound_RemoveInput(handle->apeHandle, (BAPE_Connector)input->port);
508    if ( errCode )
509    {
510        return BERR_TRACE(errCode);
511    }
512    errCode = NEXUS_AudioInput_P_RemoveInput(&handle->connector, input);
513    if ( errCode )
514    {
515        return BERR_TRACE(errCode);
516    }
517    handle->input = NULL;
518    return BERR_SUCCESS;
519}
520
521NEXUS_Error NEXUS_StudioSound_RemoveAllInputs(
522    NEXUS_StudioSoundHandle handle
523    )
524{
525    BDBG_OBJECT_ASSERT(handle, NEXUS_StudioSound);
526    if ( handle->input )
527    {
528        return NEXUS_StudioSound_RemoveInput(handle, handle->input);
529    }
530    return BERR_SUCCESS;
531}
Note: See TracBrowser for help on using the repository browser.