]> git.vomp.tv Git - vompclient-marten.git/blob - playerlivetv.cc
DVB Subtitles: Live TV
[vompclient-marten.git] / playerlivetv.cc
1 /*
2     Copyright 2007 Chris Tallon
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include "playerlivetv.h"
22
23 #include "log.h"
24 #include "audio.h"
25 #include "video.h"
26 #include "demuxerts.h"
27 #include "vdr.h"
28 #include "messagequeue.h"
29 #include "remote.h"
30 #include "message.h"
31 #include "channel.h"
32 #include "dvbsubtitles.h"
33 #include "osdreceiver.h"
34
35 // ----------------------------------- Called from outside, one offs or info funcs
36
37 PlayerLiveTV::PlayerLiveTV(MessageQueue* tmessageQueue, void* tmessageReceiver, OSDReceiver* tosdReceiver, ChannelList* tchanList)
38 : vfeed(this), afeed(this)
39 {
40   messageQueue = tmessageQueue;
41   messageReceiver = tmessageReceiver;
42   osdReceiver = tosdReceiver;
43   chanList = tchanList;
44   
45   audio = Audio::getInstance();
46   video = Video::getInstance();
47   logger = Log::getInstance();
48   vdr = VDR::getInstance();
49   initted = false;
50
51   subtitlesShowing = false;
52   videoStartup = false;
53
54   stopNow = false;
55   state = S_STOP;
56
57   video->turnVideoOn();
58 }
59
60 PlayerLiveTV::~PlayerLiveTV()
61 {
62   if (initted) shutdown();
63 }
64
65 int PlayerLiveTV::init()
66 {
67   if (initted) return 0;
68
69   demuxer = new DemuxerTS();
70   if (!demuxer) return 0;
71   subtitles = new DVBSubtitles(osdReceiver);
72   if (!subtitles) return 0;
73  
74   if (!demuxer->init(this, audio, video, 2097152, 524288, subtitles))
75   {
76     logger->log("PlayerLiveTV", Log::ERR, "Demuxer failed to init");
77     shutdown();
78     return 0;
79   }
80
81   vfeed.init();
82   afeed.init();
83
84   video->stop();
85   video->blank();
86   audio->stop();
87
88   initted = true;
89   return 1;
90 }
91
92 int PlayerLiveTV::shutdown()
93 {
94   if (!initted) return 0;
95   stop();
96   initted = false;
97
98   delete demuxer;
99   delete subtitles;
100
101   return 1;
102 }
103
104 bool* PlayerLiveTV::getDemuxerMpegAudioChannels()
105 {
106   return demuxer->getmpAudioChannels();
107 }
108
109 bool* PlayerLiveTV::getDemuxerAc3AudioChannels()
110 {
111   return demuxer->getac3AudioChannels();
112 }
113
114 int PlayerLiveTV::getCurrentAudioChannel()
115 {
116   return demuxer->getAID();
117 }
118
119 void PlayerLiveTV::setAudioChannel(int newChannel, int type)
120 {
121   return demuxer->setAID(newChannel,type);
122 }
123
124 bool PlayerLiveTV::toggleSubtitles()
125 {
126   if (!subtitlesShowing)
127   {
128     subtitlesShowing = true;
129     subtitles->show();
130   }
131   else
132   {
133     subtitlesShowing = false;
134     subtitles->hide();
135   }
136   return subtitlesShowing;
137 }
138
139 // ----------------------------------- Externally called events
140
141 void PlayerLiveTV::go(ULONG index)
142 {
143   struct PLInstruction i;
144   i.instruction = I_SETCHANNEL;
145   i.channelIndex = index;
146   instructions.push(i);
147   threadStart();
148 }
149
150 void PlayerLiveTV::setChannel(ULONG index)
151 {
152   logger->log("PlayerLiveTV", Log::DEBUG, "setChannel");
153   struct PLInstruction i;
154   i.instruction = I_SETCHANNEL;
155   i.channelIndex = index;
156   instructions.push(i);  
157   threadSignalNoLock();
158 }
159
160 void PlayerLiveTV::stop()
161 {
162   logger->log("PlayerLiveTV", Log::DEBUG, "stop");
163   struct PLInstruction i;
164   i.instruction = I_STOP;
165   instructions.push(i);
166   threadSignal();
167   threadStop();
168 }
169
170 // ----------------------------------- Callback
171
172 void PlayerLiveTV::call(void* caller)
173 {
174   if (caller == demuxer)
175   {
176     logger->log("PlayerLiveTV", Log::DEBUG, "Callback from demuxer");
177
178     int dxCurrentAspect = demuxer->getAspectRatio();
179     if (dxCurrentAspect == Demuxer::ASPECT_4_3)
180     {
181       if (video->getTVsize() == Video::ASPECT16X9)
182       {
183         logger->log("PlayerLiveTV", Log::DEBUG, "Demuxer said video is 4:3 aspect, switching TV");
184         video->setAspectRatio(Video::ASPECT4X3);
185       }
186       else
187       {
188         logger->log("PlayerLiveTV", Log::DEBUG, "TV is 4:3, ignoring aspect switching");
189       }
190
191       Message* m = new Message();
192       m->from = this;
193       m->to = messageReceiver;
194       m->message = Message::PLAYER_EVENT;
195       m->parameter = PlayerLiveTV::ASPECT43;
196       messageQueue->postMessageFromOuterSpace(m);
197     }
198     else if (dxCurrentAspect == Demuxer::ASPECT_16_9)
199     {
200       if (video->getTVsize() == Video::ASPECT16X9)
201       {
202         logger->log("PlayerLiveTV", Log::DEBUG, "Demuxer said video is 16:9 aspect, switching TV");
203         video->setAspectRatio(Video::ASPECT16X9);
204       }
205       else
206       {
207         logger->log("PlayerLiveTV", Log::DEBUG, "TV is 4:3, ignoring aspect switching");
208       }    
209
210       Message* m = new Message();
211       m->from = this;
212       m->to = messageReceiver;
213       m->message = Message::PLAYER_EVENT;
214       m->parameter = PlayerLiveTV::ASPECT169;
215       messageQueue->postMessageFromOuterSpace(m);
216     }
217     else
218     {
219       logger->log("PlayerLiveTV", Log::DEBUG, "Demuxer said video is something else... ignoring");
220     }
221   }
222   else if (caller == &afeed)
223   {
224     if (state == S_VIDEOSTARTUP)
225     {
226       logger->log("PlayerLiveTV", Log::DEBUG, "afeed video startup");
227       videoStartup = true;
228       threadSignalNoLock();
229     }
230   }
231 }
232
233 // -----------------------------------
234
235 void PlayerLiveTV::streamReceive(ULONG flag, void* data, ULONG len)
236 {
237   // Flag:
238   // 0 = normal stream packet
239   // 1 = stream end
240   // 2 = connection lost
241
242 //  logger->log("PlayerLiveTV", Log::DEBUG, "Received a streamchunk from VDR, flag = %lu", flag);
243
244   if (flag == 1)
245   {
246     if (data) abort();
247     
248     Message* m = new Message();
249     m->from = this;
250     m->to = messageReceiver;
251     m->message = Message::PLAYER_EVENT;
252     m->parameter = PlayerLiveTV::STREAM_END;
253     messageQueue->postMessageFromOuterSpace(m);
254   }
255         
256   if (streamChunks.size() < 11)
257   {
258     StreamChunk s;
259     s.data = data;
260     s.len = len;
261     streamChunks.push(s);
262     threadSignalNoLock();
263   }
264   else
265   {
266     // Too many chunks in streamChunks, drop this chunk
267     free(data);
268     logger->log("PlayerLiveTV", Log::WARN, "Dropped chunk");
269   }
270 }
271
272 void PlayerLiveTV::clearStreamChunks()
273 {
274   while(streamChunks.size())
275   {
276     logger->log("PlayerLiveTV", Log::DEBUG, "Dropping chunk from old stream");
277     struct StreamChunk s = streamChunks.front();
278     streamChunks.pop();
279     free(s.data);
280   }
281 }
282
283 void PlayerLiveTV::chunkToDemuxer()
284 {
285   StreamChunk s = streamChunks.front();
286   streamChunks.pop();
287   //logger->log("PlayerLiveTV", Log::DEBUG, "About to call demuxer with %p %lu", s.data, s.len);
288   /*int a = */demuxer->put((UCHAR*)s.data, s.len);
289   //logger->log("PlayerLiveTV", Log::DEBUG, "put %i to demuxer", a);
290   free(s.data);  
291 }
292
293 void PlayerLiveTV::switchState(UCHAR newState)
294 {
295   logger->log("PlayerLiveTV", Log::DEBUG, "Switch from state %u to state %u", state, newState);
296
297   switch(state)
298   {
299     case S_STOP:   // FROM S_STOP
300     {
301       switch(newState)
302       {
303         case S_VIDEOSTARTUP:
304         {
305           video->blank();
306           video->reset();
307           video->sync();
308           video->play();
309           video->pause();
310
311           audio->stop();
312           audio->unPause();
313           audio->reset();
314           audio->setStreamType(Audio::MPEG2_PES);
315           audio->sync();
316           audio->play();
317           audio->pause();
318
319           demuxer->reset();
320           demuxer->seek();
321
322           afeed.start();
323           vfeed.start();
324           subtitles->start();
325           
326           state = newState;
327           return;
328         }
329         default:
330         {
331           logger->log("PlayerLiveTV", Log::EMERG, "Thread called state %u to state %u which is not supported", state, newState);
332           abort();
333           break;
334         }
335       }
336     }
337
338     case S_VIDEOSTARTUP:     // FROM S_VIDEOSTARTUP
339     {
340       switch(newState)
341       {
342         case S_PREBUFFERING:
343         {
344           vfeed.release();
345           state = newState;
346           return;
347         }
348         
349         case S_VIDEOSTARTUP:
350         {
351           vdr->stopStreaming();
352           clearStreamChunks(); 
353           vfeed.stop();
354           afeed.stop();
355           subtitles->stop();
356                            
357           video->blank();
358           video->reset();
359           video->sync();
360           video->play();
361           video->pause();
362
363           audio->stop();
364           audio->unPause();
365           audio->reset();
366           audio->setStreamType(Audio::MPEG2_PES);
367           audio->sync();
368           audio->play();
369           audio->pause();
370
371           demuxer->reset();
372           demuxer->seek();
373
374           afeed.start();
375           vfeed.start();
376           subtitles->start();
377           
378           state = newState;
379           return;
380         }        
381         case S_STOP:
382         { 
383           vdr->stopStreaming();
384           clearStreamChunks();
385           vfeed.stop();
386           afeed.stop();
387           subtitles->stop();
388           video->stop();
389           video->blank();
390           audio->stop();
391           audio->reset();
392           video->reset();
393           state = newState;
394           return;
395         }
396         default:
397         {
398           logger->log("PlayerLiveTV", Log::EMERG, "Thread called state %u to state %u which is not supported", state, newState);
399           abort();
400           break;
401         }        
402       }
403     }
404     
405     case S_PREBUFFERING:    // FROM S_PREBUFFERING
406     {
407       switch(newState)
408       {
409         case S_PLAY:
410         {
411           audio->unPause();
412           video->unPause();
413           state = newState;
414           return;
415         }
416         case S_VIDEOSTARTUP:
417         {
418           vdr->stopStreaming();
419           clearStreamChunks();
420           vfeed.stop();
421           afeed.stop();
422           subtitles->stop();
423           video->stop();
424           video->blank();
425           audio->stop();
426           audio->unPause();
427           audio->reset();
428
429           video->reset();
430           video->sync();
431           video->play();
432           video->pause();
433
434           audio->setStreamType(Audio::MPEG2_PES);
435           audio->sync();
436           audio->play();
437           audio->pause();
438
439           demuxer->reset();
440           demuxer->seek();
441
442           afeed.start();
443           vfeed.start();
444           subtitles->start();
445
446           state = newState;
447           return;
448         }
449         case S_STOP:
450         {
451           vdr->stopStreaming();
452           clearStreamChunks();
453           vfeed.stop();
454           afeed.stop();
455           subtitles->stop();
456           video->stop();
457           video->blank();
458           audio->stop();
459           audio->reset();
460           video->reset();
461           state = newState;
462           return;        
463         }
464         default:
465         {
466           logger->log("PlayerLiveTV", Log::EMERG, "Thread called state %u to state %u which is not supported", state, newState);
467           abort();
468           break;
469         }        
470       }
471     }
472     
473     case S_PLAY:     // FROM S_PLAY
474     {
475       switch(newState)
476       {
477         case S_STOP:
478         { 
479           vdr->stopStreaming();
480           clearStreamChunks();
481           vfeed.stop();
482           afeed.stop();
483           subtitles->stop();
484           video->stop();
485           video->blank();
486           audio->stop();
487           audio->reset();
488           video->reset();
489           state = newState;
490           return;
491         }
492         case S_VIDEOSTARTUP:
493         {
494           vdr->stopStreaming();
495           clearStreamChunks();
496           vfeed.stop();
497           afeed.stop();
498           subtitles->stop();
499           video->stop();
500           video->blank();
501           audio->stop();
502           audio->unPause();
503           audio->reset();
504
505           video->reset();
506           video->sync();
507           video->play();
508           video->pause();
509
510           audio->setStreamType(Audio::MPEG2_PES);
511           audio->sync();
512           audio->play();
513           audio->pause();
514
515           demuxer->reset();
516           demuxer->seek();
517
518           afeed.start();
519           vfeed.start();
520           subtitles->start();
521
522           state = newState;
523           return;
524         }
525         default:
526         {
527           logger->log("PlayerLiveTV", Log::EMERG, "Thread called state %u to state %u which is not supported", state, newState);
528           abort();
529           break;
530         }        
531       }
532     }    
533   }  
534 }
535
536 bool PlayerLiveTV::checkError()
537 {
538   if (!vdr->isConnected())
539   {
540     if (state != S_STOP) switchState(S_STOP);
541     
542     Message* m = new Message();
543     m->from = this;
544     m->to = messageReceiver;
545     m->message = Message::PLAYER_EVENT;
546     m->parameter = PlayerLiveTV::CONNECTION_LOST;
547     messageQueue->postMessageFromOuterSpace(m);
548     
549     return true;
550   }   
551   return false;
552 }
553
554 void PlayerLiveTV::optimizeInstructionQueue()
555 {
556   // Walk the list
557   
558   // Currently there are only 2 instruction types, so this is a bit overkill...
559
560   struct PLInstruction i;
561   while(instructions.size() > 1)
562   {
563     i = instructions.front();
564     if (i.instruction == I_SETCHANNEL)
565     {
566       instructions.pop();  // if this is the first of more than 1 command, currently it cannot possibly be relevant
567     }
568     else if (i.instruction == I_STOP)
569     {
570       return; // return here and ensure the next instruction will be stop
571     }
572   }
573 }
574
575 void PlayerLiveTV::threadMethod()
576 {
577   while(1)
578   {
579     if (videoStartup) // we are in S_VIDEOSTARTUP, afeed has signalled that it has written some data
580     {
581       switchState(S_PREBUFFERING);
582       videoStartup = false;
583       preBufferCount = 0;
584       
585       checkError();
586     }  
587   
588     while(!instructions.empty())
589     {
590       if (instructions.size() > 1) optimizeInstructionQueue();
591
592       struct PLInstruction i = instructions.front();
593       instructions.pop();
594     
595       if (i.instruction == I_SETCHANNEL)
596       {
597         logger->log("PlayerLiveTV", Log::DEBUG, "start new stream");
598
599         switchState(S_VIDEOSTARTUP);
600         
601         if (!checkError())
602         {
603           Channel* chan = (*chanList)[i.channelIndex];
604           chan->loadPids();
605           demuxer->setVID(chan->vpid);
606           if (chan->numAPids > 0) 
607           {
608             demuxer->setAID(chan->apids[0].pid,0);
609             logger->log("PlayerLiveTV", Log::DEBUG, "Demuxer pids: %u %u", chan->vpid, chan->apids[0].pid);
610           }
611           else 
612           {
613             logger->log("PlayerLiveTV", Log::WARN, "Demuxer video pid only: %u", chan->vpid);
614           }
615           if (chan->numSPids > 0)
616             demuxer->setSubID(chan->spids[0].pid);
617
618           int streamSuccess = vdr->streamChannel(chan->number, this);
619           if (!checkError() && !streamSuccess)
620           {      
621             Message* m = new Message();
622             m->from = this;
623             m->to = messageReceiver;
624             m->message = Message::PLAYER_EVENT;
625             m->parameter = PlayerLiveTV::STREAM_END;
626             messageQueue->postMessageFromOuterSpace(m);
627           }
628         }
629       }
630       else if (i.instruction == I_STOP)
631       {
632         logger->log("PlayerLiveTV", Log::DEBUG, "Stopping");
633         switchState(S_STOP);
634         checkError();
635
636         stopNow = true;
637         break;
638       }
639     }
640
641     if (stopNow) break;
642
643     while(streamChunks.size())
644     {
645       chunkToDemuxer();
646
647       if (state == S_PREBUFFERING)
648       {
649         ++preBufferCount;
650         ULONG percentDone = (ULONG)(preBufferCount / (float)preBufferAmount * 100);
651         logger->log("PlayerLiveTV", Log::DEBUG, "Prebuffering %lu%%", percentDone);
652         
653         Message* m = new Message();
654         m->from = this;
655         m->to = messageReceiver;
656         m->message = Message::PLAYER_EVENT;
657         m->parameter = PlayerLiveTV::PREBUFFERING;
658         m->tag = percentDone;
659         messageQueue->postMessageFromOuterSpace(m);
660
661         if (preBufferCount == preBufferAmount)
662         {
663           switchState(S_PLAY);
664           checkError();
665         }
666       }
667     }
668     
669     threadLock();
670     threadWaitForSignal(); // unlocks and waits for signal
671     threadUnlock();
672   }
673
674   logger->log("PlayerLiveTV", Log::DEBUG, "End of thread");
675 }
676