blob: 904ee3b6bff8c61576778f931d165493207f0d7a
1 | #include "CAv.h" |
2 | #define LOG_TAG "CAv" |
3 | #include "../tvutils/tvutils.h" |
4 | #include "../tvconfig/tvconfig.h" |
5 | #include <stdio.h> |
6 | #include <unistd.h> |
7 | #include <sys/types.h> |
8 | #include <sys/stat.h> |
9 | #include <sys/ioctl.h> |
10 | #include <fcntl.h> |
11 | #include <amstream.h> |
12 | CAv::CAv() |
13 | { |
14 | mpObserver = NULL; |
15 | mTvPlayDevId = 0; |
16 | mCurVideoLayerMuteState = -1; |
17 | mCurDisableVideoColor = -1; |
18 | mFdAmVideo = -1; |
19 | } |
20 | CAv::~CAv() |
21 | { |
22 | |
23 | } |
24 | int CAv::SetVideoWindow(int x, int y, int w, int h) |
25 | { |
26 | return AM_AV_SetVideoWindow (mTvPlayDevId, x, y, w, h ); |
27 | } |
28 | |
29 | int CAv::Open() |
30 | { |
31 | AM_AV_OpenPara_t para_av; |
32 | memset ( ¶_av, 0, sizeof ( AM_AV_OpenPara_t ) ); |
33 | int rt = AM_AV_Open ( mTvPlayDevId, ¶_av ); |
34 | if ( rt != AM_SUCCESS ) { |
35 | LOGD ( "%s, dvbplayer_open fail %d %d\n!" , __FUNCTION__, mTvPlayDevId, rt ); |
36 | return -1; |
37 | } |
38 | |
39 | //open audio channle output |
40 | AM_AOUT_OpenPara_t aout_para; |
41 | memset ( &aout_para, 0, sizeof ( AM_AOUT_OpenPara_t ) ); |
42 | rt = AM_AOUT_Open ( 0, &aout_para ); |
43 | |
44 | if ( AM_SUCCESS != rt ) { |
45 | LOGD ( "%s, BUG: CANN'T OPEN AOUT\n", __FUNCTION__); |
46 | } |
47 | // |
48 | mFdAmVideo = open ( PATH_VIDEO_AMVIDEO, O_RDWR ); |
49 | if ( mFdAmVideo < 0 ) { |
50 | LOGE ( "mFdAmVideo < 0, error(%s)!\n", strerror ( errno ) ); |
51 | return -1; |
52 | } |
53 | /*Register events*/ |
54 | AM_EVT_Subscribe ( mTvPlayDevId, AM_AV_EVT_AV_NO_DATA, av_evt_callback, this ); |
55 | AM_EVT_Subscribe ( mTvPlayDevId, AM_AV_EVT_AV_DATA_RESUME, av_evt_callback, this ); |
56 | AM_EVT_Subscribe ( mTvPlayDevId, AM_AV_EVT_VIDEO_SCAMBLED, av_evt_callback, this ); |
57 | AM_EVT_Subscribe ( mTvPlayDevId, AM_AV_EVT_AUDIO_SCAMBLED, av_evt_callback, this ); |
58 | AM_EVT_Subscribe ( mTvPlayDevId, AM_AV_EVT_VIDEO_NOT_SUPPORT, av_evt_callback, this ); |
59 | |
60 | return rt; |
61 | } |
62 | |
63 | int CAv::Close() |
64 | { |
65 | int iRet; |
66 | iRet = AM_AV_Close ( mTvPlayDevId ); |
67 | iRet = AM_AOUT_Close ( mTvPlayDevId ); |
68 | if (mFdAmVideo > 0) { |
69 | close(mFdAmVideo); |
70 | mFdAmVideo = -1; |
71 | } |
72 | return iRet; |
73 | } |
74 | |
75 | |
76 | int CAv::GetVideoStatus(AM_AV_VideoStatus_t *status) |
77 | { |
78 | return AM_AV_GetVideoStatus(mTvPlayDevId, status); |
79 | } |
80 | |
81 | int CAv::SwitchTSAudio(int apid, AM_AV_AFormat_t afmt) |
82 | { |
83 | return AM_AV_SwitchTSAudio (mTvPlayDevId, ( uint16_t ) apid, ( AM_AV_AFormat_t ) afmt ); |
84 | } |
85 | |
86 | int CAv::ResetAudioDecoder() |
87 | { |
88 | return AM_AV_ResetAudioDecoder ( mTvPlayDevId ); |
89 | } |
90 | |
91 | int CAv::SetTSSource(AM_AV_TSSource_t ts_source) |
92 | { |
93 | return AM_AV_SetTSSource ( mTvPlayDevId, ts_source ); |
94 | } |
95 | |
96 | int CAv::StartTS(uint16_t vpid, uint16_t apid, AM_AV_VFormat_t vfmt, AM_AV_AFormat_t afmt) |
97 | { |
98 | return AM_AV_StartTS ( mTvPlayDevId, vpid, apid, ( AM_AV_VFormat_t ) vfmt, ( AM_AV_AFormat_t ) afmt ); |
99 | } |
100 | |
101 | int CAv::StopTS() |
102 | { |
103 | return AM_AV_StopTS (mTvPlayDevId); |
104 | } |
105 | |
106 | int CAv::AudioGetOutputMode(AM_AOUT_OutputMode_t *mode) |
107 | { |
108 | return AM_AOUT_GetOutputMode ( 0, mode ); |
109 | } |
110 | |
111 | int CAv::AudioSetOutputMode(AM_AOUT_OutputMode_t mode) |
112 | { |
113 | return AM_AOUT_SetOutputMode ( 0, mode ); |
114 | } |
115 | |
116 | int CAv::EnableVideoBlackout() |
117 | { |
118 | return AM_AV_EnableVideoBlackout(mTvPlayDevId); |
119 | } |
120 | |
121 | int CAv::DisableVideoBlackout() |
122 | { |
123 | return AM_AV_DisableVideoBlackout(mTvPlayDevId); |
124 | } |
125 | |
126 | int CAv::DisableVideoWithBlueColor() |
127 | { |
128 | LOGD("DisableVideoWithBlueColor"); |
129 | if (mCurVideoLayerMuteState == 1 && mCurDisableVideoColor == DISABLE_VIDEO_COLOR_BLUE) { |
130 | LOGD("video is disable with blue, return"); |
131 | return 0; |
132 | } |
133 | mCurVideoLayerMuteState = 1; |
134 | mCurDisableVideoColor = DISABLE_VIDEO_COLOR_BLUE; |
135 | SetVideoScreenColor ( 0, 41, 240, 110 ); // Show blue with vdin0, postblending disabled |
136 | return AM_AV_DisableVideo(mTvPlayDevId); |
137 | } |
138 | |
139 | int CAv::DisableVideoWithBlackColor() |
140 | { |
141 | LOGD("DisableVideoWithBlackColor"); |
142 | if (mCurVideoLayerMuteState == 1 && mCurDisableVideoColor == DISABLE_VIDEO_COLOR_BLACK) { |
143 | LOGD("video is disable with black, return"); |
144 | return 0; |
145 | } |
146 | mCurDisableVideoColor = DISABLE_VIDEO_COLOR_BLACK; |
147 | mCurVideoLayerMuteState = 1; |
148 | SetVideoScreenColor ( 0, 16, 128, 128 ); // Show blue with vdin0, postblending disabled |
149 | return AM_AV_DisableVideo(mTvPlayDevId); |
150 | } |
151 | //auto enable, |
152 | int CAv::EnableVideoAuto() |
153 | { |
154 | LOGD("EnableVideo"); |
155 | if (mCurVideoLayerMuteState == 0) { |
156 | LOGD("video is enable, return"); |
157 | return 0; |
158 | } |
159 | mCurVideoLayerMuteState = 0; |
160 | SetVideoScreenColor ( 0, 16, 128, 128 ); // Show black with vdin0, postblending disabled |
161 | ClearVideoBuffer();//disable video 2 |
162 | return 0; |
163 | } |
164 | |
165 | //just enable video |
166 | int CAv::EnableVideoNow() |
167 | { |
168 | LOGD("EnableVideoNow"); |
169 | const char *config_value = NULL; |
170 | if (mCurVideoLayerMuteState == 0) { |
171 | LOGD("video is enable, return"); |
172 | return 0; |
173 | } |
174 | mCurVideoLayerMuteState = 0; |
175 | config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" ); |
176 | if ( strcmp ( config_value, "black" ) == 0 ) { |
177 | } else { |
178 | SetVideoScreenColor ( 0, 16, 128, 128 ); // Show blue with vdin0, postblending disabled |
179 | } |
180 | return AM_AV_EnableVideo(mTvPlayDevId); |
181 | } |
182 | |
183 | int CAv::WaittingVideoPlaying(int minFrameCount , int waitTime ) |
184 | { |
185 | //EnableVideoNow(); |
186 | static const int COUNT_FOR_TIME = 20; |
187 | int times = waitTime / COUNT_FOR_TIME; |
188 | int ret = -1; |
189 | int i = 0; |
190 | for (i = 0; i < times; i++) { |
191 | if (videoIsPlaying(minFrameCount)) { |
192 | ret = 0; |
193 | break; |
194 | } |
195 | } |
196 | if (i == times) { |
197 | LOGD("EnableVideoWhenVideoPlaying time out!!!!!!!!!!!!!"); |
198 | ret = -2; |
199 | } |
200 | return ret; |
201 | } |
202 | |
203 | int CAv::EnableVideoWhenVideoPlaying(int minFrameCount, int waitTime) |
204 | { |
205 | int ret = WaittingVideoPlaying(minFrameCount, waitTime); |
206 | if (ret == 0) { //ok to playing |
207 | EnableVideoNow(); |
208 | } |
209 | return ret; |
210 | } |
211 | |
212 | bool CAv::videoIsPlaying(int minFrameCount) |
213 | { |
214 | int value[3]; |
215 | value[0] = getVideoFrameCount(); |
216 | usleep(20 * 1000); |
217 | value[1] = getVideoFrameCount(); |
218 | //usleep(20*1000); |
219 | //value[2] = getVideoFrameCount(); |
220 | LOGD("---videoIsPlaying framecount =%d = %d = %d", value[0], value[1], value[2]); |
221 | if (value[1] >= minFrameCount && (value[1] > value[0])) return true; |
222 | else return false; |
223 | } |
224 | |
225 | int CAv::getVideoFrameCount() |
226 | { |
227 | char buf[32]; |
228 | int fd = -1; |
229 | fd = open(PATH_FRAME_COUNT, O_RDWR); |
230 | if (fd < 0) { |
231 | LOGW("Open %s error(%s)!\n", PATH_FRAME_COUNT, strerror(errno)); |
232 | return -1; |
233 | } |
234 | read(fd, buf, sizeof(buf)); |
235 | int value = 0; |
236 | sscanf ( buf, "%d", &value ); |
237 | close ( fd ); |
238 | return value; |
239 | } |
240 | |
241 | tvin_sig_fmt_t CAv::getVideoResolutionToFmt() |
242 | { |
243 | tvin_sig_fmt_e sig_fmt = TVIN_SIG_FMT_HDMI_1920X1080P_60HZ; |
244 | int height = CFile::getFileAttrValue(PATH_VIDEO_HEIGHT); |
245 | LOGD("---------getVideoResolutionToFmt -------- height = %d", height); |
246 | if (height <= 576) { |
247 | sig_fmt = TVIN_SIG_FMT_HDMI_720X480P_60HZ; |
248 | } else if (height >576 && height <= 1088) { |
249 | sig_fmt = TVIN_SIG_FMT_HDMI_1920X1080P_60HZ; |
250 | } else { |
251 | sig_fmt = TVIN_SIG_FMT_HDMI_3840_2160_00HZ; |
252 | } |
253 | return sig_fmt; |
254 | } |
255 | //call disable video 2 |
256 | int CAv::ClearVideoBuffer() |
257 | { |
258 | LOGD("ClearVideoBuffer"); |
259 | return AM_AV_ClearVideoBuffer(mTvPlayDevId); |
260 | } |
261 | int CAv::SetVideoScreenColor ( int vdin_blending_mask, int y, int u, int v ) |
262 | { |
263 | FILE *fp = NULL; |
264 | unsigned long value = 0; |
265 | |
266 | value = vdin_blending_mask << 24; |
267 | |
268 | value |= ( unsigned int ) ( y << 16 ) | ( unsigned int ) ( u << 8 ) | ( unsigned int ) ( v ); |
269 | |
270 | fp = fopen ( "/sys/class/video/test_screen", "w" ); |
271 | LOGD ( "~~~fopen~~~##VPP_SetVideoScreenColor##%s : vdin_blending_mask:%d,y:%d,u:%d,v:%d ##" , "/sys/class/video/test_screen", vdin_blending_mask, y, u, v); |
272 | |
273 | |
274 | if ( fp == NULL ) { |
275 | LOGE ( "Open /sys/class/video/test_screen error(%s)!\n", strerror ( errno ) ); |
276 | return -1; |
277 | } |
278 | |
279 | fprintf ( fp, "0x%lx", ( unsigned long ) value ); |
280 | |
281 | fclose ( fp ); |
282 | fp = NULL; |
283 | |
284 | return 0; |
285 | } |
286 | |
287 | int CAv::getVideoDisableValue() |
288 | { |
289 | LOGD("this fun is empty!!!!!!!!"); |
290 | return 0; |
291 | } |
292 | |
293 | int CAv::SetVideoLayerDisable ( int value ) |
294 | { |
295 | FILE *fp = NULL; |
296 | |
297 | fp = fopen ( "/sys/class/video/disable_video", "w" ); |
298 | LOGD ( "~~~fopen~~~##VPP_SetVideoLayerDisable##%s : %d ##" , "/sys/class/video/disable_video", value); |
299 | |
300 | if ( fp == NULL ) { |
301 | LOGE ( "Open /sys/class/video/disable_video error(%s)!\n", strerror ( errno ) ); |
302 | return -1; |
303 | } |
304 | |
305 | fprintf ( fp, "%d", value ); |
306 | |
307 | fclose ( fp ); |
308 | fp = NULL; |
309 | |
310 | return 0; |
311 | } |
312 | |
313 | |
314 | int CAv::setVideoScreenMode ( int value ) |
315 | { |
316 | FILE *fp = fopen ( "/sys/class/video/screen_mode", "w" ); |
317 | LOGD ( "setVideoScreenMode %d ##" , value); |
318 | if ( fp == NULL ) { |
319 | LOGE ( "Open /sys/class/video/screen_mode error(%s)!\n", strerror ( errno ) ); |
320 | return -1; |
321 | } |
322 | fprintf ( fp, "%d", value ); |
323 | fclose ( fp ); |
324 | return 0; |
325 | } |
326 | |
327 | int CAv::setVideoAxis ( int h, int v, int width, int height ) |
328 | { |
329 | FILE *fp = NULL; |
330 | fp = fopen ( "/sys/class/video/axis", "w" ); |
331 | LOGD ( "setVideoAxis##%s : %d %d %d %d ##" , "/sys/class/video/axis", h, v, width, height); |
332 | |
333 | if ( fp == NULL ) { |
334 | LOGE ( "Open /sys/class/video/axis ERROR(%s)!!\n", strerror ( errno ) ); |
335 | return -1; |
336 | } |
337 | fprintf ( fp, "%d %d %d %d", h, v, width, height ); |
338 | fclose ( fp ); |
339 | return 0; |
340 | } |
341 | |
342 | int CAv::getVideoScreenMode() |
343 | { |
344 | int value; |
345 | FILE *fp = fopen ( "/sys/class/video/screen_mode", "r+" ); |
346 | |
347 | if ( fp == NULL ) { |
348 | LOGE ( "Open /sys/class/video/screen_mode error(%s)!\n", strerror ( errno ) ); |
349 | return -1; |
350 | } |
351 | fscanf ( fp, "%d", &value ); |
352 | fclose ( fp ); |
353 | return value; |
354 | } |
355 | |
356 | video_display_resolution_t CAv::getVideoDisplayResolution() |
357 | { |
358 | char attrV[64]; |
359 | memset (attrV, 0x0, 64); |
360 | Tv_Utils_GetFileAttrStr ( "/sys/class/video/device_resolution", 64, attrV ); |
361 | video_display_resolution_t resolution; |
362 | if (strncasecmp(attrV, "1366x768", strlen ("1366x768")) == 0) { |
363 | resolution = VPP_DISPLAY_RESOLUTION_1366X768; |
364 | } else if (strncasecmp(attrV, "3840x2160", strlen ("3840x2160")) == 0) { |
365 | resolution = VPP_DISPLAY_RESOLUTION_3840X2160; |
366 | } else if (strncasecmp(attrV, "1920x1080", strlen ("1920x1080")) == 0) { |
367 | resolution = VPP_DISPLAY_RESOLUTION_1920X1080; |
368 | } else { |
369 | LOGW("video display resolution is = (%s) not define , default it", attrV); |
370 | resolution = VPP_DISPLAY_RESOLUTION_1920X1080; |
371 | } |
372 | |
373 | return resolution; |
374 | } |
375 | |
376 | void CAv::av_evt_callback ( long dev_no, int event_type, void *param, void *user_data ) |
377 | { |
378 | CAv *pAv = ( CAv * ) user_data; |
379 | if (NULL == pAv ) { |
380 | LOGD ( "%s, ERROR : av_evt_callback NULL == pTv\n", __FUNCTION__ ); |
381 | return ; |
382 | } |
383 | if ( pAv->mpObserver == NULL ) { |
384 | LOGD ( "%s, ERROR : mpObserver NULL == mpObserver\n", __FUNCTION__ ); |
385 | return; |
386 | } |
387 | switch ( event_type ) { |
388 | case AM_AV_EVT_AV_NO_DATA: |
389 | pAv->mCurAvEvent.type = AVEvent::EVENT_AV_STOP; |
390 | pAv->mCurAvEvent.param = ( int )param; |
391 | pAv->mpObserver->onEvent(pAv->mCurAvEvent); |
392 | break; |
393 | case AM_AV_EVT_AV_DATA_RESUME: |
394 | pAv->mCurAvEvent.type = AVEvent::EVENT_AV_RESUEM; |
395 | pAv->mCurAvEvent.param = ( int )param; |
396 | pAv->mpObserver->onEvent(pAv->mCurAvEvent); |
397 | break; |
398 | case AM_AV_EVT_VIDEO_SCAMBLED: |
399 | case AM_AV_EVT_AUDIO_SCAMBLED: |
400 | pAv->mCurAvEvent.type = AVEvent::EVENT_AV_SCAMBLED; |
401 | pAv->mCurAvEvent.param = ( int )param; |
402 | pAv->mpObserver->onEvent(pAv->mCurAvEvent); |
403 | break; |
404 | case AM_AV_EVT_VIDEO_NOT_SUPPORT: { |
405 | pAv->mCurAvEvent.type = AVEvent::EVENT_AV_UNSUPPORT; |
406 | pAv->mCurAvEvent.param = ( int )param; |
407 | pAv->mpObserver->onEvent(pAv->mCurAvEvent); |
408 | break; |
409 | } |
410 | default: |
411 | break; |
412 | } |
413 | LOGD ( "%s, av_evt_callback : dev_no %d type %d param = %d\n", __FUNCTION__, dev_no, pAv->mCurAvEvent.type , (int)param); |
414 | } |
415 | |
416 | int CAv::set3DMode(VIDEO_3D_MODE_T mode, int LR_switch, int mode_3D_TO_2D) |
417 | { |
418 | unsigned int cmd = MODE_3D_DISABLE; |
419 | switch (mode) { |
420 | case VIDEO_3D_MODE_DISABLE: |
421 | cmd = MODE_3D_DISABLE; |
422 | break; |
423 | case VIDEO_3D_MODE_AUTO: |
424 | cmd = MODE_3D_ENABLE | MODE_3D_AUTO; |
425 | break; |
426 | case VIDEO_3D_MODE_LR: |
427 | cmd = MODE_3D_ENABLE | MODE_3D_LR; |
428 | break; |
429 | case VIDEO_3D_MODE_TB: |
430 | cmd = MODE_3D_ENABLE | MODE_3D_TB; |
431 | break; |
432 | case VIDEO_3D_MODE_LA: |
433 | cmd = MODE_3D_ENABLE | MODE_3D_LA; |
434 | break; |
435 | case VIDEO_3D_MODE_FA: |
436 | cmd = MODE_3D_ENABLE | MODE_3D_FA; |
437 | break; |
438 | default: |
439 | cmd = MODE_3D_DISABLE; |
440 | break; |
441 | } |
442 | |
443 | if (LR_switch == 1) { |
444 | cmd = cmd | MODE_3D_LR_SWITCH; |
445 | } |
446 | |
447 | if (mode_3D_TO_2D == 1) { |
448 | cmd = cmd | MODE_3D_TO_2D_L; |
449 | } |
450 | |
451 | if (mode_3D_TO_2D == 2) { |
452 | cmd = cmd | MODE_3D_TO_2D_R; |
453 | } |
454 | LOGD("set 3d mode fd = %d cmd = 0x%x", mFdAmVideo, cmd); |
455 | int ret = ioctl(mFdAmVideo, AMSTREAM_IOC_SET_3D_TYPE , cmd); |
456 | if (ret < 0) { |
457 | LOGE("set3DMode error ( %s )", strerror ( errno )); |
458 | } |
459 | return 0; |
460 | } |
461 | |
462 | int CAv::setLookupPtsForDtmb(int enable) |
463 | { |
464 | FILE *fp = fopen ( PATH_MEPG_DTMB_LOOKUP_PTS_FLAG, "w" ); |
465 | LOGD ( "setLookupPtsForDtmb %d ##" , enable); |
466 | if ( fp == NULL ) { |
467 | LOGE ( "Open %s error(%s)!\n", PATH_MEPG_DTMB_LOOKUP_PTS_FLAG, strerror ( errno ) ); |
468 | return -1; |
469 | } |
470 | fprintf ( fp, "%d", enable ); |
471 | fclose ( fp ); |
472 | return 0; |
473 | } |
474 |