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