summaryrefslogtreecommitdiff
path: root/tvapi/libtv/tv/CAv.cpp (plain)
blob: 54f44e255825c174d1dbac44660759284e57ee3a
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>
12CAv::CAv()
13{
14 mpObserver = NULL;
15 mTvPlayDevId = 0;
16 mCurVideoLayerMuteState = -1;
17 mCurDisableVideoColor = -1;
18 mFdAmVideo = -1;
19}
20CAv::~CAv()
21{
22
23}
24int CAv::SetVideoWindow(int x, int y, int w, int h)
25{
26 return AM_AV_SetVideoWindow (mTvPlayDevId, x, y, w, h );
27}
28
29int CAv::Open()
30{
31 AM_AV_OpenPara_t para_av;
32 memset ( &para_av, 0, sizeof ( AM_AV_OpenPara_t ) );
33 int rt = AM_AV_Open ( mTvPlayDevId, &para_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
63int 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
76int CAv::GetVideoStatus(AM_AV_VideoStatus_t *status)
77{
78 return AM_AV_GetVideoStatus(mTvPlayDevId, status);
79}
80
81int 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
86int CAv::ResetAudioDecoder()
87{
88 return AM_AV_ResetAudioDecoder ( mTvPlayDevId );
89}
90
91int CAv::SetTSSource(AM_AV_TSSource_t ts_source)
92{
93 return AM_AV_SetTSSource ( mTvPlayDevId, ts_source );
94}
95
96int 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
101int CAv::StopTS()
102{
103 return AM_AV_StopTS (mTvPlayDevId);
104}
105
106int CAv::AudioGetOutputMode(AM_AOUT_OutputMode_t *mode)
107{
108 return AM_AOUT_GetOutputMode ( 0, mode );
109}
110
111int CAv::AudioSetOutputMode(AM_AOUT_OutputMode_t mode)
112{
113 return AM_AOUT_SetOutputMode ( 0, mode );
114}
115
116int CAv::EnableVideoBlackout()
117{
118 return AM_AV_EnableVideoBlackout(mTvPlayDevId);
119}
120
121int CAv::DisableVideoBlackout()
122{
123 return AM_AV_DisableVideoBlackout(mTvPlayDevId);
124}
125
126int 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
139int 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,
152int 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
166int 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
183int 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
203int 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
212bool 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
225int 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
241tvin_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
256int CAv::ClearVideoBuffer()
257{
258 LOGD("ClearVideoBuffer");
259 return AM_AV_ClearVideoBuffer(mTvPlayDevId);
260}
261int 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
287int CAv::getVideoDisableValue()
288{
289 LOGD("this fun is empty!!!!!!!!");
290 return 0;
291}
292
293int 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
314int 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
327int 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
342int 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
356video_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
376void 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
416int 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
462int 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
generated by cgit at 2024-05-10 08:56:58 (GMT)