source: titan/titan/player.h @ 25480

Last change on this file since 25480 was 25480, checked in by gost, 9 years ago

[intern] add new function playergetptspos
File size: 41.7 KB
Line 
1#ifndef PLAYER_H
2#define PLAYER_H
3
4// playercan bits:
5// 0 policy
6// 1 auditraklist
7// 2 subtitle
8// 3 videomode
9// 4 powerofftimer
10// 5 videosettings
11// 6 stop
12// 7 ff
13// 8 fr
14// 9 pause
15// 10 play
16// 11 jump/seek reverse
17// 12 jump/seek forward
18// 13 changecodec
19// 14 infobar
20// 15 slowmotion
21
22#ifdef EPLAYER3
23Context_t * player = NULL;
24extern OutputHandler_t OutputHandler;
25extern PlaybackHandler_t PlaybackHandler;
26extern ContainerHandler_t ContainerHandler;
27extern ManagerHandler_t ManagerHandler;
28#endif
29
30#ifdef EPLAYER4
31GstElement *m_gst_playbin = NULL;
32unsigned long long m_gst_startpts = 0;
33#endif
34
35//titan player
36
37//flag 0: from play
38//flag 1: from timeshift
39//flag 2: from playrcjumpr
40int playerstartts(char* file, int flag)
41{
42        int fd = -1, ret = 0, tssize = 188;
43        int16_t pmtpid = 0;
44        int serviceid = 0;
45        int supermagic = -1;
46        struct channel* chnode = NULL;
47        struct service* snode = NULL;
48        struct dvbdev* fenode = NULL;
49        struct dvbdev* dvrnode = NULL;
50
51        //supermagic = getsupermagic(file);
52
53        if(supermagic == NFS_SUPER_MAGIC || supermagic == SMB_SUPER_MAGIC)
54        {
55                debug(150, "use O_DIRECT to open file %s", file);
56                fd = open(file, O_RDONLY | O_LARGEFILE | O_NONBLOCK | O_DIRECT);
57        }
58        else
59                fd = open(file, O_RDONLY | O_LARGEFILE | O_NONBLOCK);
60
61        if(fd < 0)
62        {
63                perr("open player file");
64                return 1;
65        }
66
67        fenode = fegetdummy();
68        dvrnode = dvropen(fenode);
69        if(dvrnode == NULL)
70        {
71                err("find dvr dev");
72                close(fd);
73                return 1;
74        }
75
76        if(flag == 0 || flag == 2)
77        {
78                //TODO: funktion to get tssize from file content
79                if(cmpfilenameext(file, ".mts") == 0) tssize = 192;
80                if(cmpfilenameext(file, ".m2ts") == 0) tssize = 192;
81               
82                ret = dvbfindpmtpid(fd, &pmtpid, &serviceid, tssize);
83                if(ret == 1)
84                {
85                        err("find sid/pmt pid");
86                        close(fd);
87                        dvrclose(dvrnode, -1);
88                        return 1;
89                }
90               
91                if(flag == 0 && getconfigint("showlastpos", NULL) == 1)
92                {
93                        char* fileseek = changefilenameext(file, ".se");
94                        FILE* fbseek = fopen(fileseek, "r");
95                        if(fbseek != NULL)
96                        {
97                                ret = textbox(_("Message"), _("Start at last position ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 10, 0);
98                                if(ret == 0 || ret == 1)
99                                {
100                                        char* skip1 = calloc(1, 20);
101                                        if(skip1 != NULL)
102                                        {
103                                                fscanf(fbseek, "%s", skip1);
104                                                off64_t seekpos = atoll(skip1);
105                                                seekpos = seekpos - (seekpos % tssize);
106                                                lseek64(fd, atoll(skip1), SEEK_SET);
107                                        }
108                                        free(skip1); skip1 = NULL;
109                                }
110                                fclose(fbseek);
111                        }
112                        free(fileseek); fileseek = NULL;
113                }       
114               
115                if(flag == 0)
116                {
117                        delmarkernode(-1);
118                        char* filemarker = changefilenameext(file, ".ma");
119                        getmarker(filemarker);
120                        free(filemarker); filemarker=NULL;
121                }
122               
123                delchannel(serviceid, 0, 1);
124                chnode = createchannel("player", 0, 0, serviceid, 99, 0, -1, -1, -1, -1, 0, -1);
125                if(chnode != NULL) chnode->pmtpid = pmtpid;
126        }
127        else
128                chnode = status.aktservice->channel;
129
130        if(chnode == NULL)
131        {
132                err("create channel");
133                close(fd);
134                dvrclose(dvrnode, -1);
135                return 1;
136        }
137
138        if(flag == 1)
139        {
140                ret = servicestart(chnode, NULL, NULL, 2);
141                if(ret != 0)
142                {
143                        err("start play");
144                        close(fd);
145                        dvrclose(dvrnode, -1);
146                        return 1;
147                }
148               
149                //on permanent timeshift seek to end, and a little back (eof problem)
150                if(status.timeshifttype == 1)
151                {
152                        if(status.timeshiftpos > 0)
153                                lseek64(fd, status.timeshiftpos, SEEK_SET);
154                        else
155                        {
156                                unsigned long long pos = lseek64(fd, 0, SEEK_END);
157                                pos -= 10000000;
158                                pos = pos - (pos & tssize);
159                                lseek64(fd, -pos, SEEK_END);
160                        }
161                }
162        }
163
164        ret = recordstartreal(NULL, fd, dvrnode->fd, RECPLAY, 0, NULL, tssize);
165        if(ret != 0)
166        {
167                err("start play thread");
168                close(fd);
169                dvrclose(dvrnode, -1);
170                return 1;
171        }
172
173        snode = getservice(RECORDPLAY, 0);
174        if(snode != NULL)
175        {
176                int dupfd = -1;
177                snode->recname = ostrcat(file, NULL, 0, 0);
178
179                dupfd = open(snode->recname, O_RDONLY | O_LARGEFILE);
180                if(dupfd > -1)
181                        gettsinfo(dupfd, &snode->lenpts, &snode->startpts, &snode->endpts, &snode->bitrate, snode->tssize);
182
183                if(flag == 1)
184                {
185                        snode->lenpts = 0;
186                        snode->endpts = 0;
187                }
188                else
189                {
190                        if(getservicebyrecname(file, 1, 0) != NULL) //playfile is recording, so len can change
191                        {
192                                snode->lenpts = 0;
193                                snode->endpts = 0;
194                        }
195                        else if(dupfd > -1)
196                                snode->endoffile = lseek64(dupfd , 0, SEEK_END);
197                }
198                close(dupfd);
199        }
200
201        if(flag == 0 || flag == 2)
202        {
203                ret = servicestart(chnode, NULL, NULL, 1);
204                if(ret != 0)
205                {
206                        err("start play");
207                        if(snode != NULL) snode->recendtime = 1;
208                        close(fd);
209                        dvrclose(dvrnode, -1);
210                        return 1;
211                }
212                //status.playercan = 0x7EFF;
213                status.playercan = 0xFFFF;     
214        }
215
216        return 0;
217}
218
219//flag 0: from play
220//flag 1: from timeshift
221//flag 2: from playrcjumpr/playerafterendts
222//flag1 0: stop from rcstop
223//flag1 1: stop from servicestop
224void playerstopts(int flag, int flag1)
225{
226        int ret = 0;
227        struct service* snode = NULL;
228        struct channel* node = NULL;
229
230        snode = getservice(RECORDPLAY, flag1);
231        if(snode != NULL) snode->recendtime = 1;
232
233        if(snode != NULL && snode->recsrcfd >= 0 && flag == 0)
234        {
235                char* fileseek = changefilenameext(snode->recname, ".se");
236                FILE* fbseek = fopen(fileseek, "w");
237                if(fbseek != NULL)
238                {
239                        off64_t pos = lseek64(snode->recsrcfd, 0, SEEK_CUR);
240                        fprintf(fbseek,"%lld", pos);
241                        fclose(fbseek);
242                }
243                free(fileseek); fileseek=NULL;
244                char* filemarker = changefilenameext(snode->recname, ".ma");
245                ret = putmarker(filemarker);
246                free(filemarker); filemarker=NULL;
247                delmarkernode(-1);
248        }
249       
250        if(flag == 0 || flag == 2)
251        {
252                playerslowts(0);
253                playerffts(0);
254
255                ret = servicestop(status.aktservice, 1, 1);
256                if(ret == 1)
257                {
258                        debug(150, "can't stop ts playback service");   
259                }
260                else
261                        status.aktservice->channel = NULL;
262
263                               
264                node = gettmpchannel();
265                if(node != NULL && ostrcmp(node->name, "player") == 0)
266                        delchannel(node->serviceid, node->transponderid, 1);
267        }
268}
269
270void playerresetts()
271{
272        audiostop(status.aktservice->audiodev);
273        videostop(status.aktservice->videodev, 0);
274        videoplay(status.aktservice->videodev);
275        audioplay(status.aktservice->audiodev);
276}
277
278void playercontinuets()
279{
280        videocontinue(status.aktservice->videodev);
281        audioplay(status.aktservice->audiodev);
282}
283
284void playerpausets()
285{
286        videofreeze(status.aktservice->videodev);
287        audiopause(status.aktservice->audiodev);
288}
289
290//flag 0: with lock
291//flag 1: without lock
292int playerseekts(struct service* servicenode, int sekunden, int flag)
293{
294        off64_t offset = 0;
295        off64_t endoffile = 0;
296        off64_t currentpos = 0;
297        //off64_t fdptspos = 0;
298        //int ret = 0;
299        unsigned long long lenpts = 0;
300        unsigned long long startpts = 0;
301        unsigned long long endpts = 0;
302        unsigned long long bitrate = 0;
303        //unsigned long long aktpts = 0;
304        //unsigned long long fdpts = 0;
305        //int aktsekunden = 0;
306        int sekundenoff = 0;
307       
308        if(servicenode == NULL) return 1;
309
310        if(servicenode->recsrcfd < 0)
311        {
312                err("source fd not ok");
313                return 1;
314        }
315       
316        if(flag == 0) m_lock(&status.tsseekmutex, 15);
317
318/*
319        ret = videogetpts(status.aktservice->videodev, &aktpts);
320        if(ret == 0)
321        {
322                aktsekunden = aktpts / 90000;
323        }
324        else
325                aktsekunden = 0;
326        ret = getpts(servicenode->recsrcfd, 0, 0, 256 * 1024, &fdpts, &fdptspos, -1, servicenode->tssize);
327        if(ret == 0 && aktsekunden != 0)
328        {
329                sekundenoff = fdpts / 90000 - aktsekunden ;
330                //currentpos = lseek64(servicenode->recsrcfd, fdptspos, SEEK_SET);
331        }
332        else
333                sekundenoff = 0;
334*/
335       
336        currentpos = lseek64(servicenode->recsrcfd, 0, SEEK_CUR);
337
338        lenpts = servicenode->lenpts;
339        startpts = servicenode->startpts;
340        endpts = servicenode->endpts;
341        bitrate = servicenode->bitrate;
342        if(gettsinfo(servicenode->recsrcfd, &lenpts, &startpts, &endpts, &bitrate, servicenode->tssize) != 0)
343        {
344                err("can't read ts info");
345                lseek64(servicenode->recsrcfd, currentpos, SEEK_SET);
346                if(flag == 0) m_unlock(&status.tsseekmutex, 15);
347                return 1;
348        }
349        if(servicenode->endoffile > 0)
350                endoffile = servicenode->endoffile - (servicenode->tssize * 2);
351        else
352                endoffile = lseek64(servicenode->recsrcfd , -servicenode->tssize * 2, SEEK_END);
353
354/*
355        ret = videoclearbuffer(status.aktservice->videodev);
356        ret = audioclearbuffer(status.aktservice->audiodev);
357        ret = videodiscontinuityskip(status.aktservice->videodev, 0);
358*/
359
360        if(sekunden >= 0)
361        {
362                if(sekundenoff != 0)
363                        offset = (bitrate / 8) * (sekunden - sekundenoff);
364                else
365                        offset = (bitrate / 8) * sekunden - 5000000;
366                offset = offset - (offset % servicenode->tssize);
367                if(currentpos + offset > endoffile)
368                {
369                        offset = endoffile - currentpos;
370                        offset = offset - (offset % servicenode->tssize);
371                }
372        }
373        else
374        {
375                sekunden = sekunden * -1;
376                if(sekundenoff != 0)
377                        offset = (bitrate / 8) * (sekunden + sekundenoff);
378                else
379                        offset = (bitrate / 8) * sekunden;
380                if(offset > 0) offset += 5000000;
381                offset = offset - (offset % servicenode->tssize);
382                if(currentpos - offset < 0)
383                        offset = currentpos;
384                offset = offset * -1;
385        }
386        offset += currentpos;
387        currentpos = lseek64(servicenode->recsrcfd, offset, SEEK_SET);
388
389        playerresetts();
390
391        if(flag == 0) m_unlock(&status.tsseekmutex, 15);
392        return 0;
393}
394
395void playerffts(int speed)
396{
397        videofastforward(status.aktservice->videodev, speed);
398}
399
400void playerslowts(int speed)
401{
402        videoslowmotion(status.aktservice->videodev, speed);
403}
404
405//flag = 0 --> recordplay
406//flag = 1 --> timeshift
407void playerfrts(int speed, int flag)
408{
409        if(flag == 1)
410                videocontinue(status.aktservice->videodev);
411        if(speed == -2)
412        {
413                videoclearbuffer(status.aktservice->videodev);
414                audioclearbuffer(status.aktservice->audiodev);
415        }
416        speed *= -1;
417        videofastforward(status.aktservice->videodev, speed);
418}
419       
420
421//flag = 0 --> play ts
422//flag = 1 --> timeshift
423//flag = 2 --> timeshift, not in play mode (only recording)
424int playergetinfots(unsigned long long* lenpts, unsigned long long* startpts, unsigned long long* endpts, unsigned long long* aktpts, unsigned long long* bitrate, int flag)
425{
426        int ret = 0, dupfd = -1;
427        double ratio = 0;
428        struct service* snode = NULL;
429        unsigned long long lenpts1 = 0;
430        unsigned long long startpts1 = 0;
431        unsigned long long endpts1 = 0;
432        unsigned long long bitrate1 = 0;
433        unsigned long long endoffile1 = 0;
434        unsigned long long aktpos = 0;
435       
436        if(flag == 2)
437                snode = getservice(RECORDTIMESHIFT, 0);
438        else
439                snode = getservice(RECORDPLAY, 0);
440               
441        if(snode == NULL) return 1;
442
443        if(snode->lenpts > 0 && snode->startpts > 0 && snode->endpts > 0 && snode->bitrate > 0 && snode->endoffile > 0)
444        {
445                if(lenpts != NULL) *lenpts = snode->lenpts;
446                if(startpts != NULL) *startpts = snode->startpts;
447                if(endpts != NULL) *endpts = snode->endpts;
448                if(bitrate != NULL) *bitrate = snode->bitrate;
449
450                //ret = videogetpts(status.aktservice->videodev, aktpts);
451                if(aktpts != NULL)
452                {
453                        m_lock(&status.tsseekmutex, 15);
454                        if(flag == 2)
455                                aktpos = lseek64(snode->recdstfd , 0, SEEK_CUR);
456                        else
457                                aktpos = lseek64(snode->recsrcfd , 0, SEEK_CUR);
458                        m_unlock(&status.tsseekmutex, 15);
459
460                        ratio = (double)snode->endoffile / (double)(snode->endpts - snode->startpts);
461                        if(ratio == 0) ratio = 1;
462                        *aktpts = ((double)aktpos / ratio);
463                        *aktpts += snode->startpts;
464                }
465
466                return ret;
467        }
468       
469        dupfd = open(snode->recname, O_RDONLY | O_LARGEFILE);
470        if(dupfd < 0)
471        {
472                err("copy source fd not ok");
473                return 1;
474        }
475
476        lenpts1 = snode->lenpts;
477        startpts1 = snode->startpts;
478        endpts1 = snode->endpts;
479        bitrate1 = snode->bitrate;
480        if(gettsinfo(dupfd, &lenpts1, &startpts1, &endpts1, &bitrate1, snode->tssize) != 0)
481        {
482                err("can't read ts info");
483                return 1;
484        }
485
486        if(lenpts != NULL) *lenpts = lenpts1;
487        if(startpts != NULL) *startpts = startpts1;
488        if(endpts != NULL) *endpts = endpts1;
489        if(bitrate != NULL) *bitrate = bitrate1;
490
491        //ret = videogetpts(status.aktservice->videodev, aktpts);
492        if(aktpts != NULL)
493        {
494                m_lock(&status.tsseekmutex, 15);
495                if(flag == 2)
496                        aktpos = lseek64(snode->recdstfd, 0, SEEK_CUR);
497                else
498                        aktpos = lseek64(snode->recsrcfd, 0, SEEK_CUR);
499                m_unlock(&status.tsseekmutex, 15);
500
501                if(snode->endoffile <= 0)
502                        endoffile1 = lseek64(dupfd, 0, SEEK_END);
503                else
504                        endoffile1 = snode->endoffile;
505
506                if(endpts1 == 0)
507                        ratio = 1;
508                else
509                        ratio = (double)endoffile1 / (double)(endpts1 - startpts1);
510
511                if(ratio == 0) ratio = 1;
512                *aktpts = ((double)aktpos / ratio);
513                *aktpts += startpts1;
514        }
515
516        close(dupfd);
517        return ret;
518}
519
520void playerchangeaudiotrackts()
521{
522        screenaudiotrack();
523}
524
525void playerchangesubtitletrackts()
526{
527        screensubtitle();
528}
529
530int playerisplayingts()
531{
532        struct service* snode = getservice(RECORDPLAY, 0);
533
534        if(snode == NULL)
535                return 0;
536        return 1;
537}
538
539void playerafterendts()
540{
541        playerstopts(2, 0);
542}
543
544//extern player
545
546int playerstart(char* file)
547{
548        char * tmpfile = NULL;
549       
550        if(file != NULL)
551        {
552#ifdef EPLAYER3
553                //use eplayer
554
555                if(player != NULL)
556                {
557                        debug(150, "eplayer allready running");
558                        playerstop();
559                }
560
561                player = calloc(1, sizeof(Context_t));
562
563                if(player == NULL)
564                {
565                        err("no mem");
566                        return 1;
567                }
568
569                if(ostrstr(file, "://") == NULL)
570                        tmpfile = ostrcat("file://", file, 0, 0);
571                else
572                        tmpfile = ostrcat(file, NULL, 0, 0);
573
574                if(tmpfile == NULL)
575                {
576                        err("no mem");
577                        free(player); player = NULL;
578                        return 1;
579                }
580
581                set_player_sound(0);
582
583                if(ostrstr(tmpfile, "file://") == NULL)
584                        status.playercan = 0x4650;
585                else
586                        status.playercan = 0xFFFF;
587               
588                player->playback = &PlaybackHandler;
589                player->output = &OutputHandler;
590                player->container = &ContainerHandler;
591                player->manager = &ManagerHandler;
592               
593                //add container befor open, so we can set buffer size
594                char* ext = getfilenameext(tmpfile);
595                if(ext != NULL)
596                {
597                        player->container->Command(player, CONTAINER_ADD, ext);
598                        free(ext); ext = NULL;
599                }
600
601                //select container_ffmpeg, if we does not found a container with extensions
602                if(player->container->selectedContainer == NULL)
603                        player->container->Command(player, CONTAINER_ADD, "mp3");
604
605                if(player && player->container && player->container->selectedContainer)
606                {
607                        int size = getconfigint("playerbuffersize", NULL);
608                        int seektime = getconfigint("playerbufferseektime", NULL);
609                        player->container->selectedContainer->Command(player, CONTAINER_SET_BUFFER_SIZE, (void*)&size);
610                        player->container->selectedContainer->Command(player, CONTAINER_SET_BUFFER_SEEK_TIME, (void*)&seektime);
611                }
612               
613                debug(150, "eplayername = %s", player->output->Name);
614
615                //Registrating output devices
616                player->output->Command(player, OUTPUT_ADD, "audio");
617                player->output->Command(player, OUTPUT_ADD, "video");
618                player->output->Command(player, OUTPUT_ADD, "subtitle");
619               
620                //for subtitle
621                SubtitleOutputDef_t subout;
622
623                subout.screen_width = skinfb->width;
624                subout.screen_height = skinfb->height;
625                subout.framebufferFD = skinfb->fd;
626                subout.destination = (uint32_t *)skinfb->fb;
627                subout.destStride = skinfb->pitch;
628                subout.shareFramebuffer = 1;
629                subout.framebufferBlit = blitfb1;
630
631                player->output->subtitle->Command(player, (OutputCmd_t)OUTPUT_SET_SUBTITLE_OUTPUT, (void*)&subout);
632               
633                if(player->playback->Command(player, PLAYBACK_OPEN, tmpfile) < 0)
634                {
635                        free(player); player = NULL;
636                        free(tmpfile);
637                        return 1;
638                }
639
640                player->output->Command(player, OUTPUT_OPEN, NULL);
641                player->playback->Command(player, PLAYBACK_PLAY, NULL);
642
643                free(tmpfile);
644
645                return 0;
646#endif
647
648#ifdef EPLAYER4
649                int flags = 0x47; //(GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_AUDIO | GST_PLAY_FLAG_NATIVE_VIDEO | GST_PLAY_FLAG_TEXT);
650               
651                if(m_gst_playbin != NULL)
652                {
653                        debug(150, "eplayer allready running");
654                        playerstop();
655                }
656               
657                if(ostrstr(file, "://") == NULL)
658                        tmpfile = ostrcat("file://", file, 0, 0);
659                else
660                        tmpfile = ostrcat(file, NULL, 0, 0);
661
662                if(tmpfile == NULL)
663                {
664                        err("no mem");
665                        free(m_gst_playbin); m_gst_playbin = NULL;
666                        return 1;
667                }
668
669                if(ostrstr(tmpfile, "file://") == NULL)
670                        status.playercan = 0x7E7F;
671                else
672                        status.playercan = 0x7E7F;
673               
674                m_gst_playbin = gst_element_factory_make("playbin2", "playbin");
675                g_object_set(G_OBJECT (m_gst_playbin), "uri", tmpfile, NULL);
676                g_object_set(G_OBJECT (m_gst_playbin), "flags", flags, NULL);
677                free(tmpfile); tmpfile = NULL;
678               
679                if(m_gst_playbin)
680                        gst_element_set_state(m_gst_playbin, GST_STATE_PLAYING);
681               
682                int count = 0;
683                m_gst_startpts = 0;
684                while(m_gst_startpts == 0 && count < 5)
685                {
686                        count++;
687                        sleep(1);
688                        m_gst_startpts = playergetpts();
689                }
690                return 0;
691#endif
692        }
693       
694        return 1;
695}
696
697void playerinit(int argc, char* argv[])
698{
699#ifdef EPLAYER4
700        gst_init(&argc, &argv);
701#endif
702}
703
704#ifdef EPLAYER4
705int gstbuscall(GstBus *bus, GstMessage *msg)
706{
707        int ret = 1;
708        if(!m_gst_playbin) return 0;
709        if(!msg) return ret;
710
711        gchar *sourceName = NULL;
712        GstObject *source = GST_MESSAGE_SRC(msg);
713
714        if(!GST_IS_OBJECT(source)) return ret;
715        sourceName = gst_object_get_name(source);
716
717        switch(GST_MESSAGE_TYPE(msg))
718        {
719                case GST_MESSAGE_EOS:
720                        debug(150, "gst player eof");
721                        ret = 0;
722                        break;
723                case GST_MESSAGE_STATE_CHANGED:
724                        if(GST_MESSAGE_SRC(msg) != GST_OBJECT(m_gst_playbin))
725                                break;
726
727                        GstState old_state, new_state;
728                        gst_message_parse_state_changed(msg, &old_state, &new_state, NULL);
729               
730                        if(old_state == new_state) break;
731       
732                        debug(150, "gst state change %s -> %s", gst_element_state_get_name(old_state), gst_element_state_get_name(new_state));
733       
734                        GstStateChange transition = (GstStateChange)GST_STATE_TRANSITION(old_state, new_state);
735       
736                        switch(transition)
737                        {
738                                case GST_STATE_CHANGE_NULL_TO_READY:
739                                        break;
740                                case GST_STATE_CHANGE_READY_TO_PAUSED:
741/*
742                                        GstElement *appsink = gst_bin_get_by_name(GST_BIN(m_gst_playbin), "subtitle_sink");
743                                        if(appsink)
744                                        {
745                                                g_object_set(G_OBJECT(appsink), "max-buffers", 2, NULL);
746                                                g_object_set(G_OBJECT(appsink), "sync", FALSE, NULL);
747                                                g_object_set(G_OBJECT(appsink), "emit-signals", TRUE, NULL);
748                                                gst_object_unref(appsink);
749                                        }
750*/
751                                        break;
752                                case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
753                                        //if(m_sourceinfo.is_streaming && m_streamingsrc_timeout )
754                                                //m_streamingsrc_timeout->stop();
755                                        break;
756                                case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
757                                        break;
758                                case GST_STATE_CHANGE_PAUSED_TO_READY:
759                                        break;
760                                case GST_STATE_CHANGE_READY_TO_NULL:
761                                        ret = 0;
762                                        break;
763                        }
764                        break;
765                case GST_MESSAGE_ERROR:
766                        debug(150, "gst player error");
767
768                        gchar *gdebug1;
769                        GError *err;
770
771                        gst_message_parse_error(msg, &err, &gdebug1);
772                        g_free(gdebug1);
773
774                        debug(150, "gst error: %s (%i) from %s", err->message, err->code, sourceName);
775                        if(err->domain == GST_STREAM_ERROR)
776                        {
777                                if(err->code == GST_STREAM_ERROR_CODEC_NOT_FOUND )
778                                {
779                                        //if(g_strrstr(sourceName, "videosink"))
780                                        //      m_event((iPlayableService*)this, evUser+11);
781                                        //else if ( g_strrstr(sourceName, "audiosink") )
782                                        //      m_event((iPlayableService*)this, evUser+10);
783                                }
784                        }
785                        g_error_free(err);
786                        break;
787                case GST_MESSAGE_INFO:
788                        debug(150, "gst player info");
789
790/*
791                        gchar *gdebug2;
792                        GError *inf;
793       
794                        gst_message_parse_info(msg, &inf, &gdebug2);
795                        g_free(gdebug2);
796                        if(inf->domain == GST_STREAM_ERROR && inf->code == GST_STREAM_ERROR_DECODE )
797                        {
798                                //if(g_strrstr(sourceName, "videosink"))
799                                //      m_event((iPlayableService*)this, evUser+14);
800                        }
801                        g_error_free(inf);
802*/
803                        break;
804                case GST_MESSAGE_TAG:
805                        debug(150, "gst player tag");
806                        break;
807                //case GST_MESSAGE_ASYNC_DONE:
808                //      debug(150, "gst player async done");
809                //      break;
810                case GST_MESSAGE_ELEMENT:
811                        debug(150, "gst player element");
812                        break;
813                case GST_MESSAGE_BUFFERING:
814                        debug(150, "gst player buffering");
815
816/*
817                        GstBufferingMode mode;
818                        gst_message_parse_buffering(msg, &(m_bufferInfo.bufferPercent));
819                        gst_message_parse_buffering_stats(msg, &mode, &(m_bufferInfo.avgInRate), &(m_bufferInfo.avgOutRate), &(m_bufferInfo.bufferingLeft));
820                        //m_event((iPlayableService*)this, evBuffering);
821*/
822                        break;
823                case GST_MESSAGE_STREAM_STATUS:
824                        debug(150, "gst player stream status");
825
826/*
827                        GstStreamStatusType type;
828                        GstElement *owner;
829
830                        gst_message_parse_stream_status(msg, &type, &owner);
831                        if(type == GST_STREAM_STATUS_TYPE_CREATE && m_sourceinfo.is_streaming)
832                        {
833                                if(GST_IS_PAD(source))
834                                        owner = gst_pad_get_parent_element(GST_PAD(source));
835                                else if(GST_IS_ELEMENT(source))
836                                        owner = GST_ELEMENT(source);
837                                else
838                                        owner = NULL;
839                                if(owner)
840                                {
841                                        GstElementFactory *factory = gst_element_get_factory(GST_ELEMENT(owner));
842                                        const gchar *name = gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(factory));
843                                        if (!strcmp(name, "souphttpsrc"))
844                                        {
845                                                //m_streamingsrc_timeout->start(10 * 1000, true);
846                                                g_object_set(G_OBJECT(owner), "timeout", 10, NULL);
847                                        }
848                                       
849                                }
850                                if(GST_IS_PAD(source))
851                                        gst_object_unref(owner);
852                        }
853*/
854                        break;
855                default:
856                        debug(150, "gst player unknown message");
857                        break;
858        }
859        g_free(sourceName);
860        return ret;
861}
862#endif
863
864int playergetbuffersize()
865{
866        int ret = 0;
867
868#ifdef EPLAYER3
869        if(player && player->container && player->container->selectedContainer)
870                player->container->selectedContainer->Command(player, CONTAINER_GET_BUFFER_SIZE, (void*)&ret);
871#endif
872
873        return ret;
874}
875
876int playergetbufferstatus()
877{
878        int ret = 0;
879
880#ifdef EPLAYER3
881        if(player && player->container && player->container->selectedContainer)
882                player->container->selectedContainer->Command(player, CONTAINER_GET_BUFFER_STATUS, (void*)&ret);
883#endif
884
885        return ret;
886}
887
888int playerstopbuffer()
889{
890        int ret = 0;
891
892#ifdef EPLAYER3
893        if(player && player->container && player->container->selectedContainer)
894                player->container->selectedContainer->Command(player, CONTAINER_STOP_BUFFER, NULL);
895#endif
896
897        return ret;
898}
899
900int playerisplaying()
901{
902#ifdef SIMULATE
903        return 1;
904#endif
905
906#ifdef EPLAYER3
907        if(player != NULL && player->playback != NULL && player->playback->isPlaying)
908                return 1;
909#endif
910
911#ifdef EPLAYER4
912        int ret = 1;
913
914        if(m_gst_playbin)
915        {
916                GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(m_gst_playbin));
917                GstMessage *message = NULL;
918                while((message = gst_bus_pop(bus)))
919                {
920                        ret = gstbuscall(bus, message);
921                        gst_message_unref(message);
922                }
923        }
924        else
925                ret = 0;
926
927        return ret;
928#endif
929        return 0;
930}
931
932void playerplay()
933{
934#ifdef EPLAYER3
935        if(player && player->playback)
936                player->playback->Command(player, PLAYBACK_PLAY, NULL);
937#endif
938
939#ifdef EPLAYER4
940        if(m_gst_playbin)
941                gst_element_set_state(m_gst_playbin, GST_STATE_PLAYING);
942#endif
943}
944
945int playerstop()
946{
947#ifdef EPLAYER3
948        if(player && player->playback)
949                player->playback->Command(player, PLAYBACK_STOP, NULL);
950        if(player && player->container && player->container->selectedContainer)
951                player->container->selectedContainer->Command(player, CONTAINER_STOP, NULL);
952        if(player && player->output)
953        {
954                player->output->Command(player, OUTPUT_CLOSE, NULL);
955                player->output->Command(player, OUTPUT_DEL, (void*)"audio");
956                player->output->Command(player, OUTPUT_DEL, (void*)"video");
957                player->output->Command(player, OUTPUT_DEL, (void*)"subtitle");
958        }
959        if(player && player->playback)
960                player->playback->Command(player, PLAYBACK_CLOSE, NULL);
961
962        free(player);
963        player = NULL;
964        set_player_sound(1);
965#endif
966
967#ifdef EPLAYER4
968        if(m_gst_playbin)
969        {
970                gst_element_set_state(m_gst_playbin, GST_STATE_NULL);
971                gst_object_unref(GST_OBJECT(m_gst_playbin));
972                m_gst_playbin = NULL;
973        }
974#endif
975
976        writesysint("/proc/sys/vm/drop_caches", 3, 0);
977        return 0;
978}
979
980void playerafterend()
981{
982#ifdef EPLAYER3
983        if(player != NULL && player->playback != NULL)
984                playerstop();
985#endif
986
987#ifdef EPLAYER4
988        if(m_gst_playbin)
989                playerstop();
990#endif
991}
992
993void playerpause()
994{
995#ifdef EPLAYER3
996        if(player && player->playback)
997                player->playback->Command(player, PLAYBACK_PAUSE, NULL);
998#endif
999
1000#ifdef EPLAYER4
1001        if(m_gst_playbin)
1002                gst_element_set_state(m_gst_playbin, GST_STATE_PAUSED);
1003#endif
1004}
1005
1006void playercontinue()
1007{
1008#ifdef EPLAYER3
1009        if(player && player->playback)
1010                player->playback->Command(player, PLAYBACK_CONTINUE, NULL);
1011#endif
1012
1013#ifdef EPLAYER4
1014        if(m_gst_playbin)
1015                gst_element_set_state(m_gst_playbin, GST_STATE_PLAYING);
1016#endif
1017}
1018
1019void playerff(int speed)
1020{
1021#ifdef EPLAYER3
1022        int speedmap = 0;
1023
1024        if (speed < 1) speed = 1;
1025        if (speed > 7) speed = 7;
1026
1027        switch(speed)
1028        {
1029                case 1: speedmap = 1; break;
1030                case 2: speedmap = 3; break;
1031                case 3: speedmap = 7; break;
1032                case 4: speedmap = 15; break;
1033                case 5: speedmap = 31; break;
1034                case 6: speedmap = 63; break;
1035                case 7: speedmap = 127; break;
1036        }
1037
1038        if(player && player->playback)
1039                player->playback->Command(player, PLAYBACK_FASTFORWARD, &speedmap);
1040#endif
1041}
1042
1043void playerslow(int speed)
1044{
1045#ifdef EPLAYER3
1046        int speedmap = 0;
1047
1048        if (speed < 1) speed = 1;
1049        if (speed > 7) speed = 7;
1050
1051        switch(speed)
1052        {
1053                case 1: speedmap = 1; break;
1054                case 2: speedmap = 3; break;
1055                case 3: speedmap = 7; break;
1056                case 4: speedmap = 15; break;
1057                case 5: speedmap = 31; break;
1058                case 6: speedmap = 63; break;
1059                case 7: speedmap = 127; break;
1060        }
1061
1062        if(player && player->playback)
1063                player->playback->Command(player, PLAYBACK_SLOWMOTION, &speedmap);
1064#endif
1065}
1066
1067void playerfr(int speed)
1068{
1069#ifdef EPLAYER3
1070        int speedmap = 0;
1071
1072        if (speed > -1) speed = -1;
1073        if (speed < -7) speed = -7;
1074
1075        switch(speed)
1076        {
1077                case -1: speedmap = -5; break;
1078                case -2: speedmap = -10; break;
1079                case -3: speedmap = -20; break;
1080                case -4: speedmap = -40; break;
1081                case -5: speedmap = -80; break;
1082                case -6: speedmap = -160; break;
1083                case -7: speedmap = -320; break;
1084        }
1085
1086        if(player && player->playback)
1087                player->playback->Command(player, PLAYBACK_FASTBACKWARD, &speedmap);
1088#endif
1089}
1090
1091void playerseek(float sec)
1092{
1093#ifdef EPLAYER3
1094        if(player && player->playback)
1095                player->playback->Command(player, PLAYBACK_SEEK, (void*)&sec);
1096#endif
1097
1098#ifdef EPLAYER4
1099        gint64 nanos_pts = 0, nanos_len = 0;
1100        gint64 pts = 0, len = 0;
1101        //GstFormat fmt = GST_FORMAT_TIME;
1102               
1103        if(m_gst_playbin)
1104        {
1105                len = playergetlength();
1106                nanos_len = len * 1000000000;
1107                if(nanos_len < 0) nanos_len = 0;
1108
1109                pts = playergetpts();
1110                nanos_pts = pts * 11111;
1111                nanos_pts = nanos_pts + (sec * 1000000000);
1112                if(nanos_pts < 0) nanos_pts = 0;
1113
1114                if(nanos_pts >= nanos_len)
1115                        playerstop();
1116                else
1117                        gst_element_seek(m_gst_playbin, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, nanos_pts, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
1118        }
1119#endif
1120}
1121
1122void playerfreetracklist(char** TrackList)
1123{
1124        int i = 0;
1125
1126        if(TrackList != NULL)
1127        {
1128                while(TrackList[i] != NULL)
1129                {
1130                        free(TrackList[i]);
1131                        free(TrackList[i + 1]);
1132                        i += 2;
1133                }
1134        }
1135}
1136
1137char** playergettracklist(int type)
1138{
1139        char ** TrackList = NULL;
1140#ifdef EPLAYER3
1141        if(player && player->manager)
1142        {
1143                switch(type)
1144                {
1145                        case 1:
1146                                if(player->manager->audio)
1147                                {
1148                                        player->manager->audio->Command(player, MANAGER_LIST, &TrackList);
1149                                        debug(150, "Audio Track List");
1150                                }
1151                                break;
1152                        case 2:
1153                                if(player->manager->subtitle)
1154                                {
1155                                        player->manager->subtitle->Command(player, MANAGER_LIST, &TrackList);
1156                                        debug(150, "Subtitle Track List");
1157                                }
1158                                break;
1159                        default:
1160                                if(player->manager->video)
1161                                {
1162                                        player->manager->video->Command(player, MANAGER_LIST, &TrackList);
1163                                        debug(150, "Video Track List");
1164                                }
1165                }
1166               
1167                int i = 0;
1168                if(TrackList != NULL)
1169                {
1170                        while(TrackList[i] != NULL)
1171                        {
1172                                string_newline(TrackList[i]);
1173                                i += 2;
1174                        }
1175                       
1176                        debug(150, "Track List");
1177                        i = 0;
1178                        while(TrackList[i] != NULL)
1179                        {
1180                                debug(150, "%s - %s", TrackList[i], TrackList[i + 1]);
1181                                i += 2;
1182                        }
1183                }
1184        }
1185#endif
1186        return TrackList;
1187}
1188
1189//*CurTrackEncoding and *CurTrackName be freed
1190void playergetcurtrac(int type, int *CurTrackId, char** CurTrackEncoding, char** CurTrackName)
1191{
1192#ifdef EPLAYER3
1193        if(player && player->manager)
1194        {
1195                switch(type)
1196                {
1197                        case 1:
1198                                if(player->manager->audio)
1199                                {
1200                                        player->manager->audio->Command(player, MANAGER_GET, CurTrackId);
1201                                        player->manager->audio->Command(player, MANAGER_GETENCODING, CurTrackEncoding);
1202                                        player->manager->audio->Command(player, MANAGER_GETNAME, CurTrackName);
1203                                }
1204                                break;
1205                        case 2:
1206                                if(player->manager->subtitle)
1207                                {
1208                                        player->manager->subtitle->Command(player, MANAGER_GET, CurTrackId);
1209                                        player->manager->subtitle->Command(player, MANAGER_GETENCODING, CurTrackEncoding);
1210                                        player->manager->subtitle->Command(player, MANAGER_GETNAME, CurTrackName);
1211                                }
1212                                break;
1213                        default:
1214                                if(player->manager->video)
1215                                {
1216                                        player->manager->video->Command(player, MANAGER_GET, CurTrackId);
1217                                        player->manager->video->Command(player, MANAGER_GETENCODING, CurTrackEncoding);
1218                                        player->manager->video->Command(player, MANAGER_GETNAME, CurTrackName);
1219                                }
1220                }
1221
1222                if(CurTrackId != NULL)
1223                        debug(150, "Current Track ID: %d", *CurTrackId);
1224                if(*CurTrackEncoding != NULL)
1225                        debug(150, "Current Track Enc: %s", *CurTrackEncoding);
1226                if(*CurTrackName != NULL)
1227                        debug(150, "Current Track Name: %s", *CurTrackName);
1228        }
1229#endif
1230
1231#ifdef EPLAYER4
1232        if(m_gst_playbin != NULL)
1233        {
1234                switch(type)
1235                {
1236                        case 1:
1237                                g_object_get(G_OBJECT(m_gst_playbin), "current-audio", CurTrackId, NULL);
1238                                break;
1239                }
1240               
1241                if(CurTrackId != NULL)
1242                        debug(150, "Current Track ID: %d", *CurTrackId);
1243        }
1244#endif
1245}
1246
1247unsigned long long playergetpts()
1248{
1249        unsigned long long pts = 0;
1250        unsigned long long sec = 0;
1251
1252#ifdef EPLAYER3
1253        if(player && player->playback)
1254        {
1255                player->playback->Command(player, PLAYBACK_PTS, &pts);
1256                sec = pts / 90000;
1257                debug(150, "Pts = %02d:%02d:%02d (%llu.0000 sec)", (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
1258        }
1259#endif
1260
1261#ifdef EPLAYER4
1262        GstFormat fmt = GST_FORMAT_TIME; //Returns time in nanosecs
1263       
1264/*
1265        if(m_gst_playbin)
1266        {
1267                gst_element_query_position(m_gst_playbin, &fmt, (gint64*)&pts);
1268                sec = pts / 1000000000;
1269                pts = sec * 90000;
1270                debug(150, "Pts = %02d:%02d:%02d (%llu.0000 sec)", (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
1271        }
1272*/
1273
1274        if(m_gst_playbin)
1275        {
1276                gint64 pos;
1277                GstElement *sink;
1278                pts = 0;
1279
1280                g_object_get(G_OBJECT (m_gst_playbin), "audio-sink", &sink, NULL);
1281
1282                if(!sink) g_object_get (G_OBJECT (m_gst_playbin), "video-sink", &sink, NULL);
1283                if(!sink) return 0;
1284
1285                gchar *name = gst_element_get_name(sink);
1286                gboolean use_get_decoder_time = ostrstr(name, "dvbaudiosink") || ostrstr(name, "dvbvideosink");
1287                g_free(name);
1288
1289                if(use_get_decoder_time) g_signal_emit_by_name(sink, "get-decoder-time", &pos);
1290
1291                gst_object_unref(sink);
1292
1293                if(!use_get_decoder_time && !gst_element_query_position(m_gst_playbin, &fmt, &pos))
1294                        return 0;
1295
1296                /* pos is in nanoseconds. we have 90 000 pts per second. */
1297                pts = pos / 11111;
1298                pts = pts - m_gst_startpts;
1299                sec = pts / 90000;
1300                debug(150, "StartPTS = %llu Pts = %02d:%02d:%02d (%llu.0000 sec)", m_gst_startpts, (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
1301        }
1302#endif
1303
1304        if(pts < 0) pts = 0;
1305        return pts;
1306}
1307
1308double playergetlength()
1309{
1310        double length = 0;
1311
1312#ifdef EPLAYER3
1313        if(player && player->playback)
1314        {
1315                player->playback->Command(player, PLAYBACK_LENGTH, &length);
1316                if(length < 0) length = 0;
1317                debug(150, "Length = %02d:%02d:%02d (%.4f sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
1318        }
1319#endif
1320
1321#ifdef EPLAYER4
1322        GstFormat fmt = GST_FORMAT_TIME; //Returns time in nanosecs
1323        gint64 len;
1324
1325        if(m_gst_playbin)
1326        {
1327                gst_element_query_duration(m_gst_playbin, &fmt, &len);
1328                length = len / 1000000000;
1329                if(length < 0) length = 0;
1330                debug(150, "Length = %02d:%02d:%02d (%.4f sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
1331        }
1332#endif
1333
1334        return length;
1335}
1336
1337char* playergetinfo(char* tag)
1338{
1339        char* ret = NULL;
1340
1341#ifdef EPLAYER3
1342        char *tags[] = {"Title", "Artist", "Album", "Year", "Genre", "Comment", "Track", "Copyright", "TestLibEplayer", NULL};
1343        int i = 0;
1344
1345        if(player && player->playback)
1346        {
1347                while(tags[i] != NULL)
1348                {
1349                        ret = tags[i];
1350                        if(ostrcmp(tag, ret) == 0)
1351                        {
1352                                player->playback->Command(player, PLAYBACK_INFO, &ret);
1353                                break;
1354                        }
1355
1356                        i++;
1357                }
1358        }
1359#endif
1360        return ret;
1361}
1362
1363void playerchangeaudiotrack(int num)
1364{
1365#ifdef EPLAYER3
1366        if(player && player->playback)
1367                player->playback->Command(player, PLAYBACK_SWITCH_AUDIO, (void*)&num);
1368#endif
1369
1370#ifdef EPLAYER4
1371        if(m_gst_playbin != NULL)
1372                g_object_set(G_OBJECT(m_gst_playbin), "current-audio", num, NULL);     
1373#endif
1374}
1375
1376void playerchangesubtitletrack(int num)
1377{
1378#ifdef EPLAYER3
1379        if(player && player->playback)
1380                player->playback->Command(player, PLAYBACK_SWITCH_SUBTITLE, (void*)&num);
1381#endif
1382}
1383
1384void playerstopsubtitletrack()
1385{
1386#ifdef EPLAYER3
1387        if(player && player->output && player->output->subtitle)
1388                player->output->subtitle->Command(player, (OutputCmd_t)OUTPUT_STOP, NULL);
1389        if(player && player->container && player->container->assContainer)
1390        {
1391                player->container->assContainer->Command(player, CONTAINER_STOP, NULL);
1392                player->container->assContainer->Command(player, CONTAINER_INIT, NULL);
1393        }
1394        if(player && player->manager && player->manager->subtitle)
1395        {
1396                int onlycurrent = 1;
1397                player->manager->subtitle->Command(player, MANAGER_DEL, (void*)&onlycurrent);
1398        }
1399#endif
1400}
1401
1402int playerjumpts(struct service* servicenode, int sekunden, int *startpts, off64_t *poslastpts, off64_t *bitrate, int vpid, int tssize)
1403{
1404        int adaptation = 0;
1405        int payload = 0;
1406        int pes = 0;
1407        int tspid = 0;
1408       
1409        off64_t pts  = 0;
1410        uint64_t aktpts = 0;
1411        long long unsigned int lenpts = 0;
1412        long long unsigned int startpts1 = 0;
1413        long long unsigned int endpts = 0;
1414        long long unsigned int aktbitrate = 0;
1415        off64_t ziehlpts = 0;
1416
1417        off64_t curpos = 0;
1418        off64_t newpos = 0;
1419        off64_t jump = 0;
1420
1421        int kleiner = 0;
1422        int groesser = 0;
1423        int gleich = 0;
1424        int len = 0;
1425        int i = 0;
1426        int ret = 0;
1427
1428        if(servicenode == NULL) return -1;
1429
1430        int buflen = tssize * 15000;
1431        char *buf = malloc(buflen);
1432        if(buf == NULL)
1433                return -1;
1434       
1435        curpos = lseek64(servicenode->recsrcfd, 0, SEEK_CUR);   
1436        int dupfd = open(servicenode->recname, O_RDONLY | O_LARGEFILE);
1437        newpos = lseek64(dupfd, curpos, SEEK_SET);
1438       
1439        if (*startpts == 0)
1440        {
1441                if(videogetpts(status.aktservice->videodev, &aktpts) == 0)
1442                {
1443                                ziehlpts = (aktpts / 90000) + sekunden;
1444                }
1445                else
1446                        return 1;
1447        }
1448        else
1449        {
1450                ziehlpts = *startpts + sekunden;
1451        }
1452        *startpts = ziehlpts;
1453
1454        if(*bitrate == 0)
1455        {
1456                lenpts = servicenode->lenpts;
1457                startpts1 = servicenode->startpts;
1458                endpts = servicenode->endpts;
1459                aktbitrate = servicenode->bitrate;
1460                ret = gettsinfo(dupfd, &lenpts, &startpts1, &endpts, &aktbitrate, servicenode->tssize);
1461                if(ret != 0)
1462                {
1463                        err("can't read ts info");
1464                }
1465                else
1466                        *bitrate = aktbitrate;
1467                newpos = lseek64(dupfd, curpos, SEEK_SET);
1468        }
1469        else
1470                aktbitrate = *bitrate;
1471               
1472        if(*poslastpts == 0)
1473                *poslastpts = curpos;
1474       
1475        if(sekunden > 0)
1476        {
1477                err("not implemented");
1478                return 1;
1479        }       
1480        else if(sekunden < 0)
1481        {
1482                sekunden = sekunden * -1;
1483                if(aktbitrate != 0)
1484                {
1485                        jump = (aktbitrate / 8) * sekunden;
1486                        jump = jump + (curpos - *poslastpts);
1487                        jump = jump + (jump % servicenode->tssize);
1488                        newpos = lseek64(dupfd, -jump, SEEK_CUR);
1489                }
1490                else
1491                        newpos = lseek64(dupfd, - buflen, SEEK_CUR);
1492                if(newpos < 0)
1493                        newpos = lseek64(dupfd, tssize, SEEK_SET);
1494        }
1495        len = read(dupfd, buf, buflen);
1496        for(i = 0; i < len; i = i + 1)
1497        {
1498                if (buf[i] == 0x47 && buf[i+tssize] == 0x47)
1499                {
1500                        newpos = lseek64(dupfd, newpos + i, SEEK_SET);
1501                        break;
1502                }
1503        }
1504        if(i >= len)
1505        {
1506                newpos = lseek64(dupfd, curpos, SEEK_SET);     
1507                return 1;
1508        }
1509        while(1)
1510        {
1511        len = read(dupfd, buf, buflen);
1512
1513                if(len > 0)
1514                {
1515                        for(i = 0; i <= len-tssize; i = i + tssize)
1516                        {
1517                                payload = 0;
1518
1519                                tspid = (buf[i+1] & 0x1F) << 8;
1520                                tspid = tspid + (buf[i+2] & 0xFF);
1521                                pes = buf[i+1] & 0x40;
1522
1523                                if(tspid == vpid)
1524                                {       
1525                                        adaptation = buf[i+3] & 0x30;
1526                                        if(adaptation == 16)
1527                                        {
1528                                                payload = 4;
1529                                        }
1530                                        if(adaptation == 32)
1531                                        {
1532                                                //printf("adaptation field only\n");
1533                                        }
1534                                        if(adaptation == 48)
1535                                        {
1536                                                payload = buf[i+4] & 0xFF;
1537                                                payload = payload + 5;
1538                                        }
1539                                        if(payload != 0)
1540                                        {
1541                                                if(pes == 64)
1542                                                {
1543                                                        if(buf[i+payload+7] & 0x80) //PTS
1544                                                        {
1545                                                                pts = ((unsigned long long)(buf[i+payload+9] & 0xE)) << 29;
1546                                                                pts |= ((unsigned long long)(buf[i+payload+10] & 0xFF)) << 22;
1547                                                                pts |= ((unsigned long long)(buf[i+payload+11] & 0xFE)) << 14;
1548                                                                pts |= ((unsigned long long)(buf[i+payload+12] & 0xFF)) << 7;
1549                                                                pts |= ((unsigned long long)(buf[i+payload+13] & 0xFE)) >> 1;
1550                                                               
1551                                                                if(pts / 90000 == ziehlpts)
1552                                                                {
1553                                                                        gleich = newpos + i;
1554                                                                        break;
1555                                                                }
1556                                                                else if(pts / 90000 > ziehlpts)
1557                                                                {                                                                       
1558                                                                        groesser = newpos + i;
1559                                                                        break;
1560                                                                }
1561                                                                else
1562                                                                {
1563                                                                        kleiner = newpos + i;
1564                                                                }
1565                                                        }
1566                                                }
1567                                        }
1568                                }
1569                        }
1570                        if(gleich != 0)
1571                        {
1572                                close(dupfd);
1573                                free(buf);buf = NULL;
1574                                *poslastpts = lseek64(servicenode->recsrcfd, gleich, SEEK_SET);
1575                                return 0;
1576                        }
1577                        else if(groesser != 0 && kleiner != 0)
1578                        {
1579                                close(dupfd);
1580                                free(buf);buf = NULL;
1581                                *poslastpts = lseek64(servicenode->recsrcfd, kleiner, SEEK_SET);
1582                                return 0;
1583                        }
1584                        else if(groesser != 0)
1585                        {
1586                                if((newpos - buflen)  < 0)
1587                                {
1588                                        close(dupfd);
1589                                        free(buf);buf = NULL;
1590                                        *poslastpts = 0;
1591                                        return -1       ;
1592                                }
1593                                else
1594                                {
1595                                        newpos = lseek64(dupfd, -(buflen * 2), SEEK_CUR);
1596                                }
1597                        }
1598                }
1599                else
1600                {
1601                        if(kleiner == 0)
1602                        {
1603                                close(dupfd);
1604                                free(buf);buf = NULL;
1605                                newpos = lseek64(servicenode->recsrcfd, curpos, SEEK_SET);
1606                                *poslastpts = 0;
1607                                return -1;
1608                        }
1609                        else
1610                        {
1611                                close(dupfd);
1612                                free(buf);buf = NULL;
1613                                *poslastpts = lseek64(servicenode->recsrcfd, kleiner, SEEK_SET);
1614                                return 0;
1615                        }
1616                }
1617        }
1618}
1619
1620//praez = 1 .... sekunden
1621//                      =       2 .... zehntel
1622//                      = 3 .... hundertstel
1623//                      = 4 .... volle Uebereinstimmung
1624//
1625//type  = 0 .... alle
1626//                      = 1 .... nur PCR
1627//                      = 2 .... nur Video
1628//                      = 3 .... nur Audio
1629//
1630//flag = 0 --> play ts
1631//flag = 1 --> timeshift
1632//flag = 2 --> timeshift, not in play mode (only recording)
1633//flag = 9 --> dataset mode
1634//
1635off64_t playergetptspos(unsigned long long fpts, off64_t pos, int dir, int praez, int type, int flag, char* dsn)
1636{
1637        unsigned long long pts;
1638        int ret = 0, dupfd = -1, left = 0, tssize = 0, recbsize = 0;
1639        unsigned char* buf = NULL;
1640        unsigned char *payload;
1641        int pid = 0, pusi = 0;
1642        char* packet;
1643       
1644        if(type > 3)
1645        {
1646                printf("type %i nicht unterstützt\n", type);
1647                return -1;
1648        }
1649       
1650        if(flag == 2)
1651                snode = getservice(RECORDTIMESHIFT, 0);
1652        else if(flag != 9)
1653                snode = getservice(RECORDPLAY, 0);
1654               
1655        if(flag == 9)
1656        {
1657                tssize = 188;
1658                recbsize = tssize * 1024;
1659                dupfd = open(dsn, O_RDONLY | O_LARGEFILE );
1660        }
1661        else
1662        {
1663                tssize = snode->tssize;
1664                recbsize = snode->tssize * 1024;
1665                dupfd = open(snode->recname, O_RDONLY | O_LARGEFILE);
1666        }
1667
1668        if(dupfd < 0)
1669        {
1670                err("copy source fd not ok");
1671                return -1;
1672        }
1673
1674        buf = malloc(recbsize);
1675        if(buf == NULL)
1676        {
1677                err("no mem");
1678                return -1;
1679        }
1680        packet = buf;
1681        if(dir > 0) 
1682                pos = lseek64(dupfd, pos, SEEK_SET);
1683        else
1684                pos = lseek64(dupfd, pos - recbsize, SEEK_SET);
1685       
1686        ret = read(dupfd,  buf, recbsize);
1687        close(dupfd);
1688        left = 0;
1689       
1690        if(buf[0] != 0x47)
1691        {
1692                while(left < tssize)
1693                {
1694                        if(buf[left] == 0x47) break;
1695                        left++;
1696                }
1697                if(left >= tssize)
1698                {
1699                        free(buf);
1700                        return -1;
1701                }       
1702        }
1703        pts = 0;
1704        while(left <= recbsize - tssize)
1705        {
1706                if(pts != 0)
1707                {
1708                        switch( praez )
1709          {
1710        case 1 :        if(fpts / 90000 != pts / 90000)
1711                                                        pts = 0;
1712                                                break;
1713        case 2 :        if(fpts / 9000 != pts / 9000)
1714                                                        pts = 0;
1715                                                break;
1716        case 3 :        if(fpts / 900 != pts / 900)
1717                                                        pts = 0;
1718                                                break;         
1719        case 4 :        if(fpts != pts )
1720                                                        pts = 0;
1721                                                break;
1722                                default :       free(buf); return -1; break;
1723                        }
1724                        if(pts != 0)
1725                        {       
1726                                pos = pos + left - tssize;
1727                                free(buf);
1728                                return pos;
1729                        }
1730                }
1731                packet = buf + left;
1732                left = left + tssize;
1733                                               
1734                pid = ((packet[1] << 8) | packet[2]) & 0x1FFF;
1735                pusi = !!(packet[1] & 0x40);
1736                //check for adaption field
1737                if(packet[3] & 0x20)
1738                {
1739                        if(type > 1)continue;
1740                        if(packet[4] >= 183) continue;
1741                        if(packet[4])
1742                        {
1743                                if(packet[5] & 0x10) //PCR present
1744                                {
1745                                        pts = ((unsigned long long)(packet[6] & 0xFF)) << 25;
1746                                        pts |= ((unsigned long long)(packet[7] & 0xFF)) << 17;
1747                                        pts |= ((unsigned long long)(packet[8] & 0xFE)) << 9;
1748                                        pts |= ((unsigned long long)(packet[9] & 0xFF)) << 1;
1749                                        pts |= ((unsigned long long)(packet[10] & 0x80)) >> 7;
1750                                        continue;
1751                                }
1752                        }
1753                        payload = packet + packet[4] + 4 + 1;
1754                } else
1755                        payload = packet + 4;
1756               
1757                if(type == 1) continue;
1758                if(!pusi) continue;
1759               
1760                if (payload[0] || payload[1] || (payload[2] != 1))
1761                        continue;
1762               
1763                        //stream use extension mechanism def in ISO 13818-1 Amendment 2
1764                if(payload[3] == 0xFD)
1765                {
1766                        if(payload[7] & 1) //PES extension flag
1767                        {
1768                                int offs = 0;
1769                                if(payload[7] & 0x80) offs += 5; //pts avail
1770                                if(payload[7] & 0x40) offs += 5; //dts avail
1771                                if(payload[7] & 0x20) offs += 6; //escr avail
1772                                if(payload[7] & 0x10) offs += 3; //es rate
1773                                if(payload[7] & 0x8) offs += 1; //dsm trickmode
1774                                if(payload[7] & 0x4) offs += 1; //additional copy info
1775                                if(payload[7] & 0x2) offs += 2; //crc
1776                                if(payload[8] < offs) continue;
1777
1778                                uint8_t pef = payload[9 + offs++]; //pes extension field
1779                                if(pef & 1) //pes extension flag 2
1780                                {
1781                                        if(pef & 0x80) offs += 16; //private data flag
1782                                        if(pef & 0x40) offs += 1; //pack header field flag
1783                                        if(pef & 0x20) offs += 2; //program packet sequence counter flag
1784                                        if(pef & 0x10) offs += 2; //P-STD buffer flag
1785                                        if(payload[8] < offs) continue;
1786
1787                                        uint8_t stream_id_extension_len = payload[9 + offs++] & 0x7F;
1788                                        if(stream_id_extension_len >= 1)
1789                                        {
1790                                                if(payload[8] < (offs + stream_id_extension_len)) continue;
1791                                                //stream_id_extension_bit (should not set)
1792                                                if(payload[9 + offs] & 0x80) continue;
1793                                                switch(payload[9 + offs])
1794                                                {
1795                                                        case 0x55 ... 0x5f: break; //VC-1
1796                                                        case 0x71: break; //AC3 / DTS
1797                                                        case 0x72: break; //DTS - HD
1798                                                        default:
1799                                                                printf("skip unknwn stream_id_extension %02x\n", payload[9 + offs]);
1800                                                                continue;
1801                                                }
1802                                        }
1803                                        else
1804                                                continue;
1805                                }
1806                                else
1807                                        continue;
1808                        }
1809                        else
1810                                continue;
1811                }
1812                //drop non-audio, non-video packets because other streams
1813                //can be non-compliant.
1814                //0xC0 = audio, 0xE0 = video
1815                else if(((payload[3] & 0xE0) != 0xC0) && ((payload[3] & 0xF0) != 0xE0))
1816                        continue;
1817
1818                if((payload[7] & 0x80) && ((payload[3] & 0xF0) != 0xE0) && (type == 0 || type == 2)) //PTS video
1819                {
1820                        pts = ((unsigned long long)(payload[9] & 0xE)) << 29;
1821                        pts |= ((unsigned long long)(payload[10] & 0xFF)) << 22;
1822                        pts |= ((unsigned long long)(payload[11] & 0xFE)) << 14;
1823                        pts |= ((unsigned long long)(payload[12] & 0xFF)) << 7;
1824                        pts |= ((unsigned long long)(payload[13] & 0xFE)) >> 1;
1825                        continue;
1826                }
1827                if((payload[7] & 0x80) && ((payload[3] & 0xE0) != 0xC0) && (type == 0 || type == 3)) //PTS audio
1828                {
1829                        pts = ((unsigned long long)(payload[9] & 0xE)) << 29;
1830                        pts |= ((unsigned long long)(payload[10] & 0xFF)) << 22;
1831                        pts |= ((unsigned long long)(payload[11] & 0xFE)) << 14;
1832                        pts |= ((unsigned long long)(payload[12] & 0xFF)) << 7;
1833                        pts |= ((unsigned long long)(payload[13] & 0xFE)) >> 1;
1834                        continue;
1835                }
1836        }
1837        free(buf);
1838        return recbsize * -1;
1839}
1840
1841#endif
Note: See TracBrowser for help on using the repository browser.