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