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) 2006-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 // (�uMStar Confidential Information�v) 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 #include <stdio.h>
96 #include <string.h>
97 #include <fcntl.h>
98
99 #include "MFE_chip.h"
100 #include "mfe_common.h"
101 #include "mfe_type.h"
102 #include "madp_ms_dprintf.h"
103
104 #include "mdrv_mfe_io.h"
105 #include "mdrv_mfe_st.h"
106 #include "madp_mfe.h"
107
108 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
109 #include <sys/mman.h>
110 #include <sys/types.h>
111 #include <sys/stat.h>
112 #include <unistd.h>
113 #include <sys/prctl.h> // use for thread naming
114 #if defined(_KERNEL_MODE_)
115 #include <poll.h> // poll
116 #include "madp_system.h"
117 #include "mdrv_system.h"
118 #include "madp_msos.h"
119 #include <sys/ioctl.h>
120 #include "../mpool/madp_mpool.h"
121 #else
122 #include "MsCommon.h"
123 #include "MsIRQ.h"
124 #include "MsOS.h"
125 #include "drvMMIO.h"
126 #include "drvMIU.h"
127 #endif
128 #define cyg_current_time() MsOS_GetSystemTime()
129 #endif
130
131 #if defined(_MFE_BIG2_)&&defined(_MIPS_PLATFORM_)
132 #include "pthread_map.h"
133 #include "shellcfg.h"
134 #else
135 #include <pthread.h>
136 #endif
137
138 #ifdef _ENC_PERFORMANCE_
139 #define EMI_MEASURE
140 #include "frame_in.h"
141 #include "chiptop.h"
142 #endif
143
144 #include <assert.h>
145 //#ifdef _FILE_IN_
146 //#include <file.h>
147 //#endif
148
149 #if defined(_FILE_IN_) ||defined(_YUVGEN_)
150 #include "yuvgen.h"
151 #endif
152 #if defined(_YUVGEN_)||defined(_FILE_IN_)
153 // File IN
154 FILE_IN_INFO mfe_file_in;
155 #endif
156 //#define _EN_DROPFRAME_
157 #define VIDEO_SHIFT 0//21
158 int video_shift_frame;
159
160 static int mfe_fd = 0;
161
162 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
163 #define MFE_DEVICE "/dev/mfe"
164 #endif
165
166 #ifndef VVOIP_INTERFACE1
167 typedef enum {
168 MFE_Invalid = 0x00,
169 MFE_Init = 0x20,
170 MFE_Idle =0x30,
171 MFE_Busy =0x40,
172 MFE_DeInit =0x50,
173 MFE_Error =0x60
174 } MFE_STATE;
175 #endif
176 MFE_STATE mfe_state = MFE_Invalid;
177
178 #include <semaphore.h>
179 //#include <linux/time.h> //added
180 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
181 MFE_S32 madp_sem_input; // Input frame
182 static pthread_mutex_t s32MFEMutex;
183 //MS_S32 s32MFEMutex;
184 #else
185 sem_t madp_sem_input; // Input frame
186 #endif
187
188
189 #if defined(CUSTOM_INTERFACE1)||defined(VVOIP_INTERFACE1)
190 static void* g_pCustomCtx;
191 static StreamCallback g_StreamCallBackFunc;
192 #endif // CUSTOM_INTERFACE1
193
194 #if defined(VVOIP_INTERFACE1)
195 static CleanCallback g_CleanCallBackFunc;
196 MFE_U32 VVOIP_MFE_input_VAaddr;
197 #endif
198
199 //////////////////////////////////////////////////////////////////////////
200 // MUX related
201 //////////////////////////////////////////////////////////////////////////
202
203 MFE_U8* mux_frame_buf; //video tempral bitstream buffer
204
205 #ifdef _MUXTS_
206 #include "TsMuxer.h"
207 #endif
208 #ifdef _MUX_WITH_AUDIO_
209 #include "Framer.h"
210 #endif
211
212 #ifdef AUDIO_MUX_DUMP
213 FILE* AUDIO_DUMP;
214 #endif
215 #ifdef _MUXTS_
216 #define DEFAULT_VIDEO_ID CODEC_ID_VIDEO_MPEG4
217 //#define DEFAULT_VIDEO_ID CODEC_ID_VIDEO_MPEG2
218 //
219 #define DEFAULT_AUDIO_ID CODEC_ID_AUDIO_MP2
220 //
221 #define DEFAULT_VIDEO_BITRATE 4096000
222 #define DEFAULT_AUDIO_BITRATE 192000//384000//256000 test.MP2//160000
223 //
224 #define MPEG_TS_CLOCKRATE 90000
225 #define DEFAULT_VIDEO_FRAMERATE 30
226 #define DEFAULT_AUDIO_FREQUENCY 48000//32000 test.MP2//44100
227 //
228 #define DOWNLOADSTREAM_BUFFER 384000
229 #define DOWNLOADSTREAM_MAX_SESSION 96000
230 #define MAX_INDEX_RING_LENGTH 64
231 #define AUDIO_ONESHOT_FRAMECOUNT 4
232 // DEBUG
233 // #define DEBUG_SEGMENT 1000000
234
235 StreamContext g_avs[2];
236 MediaContext g_av_ct;
237 AUContext g_vid_auctx, g_aud_auctx;
238
239 boolean g_bHasVideoFrame, g_bHasAudioFrame;
240 MFE_U32 g_nAvailAudFrames;
241 boolean g_bMuxTS = 0;
242 #ifdef _MUX_WITH_AUDIO_
243 BitstreamInfo g_AudInfo; //ts_VidInfo,
244 #endif
245 Outstream g_outstream;
246 // IndexRingEntry *ts_index_ring;
247 // MPEGTS specific
248 MpegTSWrite ts_muxinfo;
249 avmux_st g_avmux;
250 /*
251 #ifdef DEBUG_READ
252 MFE_U8 *ts_read_sbuf;
253 #define READ_TIMER 4 // smaller means more frequent reading.
254 FILE* ts_read_fp;
255 MFE_U8 *ts_read_ptr;
256 MFE_U32 ts_readsize;
257 // MFE_U32 ts_loopcount;
258 #endif
259 */
260 int mux_prev_pos=0;
261 int mux_curr_pos=0;
262 int mux_frame_size;
263
264 int mux_audframecount;
265 // int mux_vidframecount;
266 int mux_audioframesize;
267
268 #define MIN_SESSION_SIZE 256000
269 int mux_total_len;
270 #endif // _MUXTS_
271
272 #if defined(_MUX_WITH_AUDIO_) && defined(_FILE_IN_)
273 FILE* mux_mp2file = NULL;
274 #endif
275
276
277 static pthread_t thread_info; //stephen
278
279 int Encode_stop=1;
280 #define ADP_STATE_WAIT_GETBITS 0
281 #define ADP_STATE_WAIT_FRAMEDONE 1
282 #define ADP_STATE_WAIT_INPUT 2
283 int enc_state=0; //0: input_frame available and already frame done, 0: wait getbits 1: wait frame done 2: wait inputframe
284 int Madp_enc_frame_count=0;
285 int Madp_out_frame_count=0;
286 PVR_Info appPVR_Info;
287
288 #if defined(NEW_APVR_INTERFACE)
289 VENC_INFRAME_INFO mfe_pInfo;
290 GET_YUVFRAME_FUNC MAdp_MFE_GetDiBuffStatus/*(void*ppInfo)*/;
291 CLEAR_BUF_STATUS_FUNC MAdp_MFE_ClearDiBuffStatus/*(MFE_U16 DIP_status,void* ppInfo)*/;
292 THUMB_NAIL thumb_nail;
293 GET_AUDIO_DATA_FUNC MAdp_MFE_ReadAudioData/*(MFE_U32 *AudAddr, MFE_U32 *AudSize, MFE_U32 *AudPTS, MFE_U8 *AudFrameCnt)*/;
294 #endif
295 MFE_U32 DIP_Total_Num = 6; //the same to DIP_DI_BUFFER_COUNT in madp_apvr.c
296
297
298 MFE_INPUT_BUF_INFO madp_mfe_buff_info;
299
300 extern char* in_file_name;
301
302
MAdp_MFE_Mutex_Init(void)303 static MFE_BOOL MAdp_MFE_Mutex_Init(void)
304 {
305 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
306 pthread_mutex_init(&s32MFEMutex, NULL);
307 /*
308 ms_dprintf(ADP_L1,"Before MsOS_CreateMutex!!\n");
309 s32MFEMutex = MsOS_CreateMutex(E_MSOS_FIFO, "MFE_Mutex", MSOS_PROCESS_SHARED);
310 ms_dprintf(ADP_L1,"After MsOS_CreateMutex!!\n");
311 if(s32MFEMutex < 0)
312 {
313 ms_dprintf(ADP_L1,"%s MsOS_CreateMutex failed!!\n", __FUNCTION__);
314 return FALSE;
315 }
316 */
317 return TRUE;
318 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
319 no support now!
320 #endif
321
322 }
323
MAdp_MFE_Mutex_Delete(void)324 static MFE_BOOL MAdp_MFE_Mutex_Delete(void)
325 {
326 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
327 return pthread_mutex_destroy(&s32MFEMutex);
328 //return MsOS_DeleteMutex(s32MFEMutex);
329
330 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
331 no support now!
332 #endif
333
334 }
335
MAdp_MFE_Mutex_Lock(void)336 static MFE_BOOL MAdp_MFE_Mutex_Lock(void)
337 {
338 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
339 /*
340 if (s32MFEMutex != -1)
341 {
342 return MsOS_ObtainMutex(s32MFEMutex, MSOS_WAIT_FOREVER);
343 }
344 else
345 {
346 return FALSE;
347 }
348 */
349 return pthread_mutex_lock(&s32MFEMutex);
350 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
351 no support now!
352 #endif
353
354 }
355
MAdp_MFE_Mutex_Unlock(void)356 static MFE_BOOL MAdp_MFE_Mutex_Unlock(void)
357 {
358 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
359 /*
360 if (s32MFEMutex != -1)
361 {
362 return MsOS_ReleaseMutex(s32MFEMutex);
363 }
364 else
365 {
366 return FALSE;
367 }
368 */
369 return pthread_mutex_unlock(&s32MFEMutex);
370
371 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
372 no support now!
373 #endif
374
375 }
376
MAdp_MFE_Change_State(MFE_STATE in_state)377 static MFE_BOOL MAdp_MFE_Change_State(MFE_STATE in_state)
378 {
379 /*
380 if(MAdp_MFE_Mutex_Lock()== FALSE)
381 return FALSE;
382 mfe_state = in_state;
383 if(MAdp_MFE_Mutex_Unlock()== FALSE)
384 return FALSE;
385 */
386 MAdp_MFE_Mutex_Lock();
387 mfe_state = in_state;
388 MAdp_MFE_Mutex_Unlock();
389 return TRUE;
390 }
391
MAdp_MFE_Sem_Init(void)392 static void MAdp_MFE_Sem_Init(void)
393 {
394 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
395 madp_sem_input = MsOS_CreateSemaphore(0,E_MSOS_FIFO ,"ADP_MFE_SEM") ;
396 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
397 sem_init(&madp_sem_input, 0, 0);
398 #endif
399
400 }
401
MAdp_MFE_Sem_Wait(void)402 static void MAdp_MFE_Sem_Wait(void)
403 {
404 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
405 MsOS_ObtainSemaphore(madp_sem_input, MSOS_WAIT_FOREVER);
406 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
407 sem_wait(&madp_sem_input);
408 #endif
409
410 }
411
412
MAdp_MFE_Sem_Destroy(void)413 static void MAdp_MFE_Sem_Destroy(void)
414 {
415 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
416 MsOS_ReleaseSemaphore(madp_sem_input);
417 MsOS_DeleteSemaphore(madp_sem_input);
418 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
419 sem_destroy(&madp_sem_input);
420 #endif
421
422 }
423
MAdp_MFE_Sem_Wake_Up(void)424 static void MAdp_MFE_Sem_Wake_Up(void)
425 {
426 #if defined(_MFE_UTOPIA_)&&defined(_MIPS_PLATFORM_)
427 MsOS_ReleaseSemaphore(madp_sem_input);
428 #elif !(defined(_MFE_T8_)&&defined(_KERNEL_MODE_))
429 wake_up(&madp_sem_input);
430 #endif
431
432 }
433
my_malloc(MFE_U32 * ppVAStart,unsigned int size,const char * msg)434 MFE_U8 *my_malloc(MFE_U32* ppVAStart,unsigned int size,const char* msg)
435 {
436 MFE_U8 *ret = (MFE_U8 *)*ppVAStart;
437 ms_dprintf(ADP_L1,"MFE ADP,my_malloc[%s]: VA_START:0x%x,SIZE:0x%x\n", msg, (unsigned int)ret, size);
438
439 #ifdef MEM_CHECK
440 ms_dprintf(ADP_L1,"my_malloc:Check mem set.\n");
441 memset(ret, 0xFF, size);
442 sleep(100000);
443 #endif
444
445 *ppVAStart += size;
446 return ret;
447 }
448
449
450 #if defined(_MFE_BIG2_) && defined(_MIPS_PLATFORM_)
pthread_join(cyg_handle_t thread_hdl_obj,void ** status)451 int pthread_join(cyg_handle_t thread_hdl_obj, void **status)
452 {
453 int ret, thread_timeout=0;
454 //ret : 1 is success, others fail
455 do {
456 ret = cyg_thread_check_exit(thread_hdl_obj);
457 if (ret == 1)
458 break;
459 thread_timeout++;
460 cyg_thread_delay(10);
461 } while (!ret && (thread_timeout < 200));
462 return ret;
463 }
464
pthread_exit(int i)465 void pthread_exit(int i)
466 {
467 cyg_thread_exit();
468 }
469 #endif
470
471 #ifdef _WIN32
472 MFE_U8* WIN32_MMAP_FPGA_VBASE;
473 MFE_U8* WIN32_MMAP_MFE_VBASE;
474 #define MFE_DRAM_BASE 0x00010000
475 #define MAdp_MPool_Init()
MAdp_MPool_GetBlockVa(MFE_U32 opt,MFE_U32 * buf_start,MFE_U32 * buf_size)476 int MAdp_MPool_GetBlockVa(MFE_U32 opt, MFE_U32 *buf_start, MFE_U32 *buf_size)
477 {
478 *buf_start = (MFE_U32)(MFE_U8 *)malloc((*buf_size)*sizeof(MFE_U8));
479 assert(buf_start);
480 if (opt==E_SYS_MMAP_MFE)
481 WIN32_MMAP_MFE_VBASE = (MFE_U8*)*buf_start;
482 // else if (opt==E_SYS_MMAP_FPGA_POOL_BASE)
483 // WIN32_MMAP_FPGA_VBASE = *buf_start;
484 if ((MFE_U8*)*buf_start!=NULL)
485 return 1;
486 else
487 return 0;
488 }
MAdp_MPool_VA2PA_Win32(MFE_U32 a)489 MFE_U32 MAdp_MPool_VA2PA_Win32(MFE_U32 a)
490 {
491 return (MFE_U32)(a) - (MFE_U32)(WIN32_MMAP_MFE_VBASE) + (MFE_U32)(MFE_DRAM_BASE);
492 }
MAdp_MPool_PA2VA_Win32(MFE_U32 a)493 MFE_U32 MAdp_MPool_PA2VA_Win32(MFE_U32 a)
494 {
495 return (MFE_U32)(a) - (MFE_U32)(MFE_DRAM_BASE) + (MFE_U32)(WIN32_MMAP_MFE_VBASE);
496 }
497
498 #elif defined(_MFE_T8_) && defined(_MIPS_PLATFORM_)&&(!defined(_KERNEL_MODE_))
499 #define MAdp_MPool_Init()
500 #elif defined(_MFE_BIG2_)
501 #define MAdp_MPool_Init()
MAdp_MPool_GetBlockVa(int opt,MFE_U32 * buf_start,MFE_U32 * buf_size)502 int MAdp_MPool_GetBlockVa(int opt, MFE_U32 *buf_start, MFE_U32 *buf_size)
503 {
504 *buf_start = DRAM_BASE+MEM_LOGMAPPHY;//0x20000;
505 return 1;
506 }
507 #endif
508
509 #if defined(_MEM_READ_WRITE_CONTROL_)
510
MFE_Flush_memory(MFE_U32 u32Start_VA,MFE_U32 u32Size)511 static __inline MFE_BOOL MFE_Flush_memory( MFE_U32 u32Start_VA, MFE_U32 u32Size )
512 {
513
514 #if defined(_MFE_UTOPIA_)
515 return MsOS_Dcache_Flush(u32Start_VA ,u32Size);
516 #elif defined(_MFE_T8_) && defined(_MIPS_PLATFORM_)&&defined(_KERNEL_MODE_)
517 //LG
518 return MAdp_SYS_FlushMemory();
519 #endif
520 }
521
522 #endif
523
524 #ifdef _MUXTS_
525
MPEG2TS_Set_DownloadPID(MFE_U32 Video_PID,MFE_U32 Audio_PID)526 void MPEG2TS_Set_DownloadPID(MFE_U32 Video_PID, MFE_U32 Audio_PID)
527 {
528 g_avs[0].pid = Video_PID; // 0 means TSMUX decides it.
529 g_avs[1].pid = Audio_PID; // 0 means TSMUX decides it.
530 }
531
532 #ifdef _MUX_WITH_AUDIO_
MAdp_init_audio_info(BitstreamInfo * pBsInfo,MFE_U32 nAudBitrate,MFE_U32 nSampleFreq)533 void MAdp_init_audio_info(BitstreamInfo* pBsInfo, MFE_U32 nAudBitrate, MFE_U32 nSampleFreq)
534 {
535 pBsInfo->nAudFrameSize = (nAudBitrate>>3) * SAMPLES_IN_AUDIO_FRAME / nSampleFreq;
536 pBsInfo->pCur = pBsInfo->pLast = pBsInfo->pBits;
537 pBsInfo->pEnd = pBsInfo->pBits + pBsInfo->nFileSize;
538 pBsInfo->nFrameIndex = 0;
539 pBsInfo->bPrevVOP = 0;
540 ms_dprintf(ADP_L1,"Audio file size: %d %d %d %d %d %d\n", pBsInfo->nFileSize, pBsInfo->nAudFrameSize, pBsInfo->pCur[10]
541 , pBsInfo->pCur[11], pBsInfo->pCur[12], pBsInfo->pCur[13]);
542 }
543
MPEG2TS_Init_AudioData_Func(GET_AUDIO_DATA_FUNC getAudioDataCallbackFunc)544 void MPEG2TS_Init_AudioData_Func(GET_AUDIO_DATA_FUNC getAudioDataCallbackFunc)
545 {
546 MAdp_MFE_ReadAudioData = (GET_AUDIO_DATA_FUNC)getAudioDataCallbackFunc;
547 }
548 #endif
549
init_tsmux_plugin(avmux_st * prec_mxint,MediaContext * pav_info)550 void init_tsmux_plugin(avmux_st *prec_mxint, MediaContext *pav_info)
551 {
552 ms_dprintf(ADP_L1,"init_tsmux_plugin\n");
553 prec_mxint->mctx = pav_info;
554 prec_mxint->write_open = tsmux_open;
555 prec_mxint->write_packet = tsmux_write_packet;
556 prec_mxint->write_close = tsmux_close;
557 prec_mxint->write_pause = 0;
558 prec_mxint->write_resume = 0;
559 // read
560 prec_mxint->read = mux_read;
561 prec_mxint->read_done = mux_readdone;
562 }
563
MAdp_TSMUX_Init(MUX_TYPE MuxType,CodecID VideoType,CodecID AudioType,S32 Width,S32 Height,float Framerate,MFE_U8 * g_read_bbuf,IndexRingEntry * g_index_ring,MFE_U32 read_bbuf_size,MFE_U32 index_ring_size)564 void MAdp_TSMUX_Init(MUX_TYPE MuxType, CodecID VideoType, CodecID AudioType,
565 S32 Width, S32 Height, float Framerate,
566 MFE_U8 *g_read_bbuf, IndexRingEntry *g_index_ring,
567 MFE_U32 read_bbuf_size, MFE_U32 index_ring_size)
568 {
569 pavmux_st pavmux = &g_avmux;
570
571 switch (MuxType) {
572 case MUX_TS:
573 g_av_ct.muxinfo = &ts_muxinfo;
574 break;
575 #ifdef _EN_AVIMUX_
576 case MUX_AVI:
577 g_av_ct.muxinfo = &avi_muxinfo;
578 break;
579 #endif
580 default:
581 assert(0);
582 break;
583 }
584
585 #ifdef AUDIO_MUX_DUMP
586 AUDIO_DUMP = fopen("audio_dump.mp2","wb");
587 #endif
588 // Muxer configuration
589 g_avs[0].codec_type = CODEC_TYPE_VIDEO;
590 g_avs[0].codec_id = (VideoType==CODEC_ID_NONE ? DEFAULT_VIDEO_ID : VideoType);
591 g_avs[0].bit_rate = DEFAULT_VIDEO_BITRATE;
592 g_avs[0].framerate = Framerate;
593 g_avs[1].codec_type = CODEC_TYPE_AUDIO;
594 g_avs[1].codec_id = (AudioType==CODEC_ID_NONE ? DEFAULT_AUDIO_ID : AudioType);
595 g_avs[1].bit_rate = DEFAULT_AUDIO_BITRATE;
596 // g_avs[1].framerate = Framerate;
597 #ifdef _EN_AVIMUX_
598 if (MuxType==1) {
599 g_avs[0].width = Width;
600 g_avs[0].height = Height;
601 g_avs[0].framerate = Framerate;
602
603 g_avs[1].samplerate = DEFAULT_AUDIO_FREQUENCY;
604 }
605 #endif
606 // MPEG2TS_Set_DownloadPID(gDefaultVideoPID, gDefaultAudioPID);
607 //
608 g_av_ct.outstream = &g_outstream;
609 g_av_ct.streams[0] = &g_avs[0];
610 g_vid_auctx.stream_index = 0;
611 g_vid_auctx.pts = g_vid_auctx.dts = DEFAULT_START_PTS;
612 g_av_ct.streams[1] = &g_avs[1];
613 g_aud_auctx.stream_index = 1;
614 g_aud_auctx.pts = g_aud_auctx.dts = DEFAULT_START_PTS;
615 //
616 #ifdef _MUX_WITH_AUDIO_
617 g_av_ct.stream_count = 2;
618
619 #ifdef _FILE_IN_
620 // Open audio file
621 mux_mp2file = fopen("test.MP2", "rb");
622 if (mux_mp2file==0) {
623 ms_dprintf(ADP_L1,"no audio file input\n");
624 return;
625 }
626 fseek(mux_mp2file, 0, SEEK_END);
627 g_AudInfo.nFileSize = ftell(mux_mp2file);
628 fseek(mux_mp2file, 0, SEEK_SET);
629 g_AudInfo.pBits = my_malloc(&madp_mfe_buff_info.mfe_buf_va, 400000,"audInfo");
630 //assert(ts_AudInfo.nFileSize<400000);
631 fread(g_AudInfo.pBits, sizeof(MFE_U8), MUX(g_AudInfo.nFileSize<400000, g_AudInfo.nFileSize, 400000), mux_mp2file);
632 MAdp_init_audio_info(&g_AudInfo, DEFAULT_AUDIO_BITRATE, DEFAULT_AUDIO_FREQUENCY);
633 #else
634 g_AudInfo.nFileSize = 0;
635 #endif
636
637 if (DEFAULT_AUDIO_ID==CODEC_ID_AUDIO_MP2)
638 g_AudInfo.GetFrameBits = GetOneFrameBitsMP1A;
639 else
640 assert(0);
641
642 mux_audframecount = 0;
643 g_AudInfo.bIsAudio = 1;
644
645 //ASSERT(0!=OpenMappedFile(gMuxAudioFileName, &ts_AudInfo));
646 #else
647 g_av_ct.stream_count = 1;
648 g_aud_auctx.pts = MAXVALUE_PTS;//(S64)(0x7FFFFFFFFFFFFFFFLL);
649 #endif
650 // ts_read_bbuf = my_malloc(DOWNLOADSTREAM_BUFFER);
651 assert(g_read_bbuf!=0);
652 g_outstream.bbuffer = g_read_bbuf;
653 // ts_outstream.bbufend_ptr = ts_outstream.bbuffer + DOWNLOADSTREAM_BUFFER;
654 g_outstream.bbufend_ptr = g_outstream.bbuffer + read_bbuf_size;
655
656 //ts_index_ring = (IndexRingEntry*)my_malloc(sizeof(IndexRingEntry)*MAX_INDEX_RING_LENGTH);
657 assert(g_index_ring!=0);
658 g_outstream.index_ring = g_index_ring;
659 //ts_outstream.ring_size = MAX_INDEX_RING_LENGTH;
660 g_outstream.ring_size = index_ring_size;
661 #ifdef _EN_AVIMUX_
662 if (MuxType==MUX_AVI) {
663 avi_muxinfo.hbuffer = (MFE_U8*)malloc(16*32);
664 assert(avi_muxinfo.hbuffer);
665 avi_muxinfo.hbuf_size = 16*32;
666 avi_muxinfo.xbuffer = (MFE_U8*)malloc(700000);
667 assert(avi_muxinfo.xbuffer);
668 avi_muxinfo.xbuf_size = 700000;
669 }
670 #endif
671 switch(MuxType) {
672 case MUX_TS:
673 init_tsmux_plugin(pavmux, &g_av_ct);
674 break;
675 #ifdef _EN_AVIMUX_
676 case MUX_AVI:
677 init_avimux_plugin(pavmux, &g_av_ct);
678 pavmux->endinfo = (void*)&avi_endinfo;
679 break;
680 #endif
681 default:
682 assert(0);
683 break;
684 }
685
686 // ts_VidInfo.bIsAudio = 0;
687 // ts_VidInfo.nFrameIndex = 0;
688 #ifdef _MUXTS_
689 g_nAvailAudFrames = 0;
690 #endif
691 // Initial muxer
692 // mpegts_mux_start(&g_av_ct);
693
694 pavmux->write_open(pavmux);
695
696
697 //init appPVR_Info
698 appPVR_Info.width = Width;
699 appPVR_Info.height = Height;
700 appPVR_Info.BitsBuffStart =0;
701 appPVR_Info.BitsBuffSize =0;
702
703 appPVR_Info.nDispWidth = Width;
704 appPVR_Info.nDispHeight = Height; // Display resolution
705 appPVR_Info.nBufWidth = Width;
706 appPVR_Info.nBufHeight = Height; // Image buffer resolution (aligned to 16 or 32 byte, depends on nCodecType)
707 /*
708 // GOP
709 appPVR_Info.nPbetweenI=9;
710 appPVR_Info.nBbetweenP=0;
711 // Rate control
712 appPVR_Info.FrameRatex100 =(int) (Framerate*100);
713 appPVR_Info.nBitrate = 10000000;
714 appPVR_Info.nTotalFrames = 5; // -1 means infinite. 0 is not allowed.
715 */
716 // GOP
717 appPVR_Info.nPbetweenI=89;
718 appPVR_Info.nBbetweenP=0;
719 // Rate control
720 appPVR_Info.FrameRatex100 =(int) (Framerate*100);
721 appPVR_Info.nBitrate = 1000000;
722 appPVR_Info.nTotalFrames = 5; // -1 means infinite. 0 is not allowed.
723
724 // MFE new settings
725 if(VideoType == CODEC_ID_VIDEO_MPEG4){
726 appPVR_Info.nCodecType =0;
727 appPVR_Info.bInterlace = 1;
728 MAdp_MFE_Init(appPVR_Info.FrameRatex100 / 100,0,4);
729
730 }
731 else if(VideoType == CODEC_ID_VIDEO_H264 ){
732 appPVR_Info.bInterlace =0; // interlace is no implement now.
733 appPVR_Info.nCodecType =2;
734 MAdp_MFE_Init(appPVR_Info.FrameRatex100 / 100,2,4);
735 }
736 else{
737 ms_dprintf(ADP_L1,"[MUX_INIT]VideoType error!\n");
738 assert(0);
739 }
740
741
742 }
743
744
745 /*
746 MUX algorithm
747 while (video_avail || audio_avail) {
748 if (video_avail && audio_avail) {
749 use particular mux algorithm based on PTS difference
750 } else if (video_avail) {
751 mux 1 video frame
752 } else if (audio_avail) {
753 mux 4 audio frame
754 }
755 }
756 */
MAdp_TSMUX_AddFrame(MFE_U32 Vaddr,MFE_U32 Aaddr,MFE_U32 Vsize,MFE_U8 vop_type)757 int MAdp_TSMUX_AddFrame(MFE_U32 Vaddr, MFE_U32 Aaddr, MFE_U32 Vsize, MFE_U8 vop_type)
758 {
759 pavmux_st pavmux = &g_avmux;
760 #ifdef DEBUG_SEGMENT
761 int left_size;
762 #endif
763 // int audio_ready=1;
764 int pre_audioframe = mux_audframecount;
765 int audio_data_avail=0;
766 boolean bHasVideoFrame = 1;
767 boolean bHasAudioFrame =
768 #if defined(_MUX_WITH_AUDIO_)
769 1;
770 #else
771 0;
772 #endif
773 S64 tmp = AUDIO_ONESHOT_FRAMECOUNT*1152*MPEG_TS_CLOCKRATE/DEFAULT_AUDIO_FREQUENCY;
774 S64 tmp2 = g_vid_auctx.pts-g_aud_auctx.pts;
775
776 #ifdef AUDIO_MUX_DUMP
777 int x=0,t;
778 #endif
779
780 while (bHasVideoFrame==1 || bHasAudioFrame==1) {
781 // ms_dprintf(ADP_L1,"MUX time: %d\n", cyg_current_time());
782 #ifdef WIN32
783 ms_dprintf(ADP_L2,"vid_pts:0x%I64x aud_pts:0x%I64x AvailAudFrame:%d Vsize:0x%x 0x%I64x 0x%I64x %dn"
784 #else
785 ms_dprintf(ADP_L2,"vid_pts:0x%llx aud_pts:0x%llx AvailAudFrame:%d Vsize:0x%x 0x%llx 0x%llx %d\n"
786 #endif
787 , g_vid_auctx.pts, g_aud_auctx.pts,(unsigned int) g_nAvailAudFrames, (unsigned int)Vsize , tmp2 , tmp, (tmp2 > tmp) );
788
789 if ( (tmp2 > tmp ) || (/*Vsize==0 &&*/ g_nAvailAudFrames==0)){
790 g_nAvailAudFrames = AUDIO_ONESHOT_FRAMECOUNT;
791 ms_dprintf(ADP_L2,"g_nAvailAudFrames = AUDIO_ONESHOT_FRAMECOUNT;\n");
792 }
793 if (Vsize==0){
794 bHasVideoFrame = 0;
795 ms_dprintf(ADP_L2,"bHasVideoFrame = 0;\n");
796 }
797 if (bHasVideoFrame && ( g_nAvailAudFrames==0 || bHasAudioFrame==0)) {
798 mux_frame_size = Vsize;//mux_curr_pos-mux_prev_pos;
799 ms_dprintf(ADP_L2,"Vsize:%d %d\n", mux_frame_size, vop_type);
800 if (Madp_out_frame_count==0) // The very first frame
801 g_vid_auctx.index_type = INDEX_TYPE_SEQ_I_PIC;
802 else {
803 switch (vop_type)
804 {
805 case I_VOP:
806 g_vid_auctx.index_type = INDEX_TYPE_I_PIC; break;
807 case P_VOP:
808 g_vid_auctx.index_type = INDEX_TYPE_P_PIC; break;
809 case B_VOP:
810 g_vid_auctx.index_type = INDEX_TYPE_B_PIC; break;
811 }
812 }
813 #ifdef DEBUG_SEGMENT
814 left_size = mux_frame_size;
815 while (left_size>0) {
816 g_vid_auctx.access_unit = (MFE_U8 *)(Vaddr + (mux_frame_size - left_size));
817 g_vid_auctx.unit_size = left_size>DEBUG_SEGMENT ? DEBUG_SEGMENT : left_size;
818 g_vid_auctx.pts = (S64)((/*g_VidInfo.nFrameIndex-1*/Madp_out_frame_count) * MPEG_TS_CLOCKRATE / g_avs[0].framerate) + DEFAULT_START_PTS;
819 g_vid_auctx.dts = g_vid_auctx.pts;
820 g_vid_auctx.first_segment = (left_size==(int)Vsize ? 1 : 0);
821 g_vid_auctx.last_segment = (left_size-g_vid_auctx.unit_size==0 ? 1 : 0);
822 pavmux->write_packet(pavmux, &g_vid_auctx);
823 left_size -= g_vid_auctx.unit_size;
824 ms_dprintf(ADP_L2,"mux video frame PTS: %lld %d %d\n", g_vid_auctx.dts, Madp_out_frame_count, g_vid_auctx.unit_size);
825 }
826 #else
827 g_vid_auctx.access_unit = (MFE_U8 *)Vaddr; //mux_frame_buf;
828 g_vid_auctx.unit_size = Vsize; //mux_frame_size;
829 g_vid_auctx.pts = (Madp_out_frame_count) * MPEG_TS_CLOCKRATE / g_avs[0].framerate + DEFAULT_START_PTS;
830 g_vid_auctx.dts = g_vid_auctx.pts;
831 g_vid_auctx.first_segment = 1;
832 g_vid_auctx.last_segment = 1;
833 // mpegts_mux_writeAU(pavmux, &g_vid_auctx);
834 pavmux->write_packet(pavmux, &g_vid_auctx);
835 ms_dprintf(ADP_L2,"access: 0x%x %x %x %x %x\n", Vaddr,(unsigned int) g_vid_auctx.access_unit[10]
836 ,(unsigned int) g_vid_auctx.access_unit[11],(unsigned int) g_vid_auctx.access_unit[12], (unsigned int)g_vid_auctx.access_unit[13]);
837 #ifdef _WIN32
838 ms_dprintf(ADP_L2,"mux video frame PTS: %I64d %d %d\n", g_vid_auctx.dts, g_vid_auctx.unit_size, Madp_out_frame_count);
839 #else
840 ms_dprintf(ADP_L2,"mux video frame PTS: %lld %d %d\n", g_vid_auctx.dts, g_vid_auctx.unit_size, Madp_out_frame_count);
841 #endif
842 #endif
843 pre_audioframe = mux_audframecount; //prevent mux too many audio, and no time to mux video
844 bHasVideoFrame = 0;
845 //Vsize = 0;
846 //break;
847 }
848 else if (g_nAvailAudFrames) {
849 #ifdef _MUX_WITH_AUDIO_
850 #ifndef _FILE_IN_
851 MFE_U32 AudPTS;
852 MFE_U8 AudFrame;
853 if (mux_audframecount>(pre_audioframe+3) && Vsize==0) {
854 //prevent mux too many audio, and no time to mux video
855 ms_dprintf(ADP_L2,"audio has mux 4 frames %d %d\n", mux_audframecount, g_nAvailAudFrames);
856 break;
857 }
858 if (g_AudInfo.nFileSize==0) {
859 MAdp_MFE_ReadAudioData((MFE_U32 *)(&(g_AudInfo.pBits)), &g_AudInfo.nFileSize, &AudPTS, &AudFrame);
860 ms_dprintf(ADP_L1,"read AudioData from AuEnc 0x%x 0x%x %d %d\n", (MFE_U32)g_AudInfo.pBits, g_AudInfo.nFileSize, AudFrame, AudPTS);
861 if(g_AudInfo.pBits) {
862 /*
863 MFE_U8 *tmp_ptr = ((MFE_U32)g_AudInfo.pBits)+20000;
864 for (ii=0; ii<1024; ii++)
865 tmp_char = tmp_ptr[ii];
866 g_AudInfo.nFileSize = 0x2400;
867 AudFrame = 16;
868 */
869 MAdp_init_audio_info(&g_AudInfo, DEFAULT_AUDIO_BITRATE, DEFAULT_AUDIO_FREQUENCY);
870 g_AudInfo.nFrameIndex = mux_audframecount;
871 } else {
872 bHasAudioFrame = 0;
873 g_nAvailAudFrames = 0;
874 }
875 /*else if (audio_ready==1) {
876 audio_ready = 0;
877 } else if (audio_ready==0)
878 bHasAudioFrame = 0;
879 */
880 // ms_dprintf(ADP_L1,"read AudioData from AuEnc 0x%x 0x%x %d\n", g_AudInfo.pBits, g_AudInfo.nFileSize, AudFrame);
881 }
882 #endif
883 ms_dprintf(ADP_L2,"pBits ptr 0x%x %d\n", (MFE_U32)g_AudInfo.pBits, bHasAudioFrame);
884 if (g_AudInfo.pBits) {
885 audio_data_avail = 1; //for checking is there any frame muxing this time
886 bHasAudioFrame = g_AudInfo.GetFrameBits(&g_AudInfo, 1);
887 ms_dprintf(ADP_L2,"bHasAudioFrame:%d %d\n", bHasAudioFrame, g_AudInfo.nFileSize);
888
889 if (bHasAudioFrame) {
890 //memcpy(mux_frame_buf, g_AudInfo.pFrameBits, g_AudInfo.nFrameSize);
891 g_aud_auctx.access_unit = g_AudInfo.pFrameBits;//mux_frame_buf;
892 g_aud_auctx.unit_size = g_AudInfo.nFrameSize;
893 g_aud_auctx.pts = (((U64)g_AudInfo.nFrameIndex-1)*1152) * MPEG_TS_CLOCKRATE / DEFAULT_AUDIO_FREQUENCY;
894 g_aud_auctx.dts = g_aud_auctx.pts;
895 g_aud_auctx.index_type = INDEX_TYPE_NONE;
896 g_aud_auctx.first_segment = 1;
897 g_aud_auctx.last_segment = 1;
898 // mpegts_mux_writeAU(pavmux, &g_aud_auctx);
899 pavmux->write_packet(pavmux, &g_aud_auctx);
900 #ifdef AUDIO_MUX_DUMP
901 //simple checksum
902 for(t=0;t<576;t+=32)
903 x+=(g_AudInfo.pFrameBits)[t];
904 ms_dprintf(ADP_L5,"DUMPx=%d,, 0x%x, %d\n",x, g_AudInfo.pFrameBits, g_AudInfo.nFrameSize);
905 //fwrite(g_AudInfo.pFrameBits,g_AudInfo.nFrameSize,1,AUDIO_DUMP);
906 #endif
907 ms_dprintf(ADP_L5,"nFileSize = %d, g_nAvailAudFrames=%d\n",g_AudInfo.nFileSize,g_nAvailAudFrames);
908 g_nAvailAudFrames--;
909 mux_audframecount++;
910 g_AudInfo.nFileSize -= g_AudInfo.nFrameSize;
911 ms_dprintf(ADP_L1,"access: 0x%x %x %x %x %x\n", (MFE_U32)g_aud_auctx.access_unit, mux_audframecount
912 ,g_aud_auctx.access_unit[11], g_aud_auctx.access_unit[12], g_aud_auctx.access_unit[13]);
913
914 ms_dprintf(ADP_L5,"nFileSize = %d, g_nAvailAudFrames=%d\n",g_AudInfo.nFileSize,g_nAvailAudFrames);
915 #ifdef _WIN32
916 ms_dprintf(ADP_L2,"mux audio frame PTS: %I64d %d %d\n", g_aud_auctx.dts, g_AudInfo.nFileSize, g_AudInfo.nFrameIndex-1);
917 #else
918 ms_dprintf(ADP_L1,"mux audio frame PTS: %lld %d %d\n", g_aud_auctx.dts, g_AudInfo.nFileSize, g_AudInfo.nFrameIndex-1);
919 #endif
920 } else {
921 #ifdef _FILE_IN_
922 fread(g_AudInfo.pBits, sizeof(MFE_U8), /*ts_AudInfo.nFileSize*/400000, mux_mp2file);
923 #endif
924 g_nAvailAudFrames = 0;
925 ms_dprintf(ADP_L1,"no more Audio frame\n");
926 }
927 }
928 #endif
929 } else {
930 break;
931 }
932 } // Muxing loop
933 if (Vsize ==0 && audio_data_avail==0)
934 return -1;
935 else
936 return 0;
937 }
938
MPEG2TS_GetBuffer(MFE_U8 ** ppBuffer,MFE_U8 ** ppBufReadPtr,MFE_U8 ** ppBufWritePtr,IndexRingEntry ** ppIndexPtr)939 void MPEG2TS_GetBuffer(MFE_U8** ppBuffer, MFE_U8 **ppBufReadPtr, MFE_U8 **ppBufWritePtr, IndexRingEntry **ppIndexPtr)
940 {
941 pavmux_st pavmux = &g_avmux;
942 //mpegts_mux_read(&g_av_ct, ppBuffer, ppBufReadPtr, ppBufWritePtr, ppIndexPtr);
943 pavmux->read(pavmux, ppBuffer, ppBufReadPtr, ppBufWritePtr, ppIndexPtr);
944 }
945
MPEG2TS_GetBufferDone(MFE_U8 * pNewBufReadPtr,MFE_U32 IndexRead)946 void MPEG2TS_GetBufferDone(MFE_U8* pNewBufReadPtr, MFE_U32 IndexRead)
947 {
948 pavmux_st pavmux = &g_avmux;
949 //mpegts_mux_readdone(&g_av_ct, pNewBufReadPtr, IndexRead);
950 pavmux->read_done(pavmux, pNewBufReadPtr, IndexRead);
951 }
952 #endif //_MUXTS_
953
954 #if defined(NEW_APVR_INTERFACE)
MPEG2TS_isIFrame_Ready(MFE_U32 * pts)955 BOOL MPEG2TS_isIFrame_Ready(MFE_U32* pts) //redcloud00@lge.com BOOLEAN -> BOOL
956 {
957 *pts = thumb_nail.I_Frame_pts;
958 if (thumb_nail.have_thumb) {
959 thumb_nail.I_Frame_ptr = 0;
960 ms_dprintf(ADP_L1,"Thumbnail pts: %d\n", (unsigned int)thumb_nail.I_Frame_pts);
961 }
962 return thumb_nail.have_thumb;
963 }
964
MPEG2TS_Get_I_Frame(MFE_U32 frameBuf,MFE_U32 bufSize,MFE_U32 * pts)965 void MPEG2TS_Get_I_Frame(/*YUV420_START***/MFE_U32 frameBuf, MFE_U32 bufSize, MFE_U32* pts)
966 {
967 thumb_nail.I_Frame_ptr = frameBuf;
968 thumb_nail.have_thumb = 0;
969 ms_dprintf(ADP_L1,"DDI call MPEG2TS_Get_I_Frame 0x%x\n", (unsigned int)frameBuf);
970 }
971
MPEG2TS_Init_Buf_Info(MFE_U8 frameBufferCount,MFE_U16 width,MFE_U16 height)972 void MPEG2TS_Init_Buf_Info(MFE_U8 frameBufferCount, MFE_U16 width, MFE_U16 height) //for DIP buffer setting
973 {
974
975 DIP_Total_Num = (MFE_U32)frameBufferCount;
976
977 appPVR_Info.nDispWidth= width;
978 appPVR_Info.nDispHeight= height;
979 appPVR_Info.nBufWidth = width/16*16 + (width%16!=0 ? 16:0);
980 appPVR_Info.nBufHeight= height/16*16 + (height%16!=0 ? 16:0);
981 appPVR_Info.width = appPVR_Info.nBufWidth;
982 appPVR_Info.height = appPVR_Info.nBufHeight;
983
984 }
985
986
MPEG2TS_Init_FrameBuf_Status_Func(GET_YUVFRAME_FUNC getBufStatusCallbackFunc,CLEAR_BUF_STATUS_FUNC clearBufStatusCallbackFunc)987 void MPEG2TS_Init_FrameBuf_Status_Func(GET_YUVFRAME_FUNC getBufStatusCallbackFunc,
988 CLEAR_BUF_STATUS_FUNC clearBufStatusCallbackFunc)
989 {
990 MAdp_MFE_GetDiBuffStatus = (GET_YUVFRAME_FUNC)getBufStatusCallbackFunc;
991 MAdp_MFE_ClearDiBuffStatus = (CLEAR_BUF_STATUS_FUNC)clearBufStatusCallbackFunc;
992
993 }
994
MPEG2TS_SetVideoBitrate(MFE_U32 bitRate)995 void MPEG2TS_SetVideoBitrate(MFE_U32 bitRate)
996 {
997 int err;
998 appPVR_Info.nBitrate = bitRate;
999
1000 err = ioctl(mfe_fd, MFE_IOC_SETBITRATE, (MFE_U32)(&appPVR_Info));
1001 if(err==1)
1002 ms_dprintf(ADP_L1,"MADP SET BITRATE ERROR!!\n");
1003
1004 }
1005
MPEG2TS_Video_Encode_Enable(BOOL enable)1006 void MPEG2TS_Video_Encode_Enable(BOOL enable) //redcloud00@lge.com BOOLEAN -> BOOL
1007 {
1008 Encode_stop = !enable;
1009 #if defined(_MFE_BIG2_)&&defined(_MIPS_PLATFORM_)
1010 if(Encode_stop)
1011 pthread_join(thread_hdl, NULL); //stephen
1012 #else
1013 if(Encode_stop)
1014 pthread_join(thread_info, NULL); //stephen
1015 #endif
1016 }
1017
PrepareThumbNail(unsigned char voptype,unsigned long IVOP_address,MFE_U32 nFrameSize)1018 void PrepareThumbNail(unsigned char voptype,unsigned long IVOP_address,MFE_U32 nFrameSize)
1019 {
1020 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
1021 // ms_dprintf(ADP_L1,"thumb_nail %d 0x%x %d %lld\n", thumb_nail.have_thumb, thumb_nail.I_Frame_ptr, voptype, g_vid_auctx.pts);
1022 if (thumb_nail.have_thumb==0 && thumb_nail.I_Frame_ptr!=0 && voptype==0) {
1023 //I frame
1024 //ms_dprintf(ADP_L1,"MADP IVOP_address 0x%x 0x%x 0x%x\n", thumb_nail.I_Frame_ptr, IVOP_address, (MFE_U32)MAdp_MPool_PA2KSEG1((void *)IVOP_address));
1025 ms_dprintf(ADP_L1,"before ConvertYuvFromTile %d\n",(int) cyg_current_time());
1026 #if(!defined(_KERNEL_MODE_))
1027 memcpy((unsigned char *)thumb_nail.I_Frame_ptr, (unsigned char *)MAdp_MPool_PA2KSEG1((void *)(IVOP_address+0x10000000))
1028 , nFrameSize);
1029 #else
1030 memcpy((unsigned char *)thumb_nail.I_Frame_ptr, (unsigned char *)MAdp_MPool_PA2KSEG1((void *)(IVOP_address))
1031 , nFrameSize);
1032 #endif
1033 ms_dprintf(ADP_L1,"after ConvertYuvFromTile %d\n", (int) cyg_current_time());
1034 #ifdef _MUXTS_
1035 thumb_nail.I_Frame_pts = g_vid_auctx.pts;
1036 thumb_nail.have_thumb=1;
1037 #endif
1038 }
1039 #endif
1040 }
1041
1042 #endif //#if defined(NEW_APVR_INTERFACE)
1043
MAdp_MFE_Finish(void)1044 int MAdp_MFE_Finish(void)
1045 {
1046 int err;
1047 MFE_U32 temp=0;
1048 #ifdef _MUXTS_
1049 pavmux_st pavmux = &g_avmux;
1050 #endif
1051 Encode_stop = 1;
1052 err = ioctl(mfe_fd, MFE_IOC_FINISH, temp);
1053 ms_dprintf(ADP_L1,"MAdp_MFE_Finish\n");
1054
1055 #if defined(_MFE_BIG2_)&&defined(_MIPS_PLATFORM_)
1056 MFE_U16 thread_timeout = 0;
1057 ms_dprintf(ADP_L1,"destroy_vo_thread\n");
1058 do
1059 {
1060 cyg_thread_delay(1);
1061 thread_timeout++;
1062 if (cyg_thread_check_exit(thread_hdl))
1063 break;
1064 } while (thread_timeout < 0xFFF);
1065
1066 if(!cyg_thread_delete(thread_hdl))
1067 cyg_thread_delete(thread_hdl);
1068 #endif
1069
1070 ms_dprintf(ADP_L1,"MAdp_MFE_Finish,after pthread_mutex_destroy().\n");
1071 #ifdef _MUXTS_
1072 // mpegts_mux_end(&g_av_ct);
1073 pavmux->write_close(pavmux);
1074 #if defined(_FILE_IN_)&&defined(_MUX_WITH_AUDIO_)
1075 fclose(mux_mp2file);
1076 #endif
1077 #endif
1078
1079 #ifdef AUDIO_MUX_DUMP
1080 fclose(AUDIO_DUMP);
1081 #endif
1082
1083 MAdp_MFE_Sem_Destroy();
1084 pthread_cancel(thread_info);
1085
1086 if((err=pthread_join(thread_info,NULL))!=0)
1087 {
1088 ms_dprintf(ADP_L1,"pthread_join(thread_info,NULL) Fail!!\n");
1089 }
1090
1091 #if defined(_FILE_IN_)
1092 fclose(mfe_file_in.infile);
1093 fclose(mfe_file_in.outfile);
1094 #endif
1095
1096 MAdp_MFE_Change_State(MFE_Invalid);
1097 MAdp_MFE_Mutex_Delete();
1098 return err;
1099
1100 }
1101
1102
1103 // Buffer status
1104 #define BUF_STATE_OK 0
1105 #define BUF_STATE_SKIP 1 // Example: DIP in, no frame to encode.
1106 #define BUF_STATE_STOP 2 // Example: File in, the last frame was encoded.
1107 // Example: File in, read error.
1108
1109 #if defined(_YUVGEN_)||defined(_FILE_IN_)
1110
1111 // Needed for File input:
1112 // Convert input YUV420 frame into Block-Tile
1113 // Also calculate dest physical address
ConvertYUVToTile(MEMMAP_t * pmmapDest,MEMMAP_t * pmmapSrc,int width,int height)1114 void ConvertYUVToTile(MEMMAP_t* pmmapDest, MEMMAP_t* pmmapSrc, int width, int height)
1115 {
1116 yuv2tile(pmmapDest->miuPointer, width, height, pmmapSrc->miuPointer, 1);
1117 yuv2tile((MFE_U8 *)((MFE_U32)pmmapDest->miuPointer+width*height), width, height,
1118 (MFE_U8 *)((MFE_U32)pmmapSrc->miuPointer+width*height), 0);
1119 pmmapDest->miuAddress = (MFE_U32)MAdp_MPool_VA2PA((void*)(pmmapDest->miuPointer));
1120 MsOS_Dcache_Flush(pmmapDest->miuPointer, width*height*3/2);
1121 }
1122
1123 #if defined(_FILE_IN_)
GetFrame_FileIn(FILE_IN_INFO * pInfo,MEMMAP_t * pmmapTmp,MEMMAP_t * pmmapDst)1124 int GetFrame_FileIn(FILE_IN_INFO* pInfo, MEMMAP_t* pmmapTmp, MEMMAP_t* pmmapDst)
1125 {
1126 int err;
1127
1128 if (Madp_enc_frame_count>=pInfo->nTotalFramesInFile) {
1129 ms_dprintf(ADP_L1,"GetFrame_FileIn() Max frame encoded, no more data in file.encode stop\n");
1130 return BUF_STATE_STOP;
1131 }
1132
1133 if (Madp_enc_frame_count>=appPVR_Info.nTotalFrames) {
1134 ms_dprintf(ADP_L1,"GetFrame_FileIn() Max frame encoded, encode stop\n");
1135 return BUF_STATE_STOP;
1136 }
1137
1138 err = fread((MFE_U8 *)pmmapTmp->miuPointer, sizeof(MFE_U8), pInfo->nFrameSize, pInfo->infile);
1139
1140 // if (err != pInfo->nFrameSize) {
1141 // ms_dprintf(ADP_L1,"GetFrame_FileIn() Cannot read frame, encode stop\n");
1142 // return BUF_STATE_STOP;
1143 // }
1144
1145 ConvertYUVToTile(pmmapDst, pmmapTmp, appPVR_Info.width, appPVR_Info.height);
1146 return BUF_STATE_OK;
1147 }
1148 #endif
1149 // YUV generation
GetFrame_YUVGen(MFE_U8 seed,int width,int height,MEMMAP_t * pmmapTmp,MEMMAP_t * pmmapDst)1150 int GetFrame_YUVGen(MFE_U8 seed, int width, int height, MEMMAP_t* pmmapTmp, MEMMAP_t* pmmapDst)
1151 {
1152 if (Madp_enc_frame_count>=appPVR_Info.nTotalFrames) {
1153 ms_dprintf(ADP_L1,"GetFrame_YUVGen() Max frame encoded, encode stop\n");
1154 return BUF_STATE_STOP;
1155 }
1156
1157 YuvGen(seed, width, height, (MFE_U8 *) pmmapTmp->miuPointer);
1158 ConvertYUVToTile(pmmapDst, pmmapTmp, width, height);
1159 MsOS_Dcache_Flush(pmmapTmp->miuPointer ,width*height*3/2);
1160 return BUF_STATE_OK;
1161 }
1162
1163 #endif
1164
1165 #ifdef _SCALER_IN_
MFE_CleanDi_Function(MEMMAP_t * input_frame)1166 static void MFE_CleanDi_Function(MEMMAP_t* input_frame)
1167 {
1168 #if defined(NEW_APVR_INTERFACE) //||defined(VVOIP_INTERFACE1)
1169 MAdp_MFE_ClearDiBuffStatus(1,&mfe_pInfo);
1170 #elif defined(VVOIP_INTERFACE1)
1171 g_CleanCallBackFunc(1,(MFE_U32)input_frame->miuAddress );
1172 #else
1173 MAdp_MFE_ClearDiBuffStatus((MFE_U16)((Madp_out_frame_count-1)%DIP_Total_Num));
1174 #endif
1175
1176 }
1177
MFE_GetFrame_Function(MEMMAP_t * input_frame,int * nBufStatus)1178 static void MFE_GetFrame_Function(MEMMAP_t* input_frame,int* nBufStatus)
1179 {
1180
1181 #if defined(NEW_APVR_INTERFACE)
1182 input_frame->miuPointer = (unsigned char*)mfe_pInfo.Currentindex;
1183 #elif defined(VVOIP_INTERFACE1)
1184 input_frame->miuPointer = (unsigned char*)VVOIP_MFE_input_VAaddr;
1185 #else
1186 MAdp_MFE_GetDiBuff((MFE_U32*)(&input_frame->miuPointer));
1187 #endif
1188
1189 ms_dprintf(ADP_L2,"Video Frame: 0x%x\n",(unsigned int) input_frame->miuPointer);
1190 input_frame->miuAddress = (MFE_U32)MAdp_MPool_VA2PA((void*)(input_frame->miuPointer));
1191 ms_dprintf(ADP_L2,"Video Frame(PA): 0x%x\n",(unsigned int) input_frame->miuAddress);
1192 nBufStatus[0] = BUF_STATE_OK;
1193
1194
1195 }
1196
1197 #endif //_SCALER_IN_
1198
MFE_Thread_Naming(void)1199 void MFE_Thread_Naming(void)
1200 {
1201 //thread naming
1202 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
1203 prctl(PR_SET_NAME, (unsigned long)"mfe_thread",0,0,0);
1204 {// for debug
1205 char name[32];
1206 prctl(16, (unsigned long)name); //PR_GET_NAME = 16
1207 ms_dprintf(ADP_L2,"in MAdp_MFE_Proc, thread name = %s\n", name);
1208 }
1209 #endif
1210
1211 }
1212
MAdp_MFE_Proc(void)1213 void MAdp_MFE_Proc(void)
1214 {
1215 int nBufStatus;
1216 MFE_U32 nDispOrder=0; // Driver is responsible for frame buffer re-ordering
1217
1218 MEMMAP_t input_frame;
1219 #if defined(_YUVGEN_)||defined(_FILE_IN_)
1220 MEMMAP_t tmp_frame;
1221 MFE_U32 nFrameSize;
1222 int src_inc = 0;
1223 #endif
1224
1225 MFE_U32 Vaddr, Vsize=0;
1226 #ifdef _MUXTS_
1227 MFE_U32 Aaddr = 0; //NULL;
1228 int is_mux;
1229 #endif
1230 volatile BITSFRAME_INFO bitsinfo = {0};
1231
1232
1233 #if defined(_SCALER_IN_)||defined(_MUXTS_)
1234 MFE_U16 DIP_buff_status = 1;
1235 #endif
1236
1237 #if defined(TIME_MEASURE)
1238 MFE_U32 MFE_U32ticktmp = 0; // For TIME_MEASURE
1239 // MFE_U32 MFE_U32ticktmp2 = 0;
1240 #endif
1241 /*
1242 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
1243 struct pollfd PollFd;
1244 PollFd.fd= mfe_fd;
1245 PollFd.events= POLLIN;
1246 PollFd.revents= 0;
1247 #endif
1248 */
1249 //thread naming
1250 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
1251 prctl(PR_SET_NAME, (unsigned long)"mfe_thread",0,0,0);
1252 {// for debug
1253 char name[32];
1254 prctl(16, (unsigned long)name); //PR_GET_NAME = 16
1255 ms_dprintf(ADP_L2,"in MAdp_MFE_Proc, thread name = %s\n", name);
1256 }
1257 #endif
1258
1259 video_shift_frame = 0;
1260
1261 ms_dprintf(ADP_L2,"in MAdp_MFE_Proc");
1262 #if defined(_YUVGEN_)||defined(_FILE_IN_)
1263 nFrameSize = appPVR_Info.width*appPVR_Info.height*3/2;
1264
1265 {
1266 //input frame must 256 Align
1267 MFE_U32 tmp_pa = MAdp_MPool_VA2PA(madp_mfe_buff_info.mfe_buf_va);
1268 tmp_pa = (tmp_pa+0xFF)&~0xFF;
1269 madp_mfe_buff_info.mfe_buf_va = MAdp_MPool_PA2KSEG1(tmp_pa);
1270 input_frame.miuPointer = my_malloc(&madp_mfe_buff_info.mfe_buf_va, nFrameSize,"input_frame");
1271 input_frame.miuAddress = MAdp_MPool_VA2PA(input_frame.miuPointer);
1272 tmp_frame.miuPointer = my_malloc(&madp_mfe_buff_info.mfe_buf_va, nFrameSize,"tmp_frame");
1273 tmp_frame.miuAddress = MAdp_MPool_VA2PA(tmp_frame.miuPointer);
1274 }
1275 #endif
1276
1277 /* Prepare the very first frame */
1278 ioctl(mfe_fd, MFE_IOC_GET_DISPORDER, (MFE_U32)&nDispOrder);
1279
1280
1281 #if defined(_SCALER_IN_)
1282 //nBufStatus==BUF_STATE_STOP;
1283 ms_dprintf(ADP_L1,"wait DIP buffer..\n");
1284
1285 #if defined(VVOIP_INTERFACE1)
1286 //sem_wait(&madp_sem_input);
1287 MAdp_MFE_Change_State(MFE_Idle); //start to wait compressonepicture.
1288 MAdp_MFE_Sem_Wait();
1289 input_frame.miuPointer = (unsigned char*)VVOIP_MFE_input_VAaddr;
1290 #else
1291 do {
1292
1293 #if defined(NEW_APVR_INTERFACE)
1294 MAdp_MFE_GetDiBuffStatus(&mfe_pInfo);
1295 DIP_buff_status = (mfe_pInfo.frame_num ==0 ? FALSE : TRUE);
1296 input_frame.miuPointer = (unsigned char*)mfe_pInfo.Currentindex;
1297 #else
1298 DIP_buff_status = MAdp_MFE_GetDiBuffStatus();
1299 if (DIP_buff_status)
1300 MAdp_MFE_GetDiBuff((MFE_U32*)&input_frame.miuPointer);
1301 #endif
1302 } while(DIP_buff_status==0);
1303 #endif
1304
1305 // debug code
1306 ms_dprintf(ADP_L2,"DIP buffer: 0x%x\n", (unsigned int)input_frame.miuPointer);
1307 ms_dprintf(ADP_L2,"debug code: 0x%x %02x %02x %02x %02x\n", (unsigned int)input_frame.miuPointer,
1308 ((MFE_U8 *)input_frame.miuPointer)[0], ((MFE_U8 *)input_frame.miuPointer)[1], ((MFE_U8 *)input_frame.miuPointer)[2], ((MFE_U8 *)input_frame.miuPointer)[3]);
1309 // ms_dprintf(ADP_L2,"debug code: 0x%x %02x %02x %02x %02x\n", (unsigned int)input_frame.miuPointer,
1310 // ((MFE_U8 *)input_frame.miuPointer)[nFrameSize-8+0], ((MFE_U8 *)input_frame.miuPointer)[nFrameSize-8+1], ((MFE_U8 *)input_frame.miuPointer)[nFrameSize-8+2], ((MFE_U8 *)input_frame.miuPointer)[nFrameSize-8+3]);
1311 ////////////
1312
1313 input_frame.miuAddress = (MFE_U32)MAdp_MPool_VA2PA((void*)(input_frame.miuPointer));
1314 ms_dprintf(ADP_L2,"DIP VA2PA: 0x%x\n", input_frame.miuAddress);
1315 nBufStatus = BUF_STATE_OK;
1316
1317 #elif defined(_YUVGEN_)
1318 nBufStatus = GetFrame_YUVGen((MFE_U8)(100+src_inc*5), appPVR_Info.width, appPVR_Info.height, &tmp_frame, &input_frame);
1319 src_inc++;
1320 #elif defined(_FILE_IN_)
1321 nBufStatus = GetFrame_FileIn(&mfe_file_in, &tmp_frame, &input_frame);
1322 #endif //_scaler_in_
1323
1324
1325 #ifdef TIME_MEASURE
1326 MFE_U32ticktmp = cyg_current_time();
1327 ms_dprintf(ADP_L4,"[Time] MADP GetFrame: %d\n", (int)MFE_U32ticktmp);
1328 #endif
1329
1330 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_)
1331 input_frame.miuAddress -= (input_frame.miuAddress&madp_mfe_buff_info.mfe_miu_offset);
1332 #if defined(_MEM_READ_WRITE_CONTROL_)
1333 MAdp_SYS_FlushMemory();
1334 #endif
1335 #endif
1336
1337 if (video_shift_frame < VIDEO_SHIFT) {
1338 enc_state = ADP_STATE_WAIT_INPUT;
1339 ms_dprintf(ADP_L2,"video_shift_frame %d\n", video_shift_frame);
1340 goto START_MUX;
1341 }
1342 ms_dprintf(ADP_L2,"video_shift_frame %d %d\n", video_shift_frame, VIDEO_SHIFT);
1343
1344 #ifdef TIME_MEASURE
1345 ms_dprintf(ADP_L4,"[Time] MADP EncodeFrame: %d\n", (unsigned int)cyg_current_time());
1346 #endif
1347
1348 ioctl(mfe_fd, MFE_IOC_ENC_ONEFRAME, input_frame.miuAddress);
1349
1350 //ms_dprintf(ADP_L2,"after ioctl MFE_IOC_ENC_ONEFRAME err= %d\n", err);
1351 enc_state = ADP_STATE_WAIT_GETBITS;
1352 Madp_enc_frame_count++;
1353 Vsize = 0;
1354
1355 for (;;) {
1356 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)&&defined(_MFE_UTOPIA_)
1357 if(1)
1358 #else
1359 if ((poll(&PollFd, 1, -1) > 0))
1360 #endif
1361 {
1362 // ms_dprintf(ADP_L1,"poll enc_state %d %d\n", enc_state, cyg_current_time());
1363 if (enc_state==ADP_STATE_WAIT_GETBITS) {
1364 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)&&defined(_MFE_UTOPIA_)
1365 /*
1366 {
1367 MFE_HW_STATUS status;
1368 while(1) {
1369 ioctl(mfe_fd, MFE_IOC_CHECK_STATUS, (MFE_U32)&status);
1370 if(status == GETBITS_READY)
1371 break;
1372 usleep(1000);
1373 }
1374 }
1375 */
1376 ioctl(mfe_fd, MFE_IOC_GETBITS, (MFE_U32)(&bitsinfo));
1377 #else
1378 //no wait at APVR mode
1379 ioctl(mfe_fd, MFE_IOC_GETBITS, (MFE_U32)(&bitsinfo));
1380 #endif
1381
1382 #if defined(_MFE_T8_)&&defined(_MIPS_PLATFORM_)
1383 bitsinfo.miuAddress += madp_mfe_buff_info.mfe_miu_offset;
1384 MsOS_ReadMemory();
1385 #endif
1386 #if defined(_MEM_READ_WRITE_CONTROL_)
1387 //LG GP3 kernel space must call this function before get data from HW.
1388 MAdp_SYS_ReadMemoryRange((unsigned long) bitsinfo.miuAddress , (unsigned long) bitsinfo.size);
1389 #endif
1390 Vaddr = (MFE_U32) MAdp_MPool_PA2KSEG1((void *)bitsinfo.miuAddress);
1391 #if defined(_MUXTS_)||defined(VVOIP_INTERFACE1)
1392 if (bitsinfo.size<=0) {
1393 ms_dprintf(ADP_L2,"[ADP] ERROR: BitsSize=%d<0. Data = %x %x %x %x\n", (int)bitsinfo.size,
1394 ((MFE_U8*)Vaddr)[0], ((MFE_U8*)Vaddr)[1], ((MFE_U8*)Vaddr)[2], ((MFE_U8*)Vaddr)[3]);
1395 }
1396 #if defined(_FPGA_)
1397 // Copy from FPGA memory
1398 if(FPGA_MIURead(mux_frame_buf+Vsize, bitsinfo.size, bitsinfo.miuAddress, 0)==FALSE) {
1399 ms_dprintf(ADP_L2, "[ADP] ERROR: Read bits from FPGA DRAM.\n");
1400 }
1401 #else
1402 memcpy(mux_frame_buf+Vsize, (MFE_U8 *)Vaddr, bitsinfo.size);
1403 #endif
1404
1405 #elif defined(_FILE_IN_)
1406 fwrite(Vaddr, mfe_file_in.nFrameSize , 1 , mfe_file_in.outfile);
1407 #endif
1408 Vsize += bitsinfo.size;
1409 //assert(bitsinfo.is_more_bits == 0);
1410 ioctl(mfe_fd, MFE_IOC_CLEAR_BITSBUF, 1);
1411 ms_dprintf(ADP_L2, "[ADP] After MFE_IOC_CLEAR_BITSBUF.\n");
1412 };
1413
1414 START_MUX:
1415 #ifdef TIME_MEASURE
1416 {
1417 MFE_U32 MFE_U32tick = cyg_current_time();
1418 ms_dprintf(ADP_L4,"[Time] MADP GetBitsDone: %d\n", (unsigned int)MFE_U32tick);
1419 ms_dprintf(ADP_L4,"%d\n", (unsigned int)(MFE_U32tick-MFE_U32ticktmp));
1420 if ((MFE_U32tick-MFE_U32ticktmp)>=53) {
1421 ms_dprintf(ADP_L4,"performance problem1: %d\n",(unsigned int) (MFE_U32tick-MFE_U32ticktmp));
1422 }
1423 }
1424 #endif
1425
1426 if (bitsinfo.status==BITS_INFO_FRAMEDONE || enc_state==ADP_STATE_WAIT_INPUT)
1427 {
1428 #if defined(VVOIP_INTERFACE1)
1429 // if(Vsize)
1430 // g_StreamCallBackFunc(g_pCustomCtx, (MFE_S32)bitsinfo.voptype,mux_frame_buf, Vsize, 0x3);
1431 #endif
1432 #ifdef _MUXTS_
1433 is_mux = MAdp_TSMUX_AddFrame((MFE_U32)mux_frame_buf, Aaddr, Vsize, bitsinfo.voptype);
1434 if (((is_mux==-1)&&video_shift_frame>VIDEO_SHIFT) || (video_shift_frame<=VIDEO_SHIFT && DIP_buff_status==0)) {
1435 ms_dprintf(ADP_L2,"no more data to mux\n");
1436 // usleep(1000); //no more data to mux, sleep for a while
1437 }
1438 ms_dprintf(ADP_L2,"TSMUX Video 0x%x size=0x%x\n", (MFE_U32)mux_frame_buf, Vsize);
1439 #endif
1440 if (Vsize) {
1441 Madp_out_frame_count++;
1442 }
1443 #ifndef VVOIP_INTERFACE1
1444 Vsize = 0;
1445 #endif
1446 if (video_shift_frame>=VIDEO_SHIFT) {
1447 ms_dprintf(ADP_L1,"out #%d\n", Madp_out_frame_count-1);
1448 }
1449
1450 enc_state = ADP_STATE_WAIT_GETBITS;
1451 #if defined(TARGET_FRAME)&&(!defined(_MUXTS_))
1452 if (Madp_enc_frame_count==appPVR_Info.nTotalFrames/*TARGET_FRAME*/ && Madp_out_frame_count==appPVR_Info.nTotalFrames/*TARGET_FRAME*/) {
1453 Encode_stop=1;
1454 ms_dprintf(ADP_L1,"DEBUG_GET, Encode_stop\n");
1455 break;
1456 }
1457 #else
1458 if (Encode_stop==1) {
1459 #if defined(VVOIP_INTERFACE1)
1460 if(Vsize) {
1461 g_StreamCallBackFunc(g_pCustomCtx, (MFE_S32)bitsinfo.voptype,mux_frame_buf, Vsize, 0x3);
1462 Vsize = 0;
1463 }
1464 #endif
1465 ms_dprintf(ADP_L1,"Encode_stop\n");
1466 break;
1467 }
1468 #endif
1469 if (Encode_stop==0) {
1470 if (enc_state==ADP_STATE_WAIT_GETBITS) {
1471 // PrepareThumbNail(bitsinfo.voptype,bitsinfo.IVOP_address,nFrameSize);
1472 #ifdef _SCALER_IN_
1473 if (DIP_buff_status /*|| Madp_out_frame_count==1*/) {
1474 //clean di or callback-clean
1475 MFE_CleanDi_Function(&input_frame);
1476 }
1477
1478 #if defined(VVOIP_INTERFACE1)
1479 ms_dprintf(ADP_L1,"MADP MFE MAIT INPUT....\n");
1480 //sem_wait(&madp_sem_input);
1481 MAdp_MFE_Change_State(MFE_Idle);
1482 if(Vsize){
1483 int tmp_size = Vsize;
1484 Vsize = 0;
1485 g_StreamCallBackFunc(g_pCustomCtx, (MFE_S32)bitsinfo.voptype,mux_frame_buf, tmp_size, 0x3);
1486 }
1487 MAdp_MFE_Sem_Wait();
1488 ms_dprintf(ADP_L1,"MADP MFE MAIT INPUT....done\n");
1489 if (Encode_stop==1) {
1490 ms_dprintf(ADP_L1,"Encode_stop\n");
1491 break;
1492 }
1493 #endif
1494
1495 #if defined(NEW_APVR_INTERFACE)
1496 MAdp_MFE_GetDiBuffStatus(&mfe_pInfo);
1497 DIP_buff_status = (mfe_pInfo.frame_num ==0 ? 0 : 1);
1498 #elif !defined(VVOIP_INTERFACE1)
1499 DIP_buff_status = MAdp_MFE_GetDiBuffStatus();
1500 #endif
1501
1502 if (DIP_buff_status==0) {
1503 ms_dprintf(ADP_L4,"DIP_buff_status==0,enc_state = ADP_STATE_WAIT_INPUT,goto START_MUX\n");
1504 enc_state = ADP_STATE_WAIT_INPUT;
1505 goto START_MUX;
1506 }
1507 else{
1508 ms_dprintf(ADP_L2,"DIP_buff_status= 0x%x\n",DIP_buff_status);
1509 }
1510
1511 ioctl(mfe_fd, MFE_IOC_GET_DISPORDER, (MFE_U32)&nDispOrder);
1512 MFE_GetFrame_Function(&input_frame,&nBufStatus);
1513 #elif defined(_YUVGEN_) //yuvgen()
1514 ioctl(mfe_fd, MFE_IOC_GET_DISPORDER, (MFE_U32)&nDispOrder);
1515 nBufStatus = GetFrame_YUVGen((MFE_U8)(100+src_inc*5), appPVR_Info.width, appPVR_Info.height, &tmp_frame, &input_frame);
1516 src_inc++;
1517 #elif defined(_FILE_IN_)
1518 nBufStatus = GetFrame_FileIn(&mfe_file_in, &tmp_frame, &input_frame);
1519 #endif //_SCALER_IN_
1520
1521 if (nBufStatus==BUF_STATE_STOP) {
1522 Encode_stop = 1;
1523 break;
1524 }
1525 #ifdef TIME_MEASURE
1526 MFE_U32ticktmp = cyg_current_time(); // test only
1527 ms_dprintf(ADP_L4,"[Time] MADP EncodeFrame: %d\n",(unsigned int) MFE_U32ticktmp);
1528 #endif
1529
1530 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_)
1531 input_frame.miuAddress -= (input_frame.miuAddress&madp_mfe_buff_info.mfe_miu_offset);
1532 #if defined(_MEM_READ_WRITE_CONTROL_)
1533 MAdp_SYS_FlushMemory();
1534 #endif
1535 #endif
1536 video_shift_frame++;
1537 if (video_shift_frame < VIDEO_SHIFT) {
1538 enc_state = ADP_STATE_WAIT_INPUT;
1539 ms_dprintf(ADP_L1,"video_shift_frame %d\n", video_shift_frame);
1540 goto START_MUX;
1541 }
1542
1543 if (nBufStatus==BUF_STATE_OK)
1544 ioctl(mfe_fd, MFE_IOC_ENC_ONEFRAME, input_frame.miuAddress);
1545 // ms_dprintf(ADP_L1,"ENC time: %d\n", MFE_U32ticktmp);
1546 Madp_enc_frame_count++;
1547 }
1548 else {
1549 ms_dprintf(ADP_L1,"enc_state==ADP_STATE_WAIT_INPUT\n");
1550 }
1551 //printf("after encoding on frame %d %d\n", MFE_U32Size, encode_VOP_type);
1552 }
1553 }
1554 else {
1555 //Kernel MFE driver is encoding, will return bitsbuf later
1556 ms_dprintf(ADP_L1,"wait frame done encoding\n");
1557 //printf(,"wait frame done encoding\n");
1558 }
1559 }
1560 else {
1561 ms_dprintf(ADP_L1,"MFE adp: poll return<=0\n");
1562 }
1563 }
1564
1565 ms_dprintf(ADP_L1,"MFE proc pthread_exit.\n");
1566 pthread_exit(0); //stephen
1567
1568 }
1569
MAdp_MFE_Thread_Create(void)1570 MFE_BOOL MAdp_MFE_Thread_Create(void)
1571 {
1572
1573 // pthread_t thread_info;
1574 pthread_attr_t thrattr;
1575 struct sched_param thrsched;
1576 pthread_attr_init(&thrattr);
1577 pthread_attr_setdetachstate(&thrattr, PTHREAD_CREATE_JOINABLE);
1578 pthread_attr_setinheritsched(&thrattr, PTHREAD_EXPLICIT_SCHED);
1579 pthread_attr_setschedpolicy(&thrattr, SCHED_FIFO);
1580 pthread_attr_getschedparam(&thrattr, &thrsched);
1581 thrsched.sched_priority = 99;//86;
1582 pthread_attr_setschedparam(&thrattr, &thrsched);
1583 pthread_attr_getschedparam(&thrattr, &thrsched);
1584
1585
1586 if (0 != pthread_create(&thread_info,
1587 &thrattr,
1588 (void *(*)(void *))&MAdp_MFE_Proc,
1589 NULL))
1590 {
1591 ms_dprintf(ADP_L1,"MADP MFE create thread error\n");
1592 #ifdef _MFE_UTOPIA_
1593 printf("MADP MFE create thread error\n");
1594 #endif
1595 return FALSE;
1596 }
1597
1598 return TRUE;
1599
1600 }
1601
1602
1603
1604 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_) && (!defined(_KERNEL_MODE_))
1605
MFE_SetRIU_Base(void)1606 MFE_BOOL MFE_SetRIU_Base(void)
1607 {
1608
1609 MFE_U32 u32NonPMBankSize=0,u32RiuBaseAdd=0;
1610 if( !MDrv_MMIO_GetBASE( &u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW)){
1611 ms_dprintf(ADP_L1,"MFE Init Err: MMIO_GetBASE failure\n");
1612 return FALSE;
1613 }
1614
1615 ms_dprintf(ADP_L1,"MFE Init u32RiuBaseAdd = 0x%X, u32NonPMBankSize = 0x%X, \n", (unsigned int)u32RiuBaseAdd,(unsigned int)u32NonPMBankSize);
1616 //MDrv_MFE_SetOSRegBase(u32RiuBaseAdd);
1617 ioctl(mfe_fd, MFE_IOC_SET_RIU_BASE, u32RiuBaseAdd);
1618
1619 return TRUE;
1620
1621 }
1622
1623
MApi_MFE_SetBufferInfo(MFE_S32 miu_type,MFE_U32 mfe_pa_without_offset_addr,MFE_U32 miu_offset,MFE_U32 mem_size)1624 MFE_BOOL MApi_MFE_SetBufferInfo(MFE_S32 miu_type, MFE_U32 mfe_pa_without_offset_addr, MFE_U32 miu_offset, MFE_U32 mem_size)
1625 {
1626 madp_mfe_buff_info.mfe_buf_pa_withoutoffset=0;
1627 madp_mfe_buff_info.mfe_miu_offset = miu_offset;
1628 madp_mfe_buff_info.mfe_buf_size = mem_size;
1629 madp_mfe_buff_info.mfe_buf_pa_withoffset = mfe_pa_without_offset_addr+miu_offset;
1630 madp_mfe_buff_info.mfe_buf_va = MAdp_MPool_PA2KSEG1(madp_mfe_buff_info.mfe_buf_pa_withoffset);
1631 madp_mfe_buff_info.mfe_buf_va_end = madp_mfe_buff_info.mfe_buf_va+mem_size;
1632 madp_mfe_buff_info.mfe_buf_pa_withoutoffset = mfe_pa_without_offset_addr;
1633
1634 // remove set MIU function because this is depend on diff platform.
1635 /*
1636 if(miu_type==0)
1637 eType = MIU_SELTYPE_MIU0;
1638 else if(miu_type==1)
1639 eType = MIU_SELTYPE_MIU1;
1640 else if(miu_type==2)
1641 eType = MIU_SELTYPE_MIU_ALL;
1642 else{
1643 ms_dprintf(ADP_L1,"[ERROR]MAdp_MFE_SetMIU, no supprot miu %d.\n",(int)miu_type);
1644 error_flag=1;
1645 }
1646
1647 ms_dprintf(ADP_L1,"Switch to MIU%d.\n",miu_type);
1648 if(MDrv_MIU_SelMIU(MIU_CLIENT_MFE0_W,eType) == FALSE){
1649 ms_dprintf(ADP_L1,"[ERROR]MAdp_MFE_SetMIU, MDrv_MIU_SelMIU MIU_CLIENT_MFE0_W.\n");
1650 error_flag=1;
1651 }
1652 if(MDrv_MIU_SelMIU(MIU_CLIENT_MFE1_R,eType) == FALSE){
1653 ms_dprintf(ADP_L1,"[ERROR]MAdp_MFE_SetMIU, MDrv_MIU_SelMIU MIU_CLIENT_MFE1_R.\n");
1654 error_flag=1;
1655 }
1656 */
1657
1658 return TRUE;
1659 // return error_flag==0 ? TRUE : FALSE;
1660
1661
1662 }
1663
1664
1665 #endif //#if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_) && (!defined(_KERNEL_MODE_))
1666
MFE_SetMemory(void)1667 MFE_BOOL MFE_SetMemory(void)
1668 {
1669
1670 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_) &&defined(_KERNEL_MODE_)
1671
1672
1673 if (!MAdp_MPool_GetBlockVa((int)E_SYS_MMAP_MPOOL, &madp_mfe_buff_info.mfe_buf_va, &madp_mfe_buff_info.mfe_buf_size)){
1674 // if (!MAdp_MPool_GetBlockVa((int)E_SYS_MMAP_MAD_BASE, &madp_mfe_buff_info.mfe_buf_va, &madp_mfe_buff_info.mfe_buf_size)){
1675 // if (!MAdp_MPool_GetBlockVa((int)E_SYS_MMAP_SCALER_DNR_BUF, &madp_mfe_buff_info.mfe_buf_va, &madp_mfe_buff_info.mfe_buf_size)){
1676 // if (!MAdp_MPool_GetBlockVa((int)E_SYS_MMAP_JPG_OSD, &madp_mfe_buff_info.mfe_buf_va, &madp_mfe_buff_info.mfe_buf_size)){
1677 // if (!MAdp_MPool_GetBlockVa((int)E_SYS_MMAP_MFE, &madp_mfe_buff_info.mfe_buf_va, &madp_mfe_buff_info.mfe_buf_size)){
1678 ms_dprintf(ADP_L1,"Get MVDFB buffer fail.\n");
1679 return FALSE;
1680 }
1681 /////////
1682 madp_mfe_buff_info.mfe_buf_pa_withoffset = (MFE_U32)MAdp_MPool_VA2PA((void*)(madp_mfe_buff_info.mfe_buf_va));
1683 madp_mfe_buff_info.mfe_buf_pa_withoffset += 0xE00000;
1684 madp_mfe_buff_info.mfe_buf_va = (MFE_U32)MAdp_MPool_PA2KSEG1((void*)(madp_mfe_buff_info.mfe_buf_pa_withoffset));
1685 //////////////
1686
1687 madp_mfe_buff_info.mfe_buf_pa_withoffset = (MFE_U32)MAdp_MPool_VA2PA((void*)(madp_mfe_buff_info.mfe_buf_va));
1688 ms_dprintf(ADP_L2,"Get MFEFB PA = 0x%x.\n",(unsigned int)madp_mfe_buff_info.mfe_buf_pa_withoffset);
1689
1690 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_) //to subtract MIU1 offset. (it could be 0x8000000 or 0x10000000)
1691 madp_mfe_buff_info.mfe_buf_pa_withoutoffset -= (madp_mfe_buff_info.mfe_buf_pa_withoffset&madp_mfe_buff_info.mfe_miu_offset);
1692 #endif
1693
1694 #elif defined(_WIN32)
1695 if (!MAdp_MPool_GetBlockVa((int)E_SYS_MMAP_MFE, &madp_mfe_buff_info.mfe_buf_va, &madp_mfe_buff_info.mfe_buf_size)){
1696 ms_dprintf(ADP_L1,"Get MVDFB buffer fail.\n");
1697 return FALSE;
1698 }
1699 madp_mfe_buff_info.mfe_buf_pa_withoffset = (MFE_U32)MAdp_MPool_VA2PA((void*)(madp_mfe_buff_info.mfe_buf_va));
1700 madp_mfe_buff_info.mfe_buf_pa_withoutoffset= madp_mfe_buff_info.mfe_buf_pa_withoffset;
1701 #endif
1702
1703 return TRUE;
1704
1705 }
1706
1707
MAdp_MFE_Init(float frame_rate,int test_case_format,int test_case_num)1708 MFE_U32 MAdp_MFE_Init(float frame_rate,int test_case_format,int test_case_num)
1709 {
1710
1711 MFE_U32 temp;
1712 MFE_U32 nFrameSize = appPVR_Info.nBufHeight*appPVR_Info.nBufWidth*3/2;
1713 MFE_U32 MallocToDrvSize ;
1714 appPVR_Info.nOutBuffer = 1;
1715 appPVR_Info.OutBufferSize = 409600;
1716 ms_dprintf(ADP_L1,"OutBuf=%d,size=%d\n",appPVR_Info.nOutBuffer,appPVR_Info.OutBufferSize );
1717 MallocToDrvSize = nFrameSize*6+appPVR_Info.OutBufferSize*appPVR_Info.nOutBuffer + 10*1024;
1718
1719 MAdp_MPool_Init();
1720
1721 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_)&& !defined(_KERNEL_MODE_)
1722 //set RIU BASE
1723 if(MFE_SetRIU_Base() == FALSE)
1724 return FALSE;
1725 #else
1726 madp_mfe_buff_info.mfe_miu_offset = MIU_OFFSET;
1727 #endif
1728
1729 if(MFE_SetMemory()==FALSE)
1730 return FALSE;
1731
1732 //madp_APVRBuffPAStart be subtracted miu offset
1733 ms_dprintf(ADP_L1,"MFEFB Virtual start 0x%x, Physical start 0x%x, madp_mfe_buff_info.mfe_buf_size 0x%x.\n",
1734 (unsigned int)madp_mfe_buff_info.mfe_buf_va,(unsigned int) madp_mfe_buff_info.mfe_buf_pa_withoutoffset, (unsigned int)madp_mfe_buff_info.mfe_buf_size );
1735
1736 if (0>(mfe_fd = open_dev(MFE_DEVICE, O_RDWR)))
1737 return FALSE;
1738
1739 ioctl(mfe_fd, MFE_IOC_SET_MIU_OFFSET, madp_mfe_buff_info.mfe_miu_offset);
1740
1741 #if defined(_MUXTS_)||defined(VVOIP_INTERFACE1)
1742 mux_frame_buf = my_malloc(&madp_mfe_buff_info.mfe_buf_va, FRAM_BUF_SIZE,"mux_frame_buf");
1743 #endif
1744
1745 // malloc memory for DRV level
1746 temp = (MFE_U32)my_malloc(&madp_mfe_buff_info.mfe_buf_va, MallocToDrvSize,"pretend to allocate for MFE driver"); //pretend to allocate for MFE
1747 appPVR_Info.BitsBuffSize = MallocToDrvSize;
1748
1749 appPVR_Info.BitsBuffStart = (MFE_U32)MAdp_MPool_VA2PA((void*)(temp));
1750
1751 #if defined(_MFE_T8_) && defined(_MIPS_PLATFORM_)
1752 appPVR_Info.BitsBuffStart -= (appPVR_Info.BitsBuffStart&madp_mfe_buff_info.mfe_miu_offset);
1753 #endif
1754
1755 #if defined(_MFE_T8_)||defined(_FPGA_)||defined(WIN32)
1756 appPVR_Info.test_case_format = test_case_format;
1757 appPVR_Info.test_case_num = test_case_num;
1758 #endif
1759 ms_dprintf(ADP_L1,"Test format = %d,Num = %d\n", appPVR_Info.test_case_format, appPVR_Info.test_case_num);
1760 ms_dprintf(ADP_L1,"W=%d H=%d addr=0x%x size = %ld\n", appPVR_Info.width, appPVR_Info.height, (unsigned int)appPVR_Info.BitsBuffStart,appPVR_Info.BitsBuffSize);
1761 ms_dprintf(ADP_L1,"Frameratex100 = %d, bitrate=%d\n", appPVR_Info.FrameRatex100, appPVR_Info.nBitrate);
1762
1763
1764 if ( ioctl(mfe_fd, MFE_IOC_INIT, (MFE_U32)(&appPVR_Info)) != 0)
1765 return FALSE;
1766
1767 Madp_enc_frame_count = Madp_out_frame_count = Encode_stop = 0;
1768
1769 #ifdef NEW_APVR_INTERFACE
1770 thumb_nail.have_thumb = 0;
1771 thumb_nail.I_Frame_ptr = 0;
1772 #endif
1773
1774 #if defined(_YUVGEN_)||defined(_FILE_IN_)
1775 ms_dprintf(ADP_L1,"TARGET_FRAME = %d\n",TARGET_FRAME);
1776 appPVR_Info.nTotalFrames = TARGET_FRAME ;
1777 #endif
1778
1779 #if defined(_FILE_IN_)
1780 if(!(mfe_file_in.infile = fopen("test.yuv","rb")))
1781 ms_dprintf(ADP_L1,"_FILE_IN_ OpenFileIn fail!!\n");
1782
1783 mfe_file_in.outfile = fopen("test_out.264","wb");
1784 mfe_file_in.nFrameSize = appPVR_Info.width*appPVR_Info.height*3/2;
1785 fseek(mfe_file_in.infile,0 , SEEK_END);
1786 mfe_file_in.nTotalFramesInFile = ftell( mfe_file_in.infile ) / mfe_file_in.nFrameSize;
1787 fseek(mfe_file_in.infile,0 , SEEK_SET);
1788
1789 ms_dprintf(ADP_L1,"_FILE_IN_ nTotalFramesInFile = %d\n",mfe_file_in.nTotalFramesInFile);
1790 #endif
1791
1792 return TRUE;
1793 }
1794
MAdp_MFE_Encode(void)1795 MFE_BOOL MAdp_MFE_Encode(void)
1796 {
1797
1798 return MAdp_MFE_Thread_Create();
1799 // return 0;
1800 }
1801
1802
1803 #ifdef VVOIP_INTERFACE1
1804
MApi_MFE_ResetBitrate(MFE_S32 bitrate)1805 MFE_BOOL MApi_MFE_ResetBitrate(MFE_S32 bitrate)
1806 {
1807 if(mfe_state != MFE_Idle)
1808 return FALSE;
1809 appPVR_Info.nBitrate = bitrate;
1810
1811 if (ioctl(mfe_fd, MFE_IOC_RESET_BITRATE, (MFE_U32)(&appPVR_Info))){
1812 ms_dprintf(ADP_L1,"MFE_IOC_RESET_BITRATE error\n");
1813 return FALSE;
1814 }
1815
1816 return TRUE;
1817
1818 }
1819
MApi_MFE_ResetFramerate(MFE_S32 framerate)1820 MFE_BOOL MApi_MFE_ResetFramerate(MFE_S32 framerate)
1821 {
1822 if(mfe_state != MFE_Idle)
1823 return FALSE;
1824 appPVR_Info.FrameRatex100 = framerate*100;
1825
1826 if (ioctl(mfe_fd, MFE_IOC_RESET_FRAMERATE, (MFE_U32)(&appPVR_Info))){
1827 ms_dprintf(ADP_L1,"MFE_IOC_RESET_FRAMERATE error\n");
1828 return FALSE;
1829 }
1830
1831 return TRUE;
1832
1833 }
1834
MApi_MFE_ResetBitrateAndFramerate(MFE_S32 bitrate,MFE_S32 framerate)1835 MFE_BOOL MApi_MFE_ResetBitrateAndFramerate(MFE_S32 bitrate,MFE_S32 framerate)
1836 {
1837 if(mfe_state != MFE_Idle)
1838 return FALSE;
1839 appPVR_Info.nBitrate = bitrate;
1840 appPVR_Info.FrameRatex100 = framerate*100;
1841
1842 if (ioctl(mfe_fd, MFE_IOC_RESET_BITRATE_AND_FRAMERATE, (MFE_U32)(&appPVR_Info))){
1843 ms_dprintf(ADP_L1,"MFE_IOC_RESET_BITRATE_AND_FRAMERATE error\n");
1844 return FALSE;
1845 }
1846
1847 return TRUE;
1848
1849 }
1850
MApi_MFE_CompressOnePicture(MFE_U32 YUVPlane,MFE_BOOL bForceIframe)1851 MFE_BOOL MApi_MFE_CompressOnePicture(MFE_U32 YUVPlane, MFE_BOOL bForceIframe)
1852 {
1853
1854 if(mfe_state != MFE_Idle) {
1855 ms_dprintf(ADP_L1,"MApi_MFE_CompressOnePicture() return FALSE\n");
1856 return FALSE;
1857 }
1858 else
1859 MAdp_MFE_Change_State(MFE_Busy);
1860
1861 VVOIP_MFE_input_VAaddr = (MFE_U32) MAdp_MPool_PA2KSEG1((void *)YUVPlane);
1862 ms_dprintf(ADP_L0,"MApi_MFE_CompressOnePicture()\n");
1863
1864 if(bForceIframe) {
1865 ioctl(mfe_fd, MFE_IOC_SET_FORCEDI, (MFE_U32)NULL);
1866 }
1867 //sem_post(&madp_sem_input);
1868 MAdp_MFE_Sem_Wake_Up();
1869 return TRUE;
1870
1871 }
1872
MApi_MFE_Encode(void)1873 MFE_BOOL MApi_MFE_Encode(void)
1874 {
1875
1876 if(mfe_state == MFE_Init)
1877 MAdp_MFE_Change_State(MFE_Busy);
1878 else
1879 return FALSE;
1880
1881 return MAdp_MFE_Thread_Create();
1882
1883 }
1884
MApi_MFE_SetGOP(MFE_S32 PbetweenI,MFE_BOOL is_infinite)1885 MFE_BOOL MApi_MFE_SetGOP(MFE_S32 PbetweenI,MFE_BOOL is_infinite)
1886 {
1887 appPVR_Info.nPbetweenI = PbetweenI;
1888 appPVR_Info.nP_is_infinite = is_infinite;
1889
1890 return TRUE;
1891 }
1892
1893
MApi_MFE_Initialize(VOIP_CODEC_TYPE codec_type,MFE_U32 gDipVideoWidth,MFE_U32 gDipVideoHeight,PQ_LEVEL picture_quality,StreamCallback out_cb,CleanCallback mfe_CleanBufStatus,void * ctx)1894 MFE_BOOL MApi_MFE_Initialize(VOIP_CODEC_TYPE codec_type,MFE_U32 gDipVideoWidth,MFE_U32 gDipVideoHeight, PQ_LEVEL picture_quality,
1895 StreamCallback out_cb,CleanCallback mfe_CleanBufStatus, void *ctx)
1896 {
1897
1898 MFE_U32 ret;
1899 int bitrate = 128000;
1900 int frm_size = gDipVideoWidth*gDipVideoHeight;
1901 int test_case;
1902
1903 switch (codec_type) {
1904 case VOIP_MPEG4:
1905 appPVR_Info.nCodecType = 0;
1906 test_case = 99;
1907 break;
1908 case VOIP_H263:
1909 appPVR_Info.nCodecType = 1;
1910 test_case = 99;
1911 break;
1912 case VOIP_H264:
1913 appPVR_Info.nCodecType = 2;
1914 test_case = 99;
1915 break;
1916 default:
1917 return FALSE;
1918 }
1919
1920 appPVR_Info.nDispWidth= gDipVideoWidth;
1921 appPVR_Info.nDispHeight= gDipVideoHeight;
1922 appPVR_Info.nBufWidth = gDipVideoWidth/16*16 + (gDipVideoWidth%16!=0 ? 16:0);
1923 appPVR_Info.nBufHeight= gDipVideoHeight/16*16 + (gDipVideoHeight%16!=0 ? 16:0);
1924 appPVR_Info.width = appPVR_Info.nBufWidth;
1925 appPVR_Info.height = appPVR_Info.nBufHeight;
1926
1927 appPVR_Info.FrameRatex100 = 3000;
1928 appPVR_Info.nBbetweenP = 0;
1929 //appPVR_Info.nPbetweenI = 100;
1930 appPVR_Info.bInterlace = 0;
1931
1932 if (frm_size <= 176*144) {
1933 switch (picture_quality) {
1934 case PQ_LOW:
1935 bitrate = 32000;
1936 break;
1937 case PQ_NORMAL:
1938 bitrate = 64000;
1939 break;
1940 case PQ_HIGH:
1941 default:
1942 bitrate = 96000;
1943 break;
1944 }
1945 }
1946 else if (frm_size <= 352*288) {
1947 switch (picture_quality) {
1948 case PQ_LOW:
1949 bitrate = 128000;
1950 break;
1951 case PQ_NORMAL:
1952 bitrate = 192000;
1953 break;
1954 case PQ_HIGH:
1955 default:
1956 bitrate = 256000;
1957 break;
1958 }
1959 }
1960 //else if (frm_size <= 704*576) {
1961 else if (frm_size <= 720*576) {
1962 switch (picture_quality) {
1963 case PQ_LOW:
1964 bitrate = 512000;
1965 break;
1966 case PQ_NORMAL:
1967 bitrate = 1024000;
1968 break;
1969 case PQ_HIGH:
1970 default:
1971 bitrate = 1536000;
1972 break;
1973 }
1974 }
1975 else if (frm_size <= 960*576) {
1976 switch (picture_quality) {
1977 case PQ_LOW:
1978 bitrate = 1024000;
1979 break;
1980 case PQ_NORMAL:
1981 bitrate = 1536000;
1982 break;
1983 case PQ_HIGH:
1984 default:
1985 bitrate = 2048000;
1986 break;
1987 }
1988 }
1989 else {
1990 return FALSE;
1991 }
1992
1993 appPVR_Info.nBitrate= bitrate;
1994
1995 DIP_Total_Num = 1;
1996 g_pCustomCtx = ctx;
1997 g_StreamCallBackFunc = out_cb;
1998 g_CleanCallBackFunc = mfe_CleanBufStatus;
1999
2000 MAdp_MFE_Sem_Init();
2001 MAdp_MFE_Mutex_Init();
2002 ret = MAdp_MFE_Init((float)appPVR_Info.FrameRatex100 / 100,appPVR_Info.nCodecType,test_case);
2003
2004 ms_dprintf(ADP_L1," After msAPI_MFE_Initialize\n");
2005 ms_dprintf(ADP_L1,"BUF:%dx%d, bitrate=%d,fps=%f \n",appPVR_Info.width,appPVR_Info.height,appPVR_Info.nBitrate,(float)appPVR_Info.FrameRatex100 / 100);
2006 ms_dprintf(ADP_L1,"DIS:%dx%d\n",appPVR_Info.nDispWidth,appPVR_Info.nDispHeight);
2007
2008 if((MFE_BOOL)ret == FALSE)
2009 return FALSE;
2010
2011 return MAdp_MFE_Change_State(MFE_Init);
2012
2013
2014 }
2015
MApi_MFE_DeInitialize(void)2016 MFE_BOOL MApi_MFE_DeInitialize(void)
2017 {
2018
2019 MAdp_MFE_Change_State(MFE_DeInit);
2020 return MAdp_MFE_Finish() == 0 ? TRUE : FALSE;
2021
2022 }
2023
MApi_MFE_GetState(void)2024 MFE_STATE MApi_MFE_GetState(void)
2025 {
2026 return mfe_state;
2027 }
2028
MApi_MFE_GetVOL(MFE_S8 * Buf)2029 MFE_BOOL MApi_MFE_GetVOL(MFE_S8* Buf)
2030 {
2031
2032 if(mfe_state != MFE_Idle)
2033 return FALSE;
2034
2035 ioctl(mfe_fd, MFE_IOC_GET_VOL, (MFE_U32)Buf);
2036
2037 //GETVOL test codes
2038 /*
2039 size = (Buf[1]<<8)|Buf[0];
2040
2041 ms_dprintf(ADP_L1, "[MFE_IOC_GET_VOL] size = %d\n", size);
2042 for (i=0; i<size; i++) {
2043 ms_dprintf(ADP_L1, "%02x ", Buf[i+2]);
2044 if ((i+1)%16 == 0)
2045 ms_dprintf(ADP_L1, "\n");
2046 }
2047 */
2048
2049 return TRUE;
2050 }
2051
2052 #endif
2053
2054
2055
2056
2057