1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95
96 //-------------------------------------------------------------------------------------------------
97 // Include Files
98 //-------------------------------------------------------------------------------------------------
99 // Common Definition
100 #include "MsCommon.h"
101 #include "MsIRQ.h"
102 #include "MsOS.h"
103 #ifdef MSOS_TYPE_LINUX_KERNEL
104 #include <linux/string.h>
105 #else
106 #include <string.h>
107 #endif
108
109 // Internal Definition
110 #include "regCHIP.h"
111 #include "drvAUDIO.h"
112 #include "regAUDIO.h"
113 #include "halAUDIO.h"
114 #include "halADVAUDIO.h"
115 #include "halMAD.h"
116 #include "halMAD2.h"
117 #include "halSOUND.h"
118 #include "halSIF.h"
119 #include "r2_shm_comm.h"
120 #include "decR2_shm.h"
121 #include "halAUR2.h"
122 #include "ddr_config.h"
123
124 #define OMX_AUDIO_DEBUG 0
125
126 #if (defined ANDROID)
127
128 #include <sys/mman.h>
129 #include <cutils/ashmem.h>
130 #include <cutils/log.h>
131
132 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
133 #define LOGI ALOGI
134 #endif
135
136 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
137 #define LOGE ALOGE
138 #endif
139
140 #define HALMAD_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
141 #define HALMAD_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
142
143 #else
144 #ifdef CONFIG_MBOOT //mboot Speed up
145 #define HALMAD_PRINT(fmt, args...)
146 #define HALMAD_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
147 #else
148 #define HALMAD_PRINT(fmt, args...) printf("[[utopia]] " fmt, ## args)
149 #define HALMAD_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
150 #endif
151 #endif
152
153
154 //-------------------------------------------------------------------------------------------------
155 // Driver Compiler Options
156 //-------------------------------------------------------------------------------------------------
157 #define DBG_MAD(msg) //msg
158 #define AUD_ERRMSG(msg) MS_CRITICAL_MSG(msg)
159 #define AUD_DBGMSG(msg) MS_DEBUG_MSG(msg)
160
161 #define HALMAD_CHECK_SHM_INIT \
162 do { \
163 if (g_AudioVars2 == NULL) \
164 { \
165 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
166 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
167 if (HAL_AUDIO_InitialVars() == FALSE) \
168 { \
169 MS_ASSERT(0);\
170 } \
171 } \
172 } while(0)
173
174 //-------------------------------------------------------------------------------------------------
175 // Local Defines
176 //-------------------------------------------------------------------------------------------------
177
178 #define H2BYTE(value) ((MS_U8)((value) / 0x10000))
179 #define HIBYTE(value) ((MS_U8)((value >>8) & 0x0000FF))
180 #define LOBYTE(value) ((MS_U8)((value) & 0x0000FF))
181
182 /* TVOS2.0 DTV */
183 #define STC_CLOCK_TICK 90
184 #define STC_BITS_MASK 0x1FFFFFFFF
185 #define STC_TICK_TO_NS(t) ((((t) & STC_BITS_MASK) * 1000LL) /STC_CLOCK_TICK)
186
187 //-------------------------------------------------------------------------------------------------
188 // Local Structures
189 //-------------------------------------------------------------------------------------------------
190
191 AES_INFO audio_aes_info[4];
192
193 //-------------------------------------------------------------------------------------------------
194 // Global Variables
195 //-------------------------------------------------------------------------------------------------
196 extern AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
197 extern MS_VIRT _gMIO_MapBase;
198 extern MS_U32 g_audioDumpInfo_interval;
199 extern AUDIO_SPDIF_OUTPUT_TYPE gSpdifOutputType;
200 extern HDMI_TX_OUTPUT_TYPE gHdmiOutputType;
201 extern MS_PHY g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2];
202 MS_U32 g_AudioDumpInfoCtrl = Audio_DumpInfo_Off;
203
204 extern MS_S32 _s32MutexLoadCode;
205 extern MS_S32 _s32AUDIOMutexIDMA;
206
207 //====== STAOS PIP START 2012/02/12 ========
208
209 extern pFuncPtr_SetAudioParam2 g_FuncPrt_Hal_SetAudioParam2;
210 extern pFuncPtr_GetAudioInfo2 g_FuncPrt_Hal_GetAudioInfo2;
211
212 //====== STAOS PIP END 2012/02/12 ========
213
214 //-------------------------------------------------------------------------------------------------
215 // Local Variables
216 //-------------------------------------------------------------------------------------------------
217 //static MS_BOOL EncodeInProcess;
218 //#define ENC_BUF_SIZE 6;
219 extern AUDIO_SHARED_VARS2 *g_AudioVars2;
220 #ifndef MSOS_TYPE_NUTTX
221 extern AUDIO_TEE_INFO_SHARE_MEM *pAudioTeeInfoShm;
222 extern MS_BOOL g_bAudioTeeEnabled, g_bAudioTeeMbxInitialized;
223 extern MS_BOOL g_bDecDspSecureTeeAccessed, g_bSndDspSecureTeeAccessed;
224 #endif
225 extern MS_BOOL (*g_FuncPtr_CheckCapability)(AUDIO_DEC_ID eDecId, AudioDecStatus_t * p_AudioDecStatus);
226
227 MS_U32 EncFrameIdx;
228 MS_U32 EncBuf_W_idx;
229 MS_U32 EncBuf_R_idx;
230 MS_U8 EncBuf_Count;
231 MS_U16 Reg_REG_SOUND_MAIN_SNDEFFECT = 0x0;
232 MS_U16 Reg_REG_SOUND_ADV_CFG0 = 0x0;
233 MS_BOOL Flag_MAIN_SNDEFFET_CHG = FALSE;
234
235 AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
236 DOLBY_DRC_MODE g_drcMode = RF_MODE;
237 MS_BOOL FLAG_HDMI_AC3_IN_SE = TRUE;
238
239 static MS_U32 g_ReadTargetAddr = 0x112D00;
240 static MS_U32 g_WriteTargetAddr = 0x112D00;
241
242 static MS_U32 g_ReadTargetXbox = DSP2XboxAddr_IO_Info1;
243 static MS_U32 g_WriteTargetXobx = DSP2XboxAddr_IO_Info1;
244
245 static MS_BOOL g_bR2Adec1AD = FALSE;
246 static MS_BOOL g_bR2Adec2AD = FALSE;
247
248 MS_BOOL g_dolbyBulletin11_support = TRUE;
249
250 const MS_U16 MpegBitRateTable[6][16] =
251 {
252 // V1, L1
253 {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0},
254 // V1, L2
255 {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0},
256 // V1, L3
257 {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
258 // V2, L1
259 {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},
260 // V2, L2
261 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
262 // V2, L3
263 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
264 };
265
266
267 //-------------------------------------------------------------------------------------------------
268 // Debug Functions
269 //-------------------------------------------------------------------------------------------------
270
271 //-------------------------------------------------------------------------------------------------
272 // Local Functions
273 //-------------------------------------------------------------------------------------------------
_GetAudioCaps(AUDIO_DEC_ID eDecId)274 MMA_AudioType _GetAudioCaps(AUDIO_DEC_ID eDecId)
275 {
276 MMA_AudioType eAudioCaps = 0;
277 HALMAD_CHECK_SHM_INIT;
278
279 if ( eDecId == AU_DEC_ID1 )
280 {
281 if(g_AudioVars2->g_hbr_bypass_enable==true)
282 {
283 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
284 Audio_DEC_MP3 | Audio_DEC_AC3 |
285 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
286 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
287 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
288 Audio_DEC_WMA | Audio_DEC_WMAPRO |
289 Audio_DEC_XPCM | Audio_DEC_VORBIS |
290 Audio_DEC_DTS | Audio_DEC_FLAC |
291 Audio_DEC_DTSLBR | Audio_DEC_DRA |
292 Audio_DEC_DTS_HD_ADO_R2 | Audio_DEC_Dolby_TrueHD_Bypass_R2;
293 }
294 else
295 {
296 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
297 Audio_DEC_MP3 | Audio_DEC_AC3 |
298 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
299 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
300 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
301 Audio_DEC_WMA | Audio_DEC_WMAPRO |
302 Audio_DEC_XPCM | Audio_DEC_VORBIS |
303 Audio_DEC_DTS | Audio_DEC_FLAC |
304 Audio_DEC_DTSLBR | Audio_DEC_DRA |
305 Audio_DEC_DTS_HD_ADO_R2;
306 }
307 }
308 else if ( eDecId == AU_DEC_ID2 )
309 {
310 eAudioCaps = 0;
311 }
312 else if ( eDecId == AU_DEC_ID3 )
313 {
314 #if 1
315 if(g_AudioVars2->g_hbr_bypass_enable==true)
316 {
317 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
318 Audio_DEC_MP3 | Audio_DEC_AC3 |
319 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
320 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
321 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
322 Audio_DEC_WMA | Audio_DEC_WMAPRO |
323 Audio_DEC_XPCM | Audio_DEC_VORBIS |
324 Audio_DEC_DTS | Audio_DEC_FLAC |
325 Audio_DEC_DTSLBR | Audio_DEC_DRA |
326 Audio_DEC_DTS_HD_ADO_R2 | Audio_DEC_Dolby_TrueHD_Bypass_R2;
327 }
328 else
329 {
330 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
331 Audio_DEC_MP3 | Audio_DEC_AC3 |
332 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
333 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
334 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
335 Audio_DEC_WMA | Audio_DEC_WMAPRO |
336 Audio_DEC_XPCM | Audio_DEC_VORBIS |
337 Audio_DEC_DTS | Audio_DEC_FLAC |
338 Audio_DEC_DTSLBR | Audio_DEC_DRA |
339 Audio_DEC_DTS_HD_ADO_R2;
340 }
341 #else
342 eAudioCaps = 0;
343 #endif
344 }
345
346 return eAudioCaps;
347 }
348
349 ////////////////////////////////////////////////////////////////////////////////
350 /// @brief \b Function \b Name: HAL_MAD_GetAudioCapability()
351 /// @brief \b Function \b Description: This routine is used to get DSP capability
352 /// @param <IN> \b eDecId : Dec ID
353 /// @param <IN> \b p_AudioDecStatus : Audio Dec Status structure
354 /// @param <RET> \b value : 0-- eDecId not support
355 /// 1-- eDecId support
356 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetAudioCapability(AUDIO_DEC_ID eDecId,AudioDecStatus_t * p_AudioDecStatus)357 MS_BOOL HAL_MAD_GetAudioCapability(AUDIO_DEC_ID eDecId, AudioDecStatus_t * p_AudioDecStatus)
358 {
359 MS_BOOL ret = FALSE;
360
361 if (eDecId == AU_DEC_ID2)
362 {
363 return ret;
364 }
365
366 switch ((p_AudioDecStatus->eSourceType))
367 {
368 case E_AUDIO_INFO_HDMI_IN: // HDMI should decode in SE and DEC DSP, always return true
369 case E_AUDIO_INFO_ATV_IN:
370 ret = TRUE;
371 break;
372
373 case E_AUDIO_INFO_DTV_IN:
374 if ((p_AudioDecStatus->eGroup == E_CONNECT_MAIN) ||
375 (p_AudioDecStatus->eGroup == E_CONNECT_SUB))
376 {
377 ret = TRUE;
378 }
379 break;
380
381 case E_AUDIO_INFO_MM_IN:
382 case E_AUDIO_INFO_GAME_IN:
383 ret = TRUE;
384 break;
385
386 default:
387 if ((p_AudioDecStatus->eAudFormat) == (_GetAudioCaps(eDecId) & (p_AudioDecStatus->eAudFormat)))
388 {
389 ret = TRUE;
390 }
391 break;
392 }
393
394 return ret;
395 }
396 //-------------------------------------------------------------------------------------------------
397 // Global Functions
398 //-------------------------------------------------------------------------------------------------
399
400 ///-----------------------------------------------------------------------------
401 ////////////////////////////////////////////////////////////////////////////////
402 ////////////////////////////////////////////////////////////////////////////////
403 ///
404 /// AUDIO_MAD SYSETM Relational Hal Function
405 ///
406 ////////////////////////////////////////////////////////////////////////////////
407 ////////////////////////////////////////////////////////////////////////////////
408 ///-----------------------------------------------------------------------------
409 ////////////////////////////////////////////////////////////////////////////////
410 /// @brief \b Function \b Name: HAL_MAD_Read_DSP_sram()
411 /// @brief \b Function \b Description: This routine is used to Read DSP internal sram value by IDMA
412 /// @param <IN> \b dsp_addr : DSP internal sram address
413 /// @param <IN> \b dsp_memory_type : 0--DSP_MEM_TYPE_PM
414 /// 1--DSP_MEM_TYPE_DM
415 /// @param <OUT> \b NONE :
416 /// @param <RET> \b value : U32 sram value
417 /// @param <GLOBAL> \b NONE :
418 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Read_DSP_sram(MS_U16 u16Dsp_addr,AUDIO_DSP_MEMORY_TYPE dsp_memory_type)419 MS_U32 HAL_MAD_Read_DSP_sram(MS_U16 u16Dsp_addr,AUDIO_DSP_MEMORY_TYPE dsp_memory_type)
420 {
421 // Do nothing because no DEC-DSP in Monoco
422 u16Dsp_addr = u16Dsp_addr;
423 dsp_memory_type = dsp_memory_type;
424
425 return 0;
426 }
427
428 ////////////////////////////////////////////////////////////////////////////////
429 /// @brief \b Function \b Name: HAL_MAD_Write_DSP_sram()
430 /// @brief \b Function \b Description: This routine is used to Write DSP internal sram value by IDMA
431 /// @param <IN> \b dsp_addr : DSP internal sram address
432 /// @param <IN> \b value : data want to write
433 /// @param <IN> \b dsp_memory_type : 0-- write to DSP_MEM_TYPE_PM
434 /// 1-- write to DSP_MEM_TYPE_DM
435 /// @param <OUT> \b NONE :
436 /// @param <RET> \b NONE : TRUE/FALSE
437 /// @param <GLOBAL> \b NONE :
438 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Write_DSP_sram(MS_U16 dsp_addr,MS_U32 value,AUDIO_DSP_MEMORY_TYPE dsp_memory_type)439 MS_BOOL HAL_MAD_Write_DSP_sram(MS_U16 dsp_addr, MS_U32 value, AUDIO_DSP_MEMORY_TYPE dsp_memory_type)
440 {
441 // Do nothing because no DEC-DSP in Monoco
442 dsp_addr = dsp_addr;
443 value = value;
444 dsp_memory_type = dsp_memory_type;
445
446 return TRUE;
447 }
448
449 ////////////////////////////////////////////////////////////////////////////////
450 /// @brief \b Function \b Name: HAL_MAD_Init()
451 /// @brief \b Function \b Description: This routine is the initialization for DVB module
452 /// @param <IN> \b NONE :
453 /// @param <OUT> \b NONE :
454 /// @param <RET> \b NONE :
455 /// @param <GLOBAL> \b NONE :
456 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Init(void)457 void HAL_MAD_Init(void)
458 {
459 //CarhyNeedReview
460
461 // to do : R2 init
462 HAL_MAD_LoadCode(AU_DVB_STANDARD_MPEG);
463
464 g_FuncPrt_Hal_SetAudioParam2 = HAL_MAD_SetAudioParam2;
465 g_FuncPrt_Hal_GetAudioInfo2 = HAL_MAD_GetAudioInfo2;
466 g_FuncPtr_CheckCapability = HAL_MAD_GetAudioCapability;
467 }
468
469 ////////////////////////////////////////////////////////////////////////////////
470 /// @brief \b Function \b Name: HAL_MAD_SetMemInfo()
471 /// @brief \b Function \b Description: This routine is used to set the DEC-DSP memory information
472 /// @param <IN> \b NONE :
473 /// @param <OUT> \b NONE :
474 /// @param <RET> \b NONE :
475 /// @param <GLOBAL> \b NONE :
476 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetMemInfo(void)477 void HAL_MAD_SetMemInfo(void)
478 {
479 // Remove all memory Info(SE-DSP & R2) to SetMemInfo2
480 return;
481 }
482
483 ////////////////////////////////////////////////////////////////////////////////
484 /// @brief \b Function \b Name: HAL_MAD_SetEncCmd()
485 /// @brief \b Function \b Description: This routine is to set encode command.
486 /// @param <IN> \b u8EncCmd :
487 /// 0--STOP
488 /// 1--START ENCODE
489 /// @param <OUT> \b NONE :
490 /// @param <RET> \b NONE :
491 /// @param <GLOBAL> \b NONE :
492 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetEncCmd(AU_DVB_ENCCMD u8EncCmd)493 void HAL_MAD_SetEncCmd(AU_DVB_ENCCMD u8EncCmd)
494 {
495 // not use, remove
496 }
497
498 ////////////////////////////////////////////////////////////////////////////////
499 /// @brief \b Function \b Name: HAL_MAD_EncodeInit() @@ function can be extended
500 /// @brief \b Function \b Description: This routine is to init encode parameter.
501 /// @param <IN> \b u8EncBr :
502 /// Encode Output Bitrate: 0:192kBps, 1:384kBps, 2:128kBps, 3:64kBps
503 /// \b
504 /// @param <OUT> \b NONE :
505 /// @param <RET> \b NONE :
506 /// @param <GLOBAL> \b NONE :
507 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_EncodeInit(AU_DVB_ENCBR u8EncBr,MS_U8 u8EncFrameNum)508 void HAL_MAD_EncodeInit(AU_DVB_ENCBR u8EncBr, MS_U8 u8EncFrameNum)
509 {
510 // not use, remove
511 }
512 ////////////////////////////////////////////////////////////////////////////////
513 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeFrameInfo() @@kochien added for PVR
514 /// @brief \b Function \b Description: This routine is used to get encoded frame information
515 /// @param <IN> \b u32Addr : encoded frame start address
516 /// @param <IN> \b u32Size : encoded frame data size
517 /// @param <IN> \b u64EncIdx : frame idx for PTS
518 /// @param <OUT> \b NONE :
519 /// @param <RET> \b NONE :
520 /// @param <GLOBAL> \b NONE :
521 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeFrameInfo(AU_DVB_ENC_FRAME_INFO * FrameInfo)522 void HAL_AUDIO_GetEncodeFrameInfo(AU_DVB_ENC_FRAME_INFO *FrameInfo)
523 {
524 // not use, remove
525 }
526
527
528 ////////////////////////////////////////////////////////////////////////////////
529 /// @brief \b Function \b Name: HAL_MAD_setDecCmd()
530 /// @brief \b Function \b Description: This routine is to set the DVB1 decode command.
531 /// @param <IN> \b u8DecCmd :
532 /// 0--STOP
533 /// 1--PLAY
534 /// 1--RESYNC
535 /// @param <OUT> \b NONE :
536 /// @param <RET> \b NONE :
537 /// @param <GLOBAL> \b NONE :
538 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDecCmd(AU_DVB_DECCMD u8DecCmd)539 void HAL_MAD_SetDecCmd(AU_DVB_DECCMD u8DecCmd)
540 {
541 MS_U8 FREERUN_STATE = 0;
542 MS_U16 u16_timeout = 0;
543 MS_U32 u32_r2_cmd = 0, u32_driver_cmd = 0;
544 DBG_MAD(printf("HAL_MAD_setDecCmd:(%x)\r\n",u8DecCmd));
545
546 if (u8DecCmd == AU_DVB_DECCMD_AVSYNC)
547 {
548 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, 0x00); // bit[15] = 0
549 }
550 else if (u8DecCmd == AU_DVB_DECCMD_FREERUN)
551 {
552 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, 0x80); // bit[15] = 1, AU_DEC_R2_CMD_FREERUN
553 }
554 else
555 {
556
557 switch(u8DecCmd)
558 {
559 case AU_DVB_DECCMD_STOP:
560 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, AU_DEC_ID1, 0, 0);
561 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0, 0); //Set ES write pointer to start point.
562 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_STOP);
563 break;
564
565 case AU_DVB_DECCMD_PLAY:
566 if (g_AudioVars2->g_u8MADSkipResetFlag == TRUE)
567 {
568 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, AU_DEC_ID1, 0, 0);
569 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0, 0); //Set ES write pointer to start point.
570 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0xFF, AU_DEC_R2_CMD_STOP);
571 g_AudioVars2->g_u8MADSkipResetFlag = FALSE;
572
573 }
574 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAY);
575 break;
576
577 case AU_DVB_DECCMD_PLAYFILETSP:
578 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAYFILETSP);
579 break;
580
581 case AU_DVB_DECCMD_PLAYFRAME_GS :
582 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAYUNI);
583 break;
584
585 case AU_DVB_DECCMD_PLAYFILE:
586 case AU_DVB_DECCMD_PLAYFILE2_PTS:
587 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAYFILE);
588 break;
589
590 case AU_DVB_DECCMD_STARTBROWSE:
591 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x20, AU_DEC_R2_CMD_STARTBROWSE);
592 break;
593
594 case AU_DVB_DECCMD_PLAY_AD:
595 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x10, AU_DEC_R2_CMD_PLAY_AD);
596 break;
597
598 case AU_DVB_DECCMD_STOP_AD:
599 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x10, 0x00);
600 break;
601
602 case AU_DVB_DECCMD_PAUSE:
603 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x40, AU_DEC_R2_CMD_PAUSE);
604 break;
605
606 case AU_DVB_DECCMD_SKIP:
607 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x7F, AU_DEC_R2_CMD_SKIP);
608 g_AudioVars2->g_u8MADSkipResetFlag = TRUE;
609 break;
610
611 default:
612 break;
613 }
614
615 FREERUN_STATE = HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD)&0x80; // check free-run
616 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, FREERUN_STATE);
617
618 /* handshake scheme between R2 and Driver */
619 if((u8DecCmd == AU_DVB_DECCMD_PLAY)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILETSP)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE)
620 ||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_STAGE)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_GS)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE2_PTS))
621 {
622 u32_driver_cmd = R2_DECCMD_PLAY; //DEC_PLAYSTATE_PLAY
623 }
624 else if(u8DecCmd == AU_DVB_DECCMD_STOP)
625 {
626 u32_driver_cmd = R2_DECCMD_STOP; //DEC_PLAYSTATE_STOP
627 }
628
629 else
630 {
631 return;
632 }
633
634 /* wait command passing to r2 */
635 while(u16_timeout++ < 100)
636 {
637 u32_r2_cmd = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, AU_DEC_ID1)&0x00FFFFFF;
638 AUDIO_DELAY1MS(1);
639 if (u32_r2_cmd == u32_driver_cmd)
640 break;
641 }
642
643 if (u16_timeout >= 100 )
644 {
645 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, " === HAL_MAD_SetDecCmd %d fail===\n",u8DecCmd);
646 }
647 }
648 }
649
HAL_MAD_SetDecCmd2(AUDIO_DEC_ID DecId,AU_DVB_DECCMD u8DecCmd)650 void HAL_MAD_SetDecCmd2(AUDIO_DEC_ID DecId, AU_DVB_DECCMD u8DecCmd)
651 {
652 if (AUDIO_DSP_ID_DEC == g_AudioVars2->AudioDecStatus[DecId].eDSPId)
653 {
654 // ADEC DSP
655 HAL_MAD_SetDecCmd(u8DecCmd);
656 }
657 else if (AUDIO_DSP_ID_SND == g_AudioVars2->AudioDecStatus[DecId].eDSPId)
658 {
659 // ASND DSP
660 HAL_MAD_SetDSP2DecCmd(u8DecCmd);
661 }
662 else
663 {
664 // AU_DEC_ID2 only for ATV SIF
665 // For other case should not use AU_DEC_ID2
666 return;
667 }
668
669 // Check AD play command
670 if((AU_DVB_DECCMD_PLAY_AD == u8DecCmd) || (AU_DVB_DECCMD_STOP_AD == u8DecCmd))
671 {
672 if(g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_DTV_IN)
673 {
674 switch(DecId)
675 {
676 case AU_DEC_ID1:
677 case AU_DEC_ID2:
678 {
679 switch(u8DecCmd)
680 {
681 case AU_DVB_DECCMD_PLAY_AD:
682 {
683 g_bR2Adec1AD = TRUE;
684 }
685 break;
686 case AU_DVB_DECCMD_STOP_AD:
687 {
688 g_bR2Adec1AD = FALSE;
689 }
690 break;
691 default:
692 break;
693 }
694 }
695 break;
696 case AU_DEC_ID3:
697 {
698 switch(u8DecCmd)
699 {
700 case AU_DVB_DECCMD_PLAY_AD:
701 {
702 g_bR2Adec2AD = TRUE;
703 }
704 break;
705 case AU_DVB_DECCMD_STOP_AD:
706 {
707 g_bR2Adec2AD = FALSE;
708 }
709 break;
710 default:
711 break;
712 }
713 }
714 break;
715 default:
716 break;
717 }
718 }
719 }
720
721 switch(DecId)
722 {
723 case AU_DEC_ID1:
724 case AU_DEC_ID2:
725 {
726 switch(g_bR2Adec1AD)
727 {
728 case TRUE:
729 {
730 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY_AD);
731 }
732 break;
733 case FALSE:
734 {
735 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP_AD);
736 }
737 break;
738 default:
739 break;
740 }
741 }
742 break;
743 case AU_DEC_ID3:
744 {
745 switch(g_bR2Adec2AD)
746 {
747 case TRUE:
748 {
749 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAY_AD);
750 }
751 break;
752 case FALSE:
753 {
754 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP_AD);
755 }
756 break;
757 default:
758 break;
759 }
760 }
761 break;
762 default:
763 break;
764 }
765 }
766
767
768
769 ////////////////////////////////////////////////////////////////////////////////
770 /// @brief \b Function \b Name: HAL_MAD_SetDSP2DecCmd()
771 /// @brief \b Function \b Description: This routine is to set the DVB3 decode command.
772 /// @param <IN> \b u8DecCmd :
773 /// 0--STOP
774 /// 1--PLAY
775 /// 1--RESYNC
776 /// @param <OUT> \b NONE :
777 /// @param <RET> \b NONE :
778 /// @param <GLOBAL> \b NONE :
779 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD u8DecCmd)780 void HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD u8DecCmd)
781 {
782 MS_U8 FREERUN_STATE = 0;
783 MS_U16 u16_timeout = 0;
784 MS_U32 u32_r2_cmd = 0, u32_driver_cmd = 0;
785 DBG_MAD(printf("HAL_MAD_SetDSP2DecCmd:(%x)\r\n", u8DecCmd));
786
787 if (u8DecCmd == AU_DVB_DECCMD_AVSYNC)
788 {
789 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x80, 0x00); // bit[15] = 0
790 }
791 else if (u8DecCmd == AU_DVB_DECCMD_FREERUN)
792 {
793 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x80, 0x80); // bit[15] = 1, AU_DEC_R2_CMD_FREERUN
794 }
795 else
796 {
797
798 switch(u8DecCmd)
799 {
800 case AU_DVB_DECCMD_STOP:
801 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, AU_DEC_ID3, 0, 0);
802 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0, 0); //Set ES write pointer to start point.
803 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_STOP);
804 break;
805
806 case AU_DVB_DECCMD_PLAY:
807 if (g_AudioVars2->g_u8MAD2SkipResetFlag == TRUE)
808 {
809 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, AU_DEC_ID3, 0, 0);
810 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0, 0); //Set ES write pointer to start point.
811 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_STOP);
812 g_AudioVars2->g_u8MAD2SkipResetFlag = FALSE;
813 AUDIO_DELAY1MS(20);
814 }
815 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAY);
816 break;
817
818 case AU_DVB_DECCMD_PLAYFILETSP:
819 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAYFILETSP);
820 break;
821
822 case AU_DVB_DECCMD_PLAYFRAME_GS :
823 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAYUNI);
824 break;
825
826 case AU_DVB_DECCMD_PLAYFILE:
827 case AU_DVB_DECCMD_PLAYFILE2_PTS:
828 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAYFILE);
829 break;
830
831 case AU_DVB_DECCMD_STARTBROWSE:
832 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x20, AU_DEC_R2_CMD_STARTBROWSE);
833 break;
834
835 case AU_DVB_DECCMD_PAUSE:
836 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x40, AU_DEC_R2_CMD_PAUSE);
837 break;
838
839 case AU_DVB_DECCMD_SKIP:
840 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_SKIP);
841 g_AudioVars2->g_u8MAD2SkipResetFlag = TRUE;
842 break;
843
844 default:
845 break;
846 }
847
848 FREERUN_STATE = HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_CMD)&0x80; // check free-run
849 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x80, FREERUN_STATE);
850 /* handshake scheme between R2 and Driver */
851 if((u8DecCmd == AU_DVB_DECCMD_PLAY)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILETSP)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE)
852 ||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_STAGE)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_GS)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE2_PTS))
853 {
854 u32_driver_cmd = R2_DECCMD_PLAY; //DEC_PLAYSTATE_PLAY
855 }
856 else if(u8DecCmd == AU_DVB_DECCMD_STOP)
857 {
858 u32_driver_cmd = R2_DECCMD_STOP; //DEC_PLAYSTATE_STOP
859 }
860 else
861 {
862 return;
863 }
864
865 /* wait command passing to r2 */
866 while(u16_timeout++ < 100)
867 {
868 u32_r2_cmd = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, AU_DEC_ID3)&0x00FFFFFF;
869 AUDIO_DELAY1MS(1);
870 if (u32_r2_cmd == u32_driver_cmd)
871 break;
872 }
873
874 if (u16_timeout >= 100 )
875 {
876 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, " === HAL_MAD_SetDSP2DecCmd %d fail===\n",u8DecCmd);
877 }
878 }
879 }
880
881 ////////////////////////////////////////////////////////////////////////////////
882 /// @brief \b Function \b Name: HAL_MAD_GetDecCmd()
883 /// @brief \b Function \b Description: This routine is to get the DVB1 decode command.
884 /// @param <OUT> \b AU_DVB_DECCMD :
885 // AU_DVB_DECCMD_STOP, //0
886 // AU_DVB_DECCMD_PLAY, //1
887 // AU_DVB_DECCMD_PLAYFILETSP = 2,
888 // AU_DVB_DECCMD_RESYNC,
889 // ....etc
890 /// @param <OUT> \b NONE :
891 /// @param <RET> \b NONE :
892 /// @param <GLOBAL> \b NONE :
893 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetDecCmd(En_DVB_AudioDecoder AdoDecoderNo)894 AU_DVB_DECCMD HAL_MAD_GetDecCmd(En_DVB_AudioDecoder AdoDecoderNo)
895 {
896 AU_DEC_R2_CMD r2cmd_status = AU_DEC_R2_CMD_STOP;
897 AU_DVB_DECCMD ret_deccmd = AU_DVB_DECCMD_STOP;
898
899 switch (AdoDecoderNo)
900 {
901 case DVB_Audio_Decoder1:
902 {
903 r2cmd_status = HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD);
904 r2cmd_status &= ~AU_DEC_R2_CMD_PLAY_AD; /* Discard AU_DEC_R2_CMD_PLAY_AD */
905 r2cmd_status &= ~AU_DEC_R2_CMD_FREERUN; /* Discard AU_DEC_R2_CMD_FREERUN */
906 break;
907 }
908
909 case DVB_Audio_Decoder2:
910 {
911 r2cmd_status = HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_CMD);
912 r2cmd_status = r2cmd_status & 0x7F;
913 break;
914 }
915
916 default:
917 break;
918 }
919
920 /*
921 need to report status cmd first (stauts cmd : free-run, pause, browse, play AD)
922 */
923
924 if((r2cmd_status & AU_DEC_R2_CMD_PAUSE) == AU_DEC_R2_CMD_PAUSE) // check pause
925 {
926 ret_deccmd = AU_DVB_DECCMD_PAUSE;
927 }
928 else if((r2cmd_status & AU_DEC_R2_CMD_STARTBROWSE) == AU_DEC_R2_CMD_STARTBROWSE) // check startbrowse
929 {
930 ret_deccmd = AU_DVB_DECCMD_STARTBROWSE;
931 }
932 else if((r2cmd_status & AU_DEC_R2_CMD_PLAY_AD) == AU_DEC_R2_CMD_PLAY_AD) // check play AD
933 {
934 ret_deccmd = AU_DVB_DECCMD_PLAY_AD;
935 }
936 else // others : not status cmd
937 {
938 switch(r2cmd_status)
939 {
940 case AU_DEC_R2_CMD_STOP:
941 ret_deccmd = AU_DVB_DECCMD_STOP;
942 break;
943
944 case AU_DEC_R2_CMD_PLAY:
945 ret_deccmd = AU_DVB_DECCMD_PLAY;
946 break;
947
948 case AU_DEC_R2_CMD_PLAYFILETSP:
949 ret_deccmd = AU_DVB_DECCMD_PLAYFILETSP;
950 break;
951
952 case AU_DEC_R2_CMD_PLAYUNI:
953 ret_deccmd = AU_DVB_DECCMD_PLAYFILE2_PTS;
954 break;
955
956 case AU_DEC_R2_CMD_PLAYFILE:
957 ret_deccmd = AU_DVB_DECCMD_PLAYFILE;
958 break;
959
960 default:
961 break;
962 }
963 }
964
965 return ret_deccmd;
966 }
967
968 ////////////////////////////////////////////////////////////////////////////////
969 /// @brief \b Function \b Name: HAL_MAD_setFreeRun()
970 /// @brief \b Function \b Description: This routine is to set the decoder in free run or AV-sync mode.
971 /// @param <IN> \b u8FreeRun : 0--normal AV sync
972 /// 1--free-run mode
973 /// @param <OUT> \b NONE :
974 /// @param <RET> \b NONE :
975 /// @param <GLOBAL> \b NONE :
976 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetFreeRun(MS_U8 u8FreeRun)977 void HAL_MAD_SetFreeRun( MS_U8 u8FreeRun )
978 {
979 DBG_MAD(printf("HAL_MAD_setFreeRun:(%x)\r\n",u8FreeRun));
980 if( u8FreeRun >= 2 ){
981 DBG_MAD(printf("Invalid mode\r\n"));
982 return;
983 }
984
985 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, (u8FreeRun << 7));
986 }
987
988
989 ////////////////////////////////////////////////////////////////////////////////
990 /// @brief \b Function \b Name: HAL_MAD_DisEn_MIUREQ()
991 /// @brief \b Function \b Description: This routine is to reset DVB1 MIU request command.
992 /// @param <IN> \b NONE :
993 /// @param <OUT> \b NONE :
994 /// @param <RET> \b NONE :
995 /// @param <GLOBAL> \b NONE :
996 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_DisEn_MIUREQ(void)997 void HAL_MAD_DisEn_MIUREQ(void)
998 {
999 // Disable MIU Request
1000 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0040 );
1001 AUDIO_DELAY1MS(1);
1002 // Enable MIU Request
1003 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0000 );
1004 }
1005
1006 ////////////////////////////////////////////////////////////////////////////////
1007 /// @brief \b Function \b Name: HAL_MAD_Dis_MIUREQ()
1008 /// @brief \b Function \b Description: This routine is to reset DVB1 MIU request command.
1009 /// @param <IN> \b NONE :
1010 /// @param <OUT> \b NONE :
1011 /// @param <RET> \b NONE :
1012 /// @param <GLOBAL> \b NONE :
1013 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Dis_MIUREQ(void)1014 void HAL_MAD_Dis_MIUREQ(void)
1015 {
1016 // Disable MIU Request
1017 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0040 ); // disable
1018 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0080, 0x0080 ); // reset MAD module
1019 }
1020
1021 ////////////////////////////////////////////////////////////////////////////////
1022 /// @brief \b Function \b Name: HAL_MAD_RSTMAD_DisEn_MIUREQ()
1023 /// @brief \b Function \b Description: This routine is to reset DVB1 MIU request command.
1024 /// @param <IN> \b NONE :
1025 /// @param <OUT> \b NONE :
1026 /// @param <RET> \b NONE :
1027 /// @param <GLOBAL> \b NONE :
1028 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_RSTMAD_DisEn_MIUREQ(void)1029 void HAL_MAD_RSTMAD_DisEn_MIUREQ(void)
1030 {
1031 // Disable MIU Request
1032 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0040 ); // disable
1033 // Reset MAD
1034 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0080, 0x0080 ); // reset MAD module
1035 AUDIO_DELAY1MS(1);
1036 // Set MAD
1037 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0080, 0x00 );
1038 // Enable MIU Request
1039 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0000 );
1040 }
1041
1042 ////////////////////////////////////////////////////////////////////////////////
1043 /// @brief \b Function \b Name: HAL_MAD_DSPACK()
1044 /// @brief \b Function \b Description: This routine is to report DSP reload ACK cmd.
1045 /// @param <IN> \b NONE :
1046 /// @param <OUT> \b NONE :
1047 /// @param <RET> \b NONE :
1048 /// @param <GLOBAL> \b NONE :
1049 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetReloadCodeAck(void)1050 MS_U8 HAL_MAD_GetReloadCodeAck(void)
1051 {
1052 //NOT_DEFINE : to do
1053 return(HAL_AUDIO_ReadByte(REG_MB_DE_ACK2));
1054 }
1055
1056 ////////////////////////////////////////////////////////////////////////////////
1057 /// @brief \b Function \b Name: HAL_MAD_DSPACK()
1058 /// @brief \b Function \b Description: This routine is to report DSP reload ACK cmd.
1059 /// @param <IN> \b NONE :
1060 /// @param <OUT> \b NONE :
1061 /// @param <RET> \b NONE :
1062 /// @param <GLOBAL> \b NONE :
1063 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetLoadCodeAck(void)1064 MS_U8 HAL_MAD_GetLoadCodeAck(void)
1065 {
1066 //NOT_DEFINE : to do
1067 return(HAL_AUDIO_ReadByte(REG_MB_DE_ACK1));
1068 }
1069
1070 ////////////////////////////////////////////////////////////////////////////////
1071 /// @brief \b Function \b Name: HAL_MAD_Rpt_DTVES()
1072 /// @brief \b Function \b Description: This routine is used to report AC3/MPEG stream if exist or not.
1073 /// @param <IN> \b NONE :
1074 /// @param <OUT> \b NONE :
1075 /// @param <RET> \b MS_U8 : the decoder status
1076 /// @param <GLOBAL> \b NONE :
1077 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Rpt_DTVES(void)1078 MS_U8 HAL_MAD_Rpt_DTVES(void)
1079 {
1080 MS_U8 Rpt_DTVES_tmp;
1081 Rpt_DTVES_tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1);
1082
1083 return Rpt_DTVES_tmp;
1084 }
1085
1086 ////////////////////////////////////////////////////////////////////////////////
1087 /// @brief \b Function \b Name: HAL_MAD_SetStreamID_Mod()
1088 /// @brief \b Function \b Description: This routine is used to AC3 Stream ID mod.
1089 /// @param <IN> \b stream_id_mod :
1090 /// @param <OUT> \b NONE :
1091 /// @param <RET> \b NONE :
1092 /// @param <GLOBAL> \b NONE :
1093 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetStreamID_Mod(MS_U8 stream_id_mod)1094 void HAL_MAD_SetStreamID_Mod(MS_U8 stream_id_mod)
1095 {
1096 //NOT_DEFINE : not used, remove
1097 }
1098
1099 ////////////////////////////////////////////////////////////////////////////////
1100 /// @brief \b Function \b Name: HAL_MAD_ReadTimeStamp()
1101 /// @brief \b Function \b Description: This routine returns the stmestamp while decoding file format.
1102 /// @param <IN> \b NONE :
1103 /// @param <OUT> \b NONE :
1104 /// @param <RET> \b timestamp : time stamp value
1105 /// @param <GLOBAL> \b NONE :
1106 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_ReadTimeStamp(void)1107 MS_U32 HAL_MAD_ReadTimeStamp(void)
1108 {
1109 MS_U32 timestamp = 0;
1110 MS_U32 pts = 0;
1111
1112 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, AU_DEC_ID1);
1113 timestamp = pts/45;
1114
1115 return timestamp;
1116 }
1117
1118 ////////////////////////////////////////////////////////////////////////////////
1119 /// @brief \b Function \b Name: HAL_MAD__SetAdMixMode()
1120 /// @brief \b Function \b Description: This routine is used to set MPEG mixed with AD or AD mixed with MPEG or not.
1121 /// @param <IN> \b u8Mix_mode : 0--main mix to AD
1122 /// 1--AD mix to main
1123 /// @param <IN> \b bEnMix : 0--disable AD mix
1124 /// 1--enable AD mix
1125 /// @param <OUT> \b NONE :
1126 /// @param <RET> \b NONE :
1127 /// @param <GLOBAL> \b NONE :
1128 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAdMixMode(AD_MIX_MODE u8Mix_mode,MS_BOOL bEnMix)1129 void HAL_MAD_SetAdMixMode (AD_MIX_MODE u8Mix_mode, MS_BOOL bEnMix)
1130 {
1131 //NOT_DEFINE
1132 switch (u8Mix_mode)
1133 {
1134 case MAIN_MIX_AD:
1135 case AD_MIX_MAIN:
1136 HAL_AUDIO_WriteMaskReg(REG_MB_DEC3_CTRL, 0x8000, bEnMix<<15); // IO_100 [15]
1137 break;
1138
1139 default:
1140 break;
1141 }
1142 }
1143
1144 ////////////////////////////////////////////////////////////////////////////////
1145 /// @brief \b Function \b Name: HAL_MAD_SetMcuCmd()
1146 /// @brief \b Function \b Description: This routine is to write MCU cmd for PIO.
1147 /// @param <IN> \b NONE :
1148 /// @param <OUT> \b NONE :
1149 /// @param <RET> \b NONE :
1150 /// @param <GLOBAL> \b NONE :
1151 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetPIOCmd(MS_U8 cmd)1152 void HAL_MAD_SetPIOCmd(MS_U8 cmd)
1153 {
1154 HAL_AUDIO_WriteMaskReg(REG_MB_DEC_PIO_ID,0xFF00, cmd<<8);
1155 }
1156
1157 ////////////////////////////////////////////////////////////////////////////////
1158 /// @brief \b Function \b Name: HAL_MAD_SetMcuCmd()
1159 /// @brief \b Function \b Description: This routine is to write MCU cmd.
1160 /// @param <IN> \b NONE :
1161 /// @param <OUT> \b NONE :
1162 /// @param <RET> \b NONE :
1163 /// @param <GLOBAL> \b NONE :
1164 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetMcuCmd(MS_U8 cmd)1165 void HAL_MAD_SetMcuCmd(MS_U8 cmd)
1166 {
1167 //NOT_DEFINE : not used, remove
1168 }
1169
1170 ////////////////////////////////////////////////////////////////////////////////
1171 /// @brief \b Function \b Name: HAL_MAD_SetDspIDMA()
1172 /// @brief \b Function \b Description: This function is used to set DSP IDMA.
1173 /// @param <IN> \b NONE :
1174 /// @param <OUT> \b NONE :
1175 /// @param <RET> \b NONE :
1176 /// @param <GLOBAL> \b NONE :
1177 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDspIDMA(void)1178 void HAL_MAD_SetDspIDMA(void)
1179 {
1180 //NOT_DEFINE : not used, remove
1181 }
1182
1183 ////////////////////////////////////////////////////////////////////////////////
1184 /// @brief \b Function \b Name: HAL_MAD_TriggerPIO8()
1185 /// @brief \b Function \b Description: This function is used to trigger PIO8 init.
1186 /// @param <IN> \b NONE :
1187 /// @param <OUT> \b NONE :
1188 /// @param <RET> \b NONE :
1189 /// @param <GLOBAL> \b NONE :
1190 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_TriggerPIO8(void)1191 void HAL_MAD_TriggerPIO8(void)
1192 {
1193 //NOT_DEFINE : not used, remove
1194 }
1195
1196 ////////////////////////////////////////////////////////////////////////////////
1197 /// @brief \b Function \b Name: HAL_MAD_DvbFLockSynthesizer_En()
1198 /// @brief \b Function \b Description: This function is used to set DSP IDMA.
1199 /// @param <IN> \b NONE :
1200 /// @param <OUT> \b NONE :
1201 /// @param <RET> \b NONE :
1202 /// @param <GLOBAL> \b NONE :
1203 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_DvbFLockSynthesizer_En(void)1204 void HAL_MAD_DvbFLockSynthesizer_En(void)
1205 {
1206 // enable force lock current DVB SYNC synthesizer freq
1207 // SIF only in SE DSP
1208 HAL_AUDIO_WriteMaskReg(REG_AUDIO_INPUT_CFG, 0x0040, 0x0040 );
1209 }
1210
1211 ////////////////////////////////////////////////////////////////////////////////
1212 /// @brief \b Function \b Name: HAL_AUDIO_SetCertMode()
1213 /// @brief \b Function \b Description:
1214 /// @param CertType \b : AUDIO_DOLBY_DD_Cert,
1215 /// @param CertType \b : AUDIO_DOLBY_DDP_Cert,
1216 /// @param CertType \b : AUDIO_DOLBY_PULSE_Cert,
1217 /// @param CertType \b : AUDIO_DOLBY_MS10_Cert,
1218 /// @param CertType \b : AUDIO_DTS_DMP_Cert,
1219 /// @param CertType \b : AUDIO_DTS_BC_Cert,
1220 /// @param CertType \b : AUDIO_DTS_PremiumTV_Cert,
1221 /// @param CertType \b : AUDIO_SRS_XT_Cert,
1222 /// @param enable \b : AUDIO_CERT_Enable / AUDIO_CERT_Disable
1223 ///
1224 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetCertMode(Audio_CertMode CertType,Audio_CertEnable enCert)1225 MS_BOOL HAL_AUDIO_SetCertMode( Audio_CertMode CertType,Audio_CertEnable enCert )
1226 {
1227 switch(CertType)
1228 {
1229 case AUDIO_DOLBY_DD_Cert:
1230 case AUDIO_DOLBY_DDP_Cert:
1231 case AUDIO_DOLBY_PULSE_Cert:
1232 case AUDIO_DOLBY_MS10_Cert:
1233 case AUDIO_DTS_DMP_Cert:
1234 case AUDIO_DTS_BC_Cert:
1235 // sound effect bypass setting
1236 break;
1237
1238 case AUDIO_DOLBY_DDCO_Cert:
1239 break;
1240
1241 case AUDIO_DTS_SYMMETRY_Cert:
1242 break;
1243
1244 case AUDIO_DTS_ENVELO_Cert:
1245 break;
1246
1247 case AUDIO_SRS_XT_Cert:
1248 break;
1249
1250 default:
1251 break;
1252 }
1253 return(true);
1254 }
1255
1256
1257 ////////////////////////////////////////////////////////////////////////////////
1258 /// @brief \b Function \b Name: HAL_MAD_MM2_initAesInfo()
1259 /// @brief \b Function \b Description : Initialize AES info
1260 /// @param <IN> \b dec_id : Decoder ID
1261 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
1262 /// @param <GLOBAL> \b NONE :
1263 ////////////////////////////////////////////////////////////////////////////////
1264 static MS_U32 prv_PTS = 0, prv_PTS1 = 0, prv_PTS2 = 0;
1265 static MS_U32 accum_ES = 0, prv_accum_ES = 0, accum_ES1 = 0, prv_accum_ES1 = 0, accum_ES2 = 0, prv_accum_ES2 = 0;
HAL_MAD_MM2_initAesInfo(AUDIO_DEC_ID dec_id)1266 MS_BOOL HAL_MAD_MM2_initAesInfo( AUDIO_DEC_ID dec_id )
1267 {
1268 if ( dec_id == AU_DEC_ID1 )
1269 {
1270 audio_aes_info[0].aes_base_addr = OFFSET_ES1_DRAM_ADDR;
1271 audio_aes_info[0].aes_BufSize = ES1_DRAM_SIZE;
1272 audio_aes_info[0].aes_end_addr = audio_aes_info[0].aes_base_addr + audio_aes_info[0].aes_BufSize;
1273 audio_aes_info[0].aes_write_addr = audio_aes_info[0].aes_base_addr;
1274 audio_aes_info[0].aes_freeSpace = audio_aes_info[0].aes_BufSize - (BYTES_IN_MIU_LINE*2);
1275 audio_aes_info[0].aes_level = 0;
1276 audio_aes_info[0].aes_lastPTS = 0;
1277 audio_aes_info[0].aes_ptsCnt = 0;
1278
1279 prv_PTS = 0;
1280 accum_ES = 0;
1281 prv_accum_ES = 0;
1282
1283 /* Set ES write pointer to DSP */
1284 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, 0, 0); //Set ES write pointer to start point.
1285
1286 DBG_MAD(printf("ID1: HAL_AUDIO_MM2_init end !!\r\n"));
1287 return TRUE;
1288 }
1289 else if( dec_id == AU_DEC_ID2 )
1290 {
1291 audio_aes_info[1].aes_base_addr = OFFSET_ES2_DRAM_ADDR;
1292 audio_aes_info[1].aes_BufSize = ES2_DRAM_SIZE;
1293 audio_aes_info[1].aes_end_addr = audio_aes_info[1].aes_base_addr + audio_aes_info[1].aes_BufSize;
1294 audio_aes_info[1].aes_write_addr = audio_aes_info[1].aes_base_addr;
1295 audio_aes_info[1].aes_freeSpace = audio_aes_info[1].aes_BufSize - (BYTES_IN_MIU_LINE*2);
1296 audio_aes_info[1].aes_level = 0;
1297 audio_aes_info[1].aes_lastPTS = 0;
1298 audio_aes_info[1].aes_ptsCnt = 0;
1299
1300 prv_PTS1 = 0;
1301 accum_ES1 = 0;
1302 prv_accum_ES1 = 0;
1303
1304 /* Set ES write pointer to DSP */
1305 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, 0, 0); //Set ES write pointer to start point.
1306
1307 DBG_MAD(printf("ID2: HAL_AUDIO_MM2_init end !!\r\n"));
1308 return TRUE;
1309 }
1310 else if( dec_id == AU_DEC_ID3 )
1311 {
1312 audio_aes_info[2].aes_base_addr = OFFSET_ES3_DRAM_ADDR;
1313 audio_aes_info[2].aes_BufSize = ES3_DRAM_SIZE;
1314 audio_aes_info[2].aes_end_addr = audio_aes_info[2].aes_base_addr + audio_aes_info[2].aes_BufSize;
1315 audio_aes_info[2].aes_write_addr = audio_aes_info[2].aes_base_addr;
1316 audio_aes_info[2].aes_freeSpace = audio_aes_info[2].aes_BufSize - (BYTES_IN_MIU_LINE*2);
1317 audio_aes_info[2].aes_level = 0;
1318 audio_aes_info[2].aes_lastPTS = 0;
1319 audio_aes_info[2].aes_ptsCnt = 0;
1320
1321 prv_PTS2 = 0;
1322 accum_ES2 = 0;
1323 prv_accum_ES2 = 0;
1324
1325 /* Set ES write pointer to DSP */
1326 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, 0, 0); //Set ES write pointer to start point.
1327
1328 DBG_MAD(printf("ID3: HAL_AUDIO_MM2_init end !!\r\n"));
1329 return TRUE;
1330 }
1331 else
1332 return FALSE;
1333 }
1334
1335 ////////////////////////////////////////////////////////////////////////////////
1336 /// @brief \b Function \b Name: HAL_MAD_MM2_checkAesInfo()
1337 /// @brief \b Function \b Description : Get AES info from audio decoder
1338 /// @param <IN> \b dec_id : Decoder ID
1339 /// @param <IN> \b aes_info : AES info structure pointer
1340 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
1341 /// @param <GLOBAL> \b NONE :
1342 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MM2_checkAesInfo(AUDIO_DEC_ID dec_id,AES_INFO * aes_info)1343 MS_BOOL HAL_MAD_MM2_checkAesInfo( AUDIO_DEC_ID dec_id, AES_INFO *aes_info )
1344 {
1345 if ( dec_id == AU_DEC_ID1 )
1346 {
1347 MS_U32 tmp1, tmp2;
1348
1349 /* es level */
1350 audio_aes_info[0].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1351
1352 /* calculate free space for next data input */
1353 tmp1 = audio_aes_info[0].aes_end_addr - audio_aes_info[0].aes_write_addr;
1354 tmp2 = audio_aes_info[0].aes_BufSize - audio_aes_info[0].aes_level;
1355
1356 if ( tmp2 < audio_aes_info[0].aes_BufSize/2)
1357 tmp2 = 0;
1358 else
1359 tmp2 -= (audio_aes_info[0].aes_BufSize/2);
1360
1361 if (tmp2 > (audio_aes_info[0].aes_BufSize/4))
1362 tmp2 = audio_aes_info[0].aes_BufSize/4;
1363
1364 audio_aes_info[0].aes_freeSpace = (tmp1 > tmp2)?tmp2:tmp1;
1365 audio_aes_info[0].aes_read_addr = OFFSET_ES1_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, AU_DEC_ID1 );
1366
1367 memcpy( (void *)aes_info, (void *)&audio_aes_info[0], sizeof(AES_INFO));
1368 DBG_MAD(printf("[ID1:HAL_MAD_MM2_checkAesInfo] Ptr[w:%x,r:%x] LvL:%x, FreeSpace:%x, tmpFree:%x \n",
1369 audio_aes_info[0].aes_write_addr,
1370 audio_aes_info[0].aes_read_addr,
1371 audio_aes_info[0].aes_level,
1372 audio_aes_info[0].aes_BufSize - audio_aes_info[0].aes_level,
1373 audio_aes_info[0].aes_freeSpace));
1374
1375 return TRUE;
1376 }
1377 else if( dec_id == AU_DEC_ID2 )
1378 {
1379 MS_U32 tmp1, tmp2;
1380
1381 /* es level */
1382 audio_aes_info[1].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1383
1384 /* calculate free space for next data input */
1385 tmp1 = audio_aes_info[1].aes_end_addr - audio_aes_info[1].aes_write_addr;
1386 tmp2 = audio_aes_info[1].aes_BufSize - audio_aes_info[1].aes_level;
1387
1388 if ( tmp2 < audio_aes_info[1].aes_BufSize/2)
1389 tmp2 = 0;
1390 else
1391 tmp2 -= (audio_aes_info[1].aes_BufSize/2);
1392
1393 if (tmp2 > (audio_aes_info[1].aes_BufSize/4))
1394 tmp2 = audio_aes_info[1].aes_BufSize/4;
1395
1396 audio_aes_info[1].aes_freeSpace = (tmp1 > tmp2)?tmp2:tmp1;
1397 audio_aes_info[1].aes_read_addr = OFFSET_ES2_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, AU_DEC_ID2 );
1398
1399 memcpy( (void *)aes_info, (void *)&audio_aes_info[1], sizeof(AES_INFO));
1400 DBG_MAD(printf("[ID2:HAL_MAD_MM2_checkAesInfo] Ptr[w:%x,r:%x] LvL:%x, FreeSpace:%x, tmpFree:%x \n",
1401 audio_aes_info[1].aes_write_addr,
1402 audio_aes_info[1].aes_read_addr,
1403 audio_aes_info[1].aes_level,
1404 audio_aes_info[1].aes_BufSize - audio_aes_info[1].aes_level,
1405 audio_aes_info[1].aes_freeSpace));
1406
1407 return TRUE;
1408 }
1409 else if( dec_id == AU_DEC_ID3 )
1410 {
1411 MS_U32 tmp1, tmp2;
1412
1413 /* es level */
1414 audio_aes_info[2].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1415
1416 /* calculate free space for next data input */
1417 tmp1 = audio_aes_info[2].aes_end_addr - audio_aes_info[2].aes_write_addr;
1418 tmp2 = audio_aes_info[2].aes_BufSize - audio_aes_info[2].aes_level;
1419
1420 if ( tmp2 < audio_aes_info[2].aes_BufSize/2)
1421 tmp2 = 0;
1422 else
1423 tmp2 -= (audio_aes_info[2].aes_BufSize/2);
1424
1425 if (tmp2 > (audio_aes_info[2].aes_BufSize/4))
1426 tmp2 = audio_aes_info[2].aes_BufSize/4;
1427
1428 audio_aes_info[2].aes_freeSpace = (tmp1 > tmp2)?tmp2:tmp1;
1429 audio_aes_info[2].aes_read_addr = OFFSET_ES3_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, AU_DEC_ID3 );
1430
1431 memcpy( (void *)aes_info, (void *)&audio_aes_info[2], sizeof(AES_INFO));
1432 DBG_MAD(printf("[ID3:HAL_MAD_MM2_checkAesInfo] Ptr[w:%x,r:%x] LvL:%x, FreeSpace:%x, tmpFree:%x \n",
1433 audio_aes_info[2].aes_write_addr,
1434 audio_aes_info[2].aes_read_addr,
1435 audio_aes_info[2].aes_level,
1436 audio_aes_info[2].aes_BufSize - audio_aes_info[2].aes_level,
1437 audio_aes_info[2].aes_freeSpace));
1438
1439 return TRUE;
1440 }
1441 else
1442 {
1443 return FALSE;
1444 }
1445 }
1446
1447 ////////////////////////////////////////////////////////////////////////////////
1448 /// @brief \b Function \b Name: HAL_MAD_MM2_inputAesFinished()
1449 /// @brief \b Function \b Description : Inform DSP how much ES data is sent
1450 /// @param <IN> \b dec_id : Decoder ID
1451 /// @param <IN> \b es_size : Size of ES data
1452 /// @param <IN> \b ptsExist : Whether ES data contains PTS or not
1453 /// @param <IN> \b pts : PTS
1454 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
1455 /// @param <GLOBAL> \b NONE :
1456 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MM2_inputAesFinished(AUDIO_DEC_ID dec_id,MS_U32 es_size,MS_BOOL ptsExist,MS_U64 pts)1457 MS_BOOL HAL_MAD_MM2_inputAesFinished( AUDIO_DEC_ID dec_id, MS_U32 es_size, MS_BOOL ptsExist, MS_U64 pts )
1458 {
1459 MS_U32 es_writeLineOffset;
1460 MS_U32 tmp1, tmp2;
1461
1462 if (es_size == 0)
1463 return FALSE;
1464
1465 if ( dec_id == AU_DEC_ID1 )
1466 {
1467 /* es level */
1468 audio_aes_info[0].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1469
1470 /* calculate free space for next data input */
1471 tmp1 = audio_aes_info[0].aes_end_addr - audio_aes_info[0].aes_write_addr;
1472 tmp2 = audio_aes_info[0].aes_BufSize - audio_aes_info[0].aes_level;
1473
1474 audio_aes_info[0].aes_freeSpace = (tmp1 - tmp2)?tmp2:tmp1;
1475
1476 if ( es_size > audio_aes_info[0].aes_freeSpace )
1477 {
1478 printf("ID1:==> Error, input AES size(0x%x) is larger than current Free space(0x%x)\r\n", es_size, audio_aes_info[0].aes_freeSpace );
1479 return FALSE;
1480 }
1481
1482 DBG_MAD(printf("[ID1:HAL_MAD_MM2_inputAesFinished] wPtr:%08x => ", audio_aes_info[0].aes_write_addr));
1483
1484 /* update write pointer */
1485 audio_aes_info[0].aes_write_addr += es_size;
1486
1487 if ( audio_aes_info[0].aes_write_addr >= audio_aes_info[0].aes_end_addr )
1488 audio_aes_info[0].aes_write_addr -= audio_aes_info[0].aes_BufSize;
1489
1490 DBG_MAD(printf("%08x, size=%08x,isPtsExist:%d,PTS=%09lld",
1491 audio_aes_info[0].aes_write_addr,
1492 es_size,
1493 ptsExist,
1494 pts/90));
1495
1496 if (ptsExist)
1497 {
1498 if (prv_PTS != 0)
1499 {
1500 DBG_MAD(printf(",PTS_diff=%08lld,accum_ES = %08x,ES_diff= %08d, ES PTS diff=%08d\n",
1501 (pts - prv_PTS)/90,
1502 accum_ES,
1503 accum_ES - prv_accum_ES,
1504 (accum_ES - prv_accum_ES)*32/1536));
1505 }
1506 else
1507 {
1508 DBG_MAD(printf(", PTS_diff=%08x, accum_ES = %08x\n", 0, 0));
1509 }
1510
1511 prv_PTS = pts;
1512 prv_accum_ES = accum_ES;
1513 }
1514 else
1515 {
1516 DBG_MAD(printf("\n"));
1517 }
1518
1519 accum_ES += es_size;
1520
1521 es_writeLineOffset = audio_aes_info[0].aes_write_addr - audio_aes_info[0].aes_base_addr;
1522
1523 if (ptsExist)
1524 {
1525 if ((audio_aes_info[0].aes_lastPTS == pts)&&(audio_aes_info[0].aes_ptsCnt != 0))
1526 printf(" ======== Error PTS is same !! =============\n");
1527 else
1528 {
1529 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_INPUT_PTS, dec_id, (pts >> 1), 0);
1530 audio_aes_info[0].aes_ptsCnt++;
1531 audio_aes_info[0].aes_lastPTS = pts;
1532 AUDIO_DELAY1US(500);
1533 }
1534 }
1535
1536 /* Set ES write pointer to DSP */
1537 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, es_writeLineOffset, 0);
1538 AUDIO_DELAY1US(250); //Since DSP timer update ES_MEM_CNT at each 125us, need this delay to keep
1539 }
1540 else if (dec_id == AU_DEC_ID2)
1541 {
1542 /* es level */
1543 audio_aes_info[1].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1544
1545 /* calculate free space for next data input */
1546 tmp1 = audio_aes_info[1].aes_end_addr - audio_aes_info[1].aes_write_addr;
1547 tmp2 = audio_aes_info[1].aes_BufSize - audio_aes_info[1].aes_level;
1548
1549 audio_aes_info[1].aes_freeSpace = (tmp1 - tmp2)?tmp2:tmp1;
1550
1551 if ( es_size > audio_aes_info[1].aes_freeSpace )
1552 {
1553 printf("ID2:==> Error, input AES size(0x%x) is larger than current Free space(0x%x)\r\n", es_size, audio_aes_info[1].aes_freeSpace );
1554 return FALSE;
1555 }
1556
1557 DBG_MAD(printf("[ID2:HAL_MAD_MM2_inputAesFinished] wPtr:%08x => ", audio_aes_info[1].aes_write_addr));
1558
1559 /* update write pointer */
1560 audio_aes_info[1].aes_write_addr += es_size;
1561
1562 if ( audio_aes_info[1].aes_write_addr >= audio_aes_info[1].aes_end_addr )
1563 audio_aes_info[1].aes_write_addr -= audio_aes_info[1].aes_BufSize;
1564
1565 DBG_MAD(printf("%08x, size=%08x,isPtsExist:%d,PTS=%09lld",
1566 audio_aes_info[1].aes_write_addr,
1567 es_size,
1568 ptsExist,
1569 pts/90));
1570
1571 if (ptsExist)
1572 {
1573 if (prv_PTS1 != 0)
1574 {
1575 DBG_MAD(printf(",PTS_diff=%08lld,accum_ES = %08x,ES_diff= %08d, ES PTS diff=%08d\n",
1576 (pts - prv_PTS1)/90,
1577 accum_ES1,
1578 accum_ES1 - prv_accum_ES1,
1579 (accum_ES1 - prv_accum_ES1)*32/1536));
1580 }
1581 else
1582 {
1583 DBG_MAD(printf(", PTS_diff=%08x, accum_ES = %08x\n", 0, 0));
1584 }
1585
1586 prv_PTS1 = pts;
1587 prv_accum_ES1 = accum_ES1;
1588 }
1589 else
1590 {
1591 DBG_MAD(printf("\n"));
1592 }
1593
1594 accum_ES1 += es_size;
1595
1596 es_writeLineOffset = audio_aes_info[1].aes_write_addr - audio_aes_info[1].aes_base_addr;
1597
1598 if (ptsExist)
1599 {
1600 if ((audio_aes_info[1].aes_lastPTS == pts)&&(audio_aes_info[1].aes_ptsCnt != 0))
1601 printf(" ======== Error PTS is same !! =============\n");
1602 else
1603 {
1604 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_INPUT_PTS, dec_id, (pts >> 1), 0);
1605 audio_aes_info[1].aes_ptsCnt++;
1606 audio_aes_info[1].aes_lastPTS = pts;
1607 AUDIO_DELAY1US(500);
1608 }
1609 }
1610
1611 /* Set ES write pointer to DSP */
1612 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, es_writeLineOffset, 0);
1613 AUDIO_DELAY1US(250); //Since DSP timer update ES_MEM_CNT at each 125us, need this delay to keep
1614 }
1615 else if (dec_id == AU_DEC_ID3)
1616 {
1617 /* es level */
1618 audio_aes_info[2].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1619
1620 /* calculate free space for next data input */
1621 tmp1 = audio_aes_info[2].aes_end_addr - audio_aes_info[2].aes_write_addr;
1622 tmp2 = audio_aes_info[2].aes_BufSize - audio_aes_info[2].aes_level;
1623
1624 audio_aes_info[2].aes_freeSpace = (tmp1 - tmp2)?tmp2:tmp1;
1625
1626 if ( es_size > audio_aes_info[2].aes_freeSpace )
1627 {
1628 printf("ID3:==> Error, input AES size(0x%x) is larger than current Free space(0x%x)\r\n", es_size, audio_aes_info[2].aes_freeSpace );
1629 return FALSE;
1630 }
1631
1632 DBG_MAD(printf("[ID3:HAL_MAD_MM2_inputAesFinished] wPtr:%08x => ", audio_aes_info[2].aes_write_addr));
1633
1634 /* update write pointer */
1635 audio_aes_info[2].aes_write_addr += es_size;
1636
1637 if ( audio_aes_info[2].aes_write_addr >= audio_aes_info[2].aes_end_addr )
1638 audio_aes_info[2].aes_write_addr -= audio_aes_info[2].aes_BufSize;
1639
1640 DBG_MAD(printf("%08x, size=%08x,isPtsExist:%d,PTS=%09lld",
1641 audio_aes_info[2].aes_write_addr,
1642 es_size,
1643 ptsExist,
1644 pts/90));
1645
1646 if (ptsExist)
1647 {
1648 if (prv_PTS2 != 0)
1649 {
1650 DBG_MAD(printf(",PTS_diff=%08lld,accum_ES = %08x,ES_diff= %08d, ES PTS diff=%08d\n",
1651 (pts - prv_PTS2)/90,
1652 accum_ES2,
1653 accum_ES2 - prv_accum_ES2,
1654 (accum_ES2 - prv_accum_ES2)*32/1536));
1655 }
1656 else
1657 {
1658 DBG_MAD(printf(", PTS_diff=%08x, accum_ES = %08x\n", 0, 0));
1659 }
1660
1661 prv_PTS2 = pts;
1662 prv_accum_ES2 = accum_ES2;
1663 }
1664 else
1665 {
1666 DBG_MAD(printf("\n"));
1667 }
1668
1669 accum_ES2 += es_size;
1670
1671 es_writeLineOffset = audio_aes_info[2].aes_write_addr - audio_aes_info[2].aes_base_addr;
1672
1673 if (ptsExist)
1674 {
1675 if ((audio_aes_info[2].aes_lastPTS == pts)&&(audio_aes_info[2].aes_ptsCnt != 0))
1676 printf(" ======== Error PTS is same !! =============\n");
1677 else
1678 {
1679 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_INPUT_PTS, dec_id, (pts >> 1), 0);
1680 audio_aes_info[2].aes_ptsCnt++;
1681 audio_aes_info[2].aes_lastPTS = pts;
1682 AUDIO_DELAY1US(500);
1683 }
1684 }
1685
1686 /* Set ES write pointer to DSP */
1687 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, es_writeLineOffset, 0);
1688 AUDIO_DELAY1US(250); //Since DSP timer update ES_MEM_CNT at each 125us, need this delay to keep
1689 }
1690 return TRUE;
1691 }
1692
1693
1694 ///-----------------------------------------------------------------------------
1695 ////////////////////////////////////////////////////////////////////////////////
1696 ////////////////////////////////////////////////////////////////////////////////
1697 ///
1698 /// AUDIO_MAD MPEG Relational Hal Function
1699 ///
1700 ////////////////////////////////////////////////////////////////////////////////
1701 ////////////////////////////////////////////////////////////////////////////////
1702 ///-----------------------------------------------------------------------------
1703 ////////////////////////////////////////////////////////////////////////////////
1704 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetHeaderInfo()
1705 /// @brief \b Function \b Description: This routine will return the 32bit mpeg header
1706 /// @param <IN> \b NONE :
1707 /// @param <OUT> \b NONE :
1708 /// @param <RET> \b U32 : mpeg header information
1709 /// @param <GLOBAL> \b NONE :
1710 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetHeaderInfo(void)1711 MS_U32 HAL_MAD_MPEG_GetHeaderInfo(void)
1712 {
1713 MS_U16 data;
1714
1715 data = (MS_U16)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MPEG_HEADER, AU_DEC_ID1);
1716
1717 return (data & 0x0FFF);
1718 }
1719
1720 ////////////////////////////////////////////////////////////////////////////////
1721 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetSampleRate()
1722 /// @brief \b Function \b Description: This routine will return the 16bit mpeg samplerate
1723 /// @param <IN> \b NONE :
1724 /// @param <OUT> \b NONE :
1725 /// @param <RET> \b U16 : mpeg sampling rate
1726 /// @param <GLOBAL> \b NONE :
1727 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetSampleRate(void)1728 MS_U16 HAL_MAD_MPEG_GetSampleRate(void)
1729 {
1730 return (MS_U16)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1);
1731 }
1732
1733 ////////////////////////////////////////////////////////////////////////////////
1734 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetBitRate()
1735 /// @brief \b Function \b Description: This routine will return the 16-bit mpeg bit rate
1736 /// @param <IN> \b NONE :
1737 /// @param <OUT> \b NONE :
1738 /// @param <RET> \b U16 : mpeg bit rate
1739 /// @param <GLOBAL> \b NONE :
1740 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetBitRate(void)1741 MS_U16 HAL_MAD_MPEG_GetBitRate(void)
1742 {
1743 return (MS_U16) HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, AU_DEC_ID1);
1744 }
1745
1746 ////////////////////////////////////////////////////////////////////////////////
1747 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetSoundMode()
1748 /// @brief \b Function \b Description: This routine will return the 8bit mpeg sound mode
1749 /// @param <IN> \b NONE :
1750 /// @param <OUT> \b NONE :
1751 /// @param <RET> \b MPEG_SOUND_MODE :
1752 /// MPEG_SOUND_MODE_STEREO =0,
1753 /// MPEG_SOUND_MODE_JOINT_STEREO,
1754 /// MPEG_SOUND_MODE_DUAL_CHAN,
1755 /// MPEG_SOUND_MODE_MONO
1756 /// @param <GLOBAL> \b NONE :
1757 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetSoundMode(void)1758 MPEG_SOUND_MODE HAL_MAD_MPEG_GetSoundMode(void)
1759 {
1760 return (MPEG_SOUND_MODE)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MPEG_STEREOMODE, AU_DEC_ID1);
1761 }
1762
1763 ///-----------------------------------------------------------------------------
1764 ////////////////////////////////////////////////////////////////////////////////
1765 ////////////////////////////////////////////////////////////////////////////////
1766 ///
1767 /// AUDIO_MAD Dolby Relational Hal Function
1768 ///
1769 ////////////////////////////////////////////////////////////////////////////////
1770 ////////////////////////////////////////////////////////////////////////////////
1771 ///-----------------------------------------------------------------------------
1772 ///////////////////////////////////////////////////////////////////////////////
1773 /// @brief \b Function \b Name: HAL_MAD_Monitor_DDPlus_SPDIF_Rate()
1774 /// @brief \b Function \b Description: This routine is used to set reference ADC clock by DD+ dsp code
1775 /// @param <IN> \b NONE :
1776 /// @param <OUT> \b NONE :
1777 /// @param <RET> \b NONE :
1778 /// @param <GLOBAL> \b NONE :
1779 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Monitor_DDPlus_SPDIF_Rate(void)1780 void HAL_MAD_Monitor_DDPlus_SPDIF_Rate(void)
1781 {
1782 MS_U8 u8SpdifMode = SPDIF_OUT_PCM;
1783 MS_U8 eAudioSource = 0;
1784 MS_U8 u8MainDspCodeType = MSAPI_AUD_DVB_INVALID;
1785 MS_U8 u8Dsp1CodeType = MSAPI_AUD_DVB_INVALID;
1786 MS_U8 u8Dsp2CodeType = MSAPI_AUD_DVB_INVALID;
1787 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
1788 MS_BOOL retTx1, retTx2;
1789 MS_U8 u8MainADEC = AU_DEC_ID1;
1790 AUDIO_DEC_ID DecId = AU_DEC_ID1;
1791 MS_U32 u32spdif_info_flag = 0; //0: disable. 1: bypass/convert, 2: transcoder, 3: pcm
1792
1793
1794 HALMAD_CHECK_SHM_INIT;
1795
1796 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
1797 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
1798
1799 eAudioSource = (MS_U8)g_AudioVars2->eAudioSource;
1800 u8Dsp1CodeType = g_AudioVars2->g_DspCodeType;
1801 u8Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
1802
1803 HAL_AUDIO_SPDIF_SetMode(gSpdifOutputType, eAudioSource);
1804 HAL_AUDIO_HDMI_TX_SetMode(gHdmiOutputType, eAudioSource);
1805
1806 u8SpdifMode = _HAL_AUDIO_SPDIF_GetMode();
1807
1808 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
1809 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
1810 if (retTx1 == FALSE || retTx2 == FALSE)
1811 {
1812 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
1813 }
1814
1815 switch(eAudioSource)
1816 {
1817 case E_AUDIO_INFO_DTV_IN:
1818 case E_AUDIO_INFO_MM_IN:
1819 case E_AUDIO_INFO_GAME_IN:
1820 {
1821
1822 if(g_AudioVars2->g_R2_NonPcm_Sel == AU_DEC_ID1)
1823 {
1824 u8MainDspCodeType = u8Dsp1CodeType;
1825 u8MainADEC = AU_DEC_ID1;
1826 DecId = AU_DEC_ID1;
1827 }
1828 else
1829 {
1830 u8MainDspCodeType = u8Dsp2CodeType;
1831 u8MainADEC = AU_DEC_ID3;
1832 DecId = AU_DEC_ID3;
1833 }
1834
1835 switch(u8MainDspCodeType)
1836 {
1837 case AU_DVB_STANDARD_AC3:
1838 case AU_DVB_STANDARD_AC3P:
1839 case AU_DVB_STANDARD_MS10_DDC:
1840 {
1841 if (u8SpdifMode == SPDIF_OUT_PCM)
1842 {
1843 break;
1844 }
1845
1846 switch(HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, u8MainADEC))
1847 {
1848 case 44100:
1849 {
1850 /* change SPDIF Tx 1&2 channel status --> 44.1KHz */
1851 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
1852 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
1853 break;
1854 }
1855
1856 case 32000:
1857 {
1858 /* change SPDIF Tx 1&2 channel status --> 32KHz */
1859 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
1860 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
1861 break;
1862 }
1863
1864 default:
1865 {
1866 /* change SPDIF Tx 1&2 channel status --> 48KHz */
1867 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
1868 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
1869 break;
1870 }
1871 }
1872 break;
1873 }
1874
1875 case AU_DVB_STANDARD_DTS:
1876 case AU_DVB_STANDARD_DTSLBR:
1877 {
1878 if (u8SpdifMode == SPDIF_OUT_PCM)
1879 {
1880 break;
1881 }
1882
1883 u32spdif_info_flag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainADEC);
1884 if(u32spdif_info_flag == 0) //u32spdif_info_flag == 0 means NPCM output processing is at DSP or SND-R2 for M2
1885 {
1886 /* 48KHz */
1887 stDigitalChannelStatusTx1.u8SamplingRate = 0x40; /* change SPDIF Tx1 channel status --> 48KHz */
1888 stDigitalChannelStatusTx2.u8SamplingRate = 0x40; /* change SPDIF Tx2 channel status --> 48KHz */
1889 }
1890 else
1891 {
1892 if (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, u8MainADEC) == 44100)
1893 {
1894 /* 44.1KHz */
1895 stDigitalChannelStatusTx1.u8SamplingRate = 0x00; /* change SPDIF Tx1 channel status --> 44.1KHz */
1896 stDigitalChannelStatusTx2.u8SamplingRate = 0x00; /* change SPDIF Tx2 channel status --> 44.1KHz */
1897 }
1898 else
1899 {
1900 /* 48KHz */
1901 stDigitalChannelStatusTx1.u8SamplingRate = 0x40; /* change SPDIF Tx1 channel status --> 48KHz */
1902 stDigitalChannelStatusTx2.u8SamplingRate = 0x40; /* change SPDIF Tx2 channel status --> 48KHz */
1903 }
1904 }
1905 break;
1906 }
1907
1908 default:
1909 {
1910 break;
1911 }
1912 }
1913 break;
1914 }
1915
1916 default:
1917 {
1918 break;
1919 }
1920 }
1921 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
1922 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
1923 }
1924
1925 ///-----------------------------------------------------------------------------
1926 ////////////////////////////////////////////////////////////////////////////////
1927 ////////////////////////////////////////////////////////////////////////////////
1928 ///
1929 /// AUDIO_MAD WMA Relational Hal Function
1930 ///
1931 ////////////////////////////////////////////////////////////////////////////////
1932 ////////////////////////////////////////////////////////////////////////////////
1933 ///-----------------------------------------------------------------------------
1934 ////////////////////////////////////////////////////////////////////////////////
1935 /// @brief \b Function \b Name: HAL_MAD_WMA_SetASFParm()
1936 /// @brief \b Function \b Description: This routine will set WMA ASF Paramaters.
1937 /// @param <IN> \b NONE : WMA_ASF_PARMTYPE, value
1938 /// @param <OUT> \b NONE :
1939 /// @param <RET> \b NONE :
1940 /// @param <GLOBAL> \b NONE :
1941 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_WMA_SetASFParm(WMA_ASF_PARMTYPE parm_type,MS_U32 value)1942 void HAL_MAD_WMA_SetASFParm(WMA_ASF_PARMTYPE parm_type, MS_U32 value)
1943 {
1944 switch ( parm_type )
1945 {
1946 case WMA_PARAMTYPE_VERSION:
1947 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_VERSION, AU_DEC_ID1, value, 0);
1948 break;
1949 case WMA_PARAMTYPE_CHANNELS:
1950 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELS, AU_DEC_ID1, value, 0);
1951 break;
1952 case WMA_PARAMTYPE_SAMPLERATE:
1953 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_SAMPLERATE, AU_DEC_ID1, value, 0);
1954 break;
1955 case WMA_PARAMTYPE_BYTERATE:
1956 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BYTERATE, AU_DEC_ID1, value, 0);
1957 break;
1958 case WMA_PARAMTYPE_BLOCKALIGN:
1959 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BLOCKALIGN, AU_DEC_ID1, value, 0);
1960 break;
1961 case WMA_PARAMTYPE_ENCOPT:
1962 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_ENCOPT, AU_DEC_ID1, value, 0);
1963 break;
1964 case WMA_PARAMTYPE_PARSINGBYAPP:
1965 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_PARSINGBYAPP, AU_DEC_ID1, value, 0);
1966 break;
1967 case WMA_PARAMTYPE_BITS_PER_SAMPLE:
1968 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BITS_PER_SAMPLE, AU_DEC_ID1, value, 0);
1969 break;
1970 case WMA_PARAMTYPE_CHANNELMASK:
1971 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELMASK, AU_DEC_ID1, value, 0);
1972 break;
1973 case WMA_PARAMTYPE_DRC_PARAM_EXIST:
1974 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PARAM_EXIST, AU_DEC_ID1, value, 0);
1975 break;
1976 case WMA_PARAMTYPE_DRC_RMS_AMP_REF:
1977 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_REF, AU_DEC_ID1, value, 0);
1978 break;
1979 case WMA_PARAMTYPE_DRC_RMS_AMP_TARGET:
1980 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_TARGET, AU_DEC_ID1, value, 0);
1981 break;
1982 case WMA_PARAMTYPE_DRC_PEAK_AMP_REF:
1983 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_REF, AU_DEC_ID1, value, 0);
1984 break;
1985 case WMA_PARAMTYPE_DRC_PEAK_AMP_TARGET:
1986 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_TARGET, AU_DEC_ID1, value, 0);
1987 break;
1988 case WMA_PARAMTYPE_MAX_PACKET_SIZE:
1989 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_MAX_PACKET_SIZE, AU_DEC_ID1, value, 0);
1990 break;
1991 default:
1992 break;
1993 }
1994 }
1995
1996
1997 ///-----------------------------------------------------------------------------
1998 ////////////////////////////////////////////////////////////////////////////////
1999 ////////////////////////////////////////////////////////////////////////////////
2000 ///
2001 /// AUDIO_MAD OTHER Relational Hal Function
2002 ///
2003 ////////////////////////////////////////////////////////////////////////////////
2004 ////////////////////////////////////////////////////////////////////////////////
2005 ///-----------------------------------------------------------------------------
2006 ////////////////////////////////////////////////////////////////////////////////
2007 /// @brief \b Function \b Name: HAL_MAD_RA8_setParam()
2008 /// @brief \b Function \b Description: This routine configures necessary parameters when playing RA8 LBR data
2009 /// @param <IN> \b mNumCodecs : 1--stereo or mono
2010 /// 2~5-- multi channels
2011 /// @param <IN> \b mSamples : output samples--256, 512, 1024
2012 /// @param <IN> \b mSampleRate : 8, 11.025, 16, 22.05, 44.1, 48 (KHz)
2013 /// @param <IN> \b Channels : 1-- mono
2014 /// 2-- stereo
2015 /// @param <IN> \b cplStart : 0 ~ 51
2016 /// @param <IN> \b Regions : 0 ~ 31
2017 /// @param <IN> \b cplQbits : 0, 2, 3, 4, 5, 6
2018 /// @param <IN> \b FrameSize : bitstream size of every NumCodes (bytes)
2019 /// Range--0 ~ 65535
2020 /// @param <OUT> \b NONE :
2021 /// @param <RET> \b MS_U8 : TRUE--parameters are correct
2022 /// FALSE--parameters are incorrect
2023 /// @param <GLOBAL> \b NONE :
2024 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_RA8_setParam(MS_U16 mNumCodecs,MS_U16 mSamples,MS_U16 mSampleRate,MS_U16 * Channels,MS_U16 * Regions,MS_U16 * cplStart,MS_U16 * cplQbits,MS_U16 * FrameSize)2025 MS_U8 HAL_MAD_RA8_setParam(MS_U16 mNumCodecs, MS_U16 mSamples, MS_U16 mSampleRate,
2026 MS_U16* Channels, MS_U16* Regions, MS_U16* cplStart, MS_U16* cplQbits,
2027 MS_U16* FrameSize)
2028 {
2029
2030 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_NUMCODECS, AU_DEC_ID1, mNumCodecs, 0 );
2031 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLES, AU_DEC_ID1, mSamples, 0 );
2032 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLERATES, AU_DEC_ID1, mSampleRate, 0 );
2033 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, Channels[0], 0 );
2034 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, Regions[0], 0 );
2035 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, cplStart[0], 0 );
2036 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, cplQbits[0], 0 );
2037 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, FrameSize[0], 0 );
2038
2039 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, Channels[1], 1 );
2040 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, Regions[1], 1 );
2041 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, cplStart[1], 1 );
2042 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, cplQbits[1], 1 );
2043 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, FrameSize[1], 1 );
2044
2045 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, Channels[2], 2 );
2046 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, Regions[2], 2 );
2047 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, cplStart[2], 2 );
2048 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, cplQbits[2], 2 );
2049 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, FrameSize[2], 2 );
2050
2051 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, Channels[3], 3 );
2052 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, Regions[3], 3 );
2053 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, cplStart[3], 3 );
2054 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, cplQbits[3], 3 );
2055 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, FrameSize[3], 3 );
2056
2057 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, Channels[4], 4 );
2058 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, Regions[4], 4 );
2059 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, cplStart[4], 4 );
2060 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, cplQbits[4], 4 );
2061 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, FrameSize[4], 4 );
2062
2063 return TRUE;
2064 }
2065
2066 ////////////////////////////////////////////////////////////////////////////////
2067 /// @brief \b Function \b Name: HAL_MAD_XPCM_GetParaBase()
2068 /// @brief \b Function \b Description: This routine is used to get the base address for XPCM parameter
2069 /// @param <IN> \b NONE :
2070 /// @param <OUT> \b NONE :
2071 /// @param <RET> \b MS_U16 : XPCM parameter base address in DSP
2072 /// @param <GLOBAL> \b NONE :
2073 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_XPCM_GetParaBase(void)2074 MS_U16 HAL_MAD_XPCM_GetParaBase(void)
2075 {
2076 //NOT_DEFINE : not used
2077 return 0;
2078 }
2079
2080 ////////////////////////////////////////////////////////////////////////////////
2081 /// @brief \b Function \b Name: HAL_MAD_RA8_GetParaBase()
2082 /// @brief \b Function \b Description: This routine is used to get the base address for Ra8 parameter
2083 /// @param <IN> \b NONE :
2084 /// @param <OUT> \b NONE :
2085 /// @param <RET> \b MS_U16 : Ra8 parameter base address in DSP
2086 /// @param <GLOBAL> \b NONE :
2087 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Ra8_GetParaBase(void)2088 MS_U16 HAL_MAD_Ra8_GetParaBase(void)
2089 {
2090 //NOT_DEFINE : not used
2091 return 0;
2092 }
2093
2094 ///////////////////////////////////////////////////////////////////////////////
2095 /// @brief \b Function \b Name: HAL_MAD_SetCommInfo()
2096 /// @brief \b Function \b Description: This routine set different paramter to audio decoder
2097 /// @param <IN> \b Audio_COMM_infoType : common audio parameter type
2098 /// @param <IN> \b MS_U32 : common audio parameter 1
2099 /// @param <IN> \b MS_U32 : common audio parameter 2
2100 /// @param <OUT> \b NONE :
2101 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
2102 /// @param <GLOBAL> \b NONE :
2103 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetCommInfo(Audio_COMM_infoType infoType,MS_VIRT param1,MS_VIRT param2)2104 MS_BOOL HAL_MAD_SetCommInfo( Audio_COMM_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
2105 {
2106 HALMAD_CHECK_SHM_INIT;
2107
2108 MS_BOOL retTx1, retTx2;
2109 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
2110 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
2111 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
2112
2113 switch(infoType)
2114 {
2115 /********************************************************************************
2116 * Other CMD
2117 ********************************************************************************/
2118 case Audio_Comm_infoType_Set_UNI_NEED_DECODE_FRMCNT:
2119 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_SETUP_DECODE_FRMCNT, AU_DEC_ID1, param1, 0);
2120 break;
2121
2122 case Audio_Comm_infoType_Set_UNI_ES_Wptr:
2123 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, param1, 0);
2124 break;
2125
2126 case Audio_Comm_infoType_setBypassSPDIF_PAPB_chk: //HAL_MAD_SetDtsBypassFlag
2127 break;
2128
2129 case Audio_Comm_infoType_MMA_init:
2130 HAL_AUDIO_SetEntertainmentMode(AUDIO_ETMODE_GAME);
2131 HAL_SOUND_SetMixModeVolume(E_AUDIO_INFO_GAME_IN, GAME1_VOL, 0x12, 0x00); //DEC1 Vol
2132 HAL_SOUND_SetMixModeVolume(E_AUDIO_INFO_GAME_IN, GAME2_VOL, 0x12, 0x00); //DEC2 Vol
2133 HAL_SOUND_SetMixModeVolume(E_AUDIO_INFO_GAME_IN, PCM_VOL, 0x12, 0x00); //DEC3 Vol
2134 break;
2135
2136 case Audio_Comm_infoType_MMA_finish:
2137 HAL_AUDIO_SetEntertainmentMode(AUDIO_ETMODE_DTV);
2138 break;
2139
2140 case Audio_Comm_infoType_DMAReader_Command:
2141 if (param1)
2142 {
2143 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
2144 AUDIO_DELAY1MS(2);
2145 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
2146 }
2147 else
2148 {
2149 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0000);
2150 AUDIO_DELAY1MS(2);
2151 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0000);
2152 AUDIO_DELAY1MS(2);
2153 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0040, 0x0040); //read_init, clear dma reader data & pointer
2154 AUDIO_DELAY1MS(1);
2155 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0040, 0x0000);
2156 }
2157 break;
2158
2159 case Audio_Comm_infoType_CompressBin_LoadCode:
2160 g_AudioVars2->CompressInfo = param1;
2161 break;
2162
2163 case Audio_Comm_infoType_CompressBin_DDRAddress:
2164 g_AudioVars2->g_DSPDDRBinBaseAddress[param1] = param2;
2165 g_DSPDDRBinBaseAddress[param1] = param2;
2166 break;
2167
2168 case Audio_Comm_infoType_SetSCMS:
2169 {
2170 retTx1= HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
2171 retTx2= HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
2172
2173 if (retTx1 == FALSE || retTx2 == FALSE)
2174 {
2175 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
2176 break;
2177 }
2178
2179 if(param1)
2180 {
2181 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
2182 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
2183 }
2184 else
2185 {
2186 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
2187 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
2188 }
2189
2190 if(param2)
2191 {
2192 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
2193 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
2194 }
2195 else
2196 {
2197 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
2198 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
2199 }
2200
2201 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
2202 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
2203 }
2204 break;
2205
2206 case Audio_Comm_infoType_ADC_InputGain:
2207 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, (AUD_ADC_GAIN_TYPE)param1<<5);
2208 break;
2209
2210 case Audio_Comm_infoType_ADC1_InputGain:
2211 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0x1C, (AUD_ADC_GAIN_TYPE)param1<<2);
2212 break;
2213
2214 case Audio_Comm_infoType_KTV_SetType:
2215 switch((AUDIO_KTV_MODEL)param1)
2216 {
2217 case AUD_KTV_MODEL1: // iSing99
2218 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x00); // No this model in T12
2219 break;
2220 case AUD_KTV_MODEL2: // Multak
2221 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x21);
2222 break;
2223 case AUD_KTV_MODEL3: // ¹p¥?
2224 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x02);
2225 break;
2226 case AUD_KTV_MODEL4: // Konka
2227 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x14);
2228 break;
2229 default:
2230 break;
2231 }
2232 break;
2233
2234 case Audio_Comm_infoType_syncSTC_in_mmTs:
2235 if ( param1 )
2236 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, AU_DEC_ID1, 1, 0);
2237 else
2238 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, AU_DEC_ID1, 0, 0);
2239 break;
2240
2241 case Audio_Comm_infoType_PUSI_disable_Info:
2242 if(param1)
2243 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, AU_DEC_ID1, 1, 0);
2244 else
2245 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, AU_DEC_ID1, 0, 0);
2246 break;
2247
2248 case Audio_Comm_infoType_Parser_Spec:
2249 if(param1)
2250 {
2251 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_SPEC, AU_DEC_ID1, 1, 0);
2252 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, AU_DEC_ID1, 1, 0);
2253 }
2254 else
2255 {
2256 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_SPEC, AU_DEC_ID1, 0, 0);
2257 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, AU_DEC_ID1, 0, 0);
2258 }
2259 break;
2260
2261 case Audio_Comm_infoType_setNR_Threshold:
2262 HAL_AUDIO_WriteByte(0x2D32, (MS_U8) param1);
2263 break;
2264
2265 case Audio_Comm_infoType_Set_CallBackFunc:
2266 if ( g_FuncPrt_Hal_SetAudioParam2 == NULL )
2267 {
2268 g_FuncPrt_Hal_SetAudioParam2 = HAL_MAD_SetAudioParam2;
2269 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: g_FuncPrt_Hal_SetAudioParam2 hook OK !!\r\n", __FUNCTION__);
2270 }
2271 else
2272 {
2273 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: g_FuncPrt_Hal_SetAudioParam2 already register !!\r\n", __FUNCTION__);
2274 }
2275 if ( g_FuncPrt_Hal_GetAudioInfo2 == NULL )
2276 {
2277 g_FuncPrt_Hal_GetAudioInfo2 = HAL_MAD_GetAudioInfo2;
2278 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: g_FuncPrt_Hal_GetAudioInfo2 hook OK !!\r\n", __FUNCTION__);
2279 }
2280 else
2281 {
2282 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: g_FuncPrt_Hal_GetAudioInfo2 already register !!\r\n", __FUNCTION__);
2283 }
2284 break;
2285
2286 case Audio_Comm_infoType_Set_DFS_PowerSave:
2287 {
2288 MS_BOOL mistake_case = FALSE;
2289 MS_U8 u8MainDspCodeType = g_AudioVars2->g_DspCodeType;
2290 if(param1)
2291 {
2292 if(((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20) == 0x20) ||
2293 ((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02) == 0x02))
2294 {
2295 if(param2<4)
2296 {
2297 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: When NonPCM case, audio fs can't set under level 4\n", __FUNCTION__ );
2298 mistake_case = TRUE;
2299 param2 = 4;
2300 }
2301 }
2302 else if(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD)!=0x0) //not_stop case
2303 {
2304 switch(u8MainDspCodeType)
2305 {
2306 case AU_DVB_STANDARD_AAC:
2307 case AU_DVB_STANDARD_MS10_DDT:
2308 case AU_DVB_STANDARD_DTS:
2309 case AU_DVB_STANDARD_DTSLBR:
2310 if(param2<3)
2311 {
2312 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: When playing AAC/DTS stream, audio fs can't set under level 3\n", __FUNCTION__ );
2313 mistake_case = TRUE;
2314 param2 = 3;
2315 }
2316 break;
2317
2318 default:
2319 if(param2<2)
2320 {
2321 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: When playing any stream except AAC/DTS, audio fs can't set under level 2\n", __FUNCTION__ );
2322 mistake_case = TRUE;
2323 param2 = 2;
2324 }
2325 break;
2326 }
2327 }
2328
2329 switch(param2)
2330 {
2331 case 1: //lowest speed
2332 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x0A); //DSP = 11/32 fs
2333 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2334 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x00); //R2 = 1/32 fs
2335 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2336 break;
2337 case 2:
2338 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x15); //DSP = 22/32 fs
2339 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2340 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x0A); //R2 = 11/32 fs
2341 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2342 break;
2343 case 3:
2344 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x1A); //DSP = 27/32 fs
2345 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2346 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x15); //R2 = 22/32 fs
2347 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2348 break;
2349 case 4: //full speed
2350 default:
2351 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x1F); //DSP = 1 fs
2352 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2353 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x1F); //R2 = 1 fs
2354 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2355 break;
2356 }
2357 }
2358 else //full speed
2359 {
2360 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x1F); //DSP = 1 fs
2361 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2362 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x1F); //R2 = 1 fs
2363 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2364 }
2365 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x00);
2366 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x00);
2367
2368 if(mistake_case == TRUE)
2369 return FALSE;
2370 }
2371 break;
2372
2373 case Audio_Comm_infoType_DAC_Clock_OnOff: //DAC off for power saving
2374 {
2375 HAL_AUDIO_DAC_Clock_OnOff(param1);
2376 }
2377 break;
2378
2379 /********************************************************************************
2380 * DECODER 1
2381 ********************************************************************************/
2382 case Audio_Comm_infoType_ADEC1_Set_play_smpRate:
2383 {
2384 MS_U16 play_cmd;
2385 MS_U32 synth_H;
2386
2387 play_cmd = HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD) & 0xF;
2388 if (play_cmd != 0x02)
2389 printf("[%s : Audio_Comm_infoType_ADEC1_Set_play_smpRate]: audio play cmd is not Ts file Play !!\n", __FUNCTION__);
2390
2391 if (param1)
2392 {
2393 if ((param2 > 50000) ||(param2<6000))
2394 #if defined (__aarch64__)
2395 printf("[%s : Audio_Comm_infoType_ADEC1_Set_play_smpRate]: play rate [%ld] is invalid !!\n", __FUNCTION__, param2);
2396 #else
2397 printf("[%s : Audio_Comm_infoType_ADEC1_Set_play_smpRate]: play rate [%d] is invalid !!\n", __FUNCTION__, param2);
2398 #endif
2399 synth_H = 216000000 / param2;
2400 synth_H <<= 16;
2401 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_EXT_SMPRATE_CTRL, AU_DEC_ID1, 1, synth_H);
2402 }
2403 else
2404 {
2405 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_EXT_SMPRATE_CTRL, AU_DEC_ID1, 0, 0x11940000);
2406 }
2407 }
2408 break;
2409
2410 case Audio_Comm_infoType_ADEC1_soundmod:
2411 {
2412 MS_U8 value = 0;
2413
2414 switch((AUD_Dolby_SOUNDMODE)param1)
2415 {
2416 case AUD_Dolby_SOUNDMODE_LR: value = 0x0; break;
2417 case AUD_Dolby_SOUNDMODE_LL: value = 0x1; break;
2418 case AUD_Dolby_SOUNDMODE_RR: value = 0x2; break;
2419 default: value = 0x0; break;
2420 }
2421
2422 //NOT_DEFINE : to do
2423 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SOUND_MODE, AU_DEC_ID1, value, 0);
2424 }
2425 break;
2426
2427 case Audio_Comm_infoType_SoundMode: //HAL_MAD_SetSoundMode
2428 HAL_AUDIO_SeWriteMaskByte(REG_MB_MODE_SELECT, 0x03, (AU_DVB_MODE) param1);
2429 break;
2430
2431 case Audio_Comm_infoType_ADEC1_reqDataSize:
2432 case Audio_Comm_infoType_MMFileSize: //HAL_MAD_SetMadFileSize
2433 {
2434 MS_U32 file_size_value = 0x800;
2435
2436 switch (param1)
2437 {
2438 case FILE_SIZE_1KB: file_size_value = 0x00400; break;
2439 case FILE_SIZE_2KB: file_size_value = 0x00800; break;
2440 case FILE_SIZE_4KB: file_size_value = 0x01000; break;
2441 case FILE_SIZE_8KB: file_size_value = 0x02000; break;
2442 case FILE_SIZE_16KB: file_size_value = 0x04000; break;
2443 case FILE_SIZE_32KB: file_size_value = 0x08000; break;
2444 case FILE_SIZE_64KB: file_size_value = 0x10000; break;
2445 default: break;
2446 }
2447 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, AU_DEC_ID1, file_size_value, 0);
2448 }
2449 break;
2450
2451 case Audio_Comm_infoType_ADEC1_esBuf_informDataRdy:
2452 case Audio_Comm_infoType_DEC1_MMTag: //HAL_MAD_SetMMIntTag
2453 {
2454 MS_U32 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0);
2455 MS_U32 es_bufSz = ES1_DRAM_SIZE;
2456 MS_U32 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID1);
2457 es_wrPtr += es_reqsz;
2458
2459 if ( es_wrPtr >= es_bufSz )
2460 es_wrPtr -= es_bufSz;
2461
2462 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, es_wrPtr, 0);
2463 }
2464 break;
2465
2466 case Audio_Comm_infoType_ADEC1_FF2X:
2467 case Audio_Comm_infoType_MM_FFx2: //HAL_MAD_SetMMFFx2Mode
2468 if ( param1 )
2469 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, AU_DEC_ID1, 1, 0);
2470 else
2471 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, AU_DEC_ID1, 0, 0);
2472 break;
2473
2474 case Audio_Comm_infoType_ADEC1_mute:
2475 if ( param1 )
2476 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, AU_DEC_ID1, 1, 0);
2477 else
2478 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, AU_DEC_ID1, 0, 0);
2479 break;
2480
2481 case Audio_Comm_infoType_ADEC1_play_wo_output:
2482 if (param1)
2483 HAL_AUDIO_DecWriteMaskByte(REG_MB_DEC_CTRL, 0x80, 0x80);
2484 else
2485 HAL_AUDIO_DecWriteMaskByte(REG_MB_DEC_CTRL, 0x80, 0x00);
2486 break;
2487
2488 case Audio_Comm_infoType_ADEC1_playControl:
2489 switch((MMA_AUDIO_CONTROL)param1)
2490 {
2491 case MMA_STOP:
2492 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
2493 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_AVSYNC);
2494 g_AudioVars2->g_bDecPlayFileFlag = FALSE;
2495 break;
2496
2497 case MMA_PLAY:
2498 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY);
2499 break;
2500
2501 case MMA_PLAY_FILETSP:
2502 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILETSP);
2503 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
2504 break;
2505
2506 case MMA_RESYNC:
2507 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_RESYNC);
2508 break;
2509
2510 case MMA_PLAY_FILE:
2511 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILE);
2512 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
2513 break;
2514
2515 case MMA_BROWSE:
2516 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STARTBROWSE);
2517 break;
2518
2519 case MMA_PAUSE:
2520 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PAUSE);
2521 break;
2522
2523 case MMA_PLAY_FRAME:
2524 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFRAME);
2525 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
2526 break;
2527
2528 default:
2529 break;
2530 }
2531 break;
2532
2533 case Audio_Comm_infoType_ADEC1_setDecParam:
2534 //NOT_DEFINE : remove
2535 break;
2536
2537 case Audio_Comm_infoType_ADEC1_UNI_PCMOutCnt:
2538 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_PCM_SET_OUTPUT_CNT, AU_DEC_ID1, param1, 0);
2539 break;
2540
2541 case Audio_Comm_infoType_ADEC1_UNI_PCMInput_Addr: //assume UNI get data from PCM1.
2542 HAL_AUDIO_WriteReg(REG_DEC1_UNI_PCM3_WPTR, (MS_U16)((param1>>BYTES_IN_MIU_LINE_LOG2) - OFFSET_PCM1_DRAM_ADDR));
2543 break;
2544
2545 case Audio_Comm_infoType_DEC1_setBufferProcess:
2546 // Need Decoder Add delay support in DEC1-DSP
2547 break;
2548
2549 case Audio_Comm_infoType_33Bit_PTS:
2550 case Audio_Comm_infoType_ADEC1_33bit_PTS:
2551 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_REPORT_MM_TS_PTS_WITH_MSB, AU_DEC_ID1, param1, 0);
2552 break;
2553
2554 /********************************************************************************
2555 * DECODER 2
2556 ********************************************************************************/
2557 case Audio_Comm_infoType_ADEC2_soundmod:
2558 case Audio_Comm_infoType_ADEC2_reqDataSize:
2559 case Audio_Comm_infoType_ADEC2_FF2X:
2560 case Audio_Comm_infoType_ADEC2_mute:
2561 break;
2562
2563 case Audio_Comm_infoType_ADEC2_esBuf_informDataRdy:
2564 case Audio_Comm_infoType_DEC2_MMTag: //HAL_MAD2_SetMMIntTag
2565 {
2566 MS_U32 es_wrPtr, es_bufSz, es_reqsz;
2567 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0);
2568 es_bufSz = ES2_DRAM_SIZE;
2569 es_reqsz = param2;
2570 es_wrPtr += es_reqsz;
2571
2572 if ( es_wrPtr >= es_bufSz )
2573 es_wrPtr -= es_bufSz;
2574 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, es_wrPtr, 0);
2575 }
2576 break;
2577
2578 case Audio_Comm_infoType_ADEC2_syncSTC_in_mmTs:
2579 if ( param1 )
2580 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, AU_DEC_ID3, 1, 0);
2581 else
2582 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, AU_DEC_ID3, 0, 0);
2583 break;
2584
2585 case Audio_Comm_infoType_ADEC2_playControl:
2586 {
2587 switch((MMA_AUDIO_CONTROL)param1)
2588 {
2589 case MMA_STOP:
2590 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP);
2591 g_AudioVars2->g_bSePlayFileFlag = FALSE;
2592 break;
2593
2594 case MMA_PLAY:
2595 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAY);
2596 break;
2597
2598 case MMA_PLAY_FILETSP:
2599 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAYFILETSP);
2600 break;
2601
2602 case MMA_RESYNC:
2603 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_RESYNC);
2604 break;
2605
2606 case MMA_PLAY_FILE:
2607 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAYFILE);
2608 break;
2609
2610 case MMA_BROWSE:
2611 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STARTBROWSE);
2612 break;
2613
2614 case MMA_PAUSE:
2615 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PAUSE);
2616 break;
2617
2618 case MMA_PLAY_FRAME:
2619 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAYFRAME);
2620 break;
2621
2622 default:
2623 break;
2624 }
2625 }
2626 break;
2627
2628 case Audio_Comm_infoType_ADEC2_setDecParam:
2629 //NOT_DEFINE : remove
2630 break;
2631
2632 /********************************************************************************
2633 * OTHERS
2634 ********************************************************************************/
2635 case Audio_Comm_infoType_setSpdifDelay: // set spdif dealy time
2636 case Audio_Comm_infoType_setSpdif_BufferProcess:
2637 HAL_SOUND_SetSpdifAudioDelay((MS_U16)param1);
2638 break;
2639
2640 case Audio_Comm_infoType_setHdmiDelay: // set hdmi dealy time for CDI project
2641 HAL_SOUND_SetHdmiAudioDelay((MS_U16)param1);
2642 break;
2643
2644 case Audio_Comm_infoType_ReadByte: // For APP to read register value directly.
2645 g_ReadTargetAddr=param1;
2646 break;
2647
2648 case Audio_Comm_infoType_WriteByte: // For APP to write register value directly.
2649 HAL_AUDIO_AbsWriteMaskByte(param1,0xFF,(MS_U8)(param2&0xFF));
2650 break;
2651
2652 case Audio_Comm_infoType_PTS_info:
2653 HAL_AUDIO_PTS_info(param1);
2654 break;
2655
2656 case Audio_Comm_infoType_RTSP_Mem:
2657 {
2658 AUDIO_RTSP_INFO *ptmp = (AUDIO_RTSP_INFO *)param1;
2659 ptmp->Mem_addr = RTSP_MEM_ADDR;
2660 ptmp->Mem_size= RTSP_MEM_SIZE;
2661 }
2662 break;
2663
2664 case Audio_Comm_infoType_Dump_Dsp_Info:
2665 {
2666 g_AudioDumpInfoCtrl = param1;
2667
2668 if (param2 > 50 )
2669 g_audioDumpInfo_interval = param2;
2670 }
2671 break;
2672
2673 case Audio_Comm_infoType_Set_Video_STCPTS_DIFF:
2674 break;
2675
2676 case Audio_Comm_infoType_HDMI_Unstable_Protect:
2677 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_protect, param1);
2678 break;
2679
2680 case Audio_Comm_infoType_Vorbis_header_size:
2681 if ( param1 )
2682 {
2683 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_VORBIS_HEADER_SIZE, AU_DEC_ID1, param2, 0);
2684 }
2685 else
2686 {
2687 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_VORBIS_HEADER_SIZE, AU_DEC_ID1, param2, 0);
2688 }
2689 break;
2690
2691 case Audio_Comm_infoType_HDMI_Unstable_Threshold:
2692 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_threshold, param1);
2693 break;
2694
2695 case Audio_Comm_infoType_Set_Parser:
2696
2697 switch(param1)
2698 {
2699 case 0 : // MainWindow ADEC1 : AFIFO_A->ES1 ; AFIFO_B->ES2
2700 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0030, 0x0000); // AFIFO_A-> ES1
2701 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0180, 0x0000); // AFIFO_B-> ES2
2702 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0C00, 0x0000); // AFIFO_C-> ES3(Dummy)
2703 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x6000, 0x0000); // AFIFO_D-> ES4(Dummy)
2704 break;
2705
2706 case 1 : // MainWindow ADEC2 : AFIFO_A->ES3 ; AFIFO_B->ES4
2707 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0030, 0x0020); // AFIFO_C-> ES1 (Dummy)
2708 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0180, 0x0100); // AFIFO_D-> ES2 (Dummy)
2709 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0C00, 0x0800); // AFIFO_A-> ES3
2710 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x6000, 0x4000); // AFIFO_B-> ES4
2711 break;
2712
2713 case 2 : // SubWindow ADEC1 : AFIFO_B->ES1 ;
2714 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0030, 0x0010); // AFIFO_B-> ES1
2715 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0180, 0x0080); // AFIFO_C-> ES2(Dummy)
2716 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0C00, 0x0800); // AFIFO_A-> ES3
2717 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x6000, 0x0000); // AFIFO_D-> ES4(Dummy)
2718 break;
2719
2720 case 3 : // SubWindow ADEC2 : AFIFO_B->ES3 ;
2721 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0030, 0x0000); // AFIFO_A-> ES1
2722 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0180, 0x0080); // AFIFO_C-> ES2(Dummy)
2723 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x0C00, 0x0C00); // AFIFO_B-> ES3
2724 HAL_AUDIO_WriteMaskReg(REG_AUDIO_PARSER_CTRL, 0x6000, 0x0000); // AFIFO_D-> ES4(Dummy)
2725 break;
2726
2727 default :
2728 break;
2729 }
2730 break;
2731
2732 case Audio_Comm_infoType_STC_Select:
2733 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECTION, AU_DEC_ID1, param1, 0);
2734 break;
2735
2736 case Audio_Comm_infoType_mainAudio_setBufferProcess:
2737 HAL_SOUND_SetCH1AudioDelay(param1);
2738 break;
2739
2740 #ifndef MSOS_TYPE_NUTTX
2741 case Audio_Comm_infoType_Set_TEE_Capibility:
2742 HALAUDIO_CHECK_TEE_INFO_SHM_INIT;
2743 switch ((Audio_TEE_Capability)param1)
2744 {
2745 case Audio_TEE_Setup:
2746 g_bAudioTeeEnabled = TRUE; audio_tee_enabled = TRUE;
2747 if (audio_tee_mbx_initialized == FALSE)
2748 {
2749 if (HAL_AUDIO_RegisterMBX() == TRUE)
2750 {
2751 g_bAudioTeeMbxInitialized = TRUE; audio_tee_mbx_initialized = TRUE;
2752 }
2753 }
2754 break;
2755
2756 case Audio_TEE_Setup_and_ALL_DSP_Secure_Accessed:
2757 g_bAudioTeeEnabled = TRUE; audio_tee_enabled = TRUE;
2758 if (audio_tee_mbx_initialized == FALSE)
2759 {
2760 if (HAL_AUDIO_RegisterMBX() == TRUE)
2761 {
2762 g_bAudioTeeMbxInitialized = TRUE; audio_tee_mbx_initialized = TRUE;
2763 g_bDecDspSecureTeeAccessed = TRUE; dec_dsp_secure_tee_accessed = TRUE;
2764 g_bSndDspSecureTeeAccessed = TRUE; snd_dsp_secure_tee_accessed = TRUE;
2765 }
2766 }
2767 break;
2768
2769 case Audio_TEE_Set_DSP_Secure_Accessed:
2770 if ((audio_tee_enabled == TRUE) && (audio_tee_mbx_initialized == TRUE))
2771 {
2772 if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_DEC)
2773 {
2774 g_bDecDspSecureTeeAccessed = TRUE; dec_dsp_secure_tee_accessed = TRUE;
2775 }
2776 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_SND)
2777 {
2778 g_bSndDspSecureTeeAccessed = TRUE; snd_dsp_secure_tee_accessed = TRUE;
2779 }
2780 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_ALL)
2781 {
2782 g_bDecDspSecureTeeAccessed = TRUE; dec_dsp_secure_tee_accessed = TRUE;
2783 g_bSndDspSecureTeeAccessed = TRUE; snd_dsp_secure_tee_accessed = TRUE;
2784 }
2785 }
2786 break;
2787
2788 case Audio_TEE_Set_DSP_Normal_Accessed:
2789 if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_DEC)
2790 {
2791 g_bDecDspSecureTeeAccessed = FALSE; dec_dsp_secure_tee_accessed = FALSE;
2792 }
2793 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_SND)
2794 {
2795 g_bSndDspSecureTeeAccessed = FALSE; snd_dsp_secure_tee_accessed = FALSE;
2796 }
2797 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_ALL)
2798 {
2799 g_bDecDspSecureTeeAccessed = FALSE; dec_dsp_secure_tee_accessed = FALSE;
2800 g_bSndDspSecureTeeAccessed = FALSE; snd_dsp_secure_tee_accessed = FALSE;
2801 }
2802 break;
2803
2804 default:
2805 break;
2806 }
2807 break;
2808 #endif
2809
2810
2811 case Audio_Comm_infoType_Multi_Channel:
2812 {
2813 if ((param1 == TRUE) || (param1 == FALSE))
2814 {
2815 printf("!!!!!!!!!set Audio_Comm_infoType_Multi_Channel = [0x%x] \n", (unsigned int)param1);
2816 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MULTI_CHANNEL, AU_DEC_ID1, param1, 0);
2817 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MULTI_CHANNEL, AU_DEC_ID3, param1, 0);
2818 }
2819 else
2820 {
2821 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid value(0x%x) to enable/disable Multi-Channel\n", __FUNCTION__, (unsigned int)param1);
2822 }
2823
2824 break;
2825 }
2826
2827 case Audio_Comm_infoType_ES_PassThrough_DelaySmp:
2828 {
2829 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_PassThrough_DelaySmp, AU_DEC_ID1, param1, 0);
2830 break;
2831 }
2832
2833 case Audio_Comm_infoType_ES_PassThrough_PcmSmpRate:
2834 {
2835 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_PassThrough_PcmSamRate, AU_DEC_ID1, param1, 0);
2836 break;
2837 }
2838
2839 case Audio_Comm_infoType_ES_PassThrough_HdmiSmpRate:
2840 {
2841 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_PassThrough_HdmiSmpRate, AU_DEC_ID1, param1, 0);
2842 break;
2843 }
2844
2845 case Audio_Comm_infoType_HDMITx_Status:
2846 {
2847 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AUR2_HDMITx_TypeChanged, AU_DEC_ID1, param1, param2);
2848 break;
2849 }
2850
2851 /* not supported cmd */
2852 default:
2853 #if defined (__aarch64__)
2854 printf("%s: infoType[0x%x,0x%lx,0x%lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
2855 #else
2856 printf("%s: infoType[0x%x,0x%x,0x%x] not Supported\n",__FUNCTION__, infoType, param1, param2);
2857 #endif
2858 break;
2859 }
2860
2861 return TRUE;
2862 }
2863
2864 ////////////////////////////////////////////////////////////////////////////////
2865 /// @brief \b Function \b Name: HAL_MAD_GetCommInfo()
2866 /// @brief \b Function \b Description: This routine info of audio decoders
2867 /// @param <IN> \b Audio_COMM_infoType : request info type of audio decoder
2868 /// @param <OUT> \b NONE :
2869 /// @param <RET> \b long long : info type
2870 /// @param <GLOBAL> \b NONE :
2871 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetCommInfo(Audio_COMM_infoType infoType)2872 MS_U64 HAL_MAD_GetCommInfo( Audio_COMM_infoType infoType )
2873 {
2874 MS_U64 result = 0;
2875
2876 HALMAD_CHECK_SHM_INIT;
2877
2878 switch(infoType)
2879 {
2880 /********************************************************************************
2881 * Common
2882 ********************************************************************************/
2883 case Audio_Comm_infoType_getHDMI_CopyRight_C_Bit:
2884 result = _AU_AbsReadByte(0x1027B4) & 0x20;
2885 break;
2886
2887 case Audio_Comm_infoType_getHDMI_CopyRight_L_Bit:
2888 result = _AU_AbsReadByte(0x1027B5) & 0x01;
2889 break;
2890
2891 case Audio_Comm_infoType_Get_UNI_ES_MEMCNT:
2892 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, AU_DEC_ID1);
2893 break;
2894
2895 case Audio_Comm_infoType_Get_UNI_ES_Base:
2896 result = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES1_DRAM_ADDR;
2897 break;
2898
2899 case Audio_Comm_infoType_Get_UNI_ES_Size:
2900 result = ES1_DRAM_SIZE ;
2901 break;
2902
2903 case Audio_Comm_infoType_Get_UNI_PCM_Base:
2904 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_ADDR, AU_DEC_ID1);
2905 break;
2906
2907 case Audio_Comm_infoType_Get_UNI_PCM_Size:
2908 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_SIZE, AU_DEC_ID1);
2909 break;
2910
2911 case Audio_Comm_infoType_Get_AccumEsCnt:
2912 // result = HAL_MAD_Read_DSP_sram(REG_PTS_AccumEsCnt, DSP_MEM_TYPE_DM);
2913 result = 0;
2914 break;
2915
2916 case Audio_Comm_infoType_Is_Decoder_In_R2:
2917 result = 1;
2918 break;
2919
2920 case Audio_Comm_infoType_Is_Audio_Sync:
2921 {
2922 long long tmp = 0;
2923 MS_U32 i, no_sync_cnt = 0;
2924
2925 tmp = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_1ms_timeStamp);
2926 if (tmp == 0)
2927 {
2928 result = 0;
2929 break;
2930 }
2931
2932 tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, AU_DEC_ID1)&0x0F;
2933 if (tmp != 2)
2934 {
2935 result = 0;
2936 break;
2937 }
2938
2939 for (i = 0;i<3;i++)
2940 {
2941 tmp = HAL_MAD_GetCommInfo (Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
2942 if ((tmp >= (100*90))||(tmp <= (-100*90))) //100ms
2943 {
2944 no_sync_cnt ++;
2945 }
2946 }
2947
2948 if (no_sync_cnt == 0)
2949 {
2950 result = 1;
2951 }
2952 }
2953 break;
2954 case Audio_Comm_infoType_Parser_Info:
2955 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PARSER_INFO, AU_DEC_ID1);
2956 break;
2957 /********************************************************************************
2958 * hdmiTx
2959 ********************************************************************************/
2960 case Audio_Comm_infoType_hdmiTx_outType:
2961 {
2962 MS_U32 r2_hdmiTx_HBR = 0xFFFF;
2963
2964 if(HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20)
2965 {
2966 if(HAL_AUR2_ReadByte(REG_R2_HDMI_NONPCM_PATH) == ADEC1)
2967 {
2968 r2_hdmiTx_HBR = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMIbuf_HBR, AU_DEC_ID1);
2969 }
2970 else
2971 {
2972 r2_hdmiTx_HBR = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMIbuf_HBR, AU_DEC_ID3);
2973 }
2974
2975 if(r2_hdmiTx_HBR == 1)
2976 result = HDMI_OUT_8CH_NONPCM;
2977 else
2978 result = HDMI_OUT_NONPCM;
2979 }
2980 else
2981 result = HDMI_OUT_PCM;
2982 }
2983 break;
2984
2985 case Audio_Comm_infoType_hdmiTx_outFreq:
2986 {
2987 if(HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20)
2988 {
2989 MS_U32 r2_hdmiTx_smpRate = 0xFFFF;
2990
2991 if(HAL_AUR2_ReadByte(REG_R2_HDMI_NONPCM_PATH) == ADEC1)
2992 {
2993 r2_hdmiTx_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, AU_DEC_ID1);
2994 }
2995 else
2996 {
2997 r2_hdmiTx_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, AU_DEC_ID3);
2998 }
2999
3000 result = AUDIO_FS_NONE;
3001
3002 switch(r2_hdmiTx_smpRate)
3003 {
3004 case 32000: result = AUDIO_FS_32KHZ; break;
3005 case 44100: result = AUDIO_FS_44KHZ; break;
3006 case 48000: result = AUDIO_FS_48KHZ; break;
3007 case 64000: result = AUDIO_FS_64KHZ; break;
3008 case 88200: result = AUDIO_FS_88KHZ; break;
3009 case 96000: result = AUDIO_FS_96KHZ; break;
3010 case 176400: result = AUDIO_FS_176KHZ; break;
3011 case 192000: result = AUDIO_FS_192KHZ; break;
3012 default: result = AUDIO_FS_48KHZ; break;
3013 }
3014 }
3015 else
3016 {
3017 result = AUDIO_FS_48KHZ;
3018 }
3019 }
3020 break;
3021
3022 /********************************************************************************
3023 * DECODER 1
3024 ********************************************************************************/
3025 case Audio_Comm_infoType_ADEC1_capability:
3026 {
3027 MMA_AudioType audioType = Audio_DEC_NULL;
3028 audioType = _GetAudioCaps(AU_DEC_ID1);
3029 result = (long long)audioType;
3030 }
3031 break;
3032
3033 case Audio_Comm_infoType_ADEC1_currAudDecStatus:
3034 case Audio_Comm_infoType_DecStatus: //no change
3035 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1);
3036 break;
3037
3038 case Audio_Comm_infoType_ADEC1_AudioSyncStatus:
3039 if(HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD)&0x80)
3040 result = 0; // Free-run
3041 else
3042 result = 1; // AV-sync
3043 break;
3044
3045 case Audio_Comm_infoType_ADEC1_sampleRate:
3046 case Audio_Comm_infoType_SampleRate: //HAL_MAD_GetMadSamplingRate
3047 {
3048 MS_U32 r2_smpRate = 0xFFFF;
3049 r2_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1);
3050 result = AUDIO_FS_NONE;
3051
3052 switch(r2_smpRate)
3053 {
3054 case 8000: result = AUDIO_FS_8KHZ; break;
3055 case 11025: result = AUDIO_FS_11KHZ; break;
3056 case 12000: result = AUDIO_FS_12KHZ; break;
3057 case 16000: result = AUDIO_FS_16KHZ; break;
3058 case 22050: result = AUDIO_FS_22KHZ; break;
3059 case 24000: result = AUDIO_FS_24KHZ; break;
3060 case 32000: result = AUDIO_FS_32KHZ; break;
3061 case 44100: result = AUDIO_FS_44KHZ; break;
3062 case 48000: result = AUDIO_FS_48KHZ; break;
3063 case 65535: result = AUDIO_FS_NONE; break;
3064 case 64000: //result = AUDIO_FS_64KHZ; break;
3065 case 88200: //result = AUDIO_FS_88KHZ; break;
3066 case 96000: result = AUDIO_FS_96KHZ; break;
3067 case 176000: //result = AUDIO_FS_176KHZ; break;
3068 case 192000: //result = AUDIO_FS_192KHZ; break;
3069 default: result = AUDIO_FS_NONE; break;
3070 }
3071 }
3072 break;
3073
3074 case Audio_Comm_infoType_ADEC1_bitRate:
3075 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, AU_DEC_ID1);
3076 break;
3077
3078 case Audio_Comm_infoType_ADEC1_acmod:
3079 case Audio_Comm_infoType_ChannelMode: //HAL_MAD_GetMadChannelMode
3080 {
3081 MS_U32 ac_mode = 0xFF;
3082 MS_U32 channel_mapping = 0x0;
3083 ac_mode = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, AU_DEC_ID1);
3084 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, AU_DEC_ID1);
3085
3086 switch(ac_mode)
3087 {
3088 case adec_ch_mono:
3089 result = AUD_CH_MODE_MONO;
3090 break;
3091
3092 case adec_ch_joint_stereo:
3093 result = AUD_CH_MODE_JOINT_STEREO;
3094 break;
3095
3096 case adec_ch_stereo:
3097 result = AUD_CH_MODE_STEREO;
3098 break;
3099
3100 case adec_ch_dual_mono:
3101 result = AUD_CH_MODE_DUAL_MONO;
3102 break;
3103
3104 case adec_ch_multi:
3105 {
3106 MS_U32 channel_mapping_mask_C_L_R, channel_mapping_mask_Ls_Rs =0x00;
3107 channel_mapping_mask_Ls_Rs = (channel_mapping&(ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS));
3108 channel_mapping_mask_C_L_R = (channel_mapping&(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R));
3109
3110 if(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3111 {
3112 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3113 result = AUD_CH_MODE_3_2_MODE;
3114 else if(channel_mapping_mask_Ls_Rs == ACMOD_CH_MASK_NULL)
3115 result = AUD_CH_MODE_3_0_MODE;
3116 else
3117 result = AUD_CH_MODE_3_1_MODE;
3118 }
3119 else if((channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L))||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3120 ||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_R)))
3121 {
3122 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3123 result = AUD_CH_MODE_2_2_MODE;
3124 else
3125 result = AUD_CH_MODE_2_1_MODE;
3126 }
3127 else //other multi-channel case, set it to AUD_CH_MODE_3_2_MODE
3128 {
3129 result = AUD_CH_MODE_3_2_MODE;
3130 }
3131 }
3132 break;
3133
3134 default:
3135 result = AUD_CH_MODE_NONE;
3136 break;
3137 }
3138 }
3139 break;
3140
3141 case Audio_Comm_infoType_ADEC1_soundmod:
3142 case Audio_Comm_infoType_SoundMode:
3143 result = HAL_AUDIO_ReadReg(REG_MB_MODE_SELECT)&0x3;
3144 break;
3145
3146 case Audio_Comm_infoType_ADEC1_okFrmCnt:
3147 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, AU_DEC_ID1);
3148 break;
3149
3150 case Audio_Comm_infoType_ADEC1_errFrmCnt:
3151 case Audio_Comm_infoType_DecodeErrorCnt: //HAL_MAD_Get_DecodeErrorCnt
3152 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, AU_DEC_ID1);
3153 break;
3154
3155 case Audio_Comm_infoType_ADEC1_1ms_timeStamp:
3156 case Audio_Comm_infoType_1ms_PTS: //no change
3157 {
3158 MS_U32 pts;
3159 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, AU_DEC_ID1);
3160 result = pts/45;
3161 }
3162 break;
3163
3164 case Audio_Comm_infoType_ADEC1_33bit_PTS:
3165 case Audio_Comm_infoType_33Bit_PTS: //HAL_MAD_GetMadPts
3166 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, AU_DEC_ID1);
3167 result <<= 1;
3168 break;
3169
3170 case Audio_Comm_infoType_ADEC1_getlatest_PTS:
3171 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, AU_DEC_ID1);
3172 result <<= 1;
3173 break;
3174
3175 case Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF:
3176 case Audio_Comm_infoType_33Bit_STCPTS_DIFF: //HAL_MAD_GetMadPtsStcDelta
3177 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TD, AU_DEC_ID1);
3178
3179 //sign ext
3180 result <<= 32;
3181 result >>= 31;
3182 break;
3183
3184 case Audio_Comm_infoType_ADEC1_Get_PTS_latency:
3185 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_LATENCY, AU_DEC_ID1);
3186
3187 //sign ext
3188 result <<= 32;
3189 result >>= 31;
3190 break;
3191
3192 case Audio_Comm_infoType_ADEC1_Get_PCM_bufferEmpty:
3193 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_EMPTY_CNT, AU_DEC_ID1);
3194 break;
3195
3196 case Audio_Comm_infoType_ADEC1_esBuf_reqFlag:
3197 {
3198 if (HAL_AUDIO_GetPlayFileFlag(DSP_DEC))
3199 result = 1;
3200 else
3201 result = 0;
3202 }
3203 break;
3204
3205 case Audio_Comm_infoType_DEC1_BufferAddr: //HAL_MAD_GetBufferAddr
3206 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0) + OFFSET_ES1_DRAM_ADDR;
3207 break;
3208
3209 case Audio_Comm_infoType_ADEC1_esBuf_reqAddr:
3210 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0) + OFFSET_ES1_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
3211 break;
3212
3213 case Audio_Comm_infoType_ADEC1_esBuf_reqSize:
3214 case Audio_Comm_infoType_DEC1_BufferSize: //HAL_MAD_GetBufferSize
3215 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID1);
3216 break;
3217
3218 case Audio_Comm_infoType_ADEC1_esBuf_currLevel:
3219 case Audio_Comm_infoType_DEC1_ESBufferSize: //HAL_MAD_GetESBufferSize
3220 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, AU_DEC_ID1);
3221 break;
3222
3223 case Audio_Comm_infoType_ADEC1_pcmBuf_currLevel:
3224 case Audio_Comm_infoType_DEC1_MMResidualPCM: //HAL_MAD_GetMMResidualPCM
3225 case Audio_Comm_infoType_DEC1_PCMBufferSize: //HAL_MAD_GetPCMBufferSize
3226 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, AU_DEC_ID1);
3227 break;
3228
3229 case Audio_Comm_infoType_ADEC1_UNI_pcm_wptr:
3230 result = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_WR_PTR, AU_DEC_ID1);
3231 break;
3232
3233 case Audio_Comm_infoType_ADEC1_UNI_pcm_decSize:
3234 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_SIZE, AU_DEC_ID1);
3235 break;
3236
3237 case Audio_Comm_infoType_ADEC1_UNI_OutPCMLevel:
3238 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, AU_DEC_ID1);
3239 break;
3240
3241 case Audio_Comm_infoType_ADEC1_getDecInfo1:
3242 case Audio_Comm_infoType_ADEC1_getDecInfo2:
3243 case Audio_Comm_infoType_ADEC1_getDecInfo3:
3244 case Audio_Comm_infoType_ADEC1_getDecInfo4:
3245 case Audio_Comm_infoType_ADEC1_getDecInfo5:
3246 case Audio_Comm_infoType_ADEC1_getDecInfo6:
3247 case Audio_Comm_infoType_ADEC1_getDecInfo7:
3248 case Audio_Comm_infoType_ADEC1_getDecInfo8:
3249 {
3250 // not used, remove
3251 }
3252 break;
3253
3254 case Audio_Comm_infoType_DMAReader_BufferLevel:
3255 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
3256 result = ((MS_U32)HAL_AUDIO_ReadReg(0x2B8C)<<3); // 0x2B8C is line size
3257 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
3258 break;
3259
3260 case Audio_Comm_infoType_DMAReader_BufferSize:
3261 result = (DSP2_DMA_READER_DRAM_SIZE+1)*BYTES_IN_MIU_LINE;
3262 break;
3263
3264 case Audio_Comm_infoType_syncSTC_in_mmTs:
3265 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_MMTsSyncFlag, AU_DEC_ID1);
3266 break;
3267
3268 case Audio_Comm_infoType_ADEC1_getDecChannelInfo:
3269 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, AU_DEC_ID1);
3270 break;
3271
3272 case Audio_Comm_infoType_ADEC1_audio_unsupported:
3273 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNSUPPORT_TYPE, AU_DEC_ID1);
3274 break;
3275
3276 /*******************************************************************************
3277 * DECODER 2
3278 *******************************************************************************/
3279 case Audio_Comm_infoType_ADEC2_capability:
3280 result = Audio_DEC_MP3;
3281 break;
3282
3283 case Audio_Comm_infoType_ADEC2_currAudDecStatus:
3284 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID3);
3285 break;
3286
3287 case Audio_Comm_infoType_ADEC2_sampleRate:
3288 {
3289 MS_U32 r2_smpRate = 0xFFFF;
3290 r2_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID3);
3291 result = AUDIO_FS_NONE;
3292
3293 switch(r2_smpRate)
3294 {
3295 case 8000: result = AUDIO_FS_8KHZ; break;
3296 case 11025: result = AUDIO_FS_11KHZ; break;
3297 case 12000: result = AUDIO_FS_12KHZ; break;
3298 case 16000: result = AUDIO_FS_16KHZ; break;
3299 case 22050: result = AUDIO_FS_22KHZ; break;
3300 case 24000: result = AUDIO_FS_24KHZ; break;
3301 case 32000: result = AUDIO_FS_32KHZ; break;
3302 case 44100: result = AUDIO_FS_44KHZ; break;
3303 case 48000: result = AUDIO_FS_48KHZ; break;
3304 case 65535: result = AUDIO_FS_NONE; break;
3305 case 64000: //result = AUDIO_FS_64KHZ; break;
3306 case 88200: //result = AUDIO_FS_88KHZ; break;
3307 case 96000: //result = AUDIO_FS_96KHZ; break;
3308 case 176000: //result = AUDIO_FS_176KHZ; break;
3309 case 192000: //result = AUDIO_FS_192KHZ; break;
3310 default: result = AUDIO_FS_NONE; break;
3311 }
3312 }
3313 break;
3314
3315 case Audio_Comm_infoType_ADEC2_bitRate:
3316 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, AU_DEC_ID3);
3317 break;
3318
3319 case Audio_Comm_infoType_ADEC2_acmod:
3320 {
3321 MS_U32 ac_mode = 0xFF;
3322 MS_U32 channel_mapping = 0x0;
3323 ac_mode = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, AU_DEC_ID3);
3324 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, AU_DEC_ID3);
3325
3326 switch(ac_mode)
3327 {
3328 case adec_ch_mono:
3329 result = AUD_CH_MODE_MONO;
3330 break;
3331
3332 case adec_ch_joint_stereo:
3333 result = AUD_CH_MODE_JOINT_STEREO;
3334 break;
3335
3336 case adec_ch_stereo:
3337 result = AUD_CH_MODE_STEREO;
3338 break;
3339
3340 case adec_ch_dual_mono:
3341 result = AUD_CH_MODE_DUAL_MONO;
3342 break;
3343
3344 case adec_ch_multi:
3345 {
3346 MS_U32 channel_mapping_mask_C_L_R, channel_mapping_mask_Ls_Rs =0x00;
3347 channel_mapping_mask_Ls_Rs = (channel_mapping&(ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS));
3348 channel_mapping_mask_C_L_R = (channel_mapping&(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R));
3349
3350 if(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3351 {
3352 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3353 result = AUD_CH_MODE_3_2_MODE;
3354 else if(channel_mapping_mask_Ls_Rs == ACMOD_CH_MASK_NULL)
3355 result = AUD_CH_MODE_3_0_MODE;
3356 else
3357 result = AUD_CH_MODE_3_1_MODE;
3358 }
3359 else if((channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L))||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3360 ||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_R)))
3361 {
3362 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3363 result = AUD_CH_MODE_2_2_MODE;
3364 else
3365 result = AUD_CH_MODE_2_1_MODE;
3366 }
3367 else //other multi-channel case, set it to AUD_CH_MODE_3_2_MODE
3368 {
3369 result = AUD_CH_MODE_3_2_MODE;
3370 }
3371 }
3372 break;
3373
3374 default:
3375 result = AUD_CH_MODE_NONE;
3376 break;
3377 }
3378 }
3379 break;
3380
3381 case Audio_Comm_infoType_ADEC2_soundmod:
3382 case Audio_Comm_infoType_ADEC2_okFrmCnt:
3383 case Audio_Comm_infoType_ADEC2_errFrmCnt:
3384 break;
3385
3386 case Audio_Comm_infoType_ADEC2_1ms_timeStamp:
3387 {
3388 MS_U32 pts;
3389 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, AU_DEC_ID3);
3390 result = pts/45;
3391 }
3392 break;
3393
3394 case Audio_Comm_infoType_ADEC2_33bit_PTS:
3395 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, AU_DEC_ID3);
3396 result <<= 1;
3397 break;
3398
3399 case Audio_Comm_infoType_ADEC2_33bit_STCPTS_DIFF:
3400 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TD, AU_DEC_ID3);
3401 //sign ext
3402 result <<= 32;
3403 result >>= 31;
3404 break;
3405
3406 case Audio_Comm_infoType_ADEC2_esBuf_reqFlag:
3407 {
3408 if (HAL_AUDIO_GetPlayFileFlag(DSP_SE))
3409 result = 1;
3410 else
3411 result = 0;
3412 }
3413 break;
3414
3415 case Audio_Comm_infoType_DEC2_BufferAddr: //HAL_MAD2_GetBufferAddr
3416 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0) + OFFSET_ES2_DRAM_ADDR;
3417 break;
3418
3419 case Audio_Comm_infoType_ADEC2_esBuf_reqAddr:
3420 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0) + OFFSET_ES2_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
3421 break;
3422
3423 case Audio_Comm_infoType_ADEC2_esBuf_reqSize:
3424 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID3);
3425 break;
3426
3427 case Audio_Comm_infoType_DEC2_BufferSize: //HAL_MAD2_GetBufferSize
3428 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID3);
3429 break;
3430
3431 case Audio_Comm_infoType_ADEC2_esBuf_currLevel:
3432 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, AU_DEC_ID3);
3433 break;
3434
3435 case Audio_Comm_infoType_ADEC2_pcmBuf_currLevel:
3436 case Audio_Comm_infoType_DEC2_MMResidualPCM: //HAL_MAD2_GetMMResidualPCM
3437 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, AU_DEC_ID3);
3438 break;
3439
3440 case Audio_Comm_infoType_ADEC2_syncSTC_in_mmTs:
3441 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_MMTsSyncFlag, AU_DEC_ID3);
3442 break;
3443
3444 case Audio_Comm_infoType_ADEC2_getDecInfo1:
3445 case Audio_Comm_infoType_ADEC2_getDecInfo2:
3446 case Audio_Comm_infoType_ADEC2_getDecInfo3:
3447 case Audio_Comm_infoType_ADEC2_getDecInfo4:
3448 case Audio_Comm_infoType_ADEC2_getDecInfo5:
3449 case Audio_Comm_infoType_ADEC2_getDecInfo6:
3450 case Audio_Comm_infoType_ADEC2_getDecInfo7:
3451 case Audio_Comm_infoType_ADEC2_getDecInfo8:
3452 //{
3453 // MS_U8 param_offset = infoType - Audio_Comm_infoType_ADEC2_getDecInfo1;
3454 // result = HAL_MAD2_Read_DSP_sram(REG_DEC2_INFO_BASE+param_offset, DSP_MEM_TYPE_DM);
3455 //}
3456 break;
3457
3458 case Audio_Comm_infoType_ADEC2_getDecChannelInfo:
3459 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, AU_DEC_ID3);
3460 break;
3461
3462 /********************************************************************************
3463 * DECODER 3
3464 ********************************************************************************/
3465 case Audio_Comm_infoType_ADEC3_capability:
3466 case Audio_Comm_infoType_ADEC3_currAudDecStatus:
3467 case Audio_Comm_infoType_ADEC3_sampleRate:
3468 case Audio_Comm_infoType_ADEC3_bitRate:
3469 case Audio_Comm_infoType_ADEC3_acmod:
3470 case Audio_Comm_infoType_ADEC3_soundmod:
3471 case Audio_Comm_infoType_ADEC3_reqDataSize:
3472 case Audio_Comm_infoType_ADEC3_okFrmCnt:
3473 case Audio_Comm_infoType_ADEC3_errFrmCnt:
3474 case Audio_Comm_infoType_ADEC3_1ms_timeStamp:
3475 case Audio_Comm_infoType_ADEC3_33bit_PTS:
3476 case Audio_Comm_infoType_ADEC3_33bit_STCPTS_DIFF:
3477 case Audio_Comm_infoType_ADEC3_esBuf_reqFlag:
3478 case Audio_Comm_infoType_ADEC3_esBuf_reqAddr:
3479 case Audio_Comm_infoType_ADEC3_esBuf_reqSize:
3480 case Audio_Comm_infoType_ADEC3_esBuf_currLevel:
3481 case Audio_Comm_infoType_ADEC3_pcmBuf_currLevel:
3482 case Audio_Comm_infoType_ADEC3_getDecInfo1:
3483 case Audio_Comm_infoType_ADEC3_getDecInfo2:
3484 case Audio_Comm_infoType_ADEC3_getDecInfo3:
3485 case Audio_Comm_infoType_ADEC3_getDecInfo4:
3486 case Audio_Comm_infoType_ADEC3_getDecInfo5:
3487 case Audio_Comm_infoType_ADEC3_getDecInfo6:
3488 case Audio_Comm_infoType_ADEC3_getDecInfo7:
3489 case Audio_Comm_infoType_ADEC3_getDecInfo8:
3490 case Audio_Comm_infoType_ADEC3_getDecChannelInfo:
3491 case Audio_Comm_infoType_ADEC3_getlatest_PTS:
3492 break;
3493
3494 case Audio_Comm_infoType_ReadByte:
3495 result = (MS_U64)HAL_AUDIO_AbsReadByte(g_ReadTargetAddr);
3496 break;
3497
3498 case Audio_Comm_infoType_getSignal_Energy:
3499 result = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_dec1_signal_energy);
3500 break;
3501
3502 case Audio_Comm_infoType_getNR_Status:
3503 result = (HAL_AUDIO_ReadByte(S2M_MBOX_NR_STATUS)& 0x01);
3504 break;
3505
3506 case Audio_Comm_infoType_HDMI_Unstable_Protect:
3507 result = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_protect);
3508 break;
3509
3510 case Audio_Comm_infoType_HDMI_Unstable_Threshold:
3511 result = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_threshold);
3512 break;
3513
3514 case Audio_Comm_infoType_Get_MultiPlayer_Capability:
3515 result = 1;
3516 break;
3517
3518 case Audio_comm_infoType_Get_audio_crash_status:
3519 result = g_AudioVars2->g_u8AudioCrashFlag;
3520 break;
3521
3522 case Audio_Comm_infoType_Get_Parser_Architecture:
3523 result = E_AUD_4_PARSER_type1; // 2 AFIFO & 4 audio parser arch
3524 break;
3525
3526 case Audio_comm_infoType_Get_Main_Input_Source_Info:
3527 result = g_AudioVars2->eAudioSource;
3528 break;
3529
3530 case Audio_comm_infoType_Get_Sub_Input_Source_Info:
3531 result = HAL_AUDIO_ConvertInputType2SourceInfo(g_AudioVars2->eSubAudioSource);
3532 break;
3533
3534 case Audio_comm_infoType_Get_Main_Input_Type:
3535 result = g_AudioVars2->AudioSrcType;
3536 break;
3537
3538 case Audio_comm_infoType_Get_Sub_Input_Type:
3539 result = g_AudioVars2->AudioSubSrcType;
3540 break;
3541
3542 case Audio_Comm_infoType_AUDIO_GetDsp2CodeType:
3543 {
3544 result = HAL_AUDIO_GetDsp2CodeType();
3545 break;
3546 }
3547
3548 case Audio_Comm_infoType_AUDIO_Get_ADEC0_R2CodeType:
3549 {
3550 break;
3551 }
3552
3553 case Audio_Comm_infoType_AUDIO_Get_ADEC1_R2CodeType:
3554 {
3555 break;
3556 }
3557
3558 case Audio_Comm_infoType_Get_AD_Cabability:
3559 {
3560 #if AUDIO_AD_SUPPORT
3561 result = 1;
3562 #endif
3563 break;
3564 }
3565
3566 /* not support cmd */
3567 default:
3568 printf("%s: cmd not Supported\n", __FUNCTION__ );
3569 break;
3570 }
3571
3572 return result;
3573 }
3574
3575 ////////////////////////////////////////////////////////////////////////////////
3576 /// @brief \b Function \b Name: HAL_MAD_SetMpegInfo()
3577 /// @brief \b Function \b Description: This routine set different paramter to mpeg decoder
3578 /// @param <IN> \b Audio_MPEG_infoType : mpeg audio parameter type
3579 /// @param <IN> \b MS_U32 : common mpeg parameter 1
3580 /// @param <IN> \b MS_U32 : common mpeg parameter 2
3581 /// @param <OUT> \b NONE :
3582 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3583 /// @param <GLOBAL> \b NONE :
3584 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetMpegInfo(Audio_MPEG_infoType infoType,MS_VIRT param1,MS_VIRT param2)3585 MS_BOOL HAL_MAD_SetMpegInfo( Audio_MPEG_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3586 {
3587 switch(infoType)
3588 {
3589 case Audio_MPEG_infoType_SoundMode: //HAL_MAD_MPEG_SetSoundMode
3590 {
3591 MS_U8 value = 0; //default LL mode
3592
3593 switch((AUD_MPEG_SOUNDMODE)param1)
3594 {
3595 case AUD_MPEG_SOUNDMODE_LL: value = 0x4; break;
3596 case AUD_MPEG_SOUNDMODE_RR: value = 0x8; break;
3597 case AUD_MPEG_SOUNDMODE_LR: value = 0x0; break;
3598 case AUD_MPEG_SOUNDMODE_MIX_LR: value = 0xC; break;
3599 default: value = 0x0; break;
3600 }
3601 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPEG_SOUNDMODE, AU_DEC_ID1, (MS_U32)value, 0);
3602 }
3603 break;
3604
3605 case Audio_MPEG_infoType_MMFileSize: //HAL_MAD_MPEG_SetFileSize
3606 HAL_MAD_SetCommInfo(Audio_Comm_infoType_MMFileSize, param1, param2);
3607 break;
3608
3609 case Audio_MPEG_DTV_AVSYNC_OFFSET:
3610 if ((param1<DELAY_LOWER_LIMIT)||(param1>DELAY_UPPER_LIMIT)) //delay offset range from 30ms ~ 300ms
3611 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPG_AVOFFSET, AU_DEC_ID1, (MS_U32)MPG_AV_DEFAULT_DELAY, 0);
3612 else
3613 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPG_AVOFFSET, AU_DEC_ID1, (MS_U32)param1, 0);
3614 break;
3615
3616 case Audio_MPEG_DTV_AVSYNC_DISABLE_SETTING:
3617 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPG_AVOFFSET, AU_DEC_ID1, (MS_U32)MPG_AV_DEFAULT_DELAY, 0);
3618 break;
3619
3620 default:
3621 #if defined (__aarch64__)
3622 printf("%s: infoType[0x%x,0x%08lx,0x%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
3623 #else
3624 printf("%s: infoType[0x%x,0x%08x,0x%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
3625 #endif
3626 break;
3627 }
3628
3629 return TRUE;
3630 }
3631
3632 ////////////////////////////////////////////////////////////////////////////////
3633 /// @brief \b Function \b Name: HAL_MAD_GetMpegInfo()
3634 /// @brief \b Function \b Description: This routine info of mpeg decoder
3635 /// @param <IN> \b Audio_MPEG_infoType : request info type of mpeg decoder
3636 /// @param <OUT> \b NONE :
3637 /// @param <RET> \b MS_U32 : info type
3638 /// @param <GLOBAL> \b NONE :
3639 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetMpegInfo(Audio_MPEG_infoType infoType)3640 MS_U32 HAL_MAD_GetMpegInfo( Audio_MPEG_infoType infoType )
3641 {
3642 MS_U32 result = 0;
3643
3644 switch(infoType)
3645 {
3646 case Audio_MPEG_infoType_DecStatus: //no change
3647 if (((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_mpeg) && (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1) & 0x0001))
3648 result = 1;
3649 else
3650 result = 0;
3651 break;
3652
3653 case Audio_MPEG_infoType_BitRate: //HAL_MAD_MPEG_GetBitRate
3654 result = HAL_MAD_MPEG_GetBitRate();
3655 break;
3656
3657 case Audio_MPEG_infoType_FrameNum: //HAL_MAD_MPEG_GetframeNum
3658 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, AU_DEC_ID1);
3659 break;
3660
3661 case Audio_MPEG_infoType_Layer: //HAL_MAD_MPEG_GetLayer
3662 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MPEG_LAYER, AU_DEC_ID1);
3663 break;
3664
3665 case Audio_MPEG_infoType_SampleRate: //HAL_MAD_MPEG_GetSampleRate
3666 result = HAL_MAD_MPEG_GetSampleRate();
3667 break;
3668
3669 case Audio_MPEG_infoType_stereoMode: //HAL_MAD_MPEG_GetSoundMode
3670 result = HAL_MAD_MPEG_GetSoundMode();
3671 break;
3672
3673 case Audio_MPEG_infoType_Header: //HAL_MAD_MPEG_GetHeaderInfo
3674 result = HAL_MAD_MPEG_GetHeaderInfo();
3675 break;
3676
3677 default:
3678 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
3679 break;
3680 }
3681
3682 return result;
3683 }
3684
3685 ////////////////////////////////////////////////////////////////////////////////
3686 /// @brief \b Function \b Name: HAL_MAD_SetWmaInfo()
3687 /// @brief \b Function \b Description: This routine set different paramter to wma decoder
3688 /// @param <IN> \b Audio_WMA_infoType : wma audio parameter type
3689 /// @param <IN> \b MS_U32 : common wma parameter 1
3690 /// @param <IN> \b MS_U32 : common wma parameter 2
3691 /// @param <OUT> \b NONE :
3692 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3693 /// @param <GLOBAL> \b NONE :
3694 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetWmaInfo(Audio_WMA_infoType infoType,MS_VIRT param1,MS_VIRT param2)3695 MS_BOOL HAL_MAD_SetWmaInfo( Audio_WMA_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3696 {
3697 switch(infoType)
3698 {
3699 case Audio_WMA_infoType_Asf_Param:
3700 HAL_MAD_WMA_SetASFParm((WMA_ASF_PARMTYPE)param1, param2); //HAL_MAD_WMA_SetASFParm
3701 break;
3702
3703 case Audio_WMA_infoType_FFSpeed: //HAL_MAD_WMA_SetFastFowardSpeed
3704 printf("Currently, it is not used\n");
3705 break;
3706
3707 case Audio_WMA_infoType_MMFileSize:
3708 HAL_MAD_SetCommInfo(Audio_Comm_infoType_MMFileSize, param1, param2);
3709 break;
3710
3711 default:
3712 #if defined (__aarch64__)
3713 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
3714 #else
3715 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
3716 #endif
3717 break;
3718 }
3719
3720 return TRUE;
3721 }
3722
3723 ////////////////////////////////////////////////////////////////////////////////
3724 /// @brief \b Function \b Name: HAL_MAD_GetWmaInfo()
3725 /// @brief \b Function \b Description: This routine info of wma decoder
3726 /// @param <IN> \b Audio_WMA_infoType : request info type of wma decoder
3727 /// @param <OUT> \b NONE :
3728 /// @param <RET> \b MS_U32 : info type
3729 /// @param <GLOBAL> \b NONE :
3730 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetWmaInfo(Audio_WMA_infoType infoType)3731 MS_U32 HAL_MAD_GetWmaInfo( Audio_WMA_infoType infoType )
3732 {
3733 MS_U32 result = 0;
3734
3735 switch(infoType)
3736 {
3737 case Audio_WMA_infoType_BitRate: //HAL_MAD_WMA_GetBitRate
3738 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, AU_DEC_ID1);
3739 break;
3740
3741 case Audio_WMA_infoType_SampleRate: //HAL_MAD_WMA_GetSampleRate
3742 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1);
3743 break;
3744
3745 default:
3746 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
3747 break;
3748 }
3749
3750 return result;
3751 }
3752
3753 ////////////////////////////////////////////////////////////////////////////////
3754 /// @brief \b Function \b Name: HAL_MAD_SetAC3PInfo()
3755 /// @brief \b Function \b Description: This routine set different parameter to ac3+ decoder
3756 /// @param <IN> \b Audio_AC3P_infoType : AC3+ parameter type
3757 /// @param <IN> \b MS_U32 : AC3+ parameter 1
3758 /// @param <IN> \b MS_U32 : AC3+ parameter 2
3759 /// @param <OUT> \b NONE :
3760 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3761 /// @param <GLOBAL> \b NONE :
3762 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType infoType,MS_VIRT param1,MS_VIRT param2)3763 MS_BOOL HAL_MAD_SetAC3PInfo( Audio_AC3P_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3764 {
3765 HALMAD_CHECK_SHM_INIT;
3766 MS_U8 ADEC1_CodeType = g_AudioVars2->g_DspCodeType ;
3767 MS_U8 ADEC2_CodeType = g_AudioVars2->g_Dsp2CodeType ;
3768
3769 switch(infoType)
3770 {
3771 case Audio_AC3P_infoType_DownmixMode: //HAL_MAD_SetDolbyDownmixMode
3772 if((DOLBY_DOWNMIX_MODE)param1 == DOLBY_DOWNMIX_MODE_LORO)
3773 {
3774 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, AU_DEC_ID1, 1, 0);
3775 }
3776 else if ((DOLBY_DOWNMIX_MODE)param1 == DOLBY_DOWNMIX_MODE_LTRT)
3777 {
3778 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, AU_DEC_ID1, 0, 0);
3779 }
3780 else
3781 {
3782 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, AU_DEC_ID1, 2, 0);
3783 }
3784 break;
3785
3786 case Audio_AC3P_infoType_DrcMode: //HAL_MAD_SetDolbyDrcMode
3787 if((DOLBY_DRC_MODE)param1 == RF_MODE)
3788 {
3789 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, AU_DEC_ID1, 1, 0);
3790 g_AudioVars2->g_dolbyDrcMode = RF_MODE;
3791 }
3792 else
3793 {
3794 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, AU_DEC_ID1, 0, 0);
3795 g_AudioVars2->g_dolbyDrcMode = LINE_MODE;
3796 }
3797
3798 break;
3799
3800 case Audio_AC3P_infoType_MMFileSize: //HAL_MAD_ac3p_setFileSize
3801 HAL_MAD_SetCommInfo(Audio_Comm_infoType_MMFileSize, param1, param2);
3802 break;
3803
3804 case Audio_AC3P_infoType_syncSTC_in_mmTs:
3805 HAL_MAD_SetCommInfo(Audio_Comm_infoType_syncSTC_in_mmTs, param1, param2);
3806 break;
3807
3808 case Audio_AC3P_infoType_hdmiTxBypass_enable:
3809 if(param1)
3810 {
3811 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_HDMI_BYPASS, param2, param1, 0);
3812 HAL_AUDIO_DecWriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x40, 0x40);
3813 }
3814 else
3815 {
3816 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_HDMI_BYPASS, param2, param1, 0);
3817 HAL_AUDIO_DecWriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x40, 0x00);
3818 }
3819
3820 // MS12_hashkey on
3821 if(g_AudioVars2->g_ddenc_owner)
3822 {
3823 if( g_AudioVars2->g_R2_NonPcm_Sel == AU_DEC_ID1 )
3824 {
3825 if(ADEC1_CodeType == AU_DVB_STANDARD_AC3 || ADEC1_CodeType == AU_DVB_STANDARD_AC3P || ADEC1_CodeType == AU_DVB_STANDARD_AAC)
3826 {
3827 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID1, param1, 0);
3828 //printf("ADEC1 DoblbyCodeType = %x\n", ADEC1_CodeType);
3829 }
3830 else
3831 {
3832 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID1, 0, 0);
3833 //printf("ADEC1 CodeType = %x\n", ADEC1_CodeType);
3834 }
3835 }
3836 else if( g_AudioVars2->g_R2_NonPcm_Sel == AU_DEC_ID3 )
3837 {
3838 if(ADEC2_CodeType == AU_DVB_STANDARD_AC3 || ADEC2_CodeType == AU_DVB_STANDARD_AC3P || ADEC2_CodeType == AU_DVB_STANDARD_AAC)
3839 {
3840 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID3, param1, 0);
3841 //printf("ADEC2 DoblbyCodeType = %x\n", ADEC2_CodeType);
3842 }
3843 else
3844 {
3845 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID3, 0, 0);
3846 //printf("ADEC2 CodeType = %x\n", ADEC2_CodeType);
3847 }
3848 }
3849 else
3850 {
3851 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, param2, 0, 0);
3852 //printf("ADEC other \n");
3853 }
3854 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, param2, param1, 0);
3855 }
3856 break;
3857
3858 case Audio_AC3P_infoType_BYTESWAP:
3859 if(param1 == 1)
3860 {
3861 HAL_AUDIO_WriteMaskByte(0x2C48, 0x10, 0x10);
3862 HAL_AUDIO_WriteMaskByte(0x2C49, 0x05, 0x05);
3863 }else{
3864 HAL_AUDIO_WriteMaskByte(0x2C48, 0x10, 0x00);
3865 HAL_AUDIO_WriteMaskByte(0x2C49, 0x05, 0x00);
3866 }
3867 break;
3868
3869 case Audio_AC3P_DTV_AVSYNC_OFFSET:
3870 if ((param1<DELAY_LOWER_LIMIT)||(param1>DELAY_UPPER_LIMIT))
3871 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AC3_AVOFFSET, AU_DEC_ID1, AC3_AV_DEFAULT_DELAY, 0);
3872 else
3873 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AC3_AVOFFSET, AU_DEC_ID1, param1, 0);
3874 break;
3875
3876 case Audio_AC3P_DTV_AVSYNC_DISABLE_SETTING:
3877 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AC3_AVOFFSET, AU_DEC_ID1, AC3_AV_DEFAULT_DELAY, 0);
3878 break;
3879
3880 case Audio_AC3P_infoType_hdmiAC3inSE:
3881 if(param1 == TRUE)
3882 {
3883 FLAG_HDMI_AC3_IN_SE = TRUE;
3884 }
3885 else
3886 {
3887 FLAG_HDMI_AC3_IN_SE = FALSE;
3888 }
3889 break;
3890
3891 case Audio_AC3P_infoType_enableDolbyBulletin11:
3892 case Audio_AC3P_infoType_LoudnessMatching:
3893 if ( param1 )
3894 {
3895 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x80, 0x80);
3896 g_AudioVars2->g_dolbyLoudness_Enable = TRUE;
3897 }
3898 else
3899 {
3900 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x80, 0x00);
3901 g_AudioVars2->g_dolbyLoudness_Enable = FALSE;
3902 }
3903
3904 if ((g_AudioVars2->AudioSystemInfo.dtv_system == AUDIO_DTV_ATSC) || (g_AudioVars2->AudioSystemInfo.dtv_system == AUDIO_DTV_DMBT))
3905 {
3906 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x60, 0x40);
3907 g_AudioVars2->g_dolbyLoudness_DTVsystem = ATSC_MODE;
3908 }
3909 else if(g_AudioVars2->AudioSystemInfo.dtv_system == AUDIO_DTV_DVB)
3910 {
3911 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x60, 0x00);
3912 g_AudioVars2->g_dolbyLoudness_DTVsystem = DVB_MODE;
3913 }
3914 else
3915 {
3916 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x60, 0x20);
3917 g_AudioVars2->g_dolbyLoudness_DTVsystem = OTHER_MODE;
3918 }
3919
3920 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_RFSIGNAL_TYPE, AU_DEC_ID1, g_AudioVars2->g_dolbyLoudness_DTVsystem, 0);
3921 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_TB11_ENABLE, AU_DEC_ID1, g_AudioVars2->g_dolbyLoudness_Enable, 0);
3922 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_RFSIGNAL_TYPE, AU_DEC_ID3, g_AudioVars2->g_dolbyLoudness_DTVsystem, 0);
3923 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_TB11_ENABLE, AU_DEC_ID3, g_AudioVars2->g_dolbyLoudness_Enable, 0);
3924 break;
3925
3926 case Audio_AC3P_infoType_Drc_HighCutScale:
3927 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_HIGH_CUT, AU_DEC_ID1, param1, 0);
3928 break;
3929
3930 case Audio_AC3P_infoType_Drc_LowBootScale:
3931 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_LOW_BOOST, AU_DEC_ID1, param1, 0);
3932 break;
3933
3934 case Audio_AC3P_infoType_AD_Mixer_Balance:
3935 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, AU_DEC_ID1, param1, 0);
3936 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, AU_DEC_ID3, param1, 0);
3937 break;
3938
3939 default:
3940 #if defined (__aarch64__)
3941 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
3942 #else
3943 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
3944 #endif
3945 break;
3946 }
3947
3948 return TRUE;
3949 }
3950
3951 ////////////////////////////////////////////////////////////////////////////////
3952 /// @brief \b Function \b Name: HAL_MAD_GetAC3PInfo()
3953 /// @brief \b Function \b Description: This routine return info type of ac3+ decoder
3954 /// @param <IN> \b Audio_AC3P_infoType : AC3+ parameter type
3955 /// @param <OUT> \b NONE :
3956 /// @param <RET> \b MS_U32 : AC3+ paramter info
3957 /// @param <GLOBAL> \b NONE :
3958 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType infoType)3959 MS_U32 HAL_MAD_GetAC3PInfo( Audio_AC3P_infoType infoType )
3960 {
3961 MS_U32 result = 0;
3962
3963 switch(infoType)
3964 {
3965 case Audio_AC3P_infoType_DecStatus:
3966 if ((((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3) ||
3967 ((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3p)) &&
3968 (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1)&0x0001))
3969 result = 1;
3970 else
3971 result = 0;
3972 break;
3973
3974 case Audio_AC3P_infoType_SampleRate:
3975 {
3976 MS_U32 SMP_RATE = 0;
3977
3978 SMP_RATE = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1); //DD+
3979 switch(SMP_RATE)
3980 {
3981 case 44100: result = SAMPLE_RATE_44100; break;
3982 case 32000: result = SAMPLE_RATE_32000; break;
3983 default:
3984 case 48000: result = SAMPLE_RATE_48000; break;
3985 }
3986 }
3987 break;
3988
3989 case Audio_AC3P_infoType_BitRate: //unit : kbps
3990 {
3991 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, AU_DEC_ID1); //DD+
3992 }
3993 break;
3994
3995 case Audio_AC3P_infoType_Acmod:
3996 result = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod);
3997 break;
3998
3999 case Audio_AC3P_infoType_DrcMode:
4000 if (HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, AU_DEC_ID1, 0) == 1)
4001 result = RF_MODE;
4002 else
4003 result = LINE_MODE;
4004 break;
4005
4006 case Audio_AC3P_infoType_DownmixMode:
4007 if (HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, AU_DEC_ID1, 0) == 1)
4008 result = DOLBY_DOWNMIX_MODE_LORO;
4009 else
4010 result = DOLBY_DOWNMIX_MODE_LTRT;
4011 break;
4012
4013 case Audio_AC3P_infoType_AC3Type:
4014 if ((((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3) ||
4015 ((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3p)) &&
4016 (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1) & 0x0001))
4017 {
4018 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_DEC_TYPE, AU_DEC_ID1);
4019 result += 1;
4020 }
4021 else
4022 {
4023 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_DEC_TYPE, AU_DEC_ID1);
4024 }
4025 break;
4026
4027 case Audio_AC3P_infoType_FrameSize:
4028 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_FRAME_SIZE, AU_DEC_ID1);
4029 break;
4030
4031 case Audio_AC3P_infoType_BSMode:
4032 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_BS_MODE, AU_DEC_ID1);
4033 break;
4034
4035 case Audio_AC3P_infoType_DDP_71_Stream:
4036 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_DDP_71_STREAM, AU_DEC_ID1);
4037 break;
4038
4039 case Audio_AC3P_infoType_hdmiAC3inSE:
4040 if(FLAG_HDMI_AC3_IN_SE == TRUE)
4041 {
4042 result = 1;
4043 }
4044 else
4045 {
4046 result = 0;
4047 }
4048 break;
4049
4050 case Audio_AC3P_infoType_hdmi_in_support_DDP:
4051 result = 1;
4052 break;
4053
4054 case Audio_AC3P_infoType_ATMOS_support:
4055 result = ((g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DDP].support_SAD_byte3) & 0x1);
4056 break;
4057
4058 default:
4059 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4060 break;
4061 }
4062
4063 return result;
4064 }
4065
4066 ////////////////////////////////////////////////////////////////////////////////
4067 /// @brief \b Function \b Name: HAL_MAD_SetAC3Info()
4068 /// @brief \b Function \b Description: This routine set different paramter to ac3 decoder
4069 /// @param <IN> \b Audio_WMA_infoType : ac3 audio parameter type
4070 /// @param <IN> \b MS_U32 : common ac3 parameter 1
4071 /// @param <IN> \b MS_U32 : common ac3 parameter 2
4072 /// @param <OUT> \b NONE :
4073 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4074 /// @param <GLOBAL> \b NONE :
4075 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAC3Info(Audio_AC3_infoType infoType,MS_VIRT param1,MS_VIRT param2)4076 MS_BOOL HAL_MAD_SetAC3Info( Audio_AC3_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
4077 {
4078 switch(infoType)
4079 {
4080 case Audio_AC3_infoType_DownmixMode: //HAL_MAD_SetDolbyDownmixMode
4081 HAL_MAD_SetAC3PInfo( Audio_AC3P_infoType_DownmixMode, param1, param2);
4082 break;
4083
4084 case Audio_AC3_infoType_DrcMode: //HAL_MAD_SetDolbyDrcMode
4085 HAL_MAD_SetAC3PInfo( Audio_AC3P_infoType_DrcMode, param1, param2);
4086 break;
4087
4088 case Audio_AC3_infoType_AD_Mixer_Balance:
4089 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, AU_DEC_ID1, param1, 0);
4090 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, AU_DEC_ID3, param1, 0);
4091 break;
4092
4093 default:
4094 #if defined (__aarch64__)
4095 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
4096 #else
4097 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4098 #endif
4099 break;
4100 }
4101
4102 return TRUE;
4103 }
4104
4105 ////////////////////////////////////////////////////////////////////////////////
4106 /// @brief \b Function \b Name: HAL_MAD_GetAC3Info()
4107 /// @brief \b Function \b Description: This routine info of ac3 decoder
4108 /// @param <IN> \b Audio_AC3_infoType : request info type of ac3 decoder
4109 /// @param <OUT> \b NONE :
4110 /// @param <RET> \b MS_U32 : info type
4111 /// @param <GLOBAL> \b NONE :
4112 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetAC3Info(Audio_AC3_infoType infoType)4113 MS_U32 HAL_MAD_GetAC3Info( Audio_AC3_infoType infoType )
4114 {
4115 MS_U32 result = 0;
4116
4117 switch(infoType)
4118 {
4119 case Audio_AC3_infoType_DecStatus:
4120 if ((((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3) ||
4121 ((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3p)) &&
4122 (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1) & 0x0001))
4123 result = 1;
4124 else
4125 result = 0;
4126 break;
4127
4128 case Audio_AC3_infoType_Acmod:
4129 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_Acmod);
4130 break;
4131
4132 case Audio_AC3_infoType_BitRate:
4133 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_BitRate);
4134 break;
4135
4136 case Audio_AC3_infoType_SampleRate:
4137 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_SampleRate);
4138 break;
4139
4140 case Audio_AC3_infoType_DownmixMode:
4141 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_DownmixMode);
4142 break;
4143
4144 case Audio_AC3_infoType_DrcMode:
4145 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_DrcMode);
4146 break;
4147
4148 default:
4149 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4150 break;
4151 }
4152
4153 return result;
4154 }
4155
4156
4157 ////////////////////////////////////////////////////////////////////////////////
4158 /// @brief \b Function \b Name: HAL_MAD_SetDTSCommonCtrl()
4159 /// @brief \b Function \b Description: This routine set different control to DTS decoder
4160 /// @param <IN> \b Audio_DTS_infoType : DTS control type
4161 /// @param <IN> \b MS_U16 : DTS control value
4162 /// @param <OUT> \b NONE :
4163 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4164 /// @param <GLOBAL> \b NONE :
4165 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDTSCommonCtrl(Audio_DTS_infoType infoType,Audio_DTS_CtrlType ctrl_type)4166 MS_BOOL HAL_MAD_SetDTSCommonCtrl( Audio_DTS_infoType infoType, Audio_DTS_CtrlType ctrl_type )
4167 {
4168 switch(infoType)
4169 {
4170 case Audio_DTS_infoType_DMIX_LFE_EN:
4171 if (ctrl_type == Audio_DTS_Ctrl_DMIX_LFE_OFF)
4172 {
4173 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_LFE_ENABLE, AU_DEC_ID1, 0, 0);
4174 }
4175 else
4176 {
4177 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_LFE_ENABLE, AU_DEC_ID1, 1, 0);
4178 }
4179 break;
4180
4181 case Audio_DTS_infoType_Dialnorm_EN:
4182 // always enable
4183 break;
4184
4185 case Audio_DTS_infoType_DrcMode:
4186 // always disable in T3
4187 break;
4188
4189 case Audio_DTS_infoType_DownmixMode:
4190 if (ctrl_type == Audio_DTS_Ctrl_Downmix_LoRo)
4191 {
4192 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_MODE, AU_DEC_ID1, 0, 0);
4193 }
4194 else
4195 {
4196 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_MODE, AU_DEC_ID1, 1, 0);
4197 }
4198 break;
4199
4200 case Audio_DTS_infoType_ESDataServiceMode:
4201 //force Audio_DTS_Ctrl_INTRPTMode in T3
4202 break;
4203
4204 case Audio_DTS_infoType_ESData_ByteSwap:
4205 //Currently, it is not used;
4206 break;
4207
4208 case Audio_DTS_infoType_CertMode:
4209 //DTS Certification Mode, Need to disable Sound Eeffect
4210 if (ctrl_type == Audio_DTS_Ctrl_CertMode_ON)
4211 {
4212 Flag_MAIN_SNDEFFET_CHG = TRUE;
4213 Reg_REG_SOUND_MAIN_SNDEFFECT = HAL_AUDIO_ReadReg(REG_SOUND_MAIN_SNDEFFECT);
4214 HAL_AUDIO_WriteReg(REG_SOUND_MAIN_SNDEFFECT,0x0000);
4215 Reg_REG_SOUND_ADV_CFG0 = HAL_AUDIO_ReadReg(REG_SOUND_ADV_CFG0);
4216 HAL_AUDIO_WriteReg(REG_SOUND_ADV_CFG0,0x0000);
4217 }
4218 if (ctrl_type == Audio_DTS_Ctrl_CertMode_OFF)
4219 {
4220 if(Flag_MAIN_SNDEFFET_CHG)
4221 {
4222 HAL_AUDIO_WriteReg(REG_SOUND_MAIN_SNDEFFECT, Reg_REG_SOUND_MAIN_SNDEFFECT);
4223 HAL_AUDIO_WriteReg(REG_SOUND_ADV_CFG0, Reg_REG_SOUND_ADV_CFG0);
4224 Flag_MAIN_SNDEFFET_CHG = FALSE;
4225 }
4226 }
4227 break;
4228
4229 case Audio_DTS_infoType_DTSHD_HDMITxBypass_Enable:
4230 if(ctrl_type == Audio_DTS_Ctrl_DTSHDBypass_ON)
4231 {
4232 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, AU_DEC_ID1, Audio_DTS_Ctrl_DTSHDBypass_ON, 0);
4233 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, AU_DEC_ID3, Audio_DTS_Ctrl_DTSHDBypass_ON, 0);
4234 HAL_AUDIO_DecWriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x40, 0x40);
4235 }
4236 else
4237 {
4238 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, AU_DEC_ID1, Audio_DTS_Ctrl_DTSHDBypass_OFF, 0);
4239 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, AU_DEC_ID3, Audio_DTS_Ctrl_DTSHDBypass_OFF, 0);
4240 HAL_AUDIO_DecWriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x40, 0x00);
4241 }
4242 break;
4243
4244 default:
4245 break;
4246 }
4247
4248 return TRUE;
4249 }
4250
4251 ////////////////////////////////////////////////////////////////////////////////
4252 /// @brief \b Function \b Name: HAL_MAD_GetDTSInfo()
4253 /// @brief \b Function \b Description: This routine return info type of DTS decoder
4254 /// @param <IN> \b Audio_DTS_infoType : DTS parameter type
4255 /// @param <OUT> \b NONE :
4256 /// @param <RET> \b MS_U32 : DTS paramter info
4257 /// @param <GLOBAL> \b NONE :
4258 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetDTSInfo(Audio_DTS_infoType infoType)4259 MS_U32 HAL_MAD_GetDTSInfo( Audio_DTS_infoType infoType )
4260 {
4261 MS_U32 result = 0;
4262
4263 switch(infoType)
4264 {
4265 case Audio_DTS_infoType_DecStatus:
4266 if (((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_dts) && (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, AU_DEC_ID1)&0x0001))
4267 result = 1;
4268 else
4269 result = 0;
4270 break;
4271
4272 case Audio_DTS_infoType_KernelVersion:
4273 //Currently, it is not used;
4274 break;
4275
4276 case Audio_DTS_infoType_SampleRate: // Original FS from Header
4277 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1);
4278 break;
4279
4280 case Audio_DTS_infoType_BitRate:
4281 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, AU_DEC_ID1);
4282 break;
4283
4284 case Audio_DTS_infoType_CD_MODE:
4285 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DTS_CD_MODE, AU_DEC_ID1);
4286 break;
4287
4288 case Audio_DTS_infoType_Amode:
4289 {
4290 MS_U32 ac_mode = 0xFF;
4291 MS_U32 channel_mapping = 0x0;
4292 ac_mode = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, AU_DEC_ID1);
4293 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, AU_DEC_ID1);
4294
4295 switch(ac_mode)
4296 {
4297 case adec_ch_mono:
4298 result = AUD_CH_MODE_MONO;
4299 break;
4300
4301 case adec_ch_joint_stereo:
4302 result = AUD_CH_MODE_JOINT_STEREO;
4303 break;
4304
4305 case adec_ch_stereo:
4306 result = AUD_CH_MODE_STEREO;
4307 break;
4308
4309 case adec_ch_dual_mono:
4310 result = AUD_CH_MODE_DUAL_MONO;
4311 break;
4312
4313 case adec_ch_multi:
4314 {
4315 MS_U32 channel_mapping_mask_C_L_R, channel_mapping_mask_Ls_Rs =0x00;
4316 channel_mapping_mask_Ls_Rs = (channel_mapping&(ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS));
4317 channel_mapping_mask_C_L_R = (channel_mapping&(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R));
4318
4319 if(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
4320 {
4321 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
4322 result = AUD_CH_MODE_3_2_MODE;
4323 else if(channel_mapping_mask_Ls_Rs == ACMOD_CH_MASK_NULL)
4324 result = AUD_CH_MODE_3_0_MODE;
4325 else
4326 result = AUD_CH_MODE_3_1_MODE;
4327 }
4328 else if((channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L))||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
4329 ||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_R)))
4330 {
4331 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
4332 result = AUD_CH_MODE_2_2_MODE;
4333 else
4334 result = AUD_CH_MODE_2_1_MODE;
4335 }
4336 else //other multi-channel case, set it to AUD_CH_MODE_3_2_MODE
4337 {
4338 result = AUD_CH_MODE_3_2_MODE;
4339 }
4340 }
4341 break;
4342
4343 default:
4344 result = AUD_CH_MODE_NONE;
4345 break;
4346 }
4347 }
4348 break;
4349
4350 case Audio_DTS_infoType_HDMI_DSP_SEL:
4351 result = 0x0; //0: in DEC DSP, 1: in SND DSP
4352 break;
4353
4354 default:
4355 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4356 break;
4357 }
4358
4359 return result;
4360 }
4361
4362
4363 ////////////////////////////////////////////////////////////////////////////////
4364 /// @brief \b Function \b Name: HAL_MAD_SetAACInfo()
4365 /// @brief \b Function \b Description: This routine set different paramter to aac decoder
4366 /// @param <IN> \b Audio_WMA_infoType : aac audio parameter type
4367 /// @param <IN> \b MS_U32 : common aac parameter 1
4368 /// @param <IN> \b MS_U32 : common aac parameter 2
4369 /// @param <OUT> \b NONE :
4370 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4371 /// @param <GLOBAL> \b NONE :
4372 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAACInfo(Audio_AAC_infoType infoType,MS_VIRT param1,MS_VIRT param2)4373 MS_BOOL HAL_MAD_SetAACInfo( Audio_AAC_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
4374 {
4375 switch(infoType)
4376 {
4377 case Audio_AAC_infoType_DownmixMode: //HAL_MAD_SetDolbyDownmixMode
4378 if((DOLBY_DOWNMIX_MODE)param1 == DOLBY_DOWNMIX_MODE_LORO)
4379 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, AU_DEC_ID1, 1, 0);
4380 else
4381 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, AU_DEC_ID1, 0, 0);
4382 break;
4383
4384 case Audio_AAC_infoType_DrcMode: //HAL_MAD_SetDolbyDrcMode
4385 if((DOLBY_DRC_MODE)param1 == RF_MODE)
4386 {
4387 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, AU_DEC_ID1, 1, 0);
4388 }
4389 else
4390 {
4391 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, AU_DEC_ID1, 0, 0);
4392 }
4393 g_AudioVars2->g_dolbyDrcMode = (DOLBY_DRC_MODE)param1;
4394 break;
4395
4396 case Audio_AAC_DTV_AVSYNC_OFFSET:
4397 if ((param1<DELAY_LOWER_LIMIT)||(param1>DELAY_UPPER_LIMIT)) //delay offset range from 30ms ~ 300ms
4398 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AAC_AVOFFSET, AU_DEC_ID1, AAC_AV_DEFAULT_DELAY, 0);
4399 else
4400 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AAC_AVOFFSET, AU_DEC_ID1, param1, 0);
4401 break;
4402
4403 case Audio_AAC_mm_single_frame_mode:
4404 if (param1 > 0)
4405 {
4406 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER, AU_DEC_ID1, 1, 0);
4407 }
4408 else
4409 {
4410 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER, AU_DEC_ID1, 0, 0);
4411 }
4412 break;
4413
4414 case Audio_AAC_DTV_AVSYNC_DISABLE_SETTING:
4415 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AAC_AVOFFSET, AU_DEC_ID1, AAC_AV_DEFAULT_DELAY, 0);
4416 break;
4417
4418 case Audio_AAC_AD_Mixer_Balance:
4419 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, AU_DEC_ID1, param1, 0);
4420 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, AU_DEC_ID3, param1, 0);
4421 break;
4422
4423 default:
4424 #if defined (__aarch64__)
4425 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
4426 #else
4427 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4428 #endif
4429 break;
4430 }
4431
4432 return TRUE;
4433 }
4434
4435 ////////////////////////////////////////////////////////////////////////////////
4436 /// @brief \b Function \b Name: HAL_MAD_GetAACInfo()
4437 /// @brief \b Function \b Description: This routine info of aac decoder
4438 /// @param <IN> \b Audio_AAC_infoType : request info type of aac decoder
4439 /// @param <OUT> \b NONE :
4440 /// @param <RET> \b MS_U32 : info type
4441 /// @param <GLOBAL> \b NONE :
4442 ////////////////////////////////////////////////////////////////////////////////
4443 #define DEC_UNSUPPORT_CNT 10
4444 #define AAC_UNSUPPORT_ADDR 0x3824
HAL_MAD_GetAACInfo(Audio_AAC_infoType infoType)4445 MS_U32 HAL_MAD_GetAACInfo( Audio_AAC_infoType infoType )
4446 {
4447 MS_U32 result=0;
4448 //MS_U32 result1=0, result2=0,
4449
4450 if((HAL_MAD_Rpt_DTVES() & 0xF0) != 0x50)
4451 return result;
4452
4453 switch(infoType)
4454 {
4455 case Audio_AAC_error_count:
4456 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, AU_DEC_ID1);
4457 break;
4458
4459 case Audio_AAC_dec_unsupported:
4460 //decode unsupported, threshold 10
4461 //Currently, it is not used;
4462 break;
4463
4464 case Audio_AAC_type:
4465 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_AAC_TYPE, AU_DEC_ID1);
4466 break;
4467
4468 default:
4469 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4470 break;
4471 }
4472 return result;
4473 }
4474
4475 ////////////////////////////////////////////////////////////////////////////////
4476 /// @brief \b Function \b Name: HAL_MAD_SetDtsInfo()
4477 /// @brief \b Function \b Description: This routine set different paramter to aac decoder
4478 /// @param <IN> \b Audio_WMA_infoType : aac audio parameter type
4479 /// @param <IN> \b MS_U32 : common aac parameter 1
4480 /// @param <IN> \b MS_U32 : common aac parameter 2
4481 /// @param <OUT> \b NONE :
4482 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4483 /// @param <GLOBAL> \b NONE :
4484 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDtsInfo(Audio_DTS_infoType infoType,MS_U32 param1,MS_U32 param2)4485 MS_BOOL HAL_MAD_SetDtsInfo( Audio_DTS_infoType infoType, MS_U32 param1, MS_U32 param2 )
4486 {
4487 switch(infoType)
4488 {
4489 default:
4490 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4491 break;
4492 }
4493
4494 return TRUE;
4495 }
4496
4497 ////////////////////////////////////////////////////////////////////////////////
4498 /// @brief \b Function \b Name: HAL_MAD_GetAACInfo()
4499 /// @brief \b Function \b Description: This routine info of aac decoder
4500 /// @param <IN> \b Audio_AAC_infoType : request info type of aac decoder
4501 /// @param <OUT> \b NONE :
4502 /// @param <RET> \b MS_U32 : info type
4503 /// @param <GLOBAL> \b NONE :
4504 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetDtsInfo(Audio_DTS_infoType infoType)4505 MS_U32 HAL_MAD_GetDtsInfo( Audio_DTS_infoType infoType )
4506 {
4507 MS_U32 result = 0;
4508
4509 switch(infoType)
4510 {
4511 default:
4512 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4513 break;
4514 }
4515
4516 return result;
4517 }
4518
4519 ////////////////////////////////////////////////////////////////////////////////
4520 /// @brief \b Function \b Name: HAL_MAD_SetRA8LBRInfo()
4521 /// @brief \b Function \b Description: This routine set different paramter to ra8 lbr decoder
4522 /// @param <IN> \b Audio_RA8LBR_infoType : ra8 lbr audio parameter type
4523 /// @param <IN> \b MS_U32 : common ra8 lbr parameter 1
4524 /// @param <IN> \b MS_U32 : common ra8 lbr parameter 2
4525 /// @param <OUT> \b NONE :
4526 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4527 /// @param <GLOBAL> \b NONE :
4528 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetRA8LBRInfo(Audio_RA8LBR_infoType infoType,MS_U32 param1,MS_U32 param2)4529 MS_BOOL HAL_MAD_SetRA8LBRInfo( Audio_RA8LBR_infoType infoType, MS_U32 param1, MS_U32 param2 )
4530 {
4531 switch ( infoType )
4532 {
4533 case Audio_RA8LBR_NumCodes:
4534 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_NUMCODECS, AU_DEC_ID1, param1, 0 );
4535 break;
4536 case Audio_RA8LBR_Samples:
4537 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLES, AU_DEC_ID1, param1, 0 );
4538 break;
4539 case Audio_RA8LBR_SampleRate:
4540 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLERATES, AU_DEC_ID1, param1, 0 );
4541 break;
4542 case Audio_RA8LBR_Channels1:
4543 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, param1, 0 );
4544 break;
4545 case Audio_RA8LBR_Regions1:
4546 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, param1, 0 );
4547 break;
4548 case Audio_RA8LBR_cplStart1:
4549 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, param1, 0 );
4550 break;
4551 case Audio_RA8LBR_cplQbits1:
4552 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, param1, 0 );
4553 break;
4554 case Audio_RA8LBR_FrameSize1:
4555 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, param1, 0 );
4556 break;
4557 case Audio_RA8LBR_Channels2:
4558 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, param1, 1 );
4559 break;
4560 case Audio_RA8LBR_Regions2:
4561 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, param1, 1 );
4562 break;
4563 case Audio_RA8LBR_cplStart2:
4564 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, param1, 1 );
4565 break;
4566 case Audio_RA8LBR_cplQbits2:
4567 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, param1, 1 );
4568 break;
4569 case Audio_RA8LBR_FrameSize2:
4570 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, param1, 1 );
4571 break;
4572 case Audio_RA8LBR_Channels3:
4573 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, param1, 2 );
4574 break;
4575 case Audio_RA8LBR_Regions3:
4576 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, param1, 2 );
4577 break;
4578 case Audio_RA8LBR_cplStart3:
4579 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, param1, 2 );
4580 break;
4581 case Audio_RA8LBR_cplQbits3:
4582 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, param1, 2 );
4583 break;
4584 case Audio_RA8LBR_FrameSize3:
4585 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, param1, 2 );
4586 break;
4587 case Audio_RA8LBR_Channels4:
4588 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, param1, 3 );
4589 break;
4590 case Audio_RA8LBR_Regions4:
4591 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, param1, 3 );
4592 break;
4593 case Audio_RA8LBR_cplStart4:
4594 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, param1, 3 );
4595 break;
4596 case Audio_RA8LBR_cplQbits4:
4597 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, param1, 3 );
4598 break;
4599 case Audio_RA8LBR_FrameSize4:
4600 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, param1, 3 );
4601 break;
4602 case Audio_RA8LBR_Channels5:
4603 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, AU_DEC_ID1, param1, 4 );
4604 break;
4605 case Audio_RA8LBR_Regions5:
4606 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, AU_DEC_ID1, param1, 4 );
4607 break;
4608 case Audio_RA8LBR_cplStart5:
4609 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, AU_DEC_ID1, param1, 4 );
4610 break;
4611 case Audio_RA8LBR_cplQbits5:
4612 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, AU_DEC_ID1, param1, 4 );
4613 break;
4614 case Audio_RA8LBR_FrameSize5:
4615 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, AU_DEC_ID1, param1, 4 );
4616 break;
4617 default:
4618 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4619 break;
4620 }
4621
4622 return TRUE;
4623 }
4624
4625 ////////////////////////////////////////////////////////////////////////////////
4626 /// @brief \b Function \b Name: HAL_MAD_GetRA8LBRInfo()
4627 /// @brief \b Function \b Description: This routine info of ra8 lbr decoder
4628 /// @param <IN> \b Audio_RA8LBR_infoType : request info type of ra8 lbr decoder
4629 /// @param <OUT> \b NONE :
4630 /// @param <RET> \b MS_U32 : info type
4631 /// @param <GLOBAL> \b NONE :
4632 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetRA8LBRInfo(Audio_RA8LBR_infoType infoType)4633 MS_U32 HAL_MAD_GetRA8LBRInfo( Audio_RA8LBR_infoType infoType )
4634 {
4635 MS_U32 result = 0;
4636
4637 switch ( infoType )
4638 {
4639 default:
4640 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4641 break;
4642 }
4643
4644 return result;
4645 }
4646
4647 ////////////////////////////////////////////////////////////////////////////////
4648 /// @brief \b Function \b Name: HAL_MAD_ReLoadCode()
4649 /// @brief \b Function \b Description: This routine is used to reload the DVB algorithm code
4650 /// @param u8Type1 \b type1 : algorithm1 type
4651 /// @return MS_BOOL \b TRUE --DSP reload code okay
4652 /// FALSE--DSP reload code fail
4653 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_ReLoadCode(AUDIO_DSP_CODE_TYPE u8Type1)4654 MS_BOOL HAL_MAD_ReLoadCode(AUDIO_DSP_CODE_TYPE u8Type1)
4655 {
4656 //AUDIO_ALG_INFO *pau_info, *pau_info2, tmp_info, tmp_info2;
4657 MS_BOOL ret_status = FALSE;
4658 AU_DVB_DECCMD deccmd_status;
4659 MS_U16 deccmd_status1;
4660
4661 #if (SIF_DSP_TYPE == 1)
4662 if(u8Type1 == AU_DVB_STANDARD_MPEG_EN)
4663 {
4664 return FALSE;
4665 }
4666 #endif
4667
4668 if(((u8Type1 & 0xF0) == 0x00)||((u8Type1 & 0xF0) == 0x10)||((u8Type1 & 0xF0) == 0xb0) )
4669 {
4670 if(HAL_AUDIO_GetDspCodeType() == u8Type1) // if type is the same, don't reload again
4671 {
4672 printf("Audio DSP1 code is same(0x%x), no need to reload\n", u8Type1);
4673 return TRUE;
4674 }
4675
4676 deccmd_status = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
4677 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
4678 MsOS_DisableInterrupt(E_INT_FIQ_SE_DSP2UP);
4679
4680 // Reset MAD module
4681 HAL_MAD_DisEn_MIUREQ();
4682
4683 // enable DVB fix-sync mode
4684 HAL_MAD_DvbFLockSynthesizer_En();
4685 ret_status = HAL_AUDIO_AlgReloadCode(u8Type1);
4686
4687 MsOS_EnableInterrupt(E_INT_FIQ_SE_DSP2UP);
4688 if ( ret_status == TRUE )
4689 {
4690 if(u8Type1 != AU_DVB_STANDARD_MPEG_AD)
4691 {
4692 HAL_AUDIO_SetDspCodeType(u8Type1, ret_status);
4693 }
4694 }
4695 HAL_MAD_SetDecCmd((AU_DVB_DECCMD)deccmd_status);
4696 return ret_status;
4697 }
4698 else if(((u8Type1 & 0xF0) == 0x30)||((u8Type1 & 0xF0) == 0x20)) // MPEG AD/MPEG EN/2nd decoder
4699 {
4700 deccmd_status1 = HAL_AUDIO_ReadReg(REG_R2_DECODE1_CMD);
4701 HAL_MAD2_SetDecCmd(AU_DVB2_DECCMD_STOP);
4702
4703 MsOS_DisableInterrupt(E_INT_FIQ_SE_DSP2UP);
4704
4705 // Reset MAD module
4706 //HAL_MAD_DisEn_MIUREQ();
4707
4708 // enable DVB fix-sync mode
4709 //HAL_MAD_DvbFLockSynthesizer_En();
4710 ret_status = HAL_AUDIO_AlgReloadCode(u8Type1);
4711
4712 MsOS_EnableInterrupt(E_INT_FIQ_SE_DSP2UP);
4713 HAL_AUDIO_SetDsp2CodeType(u8Type1, ret_status);
4714 HAL_MAD2_SetDecCmd((AU_DVB_DECCMD)deccmd_status1);
4715 return ret_status;
4716 }
4717 else
4718 {
4719 return FALSE;
4720 }
4721 }
4722
4723 ////////////////////////////////////////////////////////////////////////////////
4724 /// @brief \b Function \b Name: HAL_MAD_LoadCode()
4725 /// @brief \b Function \b Description: This routine is used to load the DVB algorithm code
4726 /// @param u8Type \b algorithm type
4727 /// @return MS_BOOL \b TRUE --DSP load code okay
4728 /// FALSE--DSP load code fail
4729 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_LoadCode(AUDIO_DSP_CODE_TYPE u8Type)4730 MS_BOOL HAL_MAD_LoadCode(AUDIO_DSP_CODE_TYPE u8Type)
4731 {
4732 //AUDIO_ALG_INFO *pau_info, *pau_info2, tmp_info, tmp_info2;
4733 MS_BOOL ret_status = FALSE;
4734
4735 if(((u8Type & 0xF0) == 0x00)||((u8Type & 0xF0) == 0x10)||((u8Type & 0xF0) == 0xb0)) //mad load code
4736 {
4737 AUD_DBGMSG(printf("HAL_MAD_LoadCode(type=dvb (%x))\r\n", u8Type));
4738
4739 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07, 0x00); // decoder1 Input --> DVB
4740
4741 ret_status = HAL_AUDSP_DspLoadCode(u8Type);
4742 HAL_AUDIO_SetDspCodeType(u8Type, ret_status);
4743 HAL_AUDIO_SetIsDtvFlag(TRUE);
4744 return TRUE;
4745 }
4746 else
4747 {
4748 AUD_DBGMSG(printf("HAL_MAD_SIF_LoadCode: type(%x) is invalid\r\n",u8Type));
4749 return FALSE;
4750 }
4751 }
4752
4753 ////////////////////////////////////////////////////////////////////////////////
4754 /// @brief \b Function \b Name: HAL_MAD_XPCM_setParam
4755 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_XPCM_setParam(XPCM_TYPE audioType,MS_U8 channels,MS_U32 sampleRate,MS_U8 bitsPerSample,MS_U16 blockSize,MS_U16 samplePerBlock)4756 MS_U8 HAL_MAD_XPCM_setParam(XPCM_TYPE audioType, MS_U8 channels, MS_U32 sampleRate,
4757 MS_U8 bitsPerSample, MS_U16 blockSize, MS_U16 samplePerBlock)
4758 {
4759 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_TYPE, AU_DEC_ID1, audioType, 0 );
4760 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_CHANNELS, AU_DEC_ID1, channels, 0 );
4761 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLERATES, AU_DEC_ID1, sampleRate, 0 );
4762 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BITS_PER_SAMPLE, AU_DEC_ID1, bitsPerSample, 0 );
4763 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BLOCK_SIZE, AU_DEC_ID1, blockSize, 0 );
4764 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLE_PER_BLOCK, AU_DEC_ID1, samplePerBlock, 0 );
4765
4766 return TRUE;
4767 }
4768
4769 //====== STAOS PIP START 2012/02/01 ========
4770
HAL_MAD_XPCM_setParam2(AUDIO_DEC_ID DecId,Audio_XPCM_Param * pParam)4771 MS_BOOL HAL_MAD_XPCM_setParam2( AUDIO_DEC_ID DecId, Audio_XPCM_Param * pParam )
4772 {
4773 Audio_XPCM_Param * pParamXPCM = pParam;
4774 MS_U32 s32smprate = 0;
4775
4776 if(pParamXPCM->sampleRate == 30464) //patch for 96K sample rate
4777 {
4778 s32smprate = 96000;
4779 }
4780 else if(pParamXPCM->sampleRate == 60928) // patch for 192K sampke rate
4781 {
4782 s32smprate = 192000;
4783 }
4784 else
4785 {
4786 s32smprate = (MS_U32) pParamXPCM->sampleRate;
4787 }
4788
4789 if ( DecId < AU_DEC_MAX)
4790 {
4791 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_TYPE, DecId, (MS_U32) pParamXPCM->audioType, 0 );
4792 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_CHANNELS, DecId, (MS_U32) pParamXPCM->channels, 0 );
4793 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLERATES, DecId, s32smprate, 0 );
4794 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BITS_PER_SAMPLE, DecId, (MS_U32) pParamXPCM->bitsPerSample, 0 );
4795 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BLOCK_SIZE, DecId, (MS_U32) pParamXPCM->blockSize, 0 );
4796 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLE_PER_BLOCK, DecId, (MS_U32) pParamXPCM->samplePerBlock, 0 );
4797 return TRUE;
4798 }
4799 else
4800 {
4801 return FALSE;
4802 }
4803 }
4804
HAL_MAD_COOK_setParam2(AUDIO_DEC_ID DecId,Audio_COOK_Param * pParam)4805 MS_BOOL HAL_MAD_COOK_setParam2( AUDIO_DEC_ID DecId, Audio_COOK_Param * pParam )
4806 {
4807 Audio_COOK_Param * pParamCOOK = pParam;
4808
4809 if ( DecId < AU_DEC_MAX )
4810 {
4811 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_NUMCODECS, DecId, pParamCOOK->mNumCodecs, 0 );
4812 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLES, DecId, pParamCOOK->mSamples, 0 );
4813 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLERATES, DecId, pParamCOOK->mSampleRate, 0 );
4814 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, DecId, pParamCOOK->Channels[0], 0 );
4815 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, DecId, pParamCOOK->Regions[0], 0 );
4816 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, DecId, pParamCOOK->cplStart[0], 0 );
4817 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, DecId, pParamCOOK->cplQbits[0], 0 );
4818 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, DecId, pParamCOOK->FrameSize[0], 0 );
4819
4820 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, DecId, pParamCOOK->Channels[1], 1 );
4821 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, DecId, pParamCOOK->Regions[1], 1 );
4822 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, DecId, pParamCOOK->cplStart[1], 1 );
4823 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, DecId, pParamCOOK->cplQbits[1], 1 );
4824 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, DecId, pParamCOOK->FrameSize[1], 1 );
4825
4826 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, DecId, pParamCOOK->Channels[2], 2 );
4827 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, DecId, pParamCOOK->Regions[2], 2 );
4828 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, DecId, pParamCOOK->cplStart[2], 2 );
4829 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, DecId, pParamCOOK->cplQbits[2], 2 );
4830 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, DecId, pParamCOOK->FrameSize[2], 2 );
4831
4832 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, DecId, pParamCOOK->Channels[3], 3 );
4833 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, DecId, pParamCOOK->Regions[3], 3 );
4834 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, DecId, pParamCOOK->cplStart[3], 3 );
4835 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, DecId, pParamCOOK->cplQbits[3], 3 );
4836 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, DecId, pParamCOOK->FrameSize[3], 3 );
4837
4838 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, DecId, pParamCOOK->Channels[4], 4 );
4839 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, DecId, pParamCOOK->Regions[4], 4 );
4840 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, DecId, pParamCOOK->cplStart[4], 4 );
4841 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, DecId, pParamCOOK->cplQbits[4], 4 );
4842 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, DecId, pParamCOOK->FrameSize[4], 4 );
4843
4844 return TRUE;
4845 }
4846 else
4847 {
4848 return FALSE;
4849 }
4850 }
4851
HAL_MAD_WMA_SetASFParm2(AUDIO_DEC_ID DecId,Audio_ASF_Param * pParam)4852 MS_BOOL HAL_MAD_WMA_SetASFParm2( AUDIO_DEC_ID DecId, Audio_ASF_Param * pParam )
4853 {
4854
4855 if ( DecId < AU_DEC_MAX )
4856 {
4857 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_VERSION, DecId, pParam->u32Version, 0);
4858 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELS, DecId, pParam->u32Channels, 0);
4859 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_SAMPLERATE, DecId, pParam->u32SampleRate, 0);
4860 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BYTERATE, DecId, pParam->u32ByteRate, 0);
4861 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BLOCKALIGN, DecId, pParam->u32BlockAlign, 0);
4862 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_ENCOPT, DecId, pParam->u32Encopt, 0);
4863 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_PARSINGBYAPP, DecId, pParam->u32ParsingByApp, 0);
4864 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BITS_PER_SAMPLE, DecId, pParam->u32BitsPerSample, 0);
4865 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELMASK, DecId, pParam->u32ChannelMask, 0);
4866 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PARAM_EXIST, DecId, pParam->u32DrcParamExist, 0);
4867 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_REF, DecId, pParam->u32DrcRmsAmpRef, 0);
4868 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_TARGET, DecId, pParam->u32DrcRmsAmpTarget, 0);
4869 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_REF, DecId, pParam->u32DrcPeakAmpRef, 0);
4870 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_TARGET, DecId, pParam->u32DrcPeakAmpTarget, 0);
4871 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_MAX_PACKET_SIZE, DecId, pParam->u32MaxPacketSize, 0);
4872 return TRUE;
4873 }
4874 else
4875 {
4876 return FALSE;
4877 }
4878 }
4879
HAL_MAD_SetAudioParam2(AUDIO_DEC_ID DecId,Audio_ParamType paramType,MS_VIRT Param)4880 MS_BOOL HAL_MAD_SetAudioParam2( AUDIO_DEC_ID DecId, Audio_ParamType paramType, MS_VIRT Param )
4881 {
4882 MS_BOOL bRet = TRUE;
4883
4884 HALMAD_CHECK_SHM_INIT;
4885
4886 switch ( paramType )
4887 {
4888 case Audio_ParamType_setAudioDecoder:
4889 {
4890 En_DVB_decSystemType eAudioFormat;
4891 switch ( (MMA_AudioType) Param )
4892 {
4893 case Audio_DEC_PCM:
4894 case Audio_DEC_XPCM: eAudioFormat = MSAPI_AUD_DVB_XPCM; break;
4895 case Audio_DEC_MPEG: eAudioFormat = MSAPI_AUD_DVB_MPEG; break;
4896 case Audio_DEC_MP3: eAudioFormat = MSAPI_AUD_DVB_MP3; break;
4897 case Audio_DEC_AC3: eAudioFormat = MSAPI_AUD_DVB_AC3; break;
4898 case Audio_DEC_AC3P: eAudioFormat = MSAPI_AUD_DVB_AC3P; break;
4899 case Audio_DEC_AAC_LC:
4900 case Audio_DEC_HEAAC_V1:
4901 case Audio_DEC_HEAAC_V2: eAudioFormat = MSAPI_AUD_DVB_AAC; break;
4902 case Audio_DEC_DOLBYPULSE: eAudioFormat = MSAPI_AUD_DVB_MS10_DDT; break;
4903 case Audio_DEC_WMA: eAudioFormat = MSAPI_AUD_DVB_WMA; break;
4904 case Audio_DEC_WMAPRO: eAudioFormat = MSAPI_AUD_DVB_WMA_PRO; break;
4905 case Audio_DEC_RA8: eAudioFormat = MSAPI_AUD_DVB_RA8LBR; break;
4906 case Audio_DEC_DTS: eAudioFormat = MSAPI_AUD_DVB_DTS; break;
4907 case Audio_DEC_FLAC: eAudioFormat = MSAPI_AUD_DVB_FLAC; break;
4908 case Audio_DEC_VORBIS: eAudioFormat = MSAPI_AUD_DVB_VORBIS; break;
4909 case Audio_DEC_AMR_NB: eAudioFormat = MSAPI_AUD_DVB_AMR_NB; break;
4910 case Audio_DEC_AMR_WB: eAudioFormat = MSAPI_AUD_DVB_AMR_WB; break;
4911 case Audio_DEC_DRA: eAudioFormat = MSAPI_AUD_DVB_DRA; break;
4912 case Audio_DEC_DTSLBR: eAudioFormat = MSAPI_AUD_DVB_DTSLBR; break;
4913 case Audio_DEC_KTV:
4914 case Audio_DEC_KTV2:
4915 case Audio_DEC_Dolby_TrueHD_Bypass_R2: eAudioFormat = MSAPI_AUD_DVB_DolbyTrueHDBypass; break;
4916 case Audio_DEC_DTS_HD_ADO_R2: eAudioFormat = MSAPI_AUD_DVB_DTSHDADO; break;
4917 default: eAudioFormat = MSAPI_AUD_DVB_INVALID; break;
4918 }
4919 bRet = HAL_AUDIO_SetSystem2(DecId, eAudioFormat);
4920 if ( bRet == TRUE )
4921 {
4922 g_AudioVars2->AudioDecStatus[DecId].bConnect= TRUE;
4923 g_AudioVars2->AudioDecStatus[DecId].eSourceType = E_AUDIO_INFO_MM_IN;
4924 g_AudioVars2->AudioDecStatus[DecId].eAudFormat = (En_DVB_decSystemType) eAudioFormat;
4925 }
4926 break;
4927 }
4928
4929 case Audio_ParamType_playControl:
4930 {
4931 if ( DecId == AU_DEC_ID3 )
4932 {
4933 switch ( (MMA_AUDIO_CONTROL) Param )
4934 {
4935 case MMA_STOP:
4936 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
4937 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
4938 {
4939 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_STOP);
4940 }
4941 g_AudioVars2->u16DecodeFrmCnt[DecId] = 0;
4942 g_AudioVars2->g_bSePlayFileFlag = FALSE;
4943 break;
4944
4945 case MMA_PLAY:
4946 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAY);
4947 break;
4948
4949 case MMA_PLAY_FILETSP:
4950 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFILETSP);
4951 break;
4952
4953 case MMA_RESYNC:
4954 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_RESYNC);
4955 break;
4956
4957 case MMA_PLAY_FILE:
4958 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFILE);
4959 break;
4960
4961 case MMA_BROWSE:
4962 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_STARTBROWSE);
4963 break;
4964
4965 case MMA_PAUSE:
4966 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PAUSE);
4967 break;
4968
4969 case MMA_PLAY_FRAME:
4970 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFRAME);
4971 break;
4972
4973 case MMA_PLAY_FRAME_GS:
4974 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
4975 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
4976 {
4977 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFRAME_GS);
4978 }
4979 break;
4980
4981 case MMA_PLAY_AD:
4982 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAY_AD);
4983 g_bR2Adec2AD = TRUE;
4984 break;
4985
4986 case MMA_STOP_AD:
4987 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_STOP_AD);
4988 g_bR2Adec2AD = FALSE;
4989 break;
4990
4991 case MMA_AVSYNC:
4992 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_AVSYNC);
4993 break;
4994
4995 case MMA_FREERUN:
4996 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_FREERUN);
4997 break;
4998
4999 default:
5000 break;
5001 }
5002 }
5003 else
5004 {
5005 switch ( (MMA_AUDIO_CONTROL) Param )
5006 {
5007 case MMA_STOP:
5008 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
5009 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
5010 {
5011 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
5012 }
5013 else
5014 {
5015 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d NOT used by ANDROID MM, used by %d !!\r\n", __FUNCTION__, DecId, g_AudioVars2->AudioDecStatus[DecId].eSourceType );
5016 }
5017 g_AudioVars2->u16DecodeFrmCnt[DecId] = 0;
5018 g_AudioVars2->g_bDecPlayFileFlag = FALSE;
5019 break;
5020
5021 case MMA_PLAY:
5022 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY);
5023 break;
5024
5025 case MMA_PLAY_FILETSP:
5026 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILETSP);
5027 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
5028 break;
5029
5030 case MMA_RESYNC:
5031 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_RESYNC);
5032 break;
5033
5034 case MMA_PLAY_FILE:
5035 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILE);
5036 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
5037 break;
5038
5039 case MMA_BROWSE:
5040 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STARTBROWSE);
5041 break;
5042
5043 case MMA_PAUSE:
5044 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PAUSE);
5045 break;
5046
5047 case MMA_PLAY_FRAME:
5048 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFRAME);
5049 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
5050 break;
5051
5052 case MMA_PLAY_FRAME_GS:
5053 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
5054 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
5055 {
5056 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFRAME_GS);
5057 }
5058 break;
5059
5060 case MMA_PLAY_AD:
5061 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY_AD);
5062 g_bR2Adec1AD = TRUE;
5063 break;
5064
5065 case MMA_STOP_AD:
5066 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP_AD);
5067 g_bR2Adec1AD = FALSE;
5068 break;
5069
5070 case MMA_AVSYNC:
5071 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_AVSYNC);
5072 break;
5073
5074 case MMA_FREERUN:
5075 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
5076 break;
5077
5078 default:
5079 break;
5080 }
5081 }
5082 break;
5083 }
5084
5085 case Audio_ParamType_SoundMode: //HAL_MAD_SetSoundMode
5086 {
5087 if ( DecId == AU_DEC_ID1 )
5088 {
5089 HAL_AUDIO_SeWriteMaskByte(REG_MB_MODE_SELECT, 0x03, (AU_DVB_MODE) Param);
5090 }
5091 else
5092 {
5093 HAL_AUDIO_SeWriteMaskByte(REG_MB_MODE_SELECT, 0x0C, ((AU_DVB_MODE)Param) << 2);
5094 }
5095 break;
5096 }
5097
5098 case Audio_ParamType_PTS_info:
5099 {
5100 HAL_AUDIO_PTS_info(Param);
5101 break;
5102 }
5103
5104 case Audio_ParamType_syncSTC:
5105 {
5106 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, DecId, Param, 0);
5107 break;
5108 }
5109
5110 case Audio_ParamType_acMode:
5111 {
5112 // DD, DDP, HEAAC
5113 switch ( (AUD_Dolby_SOUNDMODE) Param )
5114 {
5115 case AUD_Dolby_SOUNDMODE_LR: Param = 0x0; break;
5116 case AUD_Dolby_SOUNDMODE_LL: Param = 0x1; break;
5117 case AUD_Dolby_SOUNDMODE_RR: Param = 0x2; break;
5118 default: Param = 0x0; break;
5119 }
5120 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SOUND_MODE, AU_DEC_ID1, Param, 0);
5121 break;
5122 }
5123
5124 case Audio_ParamType_reqDataSize:
5125 {
5126 if ( DecId == AU_DEC_ID3 )
5127 {
5128 if ( (HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD) & 0x7F) != 0 )
5129 {
5130 break;
5131 }
5132 }
5133 else
5134 {
5135 if ( (HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD) & 0x7F) != 0 )
5136 {
5137 break;
5138 }
5139 }
5140
5141 switch ( (FILE_SIZE) Param )
5142 {
5143 case FILE_SIZE_64: Param = 0x0004; break;
5144 case FILE_SIZE_128: Param = 0x0008; break;
5145 case FILE_SIZE_256: Param = 0x0010; break;
5146 case FILE_SIZE_512: Param = 0x0020; break;
5147 case FILE_SIZE_1KB: Param = 0x0040; break;
5148 case FILE_SIZE_2KB: Param = 0x0080; break;
5149 case FILE_SIZE_4KB: Param = 0x0100; break;
5150 case FILE_SIZE_8KB: Param = 0x0200; break;
5151 case FILE_SIZE_16KB: Param = 0x0400; break;
5152 case FILE_SIZE_32KB: Param = 0x0800; break;
5153 case FILE_SIZE_64KB: Param = 0x1000; break;
5154 default: Param = 0x0100; break; // default = 2KB
5155 }
5156
5157 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, DecId, Param, 0);
5158 break;
5159 }
5160
5161 case Audio_ParamType_MM_FFx2:
5162 {
5163 if ( Param )
5164 {
5165 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, DecId, 1, 0);
5166 }
5167 else
5168 {
5169 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, DecId, 0, 0);
5170 }
5171 break;
5172 }
5173
5174 case Audio_ParamType_mute:
5175 {
5176 if ( Param )
5177 {
5178 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, DecId, 1, 0);
5179 }
5180 else
5181 {
5182 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, DecId, 0, 0);
5183 }
5184 break;
5185 }
5186
5187 case Audio_ParamType_predecode:
5188 //Currently, it is not used;
5189 break;
5190
5191
5192 case Audio_ParamType_esBuf_informDataRdy:
5193 if (DecId == AU_DEC_ID1)
5194 {
5195 MS_U32 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0);
5196 MS_U32 es_bufSz = ES1_DRAM_SIZE;
5197 MS_U32 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID1);
5198 es_wrPtr += es_reqsz;
5199
5200 if ( es_wrPtr >= es_bufSz )
5201 es_wrPtr -= es_bufSz;
5202
5203 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, es_wrPtr, 0);
5204 }
5205 else if (DecId == AU_DEC_ID2)
5206 {
5207 MS_U32 es_wrPtr, es_bufSz, es_reqsz;
5208 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID2, 0);
5209 es_bufSz = ES2_DRAM_SIZE;
5210 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID2);;
5211 es_wrPtr += es_reqsz;
5212
5213 if ( es_wrPtr >= es_bufSz )
5214 es_wrPtr -= es_bufSz;
5215 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID2, es_wrPtr, 0);
5216 }
5217 else if (DecId == AU_DEC_ID3)
5218 {
5219 MS_U32 es_wrPtr, es_bufSz, es_reqsz;
5220 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0);
5221 es_bufSz = ES3_DRAM_SIZE;
5222 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID3);;
5223 es_wrPtr += es_reqsz;
5224
5225 if ( es_wrPtr >= es_bufSz )
5226 es_wrPtr -= es_bufSz;
5227 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, es_wrPtr, 0);
5228 }
5229
5230 break;
5231
5232 case Audio_ParamType_setWMADecParam:
5233 bRet = HAL_MAD_WMA_SetASFParm2(DecId, (Audio_ASF_Param *) Param);
5234 break;
5235
5236 case Audio_ParamType_setCOOKDecParam:
5237 bRet = HAL_MAD_COOK_setParam2(DecId, (Audio_COOK_Param *) Param);
5238 break;
5239
5240 case Audio_ParamType_setXPCMDecParam:
5241 bRet = HAL_MAD_XPCM_setParam2(DecId, (Audio_XPCM_Param *) Param);
5242 break;
5243
5244 case Audio_ParamType_UNI_PCM3_Input_Addr:
5245 //Currently, it is not used;
5246 break;
5247
5248 case Audio_ParamType_UNI_NEED_DECODE_FRMCNT:
5249 HALMAD_PRINT("\r\n=====ID:%X Audio_ParamType_UNI_NEED_DECODE_FRMCNT =0x%X==========\r\n", (unsigned int)DecId,(unsigned int)Param);
5250 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_SETUP_DECODE_FRMCNT, DecId, Param, 0);
5251 break;
5252
5253 case Audio_ParamType_UNI_ES_Wptr: // OMX Wptr = offset to MAD start address
5254 if(DecId == AU_DEC_ID3) // ES For 2nd Main Decoder
5255 {
5256 Param = Param - (MS_U32)(ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + OFFSET_ES3_DRAM_ADDR);
5257 }
5258 else if(DecId == AU_DEC_ID2) // ES For 1st AD Decoder
5259 {
5260 Param = Param - (MS_U32)(ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + OFFSET_ES2_DRAM_ADDR);
5261 }
5262 else // ES For 1st Main Decoder
5263 {
5264 Param = Param - (MS_U32)(ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + OFFSET_ES1_DRAM_ADDR);
5265 }
5266 #if OMX_AUDIO_DEBUG
5267 HALMAD_PRINT("\r\n=====ID:%X Audio_ParamType_UNI_ES_Wptr =0x%X==========\r\n", (unsigned int)DecId , (unsigned int)Param);
5268 #endif
5269 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, DecId , Param, 0);
5270 break;
5271
5272 case Audio_ParamType_UNI_PCMOutCnt:
5273 {
5274 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_PCM_SET_OUTPUT_CNT, DecId , Param, 0);
5275 break;
5276 }
5277
5278 case Audio_ParamType_AllocDecoder:
5279 {
5280 HALMAD_PRINT("\r\n=====DecID:%X Audio_ParamType_AllocDecoder =0x%X==========\r\n", (unsigned int)DecId, (unsigned int)Param);
5281 MMA_AudioType eAudioType = (MMA_AudioType) Param;
5282 MMA_AudioType eAudioCaps;
5283
5284 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
5285
5286 if ( g_AudioVars2->AudioDecStatus[DecId].bConnect == TRUE )
5287 {
5288 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d in Used !!\r\n", __FUNCTION__, DecId);
5289 bRet = FALSE;
5290
5291 OS_RELEASE_MUTEX(_s32MutexLoadCode);
5292
5293 break;
5294 }
5295
5296 eAudioCaps = _GetAudioCaps(DecId);
5297
5298 if ( (eAudioCaps & eAudioType) == eAudioType )
5299 {
5300 En_DVB_decSystemType eAudioFormat;
5301 switch ( eAudioType )
5302 {
5303 case Audio_DEC_PCM:
5304 case Audio_DEC_XPCM: eAudioFormat = MSAPI_AUD_DVB_XPCM; break;
5305 case Audio_DEC_MPEG: eAudioFormat = MSAPI_AUD_DVB_MPEG; break;
5306 case Audio_DEC_MP3: eAudioFormat = MSAPI_AUD_DVB_MP3; break;
5307 case Audio_DEC_AC3: eAudioFormat = MSAPI_AUD_DVB_AC3; break;
5308 case Audio_DEC_AC3P: eAudioFormat = MSAPI_AUD_DVB_AC3P; break;
5309 case Audio_DEC_AAC_LC:
5310 case Audio_DEC_HEAAC_V1:
5311 case Audio_DEC_HEAAC_V2: eAudioFormat = MSAPI_AUD_DVB_AAC; break;
5312 case Audio_DEC_DOLBYPULSE: eAudioFormat = MSAPI_AUD_DVB_MS10_DDT; break;
5313 case Audio_DEC_WMA: eAudioFormat = MSAPI_AUD_DVB_WMA; break;
5314 case Audio_DEC_WMAPRO: eAudioFormat = MSAPI_AUD_DVB_WMA_PRO; break;
5315 case Audio_DEC_RA8: eAudioFormat = MSAPI_AUD_DVB_RA8LBR; break;
5316 case Audio_DEC_DTS: eAudioFormat = MSAPI_AUD_DVB_DTS; break;
5317 case Audio_DEC_FLAC: eAudioFormat = MSAPI_AUD_DVB_FLAC; break;
5318 case Audio_DEC_VORBIS: eAudioFormat = MSAPI_AUD_DVB_VORBIS; break;
5319 case Audio_DEC_AMR_NB: eAudioFormat = MSAPI_AUD_DVB_AMR_NB; break;
5320 case Audio_DEC_AMR_WB: eAudioFormat = MSAPI_AUD_DVB_AMR_WB; break;
5321 case Audio_DEC_DRA: eAudioFormat = MSAPI_AUD_DVB_DRA; break;
5322 case Audio_DEC_DTSLBR: eAudioFormat = MSAPI_AUD_DVB_DTSLBR; break;
5323 case Audio_DEC_KTV:
5324 case Audio_DEC_KTV2:
5325 case Audio_DEC_Dolby_TrueHD_Bypass_R2: eAudioFormat = MSAPI_AUD_DVB_DolbyTrueHDBypass; break;
5326 case Audio_DEC_DTS_HD_ADO_R2: eAudioFormat = MSAPI_AUD_DVB_DTSHDADO; break;
5327 default: eAudioFormat = MSAPI_AUD_DVB_INVALID; break;
5328 }
5329 bRet = HAL_AUDIO_SetSystem2(DecId, eAudioFormat);
5330 if ( bRet == TRUE )
5331 {
5332 g_AudioVars2->AudioDecStatus[DecId].bConnect = TRUE;
5333 g_AudioVars2->AudioDecStatus[DecId].eSourceType = E_AUDIO_INFO_MM_IN;
5334 g_AudioVars2->AudioDecStatus[DecId].eAudFormat =(En_DVB_decSystemType) eAudioFormat;
5335
5336 //patch for curry sub dtv because of hw unsupport dual dtv.------chasen.cai
5337 if (DecId == AU_DEC_ID3)
5338 {
5339 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES2_IsUsedBy_Dual, AU_DEC_ID3, 0, 0);
5340 }
5341 }
5342 }
5343 else
5344 {
5345 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d Audio Type (0x%08X) not Support !!\r\n", __FUNCTION__, DecId, g_AudioVars2->AudioDecStatus[DecId].eAudFormat );
5346 bRet = FALSE;
5347 }
5348
5349 OS_RELEASE_MUTEX(_s32MutexLoadCode);
5350
5351 break;
5352 }
5353
5354 case Audio_ParamType_FreeDecoder:
5355
5356 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
5357
5358 if ( g_AudioVars2->AudioDecStatus[DecId].bConnect == TRUE )
5359 {
5360 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
5361 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
5362 {
5363 memset(&g_AudioVars2->AudioDecStatus[DecId], 0, sizeof(AudioDecStatus_t));
5364 if ( DecId == AU_DEC_ID1 )
5365 {
5366 g_AudioVars2->g_DspCodeType = AU_DVB_NONE;
5367 }
5368 else if ( DecId == AU_DEC_ID3 )
5369 {
5370 g_AudioVars2->g_Dsp2CodeType = AU_DVB_NONE;
5371 }
5372 }
5373 else
5374 {
5375 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d NOT used by ANDROID MM, used by %d !!\r\n", __FUNCTION__, DecId, g_AudioVars2->AudioDecStatus[DecId].eSourceType);
5376 }
5377 }
5378 else
5379 {
5380 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d NOT in USED !!\r\n", __FUNCTION__, DecId);
5381 bRet = FALSE;
5382 }
5383
5384 OS_RELEASE_MUTEX(_s32MutexLoadCode);
5385
5386 break;
5387
5388 case Audio_ParamType_omx_spdif_mode:
5389
5390 if ( DecId <= AU_DEC_ID3 )
5391 {
5392 MS_U32 u32SpdifParam;
5393 Audio_OMX_SPDIF_Param eMode;
5394 u32SpdifParam = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, DecId, 0);
5395 eMode = (Audio_OMX_SPDIF_Param) Param;
5396 if ( eMode == Audio_OMX_SPDIF_ON )
5397 {
5398 u32SpdifParam |= 0x00000001;
5399 }
5400 else
5401 {
5402 u32SpdifParam &= 0xFFFFFFFE;
5403 }
5404 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d SpdifParam 0x%08X !!\r\n", __FUNCTION__, DecId, u32SpdifParam);
5405 if ( (bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, DecId, u32SpdifParam, 0)) != TRUE )
5406 {
5407 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d Fail to switch SPDIF mode to %s !!\r\n", __FUNCTION__, DecId, (eMode == Audio_OMX_SPDIF_ON ? "ON" : "OFF"));
5408 }
5409 }
5410 else
5411 {
5412 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Param Type %d DecId %d Un-Support Now !!\r\n", __FUNCTION__, Audio_ParamType_omx_spdif_mode, DecId);
5413 bRet = FALSE;
5414 }
5415 break;
5416
5417 case Audio_ParamType_omx_spdif_play:
5418
5419 if ( DecId <= AU_DEC_ID3 )
5420 {
5421 MS_U32 u32SpdifParam;
5422 Audio_OMX_SPDIF_Param eMode;
5423 u32SpdifParam = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, DecId , 0);
5424 eMode = (Audio_OMX_SPDIF_Param) Param;
5425 if ( eMode == Audio_OMX_SPDIF_PLAY )
5426 {
5427 u32SpdifParam |= 0x00000002;
5428 }
5429 else
5430 {
5431 u32SpdifParam &= 0xFFFFFFFD;
5432 }
5433 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d SpdifParam 0x%08X !!\r\n", __FUNCTION__, DecId, u32SpdifParam);
5434 if ( (bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, DecId , u32SpdifParam, 0)) != TRUE )
5435 {
5436 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d Fail to switch SPDIF mode to %s !!\r\n", __FUNCTION__, DecId, (eMode == Audio_OMX_SPDIF_ON ? "ON" : "OFF"));
5437 }
5438 }
5439 else
5440 {
5441 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Param Type %d DecId %d Un-Support Now !!\r\n", __FUNCTION__, Audio_ParamType_omx_spdif_play, DecId);
5442 bRet = FALSE;
5443 }
5444 break;
5445
5446 case Audio_ParamType_omx_spdif_pcmLevel:
5447
5448 if ( DecId <= AU_DEC_ID3 )
5449 {
5450 if ( (bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_PCM_LEVEL, DecId, Param, 0)) != TRUE )
5451 {
5452 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DecId %d Fail to setup PCM Level !!\r\n", __FUNCTION__, DecId);
5453 }
5454 }
5455 else
5456 {
5457 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Param Type %d DecId %d Un-Support Now !!\r\n", __FUNCTION__, Audio_ParamType_omx_spdif_pcmLevel, DecId);
5458 bRet = FALSE;
5459 }
5460 break;
5461
5462 case Audio_ParamType_trueHD_bypass_enable:
5463 if(Param)
5464 {
5465 g_AudioVars2->g_hbr_bypass_enable = true;
5466 }
5467 else
5468 {
5469 g_AudioVars2->g_hbr_bypass_enable = FALSE;
5470 }
5471 break;
5472
5473 /* TVOS2.0 DTV */
5474 case Audio_ParamType_tvos2_PCM_rdPtr:
5475 Param = Param - (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR);
5476 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TVOS2_PCM_RDPTR, DecId, Param, 0);
5477 break;
5478
5479 case Audio_ParamType_tvos2_DTV_SyncType:
5480 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TVOS2_DTV_SYNCTYPE, DecId, Param, 0);
5481 break;
5482
5483 case Audio_R2_SHM_PARAM_DOLBY_DRC_MODE:
5484 {
5485 bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DRC_MODE, DecId, Param, 0);
5486 }
5487 break;
5488
5489 case Audio_R2_SHM_PARAM_DOLBY_DMX_MODE:
5490 {
5491 if((DOLBY_DOWNMIX_MODE)Param == DOLBY_DOWNMIX_MODE_LORO)
5492 {
5493 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, DecId, 1, 0);
5494 }
5495 else
5496 {
5497 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, DecId, 0, 0);
5498 }
5499 }
5500 break;
5501
5502 case Audio_R2_SHM_PARAM_DOLBY_HIGH_CUT:
5503 {
5504 bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_HIGH_CUT, DecId, Param, 0);
5505 }
5506 break;
5507
5508 case Audio_R2_SHM_PARAM_DOLBY_LOW_BOOST:
5509 {
5510 bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_LOW_BOOST, DecId, Param, 0);
5511 }
5512 break;
5513
5514 case Audio_R2_SHM_PARAM_AD_Volume:
5515 {
5516 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AD_VOLUME, DecId, Param, 0);
5517 }
5518 break;
5519
5520 case Audio_R2_Set_NonPcm_Sel:
5521 {
5522 g_AudioVars2->g_R2_NonPcm_Sel = DecId;
5523 }
5524 break;
5525
5526 case Audio_ParamType_Abs_ReadReg_Target:
5527 {
5528 g_ReadTargetAddr = Param;
5529 }
5530 break;
5531
5532 case Audio_ParamType_Abs_WriteReg_Target:
5533 {
5534 g_WriteTargetAddr = Param;
5535 }
5536 break;
5537
5538 case Audio_ParamType_Abs_WriteReg_Value:
5539 {
5540 HAL_AUDIO_AbsWriteReg(g_WriteTargetAddr, Param);
5541 }
5542 break;
5543
5544 case Audio_ParamType_Abs_ReadXbox_Target:
5545 {
5546 g_ReadTargetXbox = Param;
5547 }
5548 break;
5549
5550 case Audio_ParamType_Abs_WriteXbox_Target:
5551 {
5552 g_WriteTargetXobx = Param;
5553 }
5554 break;
5555
5556 case Audio_ParamType_Abs_WriteXbox_Value:
5557 {
5558 HAL_MAD2_Write_DSP_Xbox(g_WriteTargetXobx, Param);
5559 }
5560 break;
5561
5562 case Audio_ParamType_omx_spdif_pause:
5563 {
5564 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_PAUSE, DecId, Param, 0);
5565 }
5566 break;
5567
5568 case Audio_ParamType_Audio_AAC_mm_single_frame_mode:
5569 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER, DecId, Param, 0);
5570 break;
5571
5572 case Audio_ParamType_Low_Latency_Limiter_ES_enable:
5573 {
5574 if(Param)
5575 {
5576 HAL_AUDIO_AbsWriteMaskReg(REG_R2_WORD_CTRL, 0x8000, 0x8000);
5577 }
5578 else
5579 {
5580 HAL_AUDIO_AbsWriteMaskReg(REG_R2_WORD_CTRL, 0x8000, 0x0000);
5581 }
5582 }
5583 break;
5584
5585 case Audio_ParamType_Low_Latency_Limiter_ES_Threshold:
5586 {
5587 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_LOW_LATENCY_LIMITER_ES_THRESHOLD, DecId, Param, 0);
5588 }
5589 break;
5590
5591 case Audio_ParamType_Low_Latency_Limiter_PCM_Threshold:
5592 {
5593 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_LOW_LATENCY_LIMITER_PCM_THRESHOLD, DecId, Param, 0);
5594 }
5595 break;
5596
5597 case Audio_ParamType_Low_Latency_Limiter_PCM_Skip_Target:
5598 {
5599 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_LOW_LATENCY_LIMITER_PCM_SKIP_TARGET, DecId, Param, 0);
5600 }
5601 break;
5602
5603 case Audio_ParamType_ES2_IsUsedBy_Dual:
5604 {
5605 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES2_IsUsedBy_Dual, DecId, Param, 0);
5606 }
5607 break;
5608
5609 case Audio_ParamType_ddp_disable_atmos:
5610 {
5611 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_DISABLE_ATMOS, DecId, Param, 0);
5612 }
5613 break;
5614
5615 case Audio_ParamType_Decoder_RepeatPlay:
5616 {
5617 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_REPEAT_MODE, DecId, Param, 0);
5618 }
5619 break;
5620
5621 /* not supported cmd */
5622 default:
5623 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: infoType[%x] not Supported\n", __FUNCTION__, paramType);
5624 bRet = FALSE;
5625 break;
5626 }
5627
5628 return bRet;
5629 }
5630
HAL_MAD_GetAudioInfo2(AUDIO_DEC_ID DecId,Audio_InfoType infoType,void * pInfo)5631 MS_BOOL HAL_MAD_GetAudioInfo2( AUDIO_DEC_ID DecId, Audio_InfoType infoType, void * pInfo )
5632 {
5633 MS_BOOL result = TRUE;
5634
5635 HALMAD_CHECK_SHM_INIT;
5636
5637 switch ( infoType )
5638 {
5639 case Audio_infoType_capability:
5640 {
5641 MMA_AudioType * pA_Type = (MMA_AudioType *) pInfo;
5642 *pA_Type = _GetAudioCaps(DecId);
5643 break;
5644 }
5645
5646 case Audio_infoType_DecStatus: //no change
5647 {
5648 MS_U8 * pResult = (MS_U8 *) pInfo;
5649 if ( HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, DecId) != 0 )
5650 {
5651 *pResult = 1;
5652 }
5653 else
5654 {
5655 *pResult = 0;
5656 }
5657 break;
5658 }
5659
5660 case Audio_infoType_AudioSyncStatus:
5661 {
5662 MS_U8 * pResult = (MS_U8 *) pInfo;
5663 if ( DecId == AU_DEC_ID3 )
5664 {
5665 if(HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_CMD)&0x80)
5666 *pResult = 0; // Free-run
5667 else
5668 *pResult = 1; // AV-sync
5669 }
5670 else
5671 {
5672 if(HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD)&0x80)
5673 *pResult = 0; // Free-run
5674 else
5675 *pResult = 1; // AV-sync
5676 }
5677 break;
5678 }
5679
5680 case Audio_infoType_SampleRate: //HAL_MAD_GetMadSamplingRate
5681 {
5682 MS_U32 fs_type = 0xFFFFFFFF;
5683 AUDIO_FS_TYPE * pFS_Type = (AUDIO_FS_TYPE *) pInfo;
5684
5685 fs_type = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, DecId);
5686
5687 *pFS_Type = AUDIO_FS_NONE;
5688
5689 switch ( fs_type )
5690 {
5691 case 8000: *pFS_Type = AUDIO_FS_8KHZ; break;
5692 case 11025: *pFS_Type = AUDIO_FS_11KHZ; break;
5693 case 12000: *pFS_Type = AUDIO_FS_12KHZ; break;
5694 case 16000: *pFS_Type = AUDIO_FS_16KHZ; break;
5695 case 22050: *pFS_Type = AUDIO_FS_22KHZ; break;
5696 case 24000: *pFS_Type = AUDIO_FS_24KHZ; break;
5697 case 32000: *pFS_Type = AUDIO_FS_32KHZ; break;
5698 case 44100: *pFS_Type = AUDIO_FS_44KHZ; break;
5699 case 48000: *pFS_Type = AUDIO_FS_48KHZ; break;
5700 case 96000: *pFS_Type = AUDIO_FS_96KHZ; break;
5701 default: *pFS_Type = AUDIO_FS_NONE; break;
5702 }
5703 break;
5704 }
5705
5706 case Audio_infoType_SoundMode:
5707 {
5708 MS_U16 * pRet = (MS_U16 *) pInfo;
5709 *pRet = HAL_AUDIO_ReadReg(REG_MB_MODE_SELECT) & 0x3;
5710
5711 break;
5712 }
5713
5714 case Audio_infoType_okFrmCnt:
5715 {
5716 MS_U32 * pRet = (MS_U32 *) pInfo;
5717 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, DecId);
5718
5719 break;
5720 }
5721
5722 case Audio_infoType_errFrmCnt:
5723 {
5724 MS_U32 * pRet = (MS_U32 *) pInfo;
5725 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, DecId);
5726
5727 break;
5728 }
5729
5730 case Audio_infoType_1ms_timeStamp:
5731 {
5732 MS_U32 * pRet = (MS_U32 *) pInfo;
5733
5734 MS_U32 pts;
5735 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, DecId);
5736 *pRet = pts/45;
5737
5738 break;
5739 }
5740
5741 case Audio_infoType_33bit_PTS:
5742 {
5743 MS_U64 * pRet = (MS_U64 *) pInfo;
5744
5745 if(DecId >= AU_DEC_MAX)
5746 {
5747 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DEC_ID[%d] not Supported\n", __FUNCTION__, DecId);
5748 return FALSE;
5749 }
5750
5751 *pRet = ((MS_U64)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, DecId))<<1;
5752 break;
5753 }
5754
5755 case Audio_infoType_33bit_latestPTS:
5756 {
5757 MS_U64 * pRet = (MS_U64 *) pInfo;
5758
5759 if(DecId >= AU_DEC_MAX)
5760 {
5761 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DEC_ID not Supported\n", __FUNCTION__ );
5762 return FALSE;
5763 }
5764
5765 *pRet = ((MS_U64)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, DecId))<<1;
5766 break;
5767 }
5768
5769 case Audio_infoType_BufferAddr:
5770 {
5771 MS_U32 * pRet = (MS_U32 *) pInfo;
5772 if ( DecId == AU_DEC_ID3 )
5773 {
5774 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0) + OFFSET_ES3_DRAM_ADDR;
5775 }
5776 else if ( DecId == AU_DEC_ID2)
5777 {
5778 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID2, 0) + OFFSET_ES2_DRAM_ADDR;
5779 }
5780 else
5781 {
5782 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0) + OFFSET_ES1_DRAM_ADDR;
5783 }
5784 break;
5785 }
5786
5787 case Audio_infoType_BufferSize:
5788 {
5789 MS_U32 * pRet = (MS_U32 *) pInfo;
5790 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, DecId);
5791
5792 break;
5793 }
5794
5795 case Audio_infoType_esBuf_req:
5796 {
5797 MS_BOOL bFlag = FALSE;
5798
5799 if ( DecId == AU_DEC_ID3 )
5800 {
5801 bFlag = HAL_AUDIO_GetPlayFileFlag(DSP_SE);
5802 }
5803 else
5804 {
5805 bFlag = HAL_AUDIO_GetPlayFileFlag(DSP_DEC);
5806 }
5807
5808 if ( bFlag )
5809 {
5810 Audio_MM_Data_Request * pDataReq = (Audio_MM_Data_Request *) pInfo;
5811
5812 if ( DecId == AU_DEC_ID3 )
5813 {
5814 pDataReq->U32WrtBytes = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID3);
5815 pDataReq->U32WrtAddr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID3, 0) + OFFSET_ES3_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
5816 }
5817 else
5818 {
5819 pDataReq->U32WrtBytes = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID1);
5820 pDataReq->U32WrtAddr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, AU_DEC_ID1, 0) + OFFSET_ES1_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
5821 }
5822
5823 result = TRUE;
5824 }
5825 else
5826 {
5827 result = FALSE;
5828 }
5829
5830 break;
5831 }
5832
5833 case Audio_infoType_esBuf_currLevel:
5834 {
5835 MS_U32 * pRet = (MS_U32 *) pInfo;
5836 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, DecId);
5837
5838 break;
5839 }
5840
5841 case Audio_infoType_pcmBuf_currLevel:
5842 {
5843 MS_U32 * pRet = (MS_U32 *) pInfo;
5844 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, DecId);
5845
5846 break;
5847 }
5848
5849 case Audio_infoType_get_audio_filter:
5850 {
5851 MS_U32 * pRet = (MS_U32 *) pInfo;
5852 if ( DecId == AU_DEC_ID3 )
5853 {
5854 *pRet = (MS_U32) FILTER_TYPE_AUDIO_2;
5855 }
5856 else if ( DecId == AU_DEC_ID1 )
5857 {
5858 *pRet = (MS_U32) FILTER_TYPE_AUDIO_1;
5859 }
5860 else
5861 {
5862 *pRet = (MS_U32) FILTER_TYPE_AUDIO_INVALID;
5863 }
5864
5865 break;
5866 }
5867
5868 case Audio_infoType_audio_unsupported:
5869 //Currently, it is not used;
5870 break;
5871
5872
5873 case Audio_infoType_UNI_PCM1_Info:
5874 {
5875 Audio_MM_PCM_Info * pPCMInfo = (Audio_MM_PCM_Info *) pInfo;
5876
5877 if ( HAL_AUDIO_GetUniDecodeFrameCnt(DecId) != g_AudioVars2->u16DecodeFrmCnt[DecId] )
5878 {
5879 g_AudioVars2->u16DecodeFrmCnt[DecId] = HAL_AUDIO_GetUniDecodeFrameCnt(DecId);
5880
5881 if ( DecId == AU_DEC_ID3 )
5882 {
5883 pPCMInfo->U32WrtAddr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM2_DRAM_ADDR+HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_ADDR, DecId);
5884 }
5885 else
5886 {
5887 pPCMInfo->U32WrtAddr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR+ HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_ADDR, DecId);
5888 }
5889 pPCMInfo->U32WrtBytes = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_SIZE, DecId);
5890 #if OMX_AUDIO_DEBUG
5891 HALMAD_PRINT("\r\n===DecId:%d Audio_infoType_UNI_PCM1_Info addr :0x%X size:0x%X DecodeFrame=0x%X==========\r\n", (MS_U32)DecId,(MS_U32)pPCMInfo->U32WrtAddr, (MS_U32)pPCMInfo->U32WrtBytes,(MS_U32)g_AudioVars2->u16DecodeFrmCnt[DecId]);
5892 #endif
5893 }
5894
5895 pPCMInfo->U32DecodeFrame = g_AudioVars2->u16DecodeFrmCnt[DecId];
5896 }
5897 break;
5898
5899 case Audio_infoType_UNI_PCM3_Level:
5900 {
5901 MS_U32 * pRet = (MS_U32 *) pInfo;
5902 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, DecId);
5903 break;
5904 }
5905
5906 case Audio_infoType_UNI_ES_Level:
5907 {
5908 MS_U32 * pRet = (MS_U32 *) pInfo;
5909 MS_U32 R2_ES_wrptr, R2_ES_rdptr;
5910 MS_S32 ES_level; //for high rate ES data input
5911 R2_ES_wrptr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, DecId, 0);
5912 R2_ES_rdptr = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_RD_PTR, DecId);
5913 ES_level = (MS_S32)(R2_ES_wrptr - R2_ES_rdptr);
5914
5915 if(ES_level < 0)
5916 {
5917 if(DecId == AU_DEC_ID1)
5918 ES_level += (ES1_DRAM_SIZE);
5919 else if(DecId == AU_DEC_ID2)
5920 ES_level += (ES2_DRAM_SIZE);
5921 else
5922 ES_level += (ES3_DRAM_SIZE);
5923 }
5924 *pRet = (MS_U32) ES_level;
5925 break;
5926 #if OMX_AUDIO_DEBUG
5927 HALMAD_PRINT("\r\n=====ID:%X Audio_infoType_UNI_ES_Level =0x%X==========\r\n", (MS_U32)DecId, (MS_U32)*pRet);
5928 #endif
5929 break;
5930 }
5931
5932 case Audio_infoType_UNI_ES_Base:
5933 {
5934 MS_U32 * pRet = (MS_U32 *) pInfo;
5935
5936 if ( DecId == AU_DEC_ID3 )
5937 {
5938 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES3_DRAM_ADDR);
5939 }
5940 else if ( DecId == AU_DEC_ID2 )
5941 {
5942 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES2_DRAM_ADDR);
5943 }
5944 else
5945 {
5946 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES1_DRAM_ADDR);
5947 }
5948 break;
5949 }
5950
5951 case Audio_infoType_UNI_ES_Size:
5952 {
5953 MS_U32 * pRet = (MS_U32 *) pInfo;
5954 if ( DecId == AU_DEC_ID3 )
5955 {
5956 *pRet = ES3_DRAM_SIZE;
5957 }
5958 else if ( DecId == AU_DEC_ID2 )
5959 {
5960 *pRet = ES2_DRAM_SIZE;
5961 }
5962 else
5963 {
5964 *pRet = ES1_DRAM_SIZE;
5965 }
5966 break;
5967 }
5968
5969 case Audio_infoType_UNI_PCM_Base:
5970 {
5971 MS_U32 * pRet = (MS_U32 *) pInfo;
5972 if ( DecId == AU_DEC_ID3 )
5973 {
5974 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM2_DRAM_ADDR);
5975 }
5976 else
5977 {
5978 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR);
5979 }
5980 break;
5981 }
5982
5983 case Audio_infoType_UNI_PCM_Size:
5984 {
5985 MS_U32 * pRet = (MS_U32 *) pInfo;
5986 if ( DecId == AU_DEC_ID3 )
5987 {
5988 *pRet = PCM2_DRAM_SIZE;
5989 }
5990 else
5991 {
5992 *pRet = PCM1_DRAM_SIZE;
5993 }
5994 break;
5995 }
5996
5997 case Audio_infoType_MadBaseAddr:
5998 {
5999 MS_U32 * pRet = (MS_U32 *) pInfo;
6000 if ( DecId == AU_DEC_ID3 )
6001 {
6002 *pRet = HAL_AUDIO_GetDspMadBaseAddr(DSP_ADV);
6003 }
6004 else
6005 {
6006 *pRet = HAL_AUDIO_GetDspMadBaseAddr(DSP_ADV);
6007 }
6008 break;
6009 }
6010
6011 case Audio_infoType_hashkey:
6012 {
6013 /* IP AUTH :
6014 * ip_auth[0] = 1: Disable AC3
6015 * ip_auth[1] = 1: Disable AC3P
6016 * ip_auth[2] = 1: Disable DDCO (HE-AAC)
6017 * ip_auth[3] = 1: Disable DTS
6018 * ip_auth[4] = 1: Disable Dolby MS10-DDT (HE-AAC)
6019 * ip_auth[5] = 1: Disable WMA
6020 * ip_auth[6] = 1: Disable DRA
6021 * ip_auth[7] = 1: Disable DTSLBR
6022 * ip_auth[8] = 1: Disable Generic HE-AAC
6023 * ip_auth[9] = 1: Disable Dolby MS11
6024 * ip_auth[10]= 1: Disable DTSE
6025 * ip_auth[11]= 1: Disable DTS NeoUltra
6026 * ip_auth[12]= 1: Demo Mode
6027 * ip_auth[13]= 1: Disable SRS_TSHD
6028 * ip_auth[14]= 1: Disable SRS_THEATERSOUND
6029 * ip_auth[15]= 1: Disable DTS StudioSound3D
6030 * ip_auth[16]= 1: Disable COOK
6031 * ip_auth[17]= 1: Disable DTS XLL
6032 * ip_auth[18]= 1: Disable MS12 LC profile
6033 * ip_auth[19]= 1: Disable MS12 C profile
6034 * ip_auth[20]= 1: Disable ABS3D
6035 * ip_auth[21]= 1: Disable MS12 B profile
6036 */
6037 Audio_Hashkey_Info * pHashkeyInfo = (Audio_Hashkey_Info *) pInfo;
6038 MS_U32 audio_ipauth = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_HASH_KEY, AU_DEC_ID1, 0);
6039
6040 pHashkeyInfo->U32IsHashkeySupported = TRUE;
6041
6042 switch ( pHashkeyInfo->U32Name )
6043 {
6044 case Audio_DEC_AC3:
6045 {
6046 if ( (audio_ipauth & 0x1) && (audio_ipauth & 0x200) )
6047 {
6048 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6049 }
6050 break;
6051 }
6052
6053 case Audio_DEC_AC3P:
6054 {
6055 if ( (audio_ipauth & 0x2) && (audio_ipauth & 0x200))
6056 {
6057 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6058 }
6059 break;
6060 }
6061
6062 case Audio_DEC_AAC_LC:
6063 case Audio_DEC_HEAAC_V1:
6064 case Audio_DEC_HEAAC_V2:
6065 case Audio_DEC_DOLBYPULSE:
6066 {
6067 if ( (audio_ipauth & 0x10) && (audio_ipauth & 0x100) )
6068 {
6069 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6070 }
6071 break;
6072 }
6073
6074 case Audio_DEC_WMA:
6075 case Audio_DEC_WMAPRO:
6076 {
6077 if ( (audio_ipauth & 0x20) )
6078 {
6079 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6080 }
6081 break;
6082 }
6083
6084 case Audio_DEC_DTS:
6085 {
6086 if ( (audio_ipauth & 0x8) )
6087 {
6088 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6089 }
6090 break;
6091 }
6092
6093 case Audio_DEC_DRA:
6094 {
6095 if ( (audio_ipauth & 0x40) )
6096 {
6097 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6098 }
6099 break;
6100 }
6101
6102 case Audio_DEC_RA8:
6103 {
6104 if ( (audio_ipauth & 0x10000) )
6105 {
6106 pHashkeyInfo->U32IsHashkeySupported = FALSE;
6107 }
6108 break;
6109 }
6110
6111 default:
6112 break;
6113 }
6114
6115 break;
6116 }
6117
6118 case Audio_infoType_AccumEsCnt:
6119 {
6120 MS_U32 * pRet = (MS_U32 *) pInfo;
6121 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, DecId);
6122 break;
6123 }
6124
6125 case Audio_infoType_Pcm_Output_Channel:
6126 {
6127 MS_U32 * pRet = (MS_U32 *) pInfo;
6128
6129 if(DecId >= AU_DEC_MAX)
6130 {
6131 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: DEC_ID[%d] not Supported\n", __FUNCTION__, DecId);
6132 return FALSE;
6133 }
6134
6135 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_OUTPUT_CHANNEL, DecId);
6136 break;
6137 }
6138
6139 case Audio_infoType_get_trueHD_bypass_enable:
6140 {
6141 MS_U8 * pRet = (MS_U8 *) pInfo;
6142 MS_U8 true_hd_support;
6143 true_hd_support = g_AudioVars2->stDigitalOutCodecCapability[1][CODEC_TRUEHD].support_codec;
6144
6145 if ((g_AudioVars2->g_hbr_bypass_enable) && (true_hd_support != 2))
6146 {
6147 *pRet = true;
6148 }
6149 else
6150 {
6151 *pRet = false;
6152 }
6153 break;
6154 }
6155
6156 case Audio_infoType_Decoder_Type:
6157 {
6158 AUDIO_DSP_CODE_TYPE eDecoder = AU_DVB_STANDARD_INVALID;
6159 MS_U32 u32DecoderType = 0;
6160 MS_U32 *pRet = (MS_U32 *)pInfo;
6161
6162 switch (DecId)
6163 {
6164 case AU_DEC_ID1:
6165 {
6166 eDecoder = g_AudioVars2->g_DspCodeType;
6167 break;
6168 }
6169
6170 case AU_DEC_ID3:
6171 {
6172 eDecoder = g_AudioVars2->g_Dsp2CodeType;
6173 break;
6174 }
6175
6176 default:
6177 {
6178 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: invalid ID (%d)\n", __FUNCTION__, DecId);
6179 result = FALSE;
6180 break;
6181 }
6182 }
6183
6184 if (result == TRUE)
6185 {
6186 switch (eDecoder)
6187 {
6188 case AU_DVB_STANDARD_DTS:
6189 case AU_DVB_STANDARD_DTSLBR:
6190 {
6191 u32DecoderType = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DTS_ES_TYPE, DecId) & 0x00FFFFFF;
6192
6193 switch (u32DecoderType)
6194 {
6195 case DTS_TYPE_CORE:
6196 case DTS_TYPE_CORE_XLL:
6197 {
6198 *pRet = AUDIO_DTS_TYPE_CORE;
6199 break;
6200 }
6201
6202 case DTS_TYPE_LBR:
6203 {
6204 *pRet = AUDIO_DTS_TYPE_LBR;
6205 break;
6206 }
6207
6208 case DTS_TYPE_XLL:
6209 {
6210 *pRet = AUDIO_DTS_TYPE_HD;
6211 break;
6212 }
6213
6214 default:
6215 {
6216 result = FALSE;
6217 break;
6218 }
6219 }
6220 break;
6221 }
6222
6223 default:
6224 {
6225 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: invalid ID (%d)\n", __FUNCTION__, DecId);
6226 result = FALSE;
6227 break;
6228 }
6229 }
6230 }
6231
6232 break;
6233 }
6234
6235 case Audio_infoType_syncSTC_in_mmTs:
6236 {
6237 MS_U32 * pRet = (MS_U32 *) pInfo;
6238 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, DecId, 0);
6239 break;
6240 }
6241 /* TVOS2.0 DTV */
6242 case Audio_infoType_tvos2_PCM1_Info:
6243 {
6244 Audio_MM_PCM_Info * pPCMInfo = (Audio_MM_PCM_Info *) pInfo;
6245 MS_U64 u64cpts=0;
6246
6247 pPCMInfo->U32WriteAddr = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_PCM_WRPT, DecId) + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR;
6248 u64cpts = ((MS_U64)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_CPTS, DecId))<<1;
6249 u64cpts = STC_TICK_TO_NS(u64cpts);
6250 pPCMInfo->S64CPTS = (MS_S64)u64cpts;
6251 pPCMInfo->U32FrameSize = (MS_U32)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_PCM_FRAMESIZE, DecId);
6252 pPCMInfo->U32Channels = (MS_U32)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_PCM_CH, DecId);
6253 pPCMInfo->U32Bps = 2;
6254 pPCMInfo->U32SampleRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, DecId);
6255 break;
6256 }
6257
6258 case Audio_infoType_Abs_ReadReg:
6259 {
6260 MS_U16 * pRet = (MS_U16 *) pInfo;
6261
6262 *pRet = HAL_AUDIO_AbsReadReg(g_ReadTargetAddr);
6263 }
6264 break;
6265
6266 case Audio_infoType_Abs_ReadXbox:
6267 {
6268 MS_U32 * pRet = (MS_U32 *) pInfo;
6269
6270 *pRet = HAL_MAD2_Read_DSP_Xbox(g_ReadTargetXbox);
6271 }
6272 break;
6273
6274 case Audio_infoType_get_parser_info:
6275 {
6276 MS_U32 * pRet = (MS_U32 *) pInfo;
6277 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PARSER_INFO, DecId);
6278 break;
6279 }
6280
6281 case Audio_infoType_Is_Audio_Sync:
6282 {
6283 if ( DecId == AU_DEC_ID3 )
6284 {
6285 long long tmp = 0;
6286 MS_U32 i, no_sync_cnt = 0;
6287
6288 tmp = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC2_1ms_timeStamp);
6289 if (tmp == 0)
6290 {
6291 result = FALSE;
6292 break;
6293 }
6294
6295 tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, AU_DEC_ID3)&0x0F;
6296 if (tmp != 2)
6297 {
6298 result = FALSE;
6299 break;
6300 }
6301
6302 for (i = 0;i<3;i++)
6303 {
6304 tmp = HAL_MAD_GetCommInfo (Audio_Comm_infoType_ADEC2_33bit_STCPTS_DIFF);
6305 if ((tmp >= (100*90))||(tmp <= (-100*90))) //100ms
6306 {
6307 no_sync_cnt ++;
6308 }
6309 }
6310
6311 if (no_sync_cnt == 0)
6312 {
6313 result = TRUE;
6314 }
6315 }
6316 else
6317 {
6318 long long tmp = 0;
6319 MS_U32 i, no_sync_cnt = 0;
6320
6321 tmp = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_1ms_timeStamp);
6322 if (tmp == 0)
6323 {
6324 result = FALSE;
6325 break;
6326 }
6327
6328 tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, AU_DEC_ID1)&0x0F;
6329 if (tmp != 2)
6330 {
6331 result = FALSE;
6332 break;
6333 }
6334
6335 for (i = 0;i<3;i++)
6336 {
6337 tmp = HAL_MAD_GetCommInfo (Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
6338 if ((tmp >= (100*90))||(tmp <= (-100*90))) //100ms
6339 {
6340 no_sync_cnt ++;
6341 }
6342 }
6343
6344 if (no_sync_cnt == 0)
6345 {
6346 result = TRUE;
6347 }
6348 }
6349 break;
6350 }
6351
6352 /* UART INFO */
6353 case Audio_infoType_R2_uart_buf_base:
6354 {
6355 MS_U32 * pRet = (MS_U32 *) pInfo;
6356 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UART_BUF_BASE, DecId);
6357 }
6358 break;
6359
6360 case Audio_infoType_R2_uart_buf_size:
6361 {
6362 MS_U32 * pRet = (MS_U32 *) pInfo;
6363 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UART_BUF_SIZE, DecId);
6364 }
6365 break;
6366
6367 case Audio_infoType_R2_uart_buf_wptr:
6368 {
6369 MS_U32 * pRet = (MS_U32 *) pInfo;
6370 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UART_BUF_WPTR, DecId);
6371 }
6372 break;
6373
6374 /* not support cmd */
6375 default:
6376 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: cmd not Supported\n", __FUNCTION__ );
6377 result = FALSE;
6378 break;
6379 }
6380
6381 return result;
6382 }
6383
6384 //====== STAOS PIP END 2012/02/01 ========
6385
HAL_MAD_CommonCmd_TrasferData(void * pSrc,MS_U32 u32SrcSize,void * pDst,MS_U32 u32DstSzie)6386 MS_S32 HAL_MAD_CommonCmd_TrasferData(void *pSrc, MS_U32 u32SrcSize, void *pDst, MS_U32 u32DstSzie)
6387 {
6388 MS_S32 s32Ret = 0;
6389 MS_U32 u32TransferSize = 0;
6390
6391 if (pSrc == NULL)
6392 {
6393 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pSrc should not be NULL!\n", __FUNCTION__);
6394 return -A_EFAULT;
6395 }
6396
6397 if (u32SrcSize == 0)
6398 {
6399 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32SrcSize should not be zero!\n", __FUNCTION__);
6400 return -A_EINVAL;
6401 }
6402
6403 if (pDst == NULL)
6404 {
6405 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pDst should not be NULL!\n", __FUNCTION__);
6406 return -A_EFAULT;
6407 }
6408
6409 if (u32DstSzie == 0)
6410 {
6411 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32DstSzie should not be zero!\n", __FUNCTION__);
6412 return -A_EINVAL;
6413 }
6414
6415 u32TransferSize = (u32SrcSize < u32DstSzie) ? u32SrcSize : u32DstSzie;
6416 memcpy(((MS_U8 *)pDst + 8), ((MS_U8 *)pSrc + 8),(u32TransferSize - 8));
6417 if(u32SrcSize < u32DstSzie)
6418 {
6419 memset(((MS_U8 *)pDst + u32TransferSize), 0x00, (u32DstSzie - u32SrcSize));
6420 }
6421
6422 return s32Ret;
6423 }
6424
HAL_MAD_SetAudioOutputDeviceSelection(AUDIO_OUTPUT_DEVICE_SELECTION_t * pAudioOutputDeviceSelection)6425 MS_S32 HAL_MAD_SetAudioOutputDeviceSelection(AUDIO_OUTPUT_DEVICE_SELECTION_t * pAudioOutputDeviceSelection)
6426 {
6427 MS_S32 s32Ret = 0;
6428 MS_U32 u32UserStrucVer = 0;
6429 MS_U32 u32UserStrucSize = 0;
6430 MS_U32 u32DriverStrucVer = 0;
6431 MS_U32 u32DriverStrucSize = 0;
6432
6433 HALMAD_CHECK_SHM_INIT;
6434
6435 if (pAudioOutputDeviceSelection == NULL)
6436 {
6437 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pAudioOutputDeviceSelection should not be NULL!\n", __FUNCTION__);
6438 return -A_EFAULT;
6439 }
6440
6441 u32UserStrucVer = pAudioOutputDeviceSelection->u32StructVersion;
6442 u32DriverStrucVer = g_AudioVars2->g_AudioOutputDeviceSelection.u32StructVersion;
6443
6444 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (u32DriverStrucVer & AUDIO_MAJOR_VERSION_MASK))
6445 {
6446 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__,u32UserStrucVer,u32DriverStrucVer);
6447 return -A_EPERM;
6448 }
6449
6450 u32UserStrucSize = pAudioOutputDeviceSelection->u32StructSize;
6451 u32DriverStrucSize = g_AudioVars2->g_AudioOutputDeviceSelection.u32StructSize;
6452
6453 s32Ret = HAL_MAD_CommonCmd_TrasferData(pAudioOutputDeviceSelection, u32UserStrucSize, &g_AudioVars2->g_AudioOutputDeviceSelection, u32DriverStrucSize);
6454 if (s32Ret < 0)
6455 {
6456 return s32Ret;
6457 }
6458
6459 if ((g_AudioVars2->g_AudioOutputDeviceSelection.u32OutputDeviceSelection & AUDIO_OUTPUT_DEVICE_SPEAKER) == 0)
6460 {
6461 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC1, DISABLE, 0);
6462 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC2, DISABLE, 0);
6463
6464 HAL_ADVSOUND_SubProcessEnable(DOLBY_DAP_EN, FALSE);
6465 }
6466 else
6467 {
6468 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC1, ENABLE, 0);
6469 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC2, ENABLE, 0);
6470
6471 HAL_ADVSOUND_SubProcessEnable(DOLBY_DAP_EN, g_AudioVars2->g_DolbyDAPEnable);
6472 }
6473
6474 return s32Ret;
6475 }
6476
HAL_MAD_SpecifyDigitalOutputCodec(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t * pAudioSpecifiedDigitalOutput,DIGITAL_OUTPUT_TYPE u32DigitalOutputType)6477 MS_S32 HAL_MAD_SpecifyDigitalOutputCodec(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t * pAudioSpecifiedDigitalOutput, DIGITAL_OUTPUT_TYPE u32DigitalOutputType)
6478 {
6479 MS_S32 s32Ret = 0;
6480 MS_U32 u32UserStrucVer = 0;
6481 MS_U32 u32UserStrucSize = 0;
6482 MS_U32 u32DriverStrucVer = 0;
6483 MS_U32 u32DriverStrucSize = 0;
6484 AUDIO_SPECIFIED_DIGITAL_OUTPUT_t tSpecifiedDigitalOutput;
6485
6486 HALMAD_CHECK_SHM_INIT;
6487
6488 if (pAudioSpecifiedDigitalOutput == NULL)
6489 {
6490 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pAudioSpecifiedDigitalOutput should not be NULL!\n", __FUNCTION__);
6491 return -A_EFAULT;
6492 }
6493
6494 u32UserStrucVer = pAudioSpecifiedDigitalOutput->u32StructVersion;
6495 u32DriverStrucVer = g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32StructVersion;
6496
6497 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (u32DriverStrucVer & AUDIO_MAJOR_VERSION_MASK))
6498 {
6499 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__,u32UserStrucVer,u32DriverStrucVer);
6500 return -A_EPERM;
6501 }
6502
6503 u32UserStrucSize = pAudioSpecifiedDigitalOutput->u32StructSize;
6504 u32DriverStrucSize = g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32StructSize;
6505
6506 memset((void *)&tSpecifiedDigitalOutput, 0x00, sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t));
6507 tSpecifiedDigitalOutput.u32StructVersion = AUDIO_SPECIFIED_DIGITAL_OUTPUT_VERSION;
6508 tSpecifiedDigitalOutput.u32StructSize = sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t);
6509
6510 s32Ret = HAL_MAD_CommonCmd_TrasferData(pAudioSpecifiedDigitalOutput, u32UserStrucSize, &tSpecifiedDigitalOutput, u32DriverStrucSize);
6511 if (s32Ret < 0)
6512 {
6513 return s32Ret;
6514 }
6515
6516 switch (u32DigitalOutputType)
6517 {
6518 case DIGITAL_SPDIF_OUTPUT:
6519 {
6520 g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32SpdifOutputCodec = tSpecifiedDigitalOutput.u32SpdifOutputCodec;
6521 break;
6522 }
6523
6524 case DIGITAL_HDMI_ARC_OUTPUT:
6525 {
6526 g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32HdmiArcOutputCodec = tSpecifiedDigitalOutput.u32HdmiArcOutputCodec;
6527 break;
6528 }
6529
6530 case DIGITAL_HDMI_OUTPUT:
6531 {
6532 g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32HdmiTxOutputCodec = tSpecifiedDigitalOutput.u32HdmiTxOutputCodec;
6533 break;
6534 }
6535
6536 default:
6537 {
6538 memcpy((void *)&g_AudioVars2->g_AudioSpecifiedDigitalOutput, (void *)&tSpecifiedDigitalOutput, sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t));
6539 break;
6540 }
6541 }
6542
6543 return s32Ret;
6544 }
6545
HAL_MAD_DAP_Control(AUDIO_DAP_CONTROL_t * pDapControl)6546 MS_S32 HAL_MAD_DAP_Control(AUDIO_DAP_CONTROL_t * pDapControl)
6547 {
6548 MS_S32 s32Ret = 0;
6549 MS_U32 u32UserStrucVer = 0;
6550 MS_U8 u8PcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
6551
6552 HALMAD_CHECK_SHM_INIT;
6553
6554 if (pDapControl == NULL)
6555 {
6556 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pDapControl should not be NULL!\n", __FUNCTION__);
6557 return -A_EFAULT;
6558 }
6559
6560 u32UserStrucVer = pDapControl->u32StructVersion;
6561
6562 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_DAP_CONTROL_VERSION & AUDIO_MAJOR_VERSION_MASK))
6563 {
6564 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__, u32UserStrucVer, AUDIO_DAP_CONTROL_VERSION);
6565 return -A_EPERM;
6566 }
6567
6568 if (pDapControl->u32McuCtrlEnable == TRUE)
6569 {
6570 if (pDapControl->u32MultiChannelEnable == TRUE)
6571 {
6572 u8PcmRenderControl = 1; //multi-channel mode
6573 }
6574 else
6575 {
6576 u8PcmRenderControl = 2; //stereo mode
6577 }
6578 }
6579 else
6580 {
6581 u8PcmRenderControl = 0; //decoder mode
6582 }
6583
6584 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8PcmRenderControl << 1));
6585
6586 return s32Ret;
6587 }
6588
HAL_MAD_GetDecoderInfo(AUDIO_DECODER_INFO_t * pDecoderInfo)6589 MS_S32 HAL_MAD_GetDecoderInfo(AUDIO_DECODER_INFO_t * pDecoderInfo)
6590 {
6591 MS_S32 s32Ret = 0;
6592 MS_U32 u32UserStrucVer = 0;
6593 MS_U32 u32UserStrucSize = 0;
6594 MS_U32 u32DriverStrucVer = 0;
6595 MS_U32 u32DriverStrucSize = 0;
6596 Audio_id adec_id = 0;
6597 AUDIO_DECODER_INFO_t tDecoderInfo;
6598
6599 if (pDecoderInfo == NULL)
6600 {
6601 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pChannelInfo should not be NULL!\n", __FUNCTION__);
6602 return -A_EFAULT;
6603 }
6604
6605 u32UserStrucVer = pDecoderInfo->u32StructVersion;
6606 u32DriverStrucVer = AUDIO_DECODER_INFO_VERSION;
6607
6608 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (u32DriverStrucVer & AUDIO_MAJOR_VERSION_MASK))
6609 {
6610 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__, u32UserStrucVer, AUDIO_DECODER_INFO_VERSION);
6611 return -A_EPERM;
6612 }
6613
6614 u32UserStrucSize = pDecoderInfo->u32StructSize;
6615 u32DriverStrucSize = sizeof(AUDIO_DECODER_INFO_t);
6616 adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(pDecoderInfo->u8DecId);
6617
6618 memset((void *)&tDecoderInfo, 0x00, sizeof(AUDIO_DECODER_INFO_t));
6619 tDecoderInfo.u32StructVersion = AUDIO_DECODER_INFO_VERSION;
6620 tDecoderInfo.u32StructSize = sizeof(AUDIO_DECODER_INFO_t);
6621 tDecoderInfo.u8DecId = pDecoderInfo->u8DecId;
6622 tDecoderInfo.bForceMchOutput = TRUE;
6623 tDecoderInfo.u32PcmOutputType = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OMX_MCH_VALID, adec_id);
6624
6625 s32Ret = HAL_MAD_CommonCmd_TrasferData(&tDecoderInfo, u32DriverStrucSize, pDecoderInfo, u32UserStrucSize);
6626
6627 return s32Ret;
6628 }
6629
HAL_MAD_CommonCmd(AUDIO_COMMON_CMD_t * cmd)6630 MS_S32 HAL_MAD_CommonCmd(AUDIO_COMMON_CMD_t * cmd)
6631 {
6632 char *name = (char *)cmd->u8StrCmd;
6633 MS_S32 s32Ret = 0;
6634
6635 if (cmd == NULL)
6636 {
6637 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! cmd should not be NULL!\n", __FUNCTION__);
6638 return -A_EFAULT;
6639 }
6640
6641 if (!(strcmp(name, "SetAudioOutputDeviceSelection")))
6642 {
6643 s32Ret = HAL_MAD_SetAudioOutputDeviceSelection((AUDIO_OUTPUT_DEVICE_SELECTION_t *)cmd->pData);
6644 }
6645 else if (!(strcmp(name, "SpecifyDigitalOutputCodec")))
6646 {
6647 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_MAX_OUTPUT);
6648 }
6649 else if (!(strcmp(name, "SpecifyDigitalOutputCodec_Spdif")))
6650 {
6651 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_SPDIF_OUTPUT);
6652 }
6653 else if (!(strcmp(name, "SpecifyDigitalOutputCodec_HdmiArc")))
6654 {
6655 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_HDMI_ARC_OUTPUT);
6656 }
6657 else if (!(strcmp(name, "SpecifyDigitalOutputCodec_HdmiTx")))
6658 {
6659 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_HDMI_OUTPUT);
6660 }
6661 else if (!(strcmp(name, "DAP_Control")))
6662 {
6663 s32Ret = HAL_MAD_DAP_Control((AUDIO_DAP_CONTROL_t *) cmd->pData);
6664 }
6665 else if (!(strcmp(name, "GetDecoderInfo")))
6666 {
6667 s32Ret = HAL_MAD_GetDecoderInfo((AUDIO_DECODER_INFO_t *) cmd->pData);
6668 }
6669 else
6670 {
6671 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): Error! Unsupportted Common Cmd (%s)!!\n", __FUNCTION__, cmd->u8StrCmd);
6672 s32Ret = -A_EINVAL;
6673 }
6674
6675 return s32Ret;
6676 }