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