remove non working indication of playable services in servicelist
[enigma2.git] / lib / dvb / dvb.cpp
1 #include <lib/base/eerror.h>
2 #include <lib/base/filepush.h>
3 #include <lib/dvb/idvb.h>
4 #include <lib/dvb/dvb.h>
5 #include <lib/dvb/sec.h>
6
7 #include <errno.h>
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <unistd.h>
11 #include <fcntl.h>
12 #include <sys/ioctl.h>
13
14 DEFINE_REF(eDVBRegisteredFrontend);
15 DEFINE_REF(eDVBRegisteredDemux);
16
17 DEFINE_REF(eDVBAllocatedFrontend);
18
19 eDVBAllocatedFrontend::eDVBAllocatedFrontend(eDVBRegisteredFrontend *fe): m_fe(fe)
20 {
21         m_fe->m_inuse++;
22 }
23
24 eDVBAllocatedFrontend::~eDVBAllocatedFrontend()
25 {
26         --m_fe->m_inuse;
27 }
28
29 DEFINE_REF(eDVBAllocatedDemux);
30
31 eDVBAllocatedDemux::eDVBAllocatedDemux(eDVBRegisteredDemux *demux): m_demux(demux)
32 {
33         m_demux->m_inuse++;
34 }
35
36 eDVBAllocatedDemux::~eDVBAllocatedDemux()
37 {
38         --m_demux->m_inuse;
39 }
40
41 DEFINE_REF(eDVBResourceManager);
42
43 eDVBResourceManager *eDVBResourceManager::instance;
44
45 eDVBResourceManager::eDVBResourceManager()
46 {
47         avail = 1;
48         busy = 0;
49         m_sec = new eDVBSatelliteEquipmentControl(m_frontend);
50         if (!instance)
51                 instance = this;
52                 
53                 /* search available adapters... */
54
55                 // add linux devices
56         
57         int num_adapter = 0;
58         while (eDVBAdapterLinux::exist(num_adapter))
59         {
60                 addAdapter(new eDVBAdapterLinux(num_adapter));
61                 num_adapter++;
62         }
63         
64         eDebug("found %d adapter, %d frontends and %d demux", 
65                 m_adapter.size(), m_frontend.size(), m_demux.size());
66 }
67
68
69 DEFINE_REF(eDVBAdapterLinux);
70 eDVBAdapterLinux::eDVBAdapterLinux(int nr): m_nr(nr)
71 {
72                 // scan frontends
73         int num_fe = 0;
74         
75         eDebug("scanning for frontends..");
76         while (1)
77         {
78                 struct stat s;
79                 char filename[128];
80 #if HAVE_DVB_API_VERSION < 3
81                 sprintf(filename, "/dev/dvb/card%d/frontend%d", m_nr, num_fe);
82 #else
83                 sprintf(filename, "/dev/dvb/adapter%d/frontend%d", m_nr, num_fe);
84 #endif
85                 if (stat(filename, &s))
86                         break;
87                 ePtr<eDVBFrontend> fe;
88
89                 int ok = 0;
90                 fe = new eDVBFrontend(m_nr, num_fe, ok);
91                 if (ok)
92                         m_frontend.push_back(fe);
93                 ++num_fe;
94         }
95         
96                 // scan demux
97         int num_demux = 0;
98         while (1)
99         {
100                 struct stat s;
101                 char filename[128];
102 #if HAVE_DVB_API_VERSION < 3
103                 sprintf(filename, "/dev/dvb/card%d/demux%d", m_nr, num_demux);
104 #else
105                 sprintf(filename, "/dev/dvb/adapter%d/demux%d", m_nr, num_demux);
106 #endif
107                 if (stat(filename, &s))
108                         break;
109                 ePtr<eDVBDemux> demux;
110                 
111                 demux = new eDVBDemux(m_nr, num_demux);
112                 m_demux.push_back(demux);
113                         
114                 ++num_demux;
115         }
116 }
117
118 int eDVBAdapterLinux::getNumDemux()
119 {
120         return m_demux.size();
121 }
122
123 RESULT eDVBAdapterLinux::getDemux(ePtr<eDVBDemux> &demux, int nr)
124 {
125         eSmartPtrList<eDVBDemux>::iterator i(m_demux.begin());
126         while (nr && (i != m_demux.end()))
127         {
128                 --nr;
129                 ++i;
130         }
131         
132         if (i != m_demux.end())
133                 demux = *i;
134         else
135                 return -1;
136                 
137         return 0;
138 }
139
140 int eDVBAdapterLinux::getNumFrontends()
141 {
142         return m_frontend.size();
143 }
144
145 RESULT eDVBAdapterLinux::getFrontend(ePtr<eDVBFrontend> &fe, int nr)
146 {
147         eSmartPtrList<eDVBFrontend>::iterator i(m_frontend.begin());
148         while (nr && (i != m_frontend.end()))
149         {
150                 --nr;
151                 ++i;
152         }
153         
154         if (i != m_frontend.end())
155                 fe = *i;
156         else
157                 return -1;
158                 
159         return 0;
160 }
161
162 int eDVBAdapterLinux::exist(int nr)
163 {
164         struct stat s;
165         char filename[128];
166 #if HAVE_DVB_API_VERSION < 3
167         sprintf(filename, "/dev/dvb/card%d", nr);
168 #else
169         sprintf(filename, "/dev/dvb/adapter%d", nr);
170 #endif
171         if (!stat(filename, &s))
172                 return 1;
173         return 0;
174 }
175
176 eDVBResourceManager::~eDVBResourceManager()
177 {
178         if (instance == this)
179                 instance = 0;
180 }
181
182 void eDVBResourceManager::addAdapter(iDVBAdapter *adapter)
183 {
184         int num_fe = adapter->getNumFrontends();
185         int num_demux = adapter->getNumDemux();
186         
187         m_adapter.push_back(adapter);
188         
189         int i;
190         for (i=0; i<num_demux; ++i)
191         {
192                 ePtr<eDVBDemux> demux;
193                 if (!adapter->getDemux(demux, i))
194                         m_demux.push_back(new eDVBRegisteredDemux(demux, adapter));
195         }
196
197         for (i=0; i<num_fe; ++i)
198         {
199                 ePtr<eDVBFrontend> frontend;
200
201                 if (!adapter->getFrontend(frontend, i))
202                 {
203                         frontend->setTone(iDVBFrontend::toneOff);
204                         frontend->setVoltage(iDVBFrontend::voltageOff);
205                         frontend->setSEC(m_sec);
206                         m_frontend.push_back(new eDVBRegisteredFrontend(frontend, adapter));
207                 }
208         }
209 }
210
211 RESULT eDVBResourceManager::allocateFrontend(ePtr<eDVBAllocatedFrontend> &fe, ePtr<iDVBFrontendParameters> &feparm)
212 {
213         ePtr<eDVBRegisteredFrontend> best;
214         int bestval = 0;
215
216         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
217                 if (!i->m_inuse)
218                 {
219                         int c = i->m_frontend->isCompatibleWith(feparm);
220                         if (c > bestval)
221                         {
222                                 bestval = c;
223                                 best = i;
224                         }
225                 }
226
227         if (best)
228         {
229                 fe = new eDVBAllocatedFrontend(best);
230                 return 0;
231         }
232         
233         fe = 0;
234         
235         return -1;
236 }
237
238 RESULT eDVBResourceManager::allocateFrontendByIndex(ePtr<eDVBAllocatedFrontend> &fe, int nr)
239 {
240         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i, --nr)
241                 if ((!nr) && !i->m_inuse)
242                 {
243                         fe = new eDVBAllocatedFrontend(i);
244                         return 0;
245                 }
246         
247         fe = 0;
248         return -1;
249 }
250
251 RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)
252 {
253                 /* find first unused demux which is on same adapter as frontend (or any, if PVR)
254                    never use the first one unless we need a decoding demux. */
255
256         eDebug("allocate demux");
257         eSmartPtrList<eDVBRegisteredDemux>::iterator i(m_demux.begin());
258         
259         if (i == m_demux.end())
260                 return -1;
261                 
262         int n=0;
263                 /* FIXME: hardware demux policy */
264         if (!(cap & iDVBChannel::capDecode))
265                 ++i, ++n;
266         
267         for (; i != m_demux.end(); ++i, ++n)
268                 if ((!i->m_inuse) && ((!fe) || (i->m_adapter == fe->m_adapter)))
269                 {
270                         if ((cap & iDVBChannel::capDecode) && n)
271                                 continue;
272                         
273                         demux = new eDVBAllocatedDemux(i);
274                         if (fe)
275                                 demux->get().setSourceFrontend(fe->m_frontend->getID());
276                         else
277                                 demux->get().setSourcePVR(0);
278                         return 0;
279                 }
280         eDebug("demux not found");
281         return -1;
282 }
283
284 RESULT eDVBResourceManager::setChannelList(iDVBChannelList *list)
285 {
286         m_list = list;
287         return 0;
288 }
289
290 RESULT eDVBResourceManager::getChannelList(ePtr<iDVBChannelList> &list)
291 {
292         list = m_list;
293         if (list)
294                 return 0;
295         else
296                 return -ENOENT;
297 }
298
299 RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUsePtr<iDVBChannel> &channel)
300 {
301                 /* first, check if a channel is already existing. */
302         
303 //      eDebug("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
304         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
305         {
306 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
307                 if (i->m_channel_id == channelid)
308                 {
309 //                      eDebug("found shared channel..");
310                         channel = i->m_channel;
311                         return 0;
312                 }
313         }
314         
315         /* no currently available channel is tuned to this channelid. create a new one, if possible. */
316
317         if (!m_list)
318         {
319                 eDebug("no channel list set!");
320                 return -ENOENT;
321         }
322
323         ePtr<iDVBFrontendParameters> feparm;
324         if (m_list->getChannelFrontendData(channelid, feparm))
325         {
326                 eDebug("channel not found!");
327                 return -ENOENT;
328         }
329
330         /* allocate a frontend. */
331         
332         ePtr<eDVBAllocatedFrontend> fe;
333         
334         if (allocateFrontend(fe, feparm))
335                 return errNoFrontend;
336
337         RESULT res;
338         ePtr<eDVBChannel> ch;
339         ch = new eDVBChannel(this, fe);
340
341         res = ch->setChannel(channelid, feparm);
342         if (res)
343         {
344                 channel = 0;
345                 return errChidNotFound;
346         }
347         channel = ch;
348
349         return 0;
350 }
351
352 RESULT eDVBResourceManager::allocateRawChannel(eUsePtr<iDVBChannel> &channel, int frontend_index)
353 {
354         ePtr<eDVBAllocatedFrontend> fe;
355
356         if (allocateFrontendByIndex(fe, frontend_index))
357                 return errNoFrontend;
358         
359         eDVBChannel *ch;
360         ch = new eDVBChannel(this, fe);
361
362         channel = ch;
363         return 0;
364 }
365
366
367 RESULT eDVBResourceManager::allocatePVRChannel(eUsePtr<iDVBPVRChannel> &channel)
368 {
369         ePtr<eDVBAllocatedDemux> demux;
370         
371         eDVBChannel *ch;
372         ch = new eDVBChannel(this, 0);
373         
374         channel = ch;
375         return 0;
376 }
377
378 RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch)
379 {
380         m_active_channels.push_back(active_channel(chid, ch));
381         /* emit */ m_channelAdded(ch);
382         return 0;
383 }
384
385 RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch)
386 {
387         int cnt = 0;
388         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end();)
389         {
390                 if (i->m_channel == ch)
391                 {
392                         i = m_active_channels.erase(i);
393                         ++cnt;
394                 } else
395                         ++i;
396         }
397         ASSERT(cnt == 1);
398         if (cnt == 1)
399                 return 0;
400         return -ENOENT;
401 }
402
403 RESULT eDVBResourceManager::connectChannelAdded(const Slot1<void,eDVBChannel*> &channelAdded, ePtr<eConnection> &connection)
404 {
405         connection = new eConnection((eDVBResourceManager*)this, m_channelAdded.connect(channelAdded));
406         return 0;
407 }
408
409 bool eDVBResourceManager::canAllocateFrontend(ePtr<iDVBFrontendParameters> &feparm, int used_tuner_mask)
410 {
411         eDebug("canAllocateFrontend mask %08x", used_tuner_mask);
412         ePtr<eDVBRegisteredFrontend> best;
413         int bestval = 0;
414
415         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
416                 if ( !(used_tuner_mask & (1<<i->m_frontend->getID())) )
417                 {
418                         int c = i->m_frontend->isCompatibleWith(feparm);
419                         if (c > bestval)
420                                 bestval = c;
421                 }
422
423         return bestval>0;
424 }
425
426 bool eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid)
427 {
428         return true;
429 #if 0
430         int used_tuner_mask=0;
431
432                 /* first, check if a channel is already existing. */
433 //      eDebug("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
434         int cnt=0;
435         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i, ++cnt)
436         {
437 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
438                 if (i->m_channel_id == channelid)
439                 {
440 //                      eDebug("found shared channel..");
441                         return true;
442                 }
443
444                 eDebug("activeChannel %d, NonDecoderDemux %p, DecoderDemux %p",
445                         cnt, i->m_channel->getNonDecoderDemux(), i->m_channel->getDecoderDemux() );
446                 if ( i->m_channel->getNonDecoderDemux() )
447                 {
448                         ePtr<iDVBFrontend> fe;
449                         if (!i->m_channel->getFrontend(fe))
450                         {
451                                 if (fe)
452                                 {
453                                         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
454                                         {
455                                                 if ( &(*fe) == &(*ii->m_frontend) )
456                                                 {
457                                                         used_tuner_mask |= (1 << ii->m_frontend->getID());
458                                                         break;
459                                                 }
460                                         }
461                                 }
462                                 else
463                                         eDebug("fe kaputt");
464                         }
465                 }
466         }
467
468         if (!m_list)
469         {
470                 eDebug("no channel list set!");
471                 return false;
472         }
473
474         ePtr<iDVBFrontendParameters> feparm;
475         if (m_list->getChannelFrontendData(channelid, feparm))
476         {
477                 eDebug("channel not found!");
478                 return false;
479         }
480
481         return canAllocateFrontend(feparm, used_tuner_mask);
482 #endif
483 }
484
485 DEFINE_REF(eDVBChannel);
486
487 eDVBChannel::eDVBChannel(eDVBResourceManager *mgr, eDVBAllocatedFrontend *frontend): m_state(state_idle), m_mgr(mgr)
488 {
489         m_frontend = frontend;
490
491         m_pvr_thread = 0;
492         
493         if (m_frontend)
494                 m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
495 }
496
497 eDVBChannel::~eDVBChannel()
498 {
499         if (m_channel_id)
500                 m_mgr->removeChannel(this);
501         
502         if (m_pvr_thread)
503         {
504                 m_pvr_thread->stop();
505                 ::close(m_pvr_fd_src);
506                 ::close(m_pvr_fd_dst);
507                 delete m_pvr_thread;
508         }
509 }
510
511 void eDVBChannel::frontendStateChanged(iDVBFrontend*fe)
512 {
513         int state, ourstate = 0;
514         
515                 /* if we are already in shutdown, don't change state. */
516         if (m_state == state_release)
517                 return;
518         
519         if (fe->getState(state))
520                 return;
521         
522         if (state == iDVBFrontend::stateLock)
523         {
524                 eDebug("OURSTATE: ok");
525                 ourstate = state_ok;
526         } else if (state == iDVBFrontend::stateTuning)
527         {
528                 eDebug("OURSTATE: tuning");
529                 ourstate = state_tuning;
530         } else if (state == iDVBFrontend::stateLostLock)
531         {
532                 eDebug("OURSTATE: lost lock");
533                 ourstate = state_unavailable;
534         } else if (state == iDVBFrontend::stateFailed)
535         {
536                 eDebug("OURSTATE: failed");
537                 ourstate = state_failed;
538         } else
539                 eFatal("state unknown");
540         
541         if (ourstate != m_state)
542         {
543                 m_state = ourstate;
544                 m_stateChanged(this);
545         }
546 }
547
548 void eDVBChannel::AddUse()
549 {
550         ++m_use_count;
551 }
552
553 void eDVBChannel::ReleaseUse()
554 {
555         if (!--m_use_count)
556         {
557                 m_state = state_release;
558                 m_stateChanged(this);
559         }
560 }
561
562 RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid, ePtr<iDVBFrontendParameters> &feparm)
563 {
564         if (m_channel_id)
565                 m_mgr->removeChannel(this);
566                 
567         if (!channelid)
568                 return 0;
569
570         if (!m_frontend)
571         {
572                 eDebug("no frontend to tune!");
573                 return -ENODEV;
574         }
575         
576         m_channel_id = channelid;
577         m_mgr->addChannel(channelid, this);
578         m_state = state_tuning;
579                         /* if tuning fails, shutdown the channel immediately. */
580         int res;
581         res = m_frontend->get().tune(*feparm);
582         
583         if (res)
584         {
585                 m_state = state_release;
586                 m_stateChanged(this);
587                 return res;
588         }
589         
590         return 0;
591 }
592
593 RESULT eDVBChannel::connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)
594 {
595         connection = new eConnection((iDVBChannel*)this, m_stateChanged.connect(stateChange));
596         return 0;
597 }
598
599 RESULT eDVBChannel::getState(int &state)
600 {
601         state = m_state;
602         return 0;
603 }
604
605 RESULT eDVBChannel::setCIRouting(const eDVBCIRouting &routing)
606 {
607         return -1;
608 }
609
610 RESULT eDVBChannel::getDemux(ePtr<iDVBDemux> &demux, int cap)
611 {
612         eDebug("get %d demux", cap);
613         ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
614         
615         if (!our_demux)
616         {
617                 demux = 0;
618                 
619                 if (m_mgr->allocateDemux(m_frontend ? (eDVBRegisteredFrontend*)*m_frontend : (eDVBRegisteredFrontend*)0, our_demux, cap))
620                         return -1;
621                 
622         }
623         
624         demux = *our_demux;
625         if (cap & capDecode)
626         {
627                 our_demux = 0;
628         }
629         return 0;
630 }
631
632 RESULT eDVBChannel::getFrontend(ePtr<iDVBFrontend> &frontend)
633 {
634         frontend = &m_frontend->get();
635         if (frontend)
636                 return 0;
637         else
638                 return -ENODEV;
639 }
640
641 RESULT eDVBChannel::playFile(const char *file)
642 {
643         ASSERT(!m_frontend);
644         if (m_pvr_thread)
645         {
646                 m_pvr_thread->stop();
647                 delete m_pvr_thread;
648                 m_pvr_thread = 0;
649         }
650         
651         m_tstools.openFile(file);
652         
653                 /* DON'T EVEN THINK ABOUT FIXING THIS. FIX THE ATI SOURCES FIRST,
654                    THEN DO A REAL FIX HERE! */
655         
656                 /* (this codepath needs to be improved anyway.) */
657         m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
658         if (m_pvr_fd_dst < 0)
659         {
660                 eDebug("can't open /dev/misc/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
661                 return -ENODEV;
662         }
663         
664         m_pvr_fd_src = open(file, O_RDONLY);
665         if (m_pvr_fd_src < 0)
666         {
667                 eDebug("can't open PVR m_pvr_fd_src file %s (%m)", file);
668                 close(m_pvr_fd_dst);
669                 return -ENOENT;
670         }
671         
672         m_state = state_ok;
673         m_stateChanged(this);
674         
675         m_pvr_thread = new eFilePushThread();
676         m_pvr_thread->start(m_pvr_fd_src, m_pvr_fd_dst);
677
678         return 0;
679 }
680
681 RESULT eDVBChannel::getLength(pts_t &len)
682 {
683         return m_tstools.calcLen(len);
684 }
685
686 RESULT eDVBChannel::getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos)
687 {
688         if (!decoding_demux)
689                 return -1;
690         
691         off_t begin = 0;
692                 /* getPTS for offset 0 is cached, so it doesn't harm. */
693         int r = m_tstools.getPTS(begin, pos);
694         if (r)
695         {
696                 eDebug("tstools getpts(0) failed!");
697                 return r;
698         }
699         
700         pts_t now;
701         
702         r = decoding_demux->getSTC(now);
703
704         if (r)
705         {
706                 eDebug("demux getSTC failed");
707                 return -1;
708         }
709         
710 //      eDebug("STC: %08llx PTS: %08llx, diff %lld", now, pos, now - pos);
711                 /* when we are less than 10 seconds before the start, return 0. */
712                 /* (we're just waiting for the timespam to start) */
713         if ((now < pos) && ((pos - now) < 90000 * 10))
714         {
715                 pos = 0;
716                 return 0;
717         }
718         
719         if (now < pos) /* wrap around */
720                 pos = now + ((pts_t)1)<<33 - pos;
721         else
722                 pos = now - pos;
723         
724         return 0;
725 }
726
727 RESULT eDVBChannel::seekTo(iDVBDemux *decoding_demux, int relative, pts_t &pts)
728 {
729         int bitrate = m_tstools.calcBitrate(); /* in bits/s */
730         
731         if (bitrate == -1)
732                 return -1;
733         
734         if (relative)
735         {
736                 pts_t now;
737                 if (getCurrentPosition(decoding_demux, now))
738                 {
739                         eDebug("seekTo: getCurrentPosition failed!");
740                         return -1;
741                 }
742                 pts += now;
743         }
744         
745         if (pts < 0)
746                 pts = 0;
747         
748         off_t offset = (pts * (pts_t)bitrate) / 8ULL / 90000ULL;
749         
750         seekToPosition(decoding_demux, offset);
751         return 0;
752 }
753
754 RESULT eDVBChannel::seekToPosition(iDVBDemux *decoding_demux, const off_t &r)
755 {
756                         /* when seeking, we have to ensure that all buffers are flushed.
757                            there are basically 3 buffers:
758                            a.) the filepush's internal buffer
759                            b.) the PVR buffer (before demux)
760                            c.) the ratebuffer (after demux)
761                            
762                            it's important to clear them in the correct order, otherwise
763                            the ratebuffer (for example) would immediately refill from
764                            the not-yet-flushed PVR buffer.
765                         */
766         eDebug("eDVBChannel: seekToPosition .. %llx", r);
767         m_pvr_thread->pause();
768
769                 /* flush internal filepush buffer */
770         m_pvr_thread->flush();
771
772                 /* HACK: flush PVR buffer */
773         ::ioctl(m_pvr_fd_dst, 0);
774         
775                 /* flush ratebuffers (video, audio) */
776         if (decoding_demux)
777                 decoding_demux->flush();
778
779                 /* demux will also flush all decoder.. */
780         m_pvr_thread->seek(SEEK_SET, r);
781         m_pvr_thread->resume();
782         return 0;
783 }