1 #include <lib/base/ebase.h>
2 #include <lib/base/eerror.h>
3 #include <lib/dvb/decoder.h>
4 #include <linux/dvb/audio.h>
5 #include <linux/dvb/video.h>
6 #include <linux/dvb/dmx.h>
10 #include <sys/ioctl.h>
11 #include <sys/types.h>
15 #include <lib/dvb/fccdecoder.h>
17 /* these are quite new... */
19 #define AUDIO_GET_PTS _IOR('o', 19, __u64)
20 #define VIDEO_GET_PTS _IOR('o', 57, __u64)
23 #ifndef VIDEO_SOURCE_HDMI
24 #define VIDEO_SOURCE_HDMI 2
26 #ifndef AUDIO_SOURCE_HDMI
27 #define AUDIO_SOURCE_HDMI 2
30 DEFINE_REF(eDVBAudio);
32 eDVBAudio::eDVBAudio(eDVBDemux *demux, int dev)
33 :m_demux(demux), m_dev(dev)
36 sprintf(filename, "/dev/dvb/adapter%d/audio%d", demux ? demux->adapter : 0, dev);
37 m_fd = ::open(filename, O_RDWR);
39 eWarning("%s: %m", filename);
42 sprintf(filename, "/dev/dvb/adapter%d/demux%d", demux->adapter, demux->demux);
43 m_fd_demux = ::open(filename, O_RDWR);
45 eWarning("%s: %m", filename);
54 ::ioctl(m_fd, AUDIO_SELECT_SOURCE, demux ? AUDIO_SOURCE_DEMUX : AUDIO_SOURCE_HDMI);
58 int eDVBAudio::startPid(int pid, int type)
62 dmx_pes_filter_params pes;
65 pes.input = DMX_IN_FRONTEND;
66 pes.output = DMX_OUT_DECODER;
70 pes.pes_type = DMX_PES_AUDIO0;
73 pes.pes_type = DMX_PES_AUDIO1;
76 pes.pes_type = DMX_PES_AUDIO2;
79 pes.pes_type = DMX_PES_AUDIO3;
83 eDebugNoNewLine("DMX_SET_PES_FILTER(0x%02x) - audio - ", pid);
84 if (::ioctl(m_fd_demux, DMX_SET_PES_FILTER, &pes) < 0)
86 eDebug("failed (%m)");
90 eDebugNoNewLine("DEMUX_START - audio - ");
91 if (::ioctl(m_fd_demux, DMX_START) < 0)
93 eDebug("failed (%m)");
132 eDebugNoNewLine("AUDIO_SET_BYPASS(%d) - ", bypass);
133 if (::ioctl(m_fd, AUDIO_SET_BYPASS_MODE, bypass) < 0)
134 eDebug("failed (%m)");
137 freeze(); // why freeze here?!? this is a problem when only a pid change is requested... because of the unfreeze logic in Decoder::setState
138 eDebugNoNewLine("AUDIO_PLAY - ");
139 if (::ioctl(m_fd, AUDIO_PLAY) < 0)
140 eDebug("failed (%m)");
147 void eDVBAudio::stop()
151 eDebugNoNewLine("AUDIO_STOP - ");
152 if (::ioctl(m_fd, AUDIO_STOP) < 0)
153 eDebug("failed (%m)");
160 eDebugNoNewLine("DEMUX_STOP - audio - ");
161 if (::ioctl(m_fd_demux, DMX_STOP) < 0)
162 eDebug("failed (%m)");
168 void eDVBAudio::flush()
170 eDebugNoNewLine("AUDIO_CLEAR_BUFFER - ");
171 if (::ioctl(m_fd, AUDIO_CLEAR_BUFFER) < 0)
172 eDebug("failed (%m)");
177 void eDVBAudio::freeze()
179 eDebugNoNewLine("AUDIO_PAUSE - ");
180 if (::ioctl(m_fd, AUDIO_PAUSE) < 0)
181 eDebug("failed (%m)");
186 void eDVBAudio::unfreeze()
188 eDebugNoNewLine("AUDIO_CONTINUE - ");
189 if (::ioctl(m_fd, AUDIO_CONTINUE) < 0)
190 eDebug("failed (%m)");
195 void eDVBAudio::setChannel(int channel)
197 int val = AUDIO_STEREO;
200 case aMonoLeft: val = AUDIO_MONO_LEFT; break;
201 case aMonoRight: val = AUDIO_MONO_RIGHT; break;
204 eDebugNoNewLine("AUDIO_CHANNEL_SELECT(%d) - ", val);
205 if (::ioctl(m_fd, AUDIO_CHANNEL_SELECT, val) < 0)
206 eDebug("failed (%m)");
211 int eDVBAudio::getPTS(pts_t &now)
213 if (::ioctl(m_fd, AUDIO_GET_PTS, &now) < 0)
214 eDebug("AUDIO_GET_PTS failed (%m)");
218 eDVBAudio::~eDVBAudio()
220 unfreeze(); // why unfreeze here... but not unfreeze video in ~eDVBVideo ?!?
227 DEFINE_REF(eDVBVideo);
229 eDVBVideo::eDVBVideo(eDVBDemux *demux, int dev, bool fcc_enable)
230 : m_demux(demux), m_dev(dev), m_fcc_enable(fcc_enable),
231 m_width(-1), m_height(-1), m_framerate(-1), m_aspect(-1), m_progressive(-1)
234 sprintf(filename, "/dev/dvb/adapter%d/video%d", demux ? demux->adapter : 0, dev);
235 m_fd = ::open(filename, O_RDWR);
237 eWarning("%s: %m", filename);
240 m_sn = eSocketNotifier::create(eApp, m_fd, eSocketNotifier::Priority);
241 CONNECT(m_sn->activated, eDVBVideo::video_event);
243 eDebug("Video Device: %s", filename);
249 sprintf(filename, "/dev/dvb/adapter%d/demux%d", demux->adapter, demux->demux);
250 m_fd_demux = ::open(filename, O_RDWR);
252 eWarning("%s: %m", filename);
253 eDebug("demux device: %s", filename);
262 ::ioctl(m_fd, VIDEO_SELECT_SOURCE, demux ? VIDEO_SOURCE_DEMUX : VIDEO_SOURCE_HDMI);
266 // not finally values i think.. !!
267 #define VIDEO_STREAMTYPE_MPEG2 0
268 #define VIDEO_STREAMTYPE_MPEG4_H264 1
269 #define VIDEO_STREAMTYPE_VC1 3
270 #define VIDEO_STREAMTYPE_MPEG4_Part2 4
271 #define VIDEO_STREAMTYPE_VC1_SM 5
272 #define VIDEO_STREAMTYPE_MPEG1 6
273 #define VIDEO_STREAMTYPE_H265_HEVC 7
275 int eDVBVideo::startPid(int pid, int type)
282 int streamtype = VIDEO_STREAMTYPE_MPEG2;
289 streamtype = VIDEO_STREAMTYPE_MPEG4_H264;
292 streamtype = VIDEO_STREAMTYPE_MPEG1;
295 streamtype = VIDEO_STREAMTYPE_MPEG4_Part2;
298 streamtype = VIDEO_STREAMTYPE_VC1;
301 streamtype = VIDEO_STREAMTYPE_VC1_SM;
304 streamtype = VIDEO_STREAMTYPE_H265_HEVC;
308 eDebugNoNewLine("VIDEO_SET_STREAMTYPE %d - ", streamtype);
309 if (::ioctl(m_fd, VIDEO_SET_STREAMTYPE, streamtype) < 0)
310 eDebug("failed (%m)");
318 dmx_pes_filter_params pes;
321 pes.input = DMX_IN_FRONTEND;
322 pes.output = DMX_OUT_DECODER;
326 pes.pes_type = DMX_PES_VIDEO0;
329 pes.pes_type = DMX_PES_VIDEO1;
332 pes.pes_type = DMX_PES_VIDEO2;
335 pes.pes_type = DMX_PES_VIDEO3;
339 eDebugNoNewLine("DMX_SET_PES_FILTER(0x%02x) - video - ", pid);
340 if (::ioctl(m_fd_demux, DMX_SET_PES_FILTER, &pes) < 0)
342 eDebug("failed (%m)");
346 eDebugNoNewLine("DEMUX_START - video - ");
347 if (::ioctl(m_fd_demux, DMX_START) < 0)
349 eDebug("failed (%m)");
357 freeze(); // why freeze here?!? this is a problem when only a pid change is requested... because of the unfreeze logic in Decoder::setState
358 eDebugNoNewLine("VIDEO_PLAY - ");
359 if (::ioctl(m_fd, VIDEO_PLAY) < 0)
360 eDebug("failed (%m)");
367 void eDVBVideo::stop()
374 eDebugNoNewLine("DEMUX_STOP - video - ");
375 if (::ioctl(m_fd_demux, DMX_STOP) < 0)
376 eDebug("failed (%m)");
383 eDebugNoNewLine("VIDEO_STOP - ");
384 if (::ioctl(m_fd, VIDEO_STOP, 1) < 0)
385 eDebug("failed (%m)");
391 void eDVBVideo::flush()
393 eDebugNoNewLine("VIDEO_CLEAR_BUFFER - ");
394 if (::ioctl(m_fd, VIDEO_CLEAR_BUFFER) < 0)
395 eDebug("failed (%m)");
400 void eDVBVideo::freeze()
402 eDebugNoNewLine("VIDEO_FREEZE - ");
403 if (::ioctl(m_fd, VIDEO_FREEZE) < 0)
404 eDebug("failed (%m)");
409 void eDVBVideo::unfreeze()
411 eDebugNoNewLine("VIDEO_CONTINUE - ");
412 if (::ioctl(m_fd, VIDEO_CONTINUE) < 0)
413 eDebug("failed (%m)");
418 int eDVBVideo::setSlowMotion(int repeat)
420 eDebugNoNewLine("VIDEO_SLOWMOTION(%d) - ", repeat);
421 int ret = ::ioctl(m_fd, VIDEO_SLOWMOTION, repeat);
423 eDebug("failed(%m)");
429 int eDVBVideo::setFastForward(int skip)
431 eDebugNoNewLine("VIDEO_FAST_FORWARD(%d) - ", skip);
432 int ret = ::ioctl(m_fd, VIDEO_FAST_FORWARD, skip);
434 eDebug("failed(%m)");
440 int eDVBVideo::getPTS(pts_t &now)
442 int ret = ::ioctl(m_fd, VIDEO_GET_PTS, &now);
444 eDebug("VIDEO_GET_PTS failed(%m)");
448 eDVBVideo::~eDVBVideo()
456 void eDVBVideo::video_event(int)
458 struct video_event evt;
459 eDebugNoNewLine("VIDEO_GET_EVENT - ");
460 if (::ioctl(m_fd, VIDEO_GET_EVENT, &evt) < 0)
461 eDebug("failed (%m)");
465 if (evt.type == VIDEO_EVENT_SIZE_CHANGED)
467 struct iTSMPEGDecoder::videoEvent event;
468 event.type = iTSMPEGDecoder::videoEvent::eventSizeChanged;
469 m_aspect = event.aspect = evt.u.size.aspect_ratio == 0 ? 2 : 3; // convert dvb api to etsi
470 m_height = event.height = evt.u.size.h;
471 m_width = event.width = evt.u.size.w;
472 /* emit */ m_event(event);
474 else if (evt.type == VIDEO_EVENT_FRAME_RATE_CHANGED)
476 struct iTSMPEGDecoder::videoEvent event;
477 event.type = iTSMPEGDecoder::videoEvent::eventFrameRateChanged;
478 m_framerate = event.framerate = evt.u.frame_rate;
479 /* emit */ m_event(event);
481 else if (evt.type == 16 /*VIDEO_EVENT_PROGRESSIVE_CHANGED*/)
483 struct iTSMPEGDecoder::videoEvent event;
484 event.type = iTSMPEGDecoder::videoEvent::eventProgressiveChanged;
485 m_progressive = event.progressive = evt.u.frame_rate;
486 /* emit */ m_event(event);
489 eDebug("unhandled DVBAPI Video Event %d", evt.type);
493 RESULT eDVBVideo::connectEvent(const Slot1<void, struct iTSMPEGDecoder::videoEvent> &event, ePtr<eConnection> &conn)
495 conn = new eConnection(this, m_event.connect(event));
499 static int readMpegProc(const char *str, int decoder)
503 sprintf(tmp, "/proc/stb/vmpeg/%d/%s", decoder, str);
504 FILE *f = fopen(tmp, "r");
507 fscanf(f, "%x", &val);
513 static int readApiSize(int fd, int &xres, int &yres, int &aspect)
516 if (!::ioctl(fd, VIDEO_GET_SIZE, &size))
520 aspect = size.aspect_ratio == 0 ? 2 : 3; // convert dvb api to etsi
523 // eDebug("VIDEO_GET_SIZE failed (%m)");
527 static int readApiFrameRate(int fd, int &framerate)
530 if (!::ioctl(fd, VIDEO_GET_FRAME_RATE, &frate))
535 // eDebug("VIDEO_GET_FRAME_RATE failed (%m)");
539 int eDVBVideo::getWidth()
542 readApiSize(m_fd, m_width, m_height, m_aspect);
544 m_width = readMpegProc("xres", m_dev);
548 int eDVBVideo::getHeight()
551 readApiSize(m_fd, m_width, m_height, m_aspect);
553 m_height = readMpegProc("yres", m_dev);
557 int eDVBVideo::getAspect()
560 readApiSize(m_fd, m_width, m_height, m_aspect);
562 m_aspect = readMpegProc("aspect", m_dev);
566 int eDVBVideo::getProgressive()
568 if (m_progressive == -1)
569 m_progressive = readMpegProc("progressive", m_dev);
570 return m_progressive;
573 int eDVBVideo::getFrameRate()
575 if (m_framerate == -1)
576 readApiFrameRate(m_fd, m_framerate);
577 if (m_framerate == -1)
578 m_framerate = readMpegProc("framerate", m_dev);
584 eDVBPCR::eDVBPCR(eDVBDemux *demux, int dev): m_demux(demux), m_dev(dev)
587 sprintf(filename, "/dev/dvb/adapter%d/demux%d", demux->adapter, demux->demux);
588 m_fd_demux = ::open(filename, O_RDWR);
590 eWarning("%s: %m", filename);
593 int eDVBPCR::startPid(int pid)
597 dmx_pes_filter_params pes;
600 pes.input = DMX_IN_FRONTEND;
601 pes.output = DMX_OUT_DECODER;
605 pes.pes_type = DMX_PES_PCR0;
608 pes.pes_type = DMX_PES_PCR1;
611 pes.pes_type = DMX_PES_PCR2;
614 pes.pes_type = DMX_PES_PCR3;
618 eDebugNoNewLine("DMX_SET_PES_FILTER(0x%02x) - pcr - ", pid);
619 if (::ioctl(m_fd_demux, DMX_SET_PES_FILTER, &pes) < 0)
621 eDebug("failed (%m)");
625 eDebugNoNewLine("DEMUX_START - pcr - ");
626 if (::ioctl(m_fd_demux, DMX_START) < 0)
628 eDebug("failed (%m)");
637 eDebugNoNewLine("DEMUX_STOP - pcr - ");
638 if (::ioctl(m_fd_demux, DMX_STOP) < 0)
639 eDebug("failed(%m)");
650 DEFINE_REF(eDVBTText);
652 eDVBTText::eDVBTText(eDVBDemux *demux, int dev)
653 :m_demux(demux), m_dev(dev)
656 sprintf(filename, "/dev/dvb/adapter%d/demux%d", demux->adapter, demux->demux);
657 m_fd_demux = ::open(filename, O_RDWR);
659 eWarning("%s: %m", filename);
662 int eDVBTText::startPid(int pid)
666 dmx_pes_filter_params pes;
669 pes.input = DMX_IN_FRONTEND;
670 pes.output = DMX_OUT_DECODER;
671 pes.pes_type = m_dev ? DMX_PES_TELETEXT1 : DMX_PES_TELETEXT0; // FIXME
674 eDebugNoNewLine("DMX_SET_PES_FILTER(0x%02x) - ttx - ", pid);
675 if (::ioctl(m_fd_demux, DMX_SET_PES_FILTER, &pes) < 0)
677 eDebug("failed(%m)");
681 eDebugNoNewLine("DEMUX_START - ttx - ");
682 if (::ioctl(m_fd_demux, DMX_START) < 0)
684 eDebug("failed(%m)");
691 void eDVBTText::stop()
693 eDebugNoNewLine("DEMUX_STOP - ttx - ");
694 if (::ioctl(m_fd_demux, DMX_STOP) < 0)
695 eDebug("failed(%m)");
700 eDVBTText::~eDVBTText()
706 DEFINE_REF(eTSMPEGDecoder);
708 int eTSMPEGDecoder::setState()
712 int noaudio = (m_state != statePlay) && (m_state != statePause);
713 int nott = noaudio; /* actually same conditions */
715 if ((noaudio && m_audio) || (!m_audio && !noaudio))
716 m_changed |= changeAudio | changeState;
718 if ((nott && m_text) || (!m_text && !nott))
719 m_changed |= changeText | changeState;
721 const char *decoder_states[] = {"stop", "pause", "play", "decoderfastforward", "trickmode", "slowmotion"};
722 eDebug("decoder state: %s, vpid=%d, apid=%d", decoder_states[m_state], m_vpid, m_apid);
724 int changed = m_changed;
725 if (m_changed & changePCR)
731 if (m_changed & changeVideo)
737 m_video_event_conn = 0;
740 if (m_changed & changeAudio)
746 if (m_changed & changeText)
752 if (m_changed & changePCR)
754 if ((m_pcrpid >= 0) && (m_pcrpid < 0x1FFF))
756 m_pcr = new eDVBPCR(m_demux, m_decoder);
757 if (m_pcr->startPid(m_pcrpid))
760 m_changed &= ~changePCR;
762 if (m_changed & changeAudio)
764 if ((m_apid >= 0) && (m_apid < 0x1FFF) && !noaudio)
766 m_audio = new eDVBAudio(m_demux, m_decoder);
767 if (m_audio->startPid(m_apid, m_atype))
770 m_changed &= ~changeAudio;
772 if (m_changed & changeVideo)
774 if ((m_vpid >= 0) && (m_vpid < 0x1FFF))
776 m_video = new eDVBVideo(m_demux, m_decoder, m_fcc_enable);
777 m_video->connectEvent(slot(*this, &eTSMPEGDecoder::video_event), m_video_event_conn);
778 if (m_video->startPid(m_vpid, m_vtype))
781 m_changed &= ~changeVideo;
783 if (m_changed & changeText)
785 if ((m_textpid >= 0) && (m_textpid < 0x1FFF) && !nott)
787 m_text = new eDVBTText(m_demux, m_decoder);
788 if (m_text->startPid(m_textpid))
791 m_changed &= ~changeText;
794 if (changed & (changeState|changeVideo|changeAudio))
796 /* play, slowmotion, fast-forward */
797 int state_table[6][4] =
799 /* [stateStop] = */ {0, 0, 0},
800 /* [statePause] = */ {0, 0, 0},
801 /* [statePlay] = */ {1, 0, 0},
802 /* [stateDecoderFastForward] = */ {1, 0, m_ff_sm_ratio},
803 /* [stateHighspeedFastForward] = */ {1, 0, 1},
804 /* [stateSlowMotion] = */ {1, m_ff_sm_ratio, 0}
806 int *s = state_table[m_state];
807 if (changed & (changeState|changeVideo) && m_video)
809 m_video->setSlowMotion(s[1]);
810 m_video->setFastForward(s[2]);
816 if (changed & (changeState|changeAudio) && m_audio)
823 m_changed &= ~changeState;
826 if (changed && !m_video && m_audio && m_radio_pic.length())
827 showSinglePic(m_radio_pic.c_str());
832 int eTSMPEGDecoder::m_pcm_delay=-1,
833 eTSMPEGDecoder::m_ac3_delay=-1;
835 RESULT eTSMPEGDecoder::setHwPCMDelay(int delay)
837 if (delay != m_pcm_delay )
839 FILE *fp = fopen("/proc/stb/audio/audio_delay_pcm", "w");
842 fprintf(fp, "%x", delay*90);
851 RESULT eTSMPEGDecoder::setHwAC3Delay(int delay)
853 if ( delay != m_ac3_delay )
855 FILE *fp = fopen("/proc/stb/audio/audio_delay_bitstream", "w");
858 fprintf(fp, "%x", delay*90);
868 RESULT eTSMPEGDecoder::setPCMDelay(int delay)
870 return m_decoder == 0 ? setHwPCMDelay(delay) : -1;
873 RESULT eTSMPEGDecoder::setAC3Delay(int delay)
875 return m_decoder == 0 ? setHwAC3Delay(delay) : -1;
878 eTSMPEGDecoder::eTSMPEGDecoder(eDVBDemux *demux, int decoder)
880 m_vpid(-1), m_vtype(-1), m_apid(-1), m_atype(-1), m_pcrpid(-1), m_textpid(-1),
881 m_changed(0), m_decoder(decoder), m_video_clip_fd(-1), m_showSinglePicTimer(eTimer::create(eApp)),
882 m_fcc_fd(-1), m_fcc_enable(false), m_fcc_state(fcc_state_stop), m_fcc_feid(-1), m_fcc_vpid(-1), m_fcc_vtype(-1), m_fcc_pcrpid(-1)
886 demux->connectEvent(slot(*this, &eTSMPEGDecoder::demux_event), m_demux_event_conn);
888 CONNECT(m_showSinglePicTimer->timeout, eTSMPEGDecoder::finishShowSinglePic);
892 eTSMPEGDecoder::~eTSMPEGDecoder()
894 finishShowSinglePic();
895 m_vpid = m_apid = m_pcrpid = m_textpid = pidNone;
902 RESULT eTSMPEGDecoder::setVideoPID(int vpid, int type)
904 if ((m_vpid != vpid) || (m_vtype != type))
906 m_changed |= changeVideo;
913 RESULT eTSMPEGDecoder::setAudioPID(int apid, int type)
915 if ((m_apid != apid) || (m_atype != type))
917 m_changed |= changeAudio;
924 int eTSMPEGDecoder::m_audio_channel = -1;
926 RESULT eTSMPEGDecoder::setAudioChannel(int channel)
930 if (m_decoder == 0 && m_audio_channel != channel)
934 m_audio->setChannel(channel);
935 m_audio_channel=channel;
938 eDebug("eTSMPEGDecoder::setAudioChannel but no audio decoder exist");
943 int eTSMPEGDecoder::getAudioChannel()
945 return m_audio_channel == -1 ? ac_stereo : m_audio_channel;
948 RESULT eTSMPEGDecoder::setSyncPCR(int pcrpid)
950 if (m_pcrpid != pcrpid)
952 m_changed |= changePCR;
958 RESULT eTSMPEGDecoder::setTextPID(int textpid)
960 if (m_textpid != textpid)
962 m_changed |= changeText;
968 RESULT eTSMPEGDecoder::setSyncMaster(int who)
973 RESULT eTSMPEGDecoder::set()
978 RESULT eTSMPEGDecoder::play()
980 if (m_state == statePlay)
987 m_changed |= changeState;
992 RESULT eTSMPEGDecoder::pause()
994 if (m_state == statePause)
996 m_state = statePause;
997 m_changed |= changeState;
1001 RESULT eTSMPEGDecoder::setFastForward(int frames_to_skip)
1003 if ((m_state == stateDecoderFastForward) && (m_ff_sm_ratio == frames_to_skip))
1006 m_state = stateDecoderFastForward;
1007 m_ff_sm_ratio = frames_to_skip;
1008 m_changed |= changeState;
1011 // return m_video->setFastForward(frames_to_skip);
1014 RESULT eTSMPEGDecoder::setSlowMotion(int repeat)
1016 if ((m_state == stateSlowMotion) && (m_ff_sm_ratio == repeat))
1019 m_state = stateSlowMotion;
1020 m_ff_sm_ratio = repeat;
1021 m_changed |= changeState;
1025 RESULT eTSMPEGDecoder::setTrickmode()
1027 if (m_state == stateTrickmode)
1030 m_state = stateTrickmode;
1031 m_changed |= changeState;
1035 RESULT eTSMPEGDecoder::flush()
1044 void eTSMPEGDecoder::demux_event(int event)
1048 case eDVBDemux::evtFlush:
1056 RESULT eTSMPEGDecoder::getPTS(int what, pts_t &pts)
1058 if (what == 0) /* auto */
1059 what = m_video ? 1 : 2;
1061 if (what == 1) /* video */
1064 return m_video->getPTS(pts);
1069 if (what == 2) /* audio */
1072 return m_audio->getPTS(pts);
1080 RESULT eTSMPEGDecoder::setRadioPic(const std::string &filename)
1082 m_radio_pic = filename;
1086 RESULT eTSMPEGDecoder::showSinglePic(const char *filename)
1090 eDebug("showSinglePic %s", filename);
1091 int f = open(filename, O_RDONLY);
1097 if (m_video_clip_fd == -1)
1098 m_video_clip_fd = open("/dev/dvb/adapter0/video0", O_WRONLY);
1099 if (m_video_clip_fd >= 0)
1101 bool seq_end_avail = false;
1103 unsigned char pes_header[] = { 0x00, 0x00, 0x01, 0xE0, 0x00, 0x00, 0x80, 0x00, 0x00 };
1104 unsigned char seq_end[] = { 0x00, 0x00, 0x01, 0xB7 };
1105 unsigned char iframe[s.st_size];
1106 unsigned char stuffing[8192];
1107 int streamtype = VIDEO_STREAMTYPE_MPEG2;
1108 memset(stuffing, 0, 8192);
1109 read(f, iframe, s.st_size);
1110 if (ioctl(m_video_clip_fd, VIDEO_SELECT_SOURCE, VIDEO_SOURCE_MEMORY) < 0)
1111 eDebug("VIDEO_SELECT_SOURCE MEMORY failed (%m)");
1112 if (ioctl(m_video_clip_fd, VIDEO_SET_STREAMTYPE, streamtype) < 0)
1113 eDebug("VIDEO_SET_STREAMTYPE failed(%m)");
1114 if (ioctl(m_video_clip_fd, VIDEO_PLAY) < 0)
1115 eDebug("VIDEO_PLAY failed (%m)");
1116 if (ioctl(m_video_clip_fd, VIDEO_CONTINUE) < 0)
1117 eDebug("video: VIDEO_CONTINUE: %m");
1118 if (ioctl(m_video_clip_fd, VIDEO_CLEAR_BUFFER) < 0)
1119 eDebug("video: VIDEO_CLEAR_BUFFER: %m");
1120 while(pos <= (s.st_size-4) && !(seq_end_avail = (!iframe[pos] && !iframe[pos+1] && iframe[pos+2] == 1 && iframe[pos+3] == 0xB7)))
1122 if ((iframe[3] >> 4) != 0xE) // no pes header
1123 write(m_video_clip_fd, pes_header, sizeof(pes_header));
1125 iframe[4] = iframe[5] = 0x00;
1126 write(m_video_clip_fd, iframe, s.st_size);
1128 write(m_video_clip_fd, seq_end, sizeof(seq_end));
1129 write(m_video_clip_fd, stuffing, 8192);
1130 m_showSinglePicTimer->start(150, true);
1136 eDebug("couldnt open %s", filename);
1142 eDebug("only show single pics on first decoder");
1148 void eTSMPEGDecoder::finishShowSinglePic()
1150 if (m_video_clip_fd >= 0)
1152 if (ioctl(m_video_clip_fd, VIDEO_STOP, 0) < 0)
1153 eDebug("VIDEO_STOP failed (%m)");
1154 if (ioctl(m_video_clip_fd, VIDEO_SELECT_SOURCE, VIDEO_SOURCE_DEMUX) < 0)
1155 eDebug("VIDEO_SELECT_SOURCE DEMUX failed (%m)");
1156 close(m_video_clip_fd);
1157 m_video_clip_fd = -1;
1161 RESULT eTSMPEGDecoder::connectVideoEvent(const Slot1<void, struct videoEvent> &event, ePtr<eConnection> &conn)
1163 conn = new eConnection(this, m_video_event.connect(event));
1167 void eTSMPEGDecoder::video_event(struct videoEvent event)
1169 /* emit */ m_video_event(event);
1172 int eTSMPEGDecoder::getVideoWidth()
1175 return m_video->getWidth();
1179 int eTSMPEGDecoder::getVideoHeight()
1182 return m_video->getHeight();
1186 int eTSMPEGDecoder::getVideoProgressive()
1189 return m_video->getProgressive();
1193 int eTSMPEGDecoder::getVideoFrameRate()
1196 return m_video->getFrameRate();
1200 int eTSMPEGDecoder::getVideoAspect()
1203 return m_video->getAspect();
1207 #define FCC_SET_VPID 100
1208 #define FCC_SET_APID 101
1209 #define FCC_SET_PCRPID 102
1210 #define FCC_SET_VCODEC 103
1211 #define FCC_SET_ACODEC 104
1212 #define FCC_SET_FRONTEND_ID 105
1213 #define FCC_START 106
1214 #define FCC_STOP 107
1215 #define FCC_DECODER_START 108
1216 #define FCC_DECODER_STOP 109
1218 RESULT eTSMPEGDecoder::prepareFCC(int fe_id, int vpid, int vtype, int pcrpid)
1220 //eDebug("[eTSMPEGDecoder::prepareFCC] vp : %d, vt : %d, pp : %d, fe : %d", vpid, vtype, pcrpid, fe_id);
1222 if ((fccGetFD() == -1) || (fccSetPids(fe_id, vpid, vtype, pcrpid) < 0) || (fccStart() < 0))
1228 m_fcc_enable = true;
1233 RESULT eTSMPEGDecoder::fccDecoderStart()
1238 if (m_fcc_state != fcc_state_ready)
1240 eDebug("FCC decoder is already in decoding state.");
1244 if (ioctl(m_fcc_fd, FCC_DECODER_START) < 0)
1246 eDebug("ioctl FCC_DECODER_START failed! (%m)");
1250 m_fcc_state = fcc_state_decoding;
1252 eDebug("[eTSMPEGDecoder] FCC_DECODER_START OK!");
1256 RESULT eTSMPEGDecoder::fccDecoderStop()
1261 if (m_fcc_state != fcc_state_decoding)
1263 eDebug("FCC decoder is not in decoding state.");
1265 else if (ioctl(m_fcc_fd, FCC_DECODER_STOP) < 0)
1267 eDebug("ioctl FCC_DECODER_STOP failed! (%m)");
1271 m_fcc_state = fcc_state_ready;
1273 /* stop pcr, video, audio, text */
1274 finishShowSinglePic();
1276 m_vpid = m_apid = m_pcrpid = m_textpid = pidNone;
1280 eDebug("[eTSMPEGDecoder] FCC_DECODER_STOP OK!");
1284 RESULT eTSMPEGDecoder::fccUpdatePids(int fe_id, int vpid, int vtype, int pcrpid)
1286 //eDebug("[eTSMPEGDecoder] vp : %d, vt : %d, pp : %d, fe : %d", vpid, vtype, pcrpid, fe_id);
1288 if ((fe_id != m_fcc_feid) || (vpid != m_fcc_vpid) || (vtype != m_fcc_vtype) || (pcrpid != m_fcc_pcrpid))
1290 int cur_fcc_state = m_fcc_state;
1292 if (prepareFCC(fe_id, vpid, vtype, pcrpid))
1294 eDebug("[eTSMPEGDecoder] prepare FCC failed!");
1301 RESULT eTSMPEGDecoder::fccStart()
1306 if (m_fcc_state != fcc_state_stop)
1308 eDebug("[eTSMPEGDecoder] FCC is already started!");
1311 else if (ioctl(m_fcc_fd, FCC_START) < 0)
1313 eDebug("ioctl FCC_START failed! (%m)");
1317 eDebug("[eTSMPEGDecoder] FCC_START OK!");
1319 m_fcc_state = fcc_state_ready;
1323 RESULT eTSMPEGDecoder::fccStop()
1328 if (m_fcc_state == fcc_state_stop)
1330 eDebug("[eTSMPEGDecoder] FCC is already stopped!");
1334 else if (m_fcc_state == fcc_state_decoding)
1339 if (ioctl(m_fcc_fd, FCC_STOP) < 0)
1341 eDebug("ioctl FCC_STOP failed! (%m)");
1345 m_fcc_state = fcc_state_stop;
1347 eDebug("[eTSMPEGDecoder] FCC_STOP OK!");
1351 RESULT eTSMPEGDecoder::fccSetPids(int fe_id, int vpid, int vtype, int pcrpid)
1353 int streamtype = VIDEO_STREAMTYPE_MPEG2;
1358 if (ioctl(m_fcc_fd, FCC_SET_FRONTEND_ID, fe_id) < 0)
1360 eDebug("[eTSMPEGDecoder] FCC_SET_FRONTEND_ID failed! (%m)");
1364 else if(ioctl(m_fcc_fd, FCC_SET_PCRPID, pcrpid) < 0)
1366 eDebug("[eTSMPEGDecoder] FCC_SET_PCRPID failed! (%m)");
1370 else if (ioctl(m_fcc_fd, FCC_SET_VPID, vpid) < 0)
1372 eDebug("[eTSMPEGDecoder] FCC_SET_VPID failed! (%m)");
1379 case eDVBVideo::MPEG2:
1381 case eDVBVideo::MPEG4_H264:
1382 streamtype = VIDEO_STREAMTYPE_MPEG4_H264;
1384 case eDVBVideo::MPEG1:
1385 streamtype = VIDEO_STREAMTYPE_MPEG1;
1387 case eDVBVideo::MPEG4_Part2:
1388 streamtype = VIDEO_STREAMTYPE_MPEG4_Part2;
1390 case eDVBVideo::VC1:
1391 streamtype = VIDEO_STREAMTYPE_VC1;
1393 case eDVBVideo::VC1_SM:
1394 streamtype = VIDEO_STREAMTYPE_VC1_SM;
1396 case eDVBVideo::H265_HEVC:
1397 streamtype = VIDEO_STREAMTYPE_H265_HEVC;
1401 if(ioctl(m_fcc_fd, FCC_SET_VCODEC, streamtype) < 0)
1403 eDebug("[eTSMPEGDecoder] FCC_SET_VCODEC failed! (%m)");
1409 m_fcc_vtype = vtype;
1410 m_fcc_pcrpid = pcrpid;
1412 //eDebug("[eTSMPEGDecoder] SET PIDS OK!");
1416 RESULT eTSMPEGDecoder::fccGetFD()
1420 eFCCDecoder* fcc = eFCCDecoder::getInstance();
1423 m_fcc_fd = fcc->allocateFcc();
1430 RESULT eTSMPEGDecoder::fccFreeFD()
1434 eFCCDecoder* fcc = eFCCDecoder::getInstance();
1437 fcc->freeFcc(m_fcc_fd);