source: titan/titan/player.h @ 41348

Last change on this file since 41348 was 41348, checked in by obi, 5 years ago

fix player

File size: 93.9 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
29#ifdef EXTEPLAYER3
30#include <stdlib.h>
31#include <stdio.h>
32#include <string.h>
33#include <fcntl.h>
34#include <unistd.h>
35#include <sched.h>
36#include <signal.h>
37
38#include <sys/ioctl.h>
39#include <sys/prctl.h>
40#include <sys/types.h>
41#include <sys/stat.h>
42#include <sys/time.h>
43#include <sys/resource.h>
44#include <sys/mman.h>
45
46#include "common.h"
47
48extern int ffmpeg_av_dict_set(const char *key, const char *value, int flags);
49extern void       aac_software_decoder_set(const int32_t val);
50extern void  aac_latm_software_decoder_set(const int32_t val);
51extern void       dts_software_decoder_set(const int32_t val);
52extern void       wma_software_decoder_set(const int32_t val);
53extern void       ac3_software_decoder_set(const int32_t val);
54extern void      eac3_software_decoder_set(const int32_t val);
55extern void       mp3_software_decoder_set(const int32_t val);
56extern void            rtmp_proto_impl_set(const int32_t val);
57extern void        flv2mpeg4_converter_set(const int32_t val);
58
59extern void pcm_resampling_set(int32_t val);
60extern void stereo_software_decoder_set(int32_t val);
61extern void insert_pcm_as_lpcm_set(int32_t val);
62extern void progressive_playback_set(int32_t val);
63
64static void SetBuffering()
65{
66    static char buff[2048];
67    memset( buff, '\0', sizeof(buff));
68    if( setvbuf(stderr, buff, _IOLBF, sizeof(buff)) )
69    {
70        printf("SetBuffering: failed to change the buffer of stderr\n");
71    }
72   
73    // make fgets not blocking
74    int flags = fcntl(stdin->_fileno, F_GETFL, 0);
75    fcntl(stdin->_fileno, F_SETFL, flags | O_NONBLOCK);
76}
77
78/*
79static void SetNice(int prio)
80{
81#if 0
82    setpriority(PRIO_PROCESS, 0, -8);
83   
84    int prio = sched_get_priority_max(SCHED_RR) / 2;
85    struct sched_param param = {
86        .sched_priority = prio
87    };
88    sched_setscheduler(0, SCHED_RR, &param);
89#else
90    int prevPrio = getpriority(PRIO_PROCESS, 0);
91    if (-1 == setpriority(PRIO_PROCESS, 0, prio))
92    {
93        printf("setpriority - failed\n");
94    }
95#endif
96}
97*/
98
99static int HandleTracks(const Manager_t *ptrManager, const PlaybackCmd_t playbackSwitchCmd, const char *argvBuff)
100{
101    int commandRetVal = 0;
102   
103    if (NULL == ptrManager || NULL == argvBuff || 2 != strnlen(argvBuff, 2))
104    {
105        return -1;
106    }
107   
108    switch (argvBuff[1])
109    {
110        case 'l':
111        {
112            TrackDescription_t *TrackList = NULL;
113            ptrManager->Command(player, MANAGER_LIST, &TrackList);
114            if( NULL != TrackList)
115            {
116                int i = 0;
117                fprintf(stderr, "{\"%c_%c\": [", argvBuff[0], argvBuff[1]);
118                for (i = 0; TrackList[i].Id >= 0; ++i)
119                {
120                    if(0 < i)
121                    {
122                        fprintf(stderr, ", ");
123                    }
124                    fprintf(stderr, "{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}", TrackList[i].Id , TrackList[i].Encoding, TrackList[i].Name);
125                    free(TrackList[i].Encoding);
126                    free(TrackList[i].Name);
127                }
128                fprintf(stderr, "]}\n");
129                free(TrackList);
130            }
131            else
132            {
133                // not tracks
134                fprintf(stderr, "{\"%c_%c\": []}\n", argvBuff[0], argvBuff[1]);
135            }
136            break;
137        }
138        case 'c':
139        {
140           
141            TrackDescription_t *track = NULL;
142            ptrManager->Command(player, MANAGER_GET_TRACK_DESC, &track);
143            if (NULL != track)
144            {
145                if ('a' == argvBuff[0] || 's' == argvBuff[0])
146                {
147                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}}\n", argvBuff[0], argvBuff[1], track->Id , track->Encoding, track->Name);
148                }
149                else // video
150                {
151                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\",\"w\":%d,\"h\":%d,\"f\":%u,\"p\":%d,\"an\":%d,\"ad\":%d}}\n", \
152                    argvBuff[0], argvBuff[1], track->Id , track->Encoding, track->Name, track->width, track->height, track->frame_rate, track->progressive, track->aspect_ratio_num, track->aspect_ratio_den);
153                }
154                free(track->Encoding);
155                free(track->Name);
156                free(track);
157            }
158            else
159            {
160                // no tracks
161                if ('a' == argvBuff[0] || 's' == argvBuff[0])
162                {
163                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}}\n", argvBuff[0], argvBuff[1], -1, "", "");
164                }
165                else // video
166                {
167                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\",\"w\":%d,\"h\":%d,\"f\":%u,\"p\":%d}}\n", argvBuff[0], argvBuff[1], -1, "", "", -1, -1, 0, -1);
168                }
169            }
170            break;
171        }
172        default:
173        {
174            /* switch command available only for audio and subtitle tracks */
175            if ('a' == argvBuff[0] || 's' == argvBuff[0])
176            {
177                int ok = 0;
178                int id = -1;
179                if ('i' == argvBuff[1])
180                {
181                    int idx = -1;
182                    ok = sscanf(argvBuff+2, "%d", &idx);
183                    if (idx >= 0)
184                    {
185                        TrackDescription_t *TrackList = NULL;
186                        ptrManager->Command(player, MANAGER_LIST, &TrackList);
187                        if( NULL != TrackList)
188                        {
189                            int i = 0;
190                            for (i = 0; TrackList[i].Id >= 0; ++i)
191                            {
192                                if (idx == i)
193                                {
194                                    id = TrackList[i].Id;
195                                }
196                                free(TrackList[i].Encoding);
197                                free(TrackList[i].Name);
198                            }
199                            free(TrackList);
200                        }
201                    }
202                    else
203                    {
204                        id = idx;
205                    }
206                }
207                else
208                {
209                    ok = sscanf(argvBuff+1, "%d", &id);
210                }
211               
212                if(id >= 0 || (1 == ok && id == -1))
213                {
214                    commandRetVal = player->playback->Command(player, playbackSwitchCmd, (void*)&id);
215                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"sts\":%d}}\n", argvBuff[0], 's', id, commandRetVal);
216                }
217            }
218            break;
219        }
220    }
221   
222    return commandRetVal;
223}
224
225static void UpdateVideoTrack()
226{
227    HandleTracks(player->manager->video, (PlaybackCmd_t)-1, "vc");
228}
229#endif
230#endif
231
232#ifdef EPLAYER4
233//#define GST_VERSION_MAJOR (0)
234GstElement *pipeline = NULL;
235gint m_framerate;
236unsigned long long m_gst_startpts = 0;
237CustomData data;
238GstElement *video_sink = NULL;
239struct stimerthread* subtitlethread = NULL;
240uint32_t buf_pos_ms = 0;
241uint32_t duration_ms = 0;
242int subtitleflag = 0;
243char *subtext = NULL;
244#else
245struct stimerthread* subtitlethread = NULL;
246uint32_t buf_pos_ms = 0;
247uint32_t duration_ms = 0;
248int subtitleflag = 0;
249char *subtext = NULL;
250#endif
251
252//titan player
253
254//flag 0: from play
255//flag 1: from timeshift
256//flag 2: from playrcjumpr
257int playerstartts(char* file, int flag)
258{
259        int fd = -1, ret = 0, tssize = 188;
260        int16_t pmtpid = 0;
261        int serviceid = 0;
262        int supermagic = -1;
263        int lastpos = 0;
264        struct channel* chnode = NULL;
265        struct service* snode = NULL;
266        struct dvbdev* fenode = NULL;
267        struct dvbdev* dvrnode = NULL;
268        status.prefillbuffer = 0;
269#ifdef EPLAYER4
270        status.bufferpercent = 0;
271#endif
272        //supermagic = getsupermagic(file);
273
274        if(supermagic == NFS_SUPER_MAGIC || supermagic == SMB_SUPER_MAGIC)
275        {
276                debug(150, "use O_DIRECT to open file %s", file);
277                fd = open(file, O_RDONLY | O_LARGEFILE | O_NONBLOCK | O_DIRECT);
278        }
279        else
280                fd = open(file, O_RDONLY | O_LARGEFILE | O_NONBLOCK);
281
282        if(fd < 0)
283        {
284                perr("open player file");
285                return 1;
286        }
287
288        fenode = fegetdummy();
289        dvrnode = dvropen(fenode);
290        if(dvrnode == NULL)
291        {
292                err("find dvr dev");
293                close(fd);
294                return 1;
295        }
296
297        if(flag == 0 || flag == 2)
298        {
299                //TODO: funktion to get tssize from file content
300                if(cmpfilenameext(file, ".mts") == 0) tssize = 192;
301                if(cmpfilenameext(file, ".m2ts") == 0) tssize = 192;
302               
303                ret = dvbfindpmtpid(fd, &pmtpid, &serviceid, tssize);
304                if(ret == 1)
305                {
306                        err("find sid/pmt pid");
307                        close(fd);
308                        dvrclose(dvrnode, -1);
309                        return 1;
310                }
311               
312                lastpos = 0;
313                if(flag == 0 && getconfigint("showlastpos", NULL) == 1)
314                {
315                        char* fileseek = changefilenameext(file, ".se");
316                        FILE* fbseek = fopen(fileseek, "r");
317                        if(fbseek != NULL)
318                        {
319                                ret = textbox(_("Message"), _("Start at last position ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 10, 0);
320                                if(ret == 0 || ret == 1)
321                                {
322                                        char* skip1 = calloc(1, 20);
323                                        if(skip1 != NULL)
324                                        {
325                                                fscanf(fbseek, "%s", skip1);
326                                                off64_t seekpos = atoll(skip1);
327                                                seekpos = seekpos - (seekpos % tssize);
328                                                lseek64(fd, atoll(skip1), SEEK_SET);
329                                                lastpos = 1;
330                                        }
331                                        free(skip1); skip1 = NULL;
332                                }
333                                fclose(fbseek);
334                        }
335                        free(fileseek); fileseek = NULL;
336                }       
337               
338                status.autoseek = 0;
339               
340                if(flag == 0)
341                {
342                        delmarkernode(-1);
343                        char* filemarker = changefilenameext(file, ".ma");
344                        getmarker(filemarker);
345                        free(filemarker); filemarker=NULL;
346                }
347               
348                if(status.playmarker != NULL)
349                {
350                        char* testfile = changefilenameext(file, ".as");
351                        FILE* testseek = fopen(testfile, "r");
352                        if(testseek != NULL)
353                        {
354                                if(lastpos == 0)
355                                        lseek64(fd, status.playmarker->pos, SEEK_SET);
356                                status.autoseek = 2;
357                                addtimer(&markerautoseek_thread, START, 10000, 1, NULL, NULL, NULL);
358                                fclose(testseek);
359                        }
360                        free(testfile); testfile = NULL;
361                }
362                               
363                delchannel(serviceid, 0, 1);
364                chnode = createchannel("player", 0, 0, serviceid, 99, 0, -1, -1, -1, -1, 0, -1);
365                if(chnode != NULL) chnode->pmtpid = pmtpid;
366        }
367        else
368                chnode = status.aktservice->channel;
369
370        if(chnode == NULL)
371        {
372                err("create channel");
373                close(fd);
374                dvrclose(dvrnode, -1);
375                return 1;
376        }
377
378        if(flag == 1)
379        {
380                ret = servicestart(chnode, NULL, NULL, 2);
381                if(ret != 0)
382                {
383                        err("start play");
384                        close(fd);
385                        dvrclose(dvrnode, -1);
386                        return 1;
387                }
388               
389                //on permanent timeshift seek to end, and a little back (eof problem)
390                if(status.timeshifttype == 1)
391                {
392                        if(status.timeshiftpos > 0)
393                                lseek64(fd, status.timeshiftpos, SEEK_SET);
394                        else
395                        {
396                                unsigned long long pos = lseek64(fd, 0, SEEK_END);
397                                pos -= 10000000;
398                                pos = pos - (pos & tssize);
399                                lseek64(fd, -pos, SEEK_END);
400                        }
401                }
402        }
403
404        ret = recordstartreal(NULL, fd, dvrnode->fd, RECPLAY, 0, NULL, tssize);
405        if(ret != 0)
406        {
407                err("start play thread");
408                close(fd);
409                dvrclose(dvrnode, -1);
410                return 1;
411        }
412
413        snode = getservice(RECORDPLAY, 0);
414        if(snode != NULL)
415        {
416                int dupfd = -1;
417                snode->recname = ostrcat(file, NULL, 0, 0);
418
419                dupfd = open(snode->recname, O_RDONLY | O_LARGEFILE);
420                if(dupfd > -1)
421                        gettsinfo(dupfd, &snode->lenpts, &snode->startpts, &snode->endpts, &snode->bitrate, snode->tssize);
422
423                if(flag == 1)
424                {
425                        snode->lenpts = 0;
426                        snode->endpts = 0;
427                }
428                else
429                {
430                        if(getservicebyrecname(file, 1, 0) != NULL) //playfile is recording, so len can change
431                        {
432                                snode->lenpts = 0;
433                                snode->endpts = 0;
434                        }
435                        else if(dupfd > -1)
436                                snode->endoffile = lseek64(dupfd , 0, SEEK_END);
437                }
438                close(dupfd);
439        }
440
441        if(flag == 0 || flag == 2)
442        {
443                ret = servicestart(chnode, NULL, NULL, 1);
444                if(ret != 0)
445                {
446                        err("start play");
447                        if(snode != NULL) snode->recendtime = 1;
448                        close(fd);
449                        dvrclose(dvrnode, -1);
450                        return 1;
451                }
452                //status.playercan = 0x7EFF;
453                status.playercan = 0xFFFF;     
454        }
455
456        return 0;
457}
458
459//flag 0: from play
460//flag 1: from timeshift
461//flag 2: from playrcjumpr/playerafterendts
462//flag1 0: stop from rcstop
463//flag1 1: stop from servicestop
464void playerstopts(int flag, int flag1)
465{
466        int ret = 0;
467        struct service* snode = NULL;
468        struct channel* node = NULL;
469
470        snode = getservice(RECORDPLAY, flag1);
471
472        if(snode != NULL && snode->recsrcfd >= 0 && flag == 0 && flag1 == 0)
473        {
474                char* fileseek = changefilenameext(snode->recname, ".se");
475                FILE* fbseek = fopen(fileseek, "w");
476                if(fbseek != NULL)
477                {
478                        off64_t pos = getcurrentpos(snode);
479                        if(pos <= 0)
480                                pos = lseek64(snode->recsrcfd, 0, SEEK_CUR);
481                        fprintf(fbseek,"%lld", pos);
482                        fclose(fbseek);
483                }
484                free(fileseek); fileseek=NULL;
485                char* filemarker = changefilenameext(snode->recname, ".ma");
486                ret = putmarker(filemarker);
487                free(filemarker); filemarker=NULL;
488                delmarkernode(-1);
489        }
490       
491        if(snode != NULL) snode->recendtime = 1;
492       
493        if(flag == 0 || flag == 2)
494        {
495                playerslowts(0);
496                playerffts(0);
497
498                ret = servicestop(status.aktservice, 1, 1);
499                if(ret == 1)
500                {
501                        debug(150, "can't stop ts playback service");   
502                }
503                else
504                        status.aktservice->channel = NULL;
505
506                               
507                node = gettmpchannel();
508                if(node != NULL && ostrcmp(node->name, "player") == 0)
509                        delchannel(node->serviceid, node->transponderid, 1);
510        }
511}
512
513void playerresetts()
514{
515#ifdef DREAMBOX
516        videofreeze(status.aktservice->videodev);
517        dmxstart(status.aktservice->dmxaudiodev);
518        audioplay(status.aktservice->audiodev);
519        audiopause(status.aktservice->audiodev);
520#else
521        audiostop(status.aktservice->audiodev);
522        videostop(status.aktservice->videodev, 0);
523#endif
524
525#ifdef MIPSEL
526        videoclearbuffer(status.aktservice->videodev);
527        audioclearbuffer(status.aktservice->audiodev);
528#endif
529
530#ifdef DREAMBOX
531        videoslowmotion(status.aktservice->videodev, 0);
532        videofastforward(status.aktservice->videodev, 0);
533        videocontinue(status.aktservice->videodev);
534        audiocontinue(status.aktservice->audiodev);
535#else
536        videoplay(status.aktservice->videodev);
537        audioplay(status.aktservice->audiodev);
538#endif
539}
540
541void playercontinuets()
542{
543        videocontinue(status.aktservice->videodev);
544#ifdef MIPSEL
545        audiocontinue(status.aktservice->audiodev);
546#else
547        audioplay(status.aktservice->audiodev);
548#endif
549}
550
551void playerpausets()
552{
553        videofreeze(status.aktservice->videodev);
554        audiopause(status.aktservice->audiodev);
555}
556
557//flag 0: with lock
558//flag 1: without lock
559int playerseekts(struct service* servicenode, int sekunden, int flag)
560{
561        off64_t offset = 0;
562        off64_t endoffile = 0;
563        off64_t currentpos = 0;
564        //off64_t fdptspos = 0;
565        //int ret = 0;
566        unsigned long long lenpts = 0;
567        unsigned long long startpts = 0;
568        unsigned long long endpts = 0;
569        unsigned long long bitrate = 0;
570        //unsigned long long aktpts = 0;
571        //unsigned long long fdpts = 0;
572        //int aktsekunden = 0;
573        int sekundenoff = 0;
574       
575        if(servicenode == NULL) return 1;
576
577        if(servicenode->recsrcfd < 0)
578        {
579                err("source fd not ok");
580                return 1;
581        }
582       
583        if(flag == 0) m_lock(&status.tsseekmutex, 15);
584
585/*
586        ret = videogetpts(status.aktservice->videodev, &aktpts);
587        if(ret == 0)
588        {
589                aktsekunden = aktpts / 90000;
590        }
591        else
592                aktsekunden = 0;
593        ret = getpts(servicenode->recsrcfd, 0, 0, 256 * 1024, &fdpts, &fdptspos, -1, servicenode->tssize);
594        if(ret == 0 && aktsekunden != 0)
595        {
596                sekundenoff = fdpts / 90000 - aktsekunden ;
597                //currentpos = lseek64(servicenode->recsrcfd, fdptspos, SEEK_SET);
598        }
599        else
600                sekundenoff = 0;
601*/
602       
603        currentpos = lseek64(servicenode->recsrcfd, 0, SEEK_CUR);
604
605        lenpts = servicenode->lenpts;
606        startpts = servicenode->startpts;
607        endpts = servicenode->endpts;
608        bitrate = servicenode->bitrate;
609        if(gettsinfo(servicenode->recsrcfd, &lenpts, &startpts, &endpts, &bitrate, servicenode->tssize) != 0)
610        {
611                err("can't read ts info");
612                lseek64(servicenode->recsrcfd, currentpos, SEEK_SET);
613                if(flag == 0) m_unlock(&status.tsseekmutex, 15);
614                return 1;
615        }
616        if(servicenode->endoffile > 0)
617                endoffile = servicenode->endoffile - (servicenode->tssize * 2);
618        else
619                endoffile = lseek64(servicenode->recsrcfd , -servicenode->tssize * 2, SEEK_END);
620
621/*
622        ret = videoclearbuffer(status.aktservice->videodev);
623        ret = audioclearbuffer(status.aktservice->audiodev);
624        ret = videodiscontinuityskip(status.aktservice->videodev, 0);
625*/
626
627        if(sekunden >= 0)
628        {
629                if(sekundenoff != 0)
630                        offset = (bitrate / 8) * (sekunden - sekundenoff);
631                else
632                        offset = (bitrate / 8) * sekunden - 5000000;
633                offset = offset - (offset % servicenode->tssize);
634                if(currentpos + offset > endoffile)
635                {
636                        offset = endoffile - currentpos;
637                        offset = offset - (offset % servicenode->tssize);
638                }
639        }
640        else
641        {
642                sekunden = sekunden * -1;
643                if(sekundenoff != 0)
644                        offset = (bitrate / 8) * (sekunden + sekundenoff);
645                else
646                        offset = (bitrate / 8) * sekunden;
647                if(offset > 0) offset += 5000000;
648                offset = offset - (offset % servicenode->tssize);
649                if(currentpos - offset < 0)
650                        offset = currentpos;
651                offset = offset * -1;
652        }
653        offset += currentpos;
654        currentpos = lseek64(servicenode->recsrcfd, offset, SEEK_SET);
655
656        playerresetts();
657
658        if(flag == 0) m_unlock(&status.tsseekmutex, 15);
659        return 0;
660}
661
662void playerffts(int speed)
663{
664#ifdef MIPSEL
665        audiostop(status.aktservice->audiodev);
666
667#ifdef DREAMBOX
668        dmxstop(status.aktservice->dmxaudiodev);
669#endif
670
671        videoslowmotion(status.aktservice->videodev, 0);
672        videofastforward(status.aktservice->videodev, speed);
673        videocontinue(status.aktservice->videodev);
674#else   
675        videofastforward(status.aktservice->videodev, speed);
676#endif
677}
678
679void playerslowts(int speed)
680{
681#ifdef MIPSEL
682        audiostop(status.aktservice->audiodev);
683       
684#ifdef DREAMBOX
685        dmxstop(status.aktservice->dmxaudiodev);
686#endif 
687
688        videoslowmotion(status.aktservice->videodev, speed);
689        videofastforward(status.aktservice->videodev, 0);
690        videocontinue(status.aktservice->videodev);
691#else           
692        videoslowmotion(status.aktservice->videodev, speed);
693#endif
694}
695
696//flag = 0 --> recordplay
697//flag = 1 --> timeshift
698void playerfrts(int speed, int flag)
699{
700        if(flag == 1)
701                videocontinue(status.aktservice->videodev);
702        if(speed == -2)
703        {
704                videoclearbuffer(status.aktservice->videodev);
705                audioclearbuffer(status.aktservice->audiodev);
706        }
707        speed *= -1;
708#ifdef MIPSEL
709        audiostop(status.aktservice->audiodev);
710#ifdef DREAMBOX
711        dmxstop(status.aktservice->dmxaudiodev);
712#endif
713        videoslowmotion(status.aktservice->videodev, 0);
714        videofastforward(status.aktservice->videodev, speed);
715        videocontinue(status.aktservice->videodev);
716#else   
717        videofastforward(status.aktservice->videodev, speed);
718#endif
719}
720       
721
722//flag = 0 --> play ts
723//flag = 1 --> timeshift
724//flag = 2 --> timeshift, not in play mode (only recording)
725int playergetinfots(unsigned long long* lenpts, unsigned long long* startpts, unsigned long long* endpts, unsigned long long* aktpts, unsigned long long* bitrate, int flag)
726{
727        int ret = 0, dupfd = -1;
728        double ratio = 0;
729        struct service* snode = NULL;
730        unsigned long long lenpts1 = 0;
731        unsigned long long startpts1 = 0;
732        unsigned long long endpts1 = 0;
733        unsigned long long bitrate1 = 0;
734        unsigned long long endoffile1 = 0;
735        unsigned long long aktpos = 0;
736       
737        if(flag == 2)
738                snode = getservice(RECORDTIMESHIFT, 0);
739        else
740                snode = getservice(RECORDPLAY, 0);
741               
742        if(snode == NULL) return 1;
743
744        if(snode->lenpts > 0 && snode->startpts > 0 && snode->endpts > 0 && snode->bitrate > 0 && snode->endoffile > 0)
745        {
746                if(lenpts != NULL) *lenpts = snode->lenpts;
747                if(startpts != NULL) *startpts = snode->startpts;
748                if(endpts != NULL) *endpts = snode->endpts;
749                if(bitrate != NULL) *bitrate = snode->bitrate;
750
751                //ret = videogetpts(status.aktservice->videodev, aktpts);
752                if(aktpts != NULL)
753                {
754                        m_lock(&status.tsseekmutex, 15);
755                        if(flag == 2)
756                                aktpos = lseek64(snode->recdstfd , 0, SEEK_CUR);
757                        else
758                                aktpos = lseek64(snode->recsrcfd , 0, SEEK_CUR);
759                        m_unlock(&status.tsseekmutex, 15);
760
761                        ratio = (double)snode->endoffile / (double)(snode->endpts - snode->startpts);
762                        if(ratio == 0) ratio = 1;
763                        *aktpts = ((double)aktpos / ratio);
764                        *aktpts += snode->startpts;
765                }
766
767                return ret;
768        }
769       
770        dupfd = open(snode->recname, O_RDONLY | O_LARGEFILE);
771        if(dupfd < 0)
772        {
773                err("copy source fd not ok");
774                return 1;
775        }
776
777        lenpts1 = snode->lenpts;
778        startpts1 = snode->startpts;
779        endpts1 = snode->endpts;
780        bitrate1 = snode->bitrate;
781        if(gettsinfo(dupfd, &lenpts1, &startpts1, &endpts1, &bitrate1, snode->tssize) != 0)
782        {
783                err("can't read ts info");
784                return 1;
785        }
786
787        if(lenpts != NULL) *lenpts = lenpts1;
788        if(startpts != NULL) *startpts = startpts1;
789        if(endpts != NULL) *endpts = endpts1;
790        if(bitrate != NULL) *bitrate = bitrate1;
791
792        //ret = videogetpts(status.aktservice->videodev, aktpts);
793        if(aktpts != NULL)
794        {
795                m_lock(&status.tsseekmutex, 15);
796                if(flag == 2)
797                        aktpos = lseek64(snode->recdstfd, 0, SEEK_CUR);
798                else
799                        aktpos = lseek64(snode->recsrcfd, 0, SEEK_CUR);
800                m_unlock(&status.tsseekmutex, 15);
801
802                if(snode->endoffile <= 0)
803                        endoffile1 = lseek64(dupfd, 0, SEEK_END);
804                else
805                        endoffile1 = snode->endoffile;
806
807                if(endpts1 == 0)
808                        ratio = 1;
809                else
810                        ratio = (double)endoffile1 / (double)(endpts1 - startpts1);
811
812                if(ratio == 0) ratio = 1;
813                *aktpts = ((double)aktpos / ratio);
814                *aktpts += startpts1;
815        }
816
817        close(dupfd);
818        return ret;
819}
820
821void playerchangeaudiotrackts()
822{
823        screenaudiotrack();
824}
825
826void playerchangesubtitletrackts()
827{
828        screensubtitle();
829}
830
831int playerisplayingts()
832{
833        struct service* snode = getservice(RECORDPLAY, 0);
834
835        if(snode == NULL)
836                return 0;
837        return 1;
838}
839
840void playerafterendts()
841{
842        playerstopts(2, 0);
843}
844
845#ifdef EPLAYER4
846void playersubtitleclean(char* data, int len)
847{
848        char* zeichen = NULL;
849        int found = 1;
850       
851        while(found == 1)
852        {
853                found = 0;
854                zeichen = NULL;
855                zeichen = strstr(data, "&apos;");
856                if(zeichen != NULL)
857                {
858                        zeichen[0] = '\'';
859                        memcpy(zeichen+1, zeichen+6, len - (zeichen - data + 1));
860                        found = 1;
861                }
862                zeichen = NULL;
863                zeichen = strstr(data, "&amp;");
864                if(zeichen != NULL)
865                {
866                        zeichen[0] = '&';
867                        memcpy(zeichen+1, zeichen+5, len - (zeichen - data + 1));
868                        found = 1;
869                }
870                zeichen = NULL;
871                zeichen = strstr(data, "&quot;");
872                if(zeichen != NULL)
873                {
874                        zeichen[0] = '"';
875                        memcpy(zeichen+1, zeichen+6, len - (zeichen - data + 1));
876                        found = 1;
877                }
878                zeichen = NULL;
879                zeichen = strstr(data, "&lt;");
880                if(zeichen != NULL)
881                {
882                        zeichen[0] = '<';
883                        memcpy(zeichen+1, zeichen+4, len - (zeichen - data + 1));
884                        found = 1;
885                }
886                zeichen = NULL;
887                zeichen = strstr(data, "&gt;");
888                if(zeichen != NULL)
889                {
890                        zeichen[0] = '<';
891                        memcpy(zeichen+1, zeichen+4, len - (zeichen - data + 1));
892                        found = 1;
893                }
894                //workaround da keine Aufbereitung
895                zeichen = NULL;
896                zeichen = strstr(data, "<i>");
897                if(zeichen != NULL)
898                {
899                        memcpy(zeichen, zeichen+3, len - (zeichen - data + 1));
900                        found = 1;
901                }
902                zeichen = NULL;
903                zeichen = strstr(data, "</i>");
904                if(zeichen != NULL)
905                {
906                        memcpy(zeichen, zeichen+4, len - (zeichen - data + 1));
907                        found = 1;
908                }
909        }
910}
911#endif
912
913#ifdef EPLAYER4
914void playersubtitle_thread()
915{
916        struct skin* framebuffer = getscreen("framebuffer");
917        struct skin* subtitle = getscreen("gstsubtitle");
918        char* bg = NULL;
919        int count = 0;
920       
921        subtitle->bgcol = -1;
922       
923        setnodeattr(subtitle, framebuffer, 0);
924        bg = savescreen(subtitle);
925       
926        while(subtitlethread->aktion != STOP)
927        {
928                if(duration_ms != 0)
929                {
930                        count = 0;
931                        changetext(subtitle, subtext);
932                        count = duration_ms / 100;
933                        drawscreen(subtitle, 0, 0);
934                        while(count > 0 && subtitlethread->aktion != STOP)
935                        {
936                                usleep(100000);
937                                count = count - 1;
938                        }
939                        changetext(subtitle, " ");
940                        drawscreen(subtitle, 0, 0);
941                        duration_ms = 0;
942                }
943                else
944                        usleep(100000);
945        }
946        free(subtext); subtext = NULL;
947        restorescreen(bg, subtitle);
948        blitfb(0);
949        subtitlethread = NULL;
950}
951#else
952void playersubtitle_thread()
953{
954        struct skin* framebuffer = getscreen("framebuffer");
955        struct skin* subtitle = getscreen("gstsubtitle");
956        char* bg = NULL;
957        int count = 0;
958       
959        subtitle->bgcol = -1;
960       
961        setnodeattr(subtitle, framebuffer, 0);
962        bg = savescreen(subtitle);
963       
964        while(subtitlethread->aktion != STOP)
965        {
966                if(duration_ms != 0)
967                {
968                        count = 0;
969                        changetext(subtitle, subtext);
970                        count = duration_ms / 100;
971                        drawscreen(subtitle, 0, 0);
972                        while(count > 0 && subtitlethread->aktion != STOP)
973                        {
974                                usleep(100000);
975                                count = count - 1;
976                        }
977                        changetext(subtitle, " ");
978                        drawscreen(subtitle, 0, 0);
979                        duration_ms = 0;
980                }
981                else
982                        usleep(100000);
983        }
984        free(subtext); subtext = NULL;
985        restorescreen(bg, subtitle);
986        blitfb(0);
987        subtitlethread = NULL;
988}
989#endif
990
991#ifdef EPLAYER4
992void playersubtitleAvail(GstElement *subsink, GstBuffer *buffer, gpointer user_data)
993{
994        //printf("++++++ subtitelflag: %i\n", subtitleflag);
995        if(subtitleflag == 0 || subtitleflag == 2) return;
996
997#if GST_VERSION_MAJOR < 1
998        gint64 buf_pos = GST_BUFFER_TIMESTAMP(buffer);
999        gint64 duration_ns = GST_BUFFER_DURATION(buffer);
1000#endif 
1001        time_t running_pts = 0;
1002        gint64 pos = 0;
1003        int32_t decoder_ms;
1004        GstFormat fmt = GST_FORMAT_TIME;
1005       
1006#if GST_VERSION_MAJOR < 1
1007        if (!gst_element_query_position(pipeline, &fmt, &pos))
1008#else
1009        if (!gst_element_query_position(pipeline, fmt, &pos))
1010#endif
1011        {
1012                err("gst_element_query_position failed");
1013                return;
1014        }
1015        running_pts = pos / 11111LL;
1016        decoder_ms = running_pts / 90;
1017               
1018        if(subtitlethread == NULL)
1019                subtitlethread = addtimer(&playersubtitle_thread, START, 10000, 1, NULL, NULL, NULL);
1020       
1021#if GST_VERSION_MAJOR < 1
1022        size_t len = GST_BUFFER_SIZE(buffer);
1023#else
1024//      size_t len = gst_buffer_get_size(buffer);
1025        GstMapInfo map;
1026        if(!gst_buffer_map(buffer, &map, GST_MAP_READ))
1027        {
1028                printf("eServiceMP3::pullSubtitle gst_buffer_map failed\n");
1029                return;
1030        }
1031        gint64 buf_pos = GST_BUFFER_PTS(buffer);
1032        size_t len = map.size;
1033#if GST_VERSION_MAJOR < 1
1034        printf("gst_buffer_get_size %zu map.size %zu\n", gst_buffer_get_size(buffer), len);
1035#endif
1036        gint64 duration_ns = GST_BUFFER_DURATION(buffer);
1037#endif
1038                       
1039        //printf("BUFFER_TIMESTAMP: %lld - BUFFER_DURATION: %lld in ns\n", buf_pos, duration_ns);
1040        //printf("BUFFER_SIZE: %d\n", len);
1041        //printf("BUFFER_DATA: %s\n", GST_BUFFER_DATA(buffer));
1042       
1043        while(duration_ms != 0 && subtitlethread != NULL)
1044        {
1045                usleep(100000);
1046        }
1047        if(subtext != NULL)
1048                free(subtext);
1049        subtext = malloc(len+10);
1050        if(subtext == NULL)
1051        {
1052                err("no mem");
1053                return;
1054        }
1055#if GST_VERSION_MAJOR > 1
1056        guint8 *data;
1057//      gsize size;
1058        GstMapInfo map;
1059        gst_buffer_map(buffer, &map, GST_MAP_READ);
1060        data = map.data;
1061        sprintf(subtext, "%s", data);
1062//      sprintf(subtext, "%s", GST_BUFFER_DATA(buffer));
1063#endif
1064        playersubtitleclean(subtext, len+10);
1065       
1066        double convert_fps = 1.0;
1067        buf_pos_ms  = (buf_pos / 1000000ULL) * convert_fps;
1068        duration_ms = duration_ns / 1000000ULL;
1069
1070        //printf("++++++ buff_pos  : %u\n", buf_pos_ms);
1071        //printf("++++++ decoder_ms: %i\n", decoder_ms);
1072}
1073#endif
1074
1075#ifdef EPLAYER4
1076// set http extra-header and user-agent
1077void playbinNotifySource(GObject *object, GParamSpec *unused, char* file)
1078{
1079        printf("[player.h] playbinNotifySource: %s\n", file);
1080        GstElement *source = NULL;
1081        g_object_get(object, "source", &source, NULL);
1082        if (source)
1083        {
1084                if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "cookiejar-file-name") != 0)
1085                {
1086                        printf("[player.h] set cookiejar-file-name: /mnt/network/cookies\n");
1087                        g_object_set(G_OBJECT(source), "cookiejar-file-name", "/mnt/network/cookies", NULL);
1088                }
1089
1090                if(ostrstr(file, "|") != NULL)
1091                {
1092                        if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "extra-headers") != 0)
1093                        {
1094        #if GST_VERSION_MAJOR < 1
1095                                GstStructure *extras = gst_structure_empty_new("extras");
1096        #else
1097                                GstStructure *extras = gst_structure_new_empty("extras");
1098        #endif
1099                                char* tmpstr1 = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL, *tmpstr4 = NULL;
1100                                tmpstr1 = ostrcat(file, NULL, 0, 0);
1101                                int count1 = 0, i = 0;
1102                                struct splitstr* ret1 = NULL;
1103                                ret1 = strsplit(tmpstr1, "|", &count1);
1104       
1105                                for(i = 0; i < count1; i++)
1106                                {
1107                                        if(i == 0)
1108                                        {
1109                                                printf("[player.h] playbinNotifySource: skip url string: %s\n", ret1[i].part);
1110                                                continue;
1111                                        }
1112                                        tmpstr2 = ostrcat(ret1[i].part, NULL, 0, 0);
1113       
1114                                        int count2 = 0, i2 = 0;
1115                                        struct splitstr* ret2 = NULL;
1116                                        ret2 = strsplit(tmpstr2, "&", &count2);
1117
1118                                        if(ret2 != NULL)
1119                                        {
1120                                                for(i2 = 0; i2 < count2; i2++)
1121                                                {
1122                                                        int count3 = 0, i3 = 0;
1123                                                        struct splitstr* ret3 = NULL;
1124                                                        tmpstr3 = ostrcat(ret2[i2].part, NULL, 0, 0);
1125                                                        ret3 = strsplit(tmpstr3, "=", &count3);
1126                                       
1127                                                        if(ret3 != NULL)
1128                                                        {
1129                                                                int max = count3 - 1;
1130                                                                for(i3 = 0; i3 < max; i3++)
1131                                                                {
1132                                                                        if(ostrstr(ret3[i3].part, "User-Agent") != NULL)
1133                                                                        {
1134                        //                                                      printf("[player.h] skip set user-agent: %s\n", ret2[1].part);
1135                                                                                printf("[player.h] set user-agent: %s\n", ret3[i3 + 1].part);
1136                                                                                g_object_set(G_OBJECT(source), "user-agent", ret3[i3 + 1].part, NULL);
1137                                                                        }
1138                                                                        else
1139                                                                        {
1140                                                                                if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "extra-headers") != 0)
1141                                                                                {                                       
1142                                                                                        GValue header;
1143                                                                                        // eDebug("setting extra-header '%s:%s'", name.c_str(), value.c_str());
1144                                                                                        printf("[player.h] set extra-header %s: %s\n", ret3[i3].part, ret3[i3 + 1].part);
1145                                                                                       
1146                                                                                        tmpstr4 = ostrcat(ret3[i3 + 1].part, NULL, 0, 0);
1147                                                                                        htmldecode(tmpstr4, tmpstr4);
1148                                                                                        printf("[player.h] set extra-header decode %s: %s\n", ret3[i3].part, tmpstr4);
1149                       
1150                                                                                        memset(&header, 0, sizeof(GValue));
1151                                                                                        g_value_init(&header, G_TYPE_STRING);
1152                                                                                        //value
1153                                                                                        g_value_set_string(&header, tmpstr4);
1154                                                                                        //name
1155                                                                                        gst_structure_set_value(extras, ret3[i3].part, &header);
1156                                                                                        free(tmpstr4), tmpstr4 = NULL;
1157                                                                                }
1158                                                                        }
1159                                                                }
1160                                                        }
1161                                                        free(ret3), ret3 = NULL;
1162                                                        free(tmpstr3), tmpstr3 = NULL;
1163                                                }
1164                                        }
1165                                        free(ret2), ret2 = NULL;
1166                                        free(tmpstr2), tmpstr2 = NULL;
1167                                }
1168
1169                                free(ret1), ret1 = NULL;
1170                                free(tmpstr1), tmpstr1 = NULL;
1171
1172                                if (gst_structure_n_fields(extras) > 0)
1173                                {
1174                                        g_object_set(G_OBJECT(source), "extra-headers", extras, NULL);
1175                                }
1176                                gst_structure_free(extras);
1177                        }
1178                }
1179
1180                if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "ssl-strict") != 0)
1181                {
1182                        printf("[player.h] set ssl-strict\n");
1183                        g_object_set(G_OBJECT(source), "ssl-strict", FALSE, NULL);
1184                }
1185        }
1186        gst_object_unref(source);
1187}
1188#endif
1189
1190//extern player
1191int playerstart(char* file)
1192{
1193        char * tmpfile = NULL;
1194        status.prefillbuffer = 0;
1195#ifdef EPLAYER4
1196        status.prefillbuffercount = 0;
1197        status.bufferpercent = 0;
1198#endif 
1199        if(file != NULL)
1200        {
1201#ifdef EPLAYER3
1202                //use eplayer
1203
1204                if(player != NULL)
1205                {
1206                        debug(150, "eplayer allready running");
1207                        playerstop();
1208                }
1209
1210                player = calloc(1, sizeof(Context_t));
1211
1212                if(player == NULL)
1213                {
1214                        err("no mem");
1215                        return 1;
1216                }
1217
1218                if(ostrstr(file, "://") == NULL)
1219                        tmpfile = ostrcat("file://", file, 0, 0);
1220                else
1221                        tmpfile = ostrcat(file, NULL, 0, 0);
1222
1223                if(tmpfile == NULL)
1224                {
1225                        err("no mem");
1226                        free(player); player = NULL;
1227                        return 1;
1228                }
1229// move to mc
1230//              set_player_sound(0);
1231
1232                if(ostrstr(tmpfile, "file://") == NULL)
1233                        status.playercan = 0x4650;
1234                else
1235                        status.playercan = 0xFFFF;
1236
1237                player->playback = &PlaybackHandler;
1238                player->output = &OutputHandler;
1239                player->container = &ContainerHandler;
1240                player->manager = &ManagerHandler;
1241
1242//#ifndef EXTEPLAYER3           
1243                //add container befor open, so we can set buffer size
1244                char* extffm = getfilenameext(tmpfile);
1245                if(extffm != NULL)
1246                {
1247                        player->container->Command(player, CONTAINER_ADD, extffm);
1248                        free(extffm); extffm = NULL;
1249                }
1250
1251                //select container_ffmpeg, if we does not found a container with extensions
1252                if(player->container->selectedContainer == NULL)
1253                        player->container->Command(player, CONTAINER_ADD, "mp3");
1254//#endif
1255
1256                if(player && player->container && player->container->selectedContainer)
1257                {
1258#ifndef EXTEPLAYER3
1259                        int32_t size = getconfigint("playerbuffersize", NULL);
1260                        int32_t seektime = getconfigint("playerbufferseektime", NULL);
1261#else
1262                        int32_t* size = (int32_t*)getconfigint("playerbuffersize", NULL);
1263                        int32_t* seektime = (int32_t*)getconfigint("playerbufferseektime", NULL);
1264
1265                        if(strstr(tmpfile, "http://") == tmpfile || strstr(tmpfile, "https://") == tmpfile)
1266                                progressive_playback_set(1);
1267
1268//                      if(ostrcmp(getconfig("av_ac3mode", NULL), "downmix") == 0)
1269#ifndef MIPSEL
1270                        int tmpdownmix = 0;
1271                        char* downmix = readfiletomem(getconfig("ac3dev", NULL), 1);
1272//                      printf("ac3dev: %s\n",getconfig("ac3dev", NULL));
1273                        debug(150, "ac3dev %s\n", getconfig("ac3dev", NULL));
1274
1275//                      printf("downmix: %s\n",downmix);
1276                        debug(150, "downmix %s\n", downmix);
1277
1278                        if(ostrcmp(downmix, "passthrough") == 0)
1279                                tmpdownmix = 0;
1280                        else
1281                                tmpdownmix = 1;
1282
1283                        free(downmix), downmix == NULL;
1284                        if(tmpdownmix != status.downmix)
1285                                debug(150, "change downmix %d to %d\n", status.downmix, tmpdownmix);
1286
1287
1288//                      printf("status.downmix: %d\n",status.downmix);
1289                        debug(150, "status.downmix %d\n", status.downmix);
1290
1291                        if(tmpdownmix == 1)
1292                        {
1293                                debug(150, "enable dts downmix\n");
1294                                dts_software_decoder_set(1);
1295                                stereo_software_decoder_set(1);
1296                        }
1297#endif
1298//                      container_set_ffmpeg_buf_size(size);
1299#endif
1300
1301                        player->container->selectedContainer->Command(player, CONTAINER_SET_BUFFER_SIZE, (void*)&size);
1302                        player->container->selectedContainer->Command(player, CONTAINER_SET_BUFFER_SEEK_TIME, (void*)&seektime);
1303                }
1304               
1305                debug(150, "eplayername = %s", player->output->Name);
1306#ifdef EXTEPLAYER3
1307            // make sure to kill myself when parent dies
1308            prctl(PR_SET_PDEATHSIG, SIGKILL);
1309
1310            SetBuffering();
1311#endif
1312                //Registrating output devices
1313                player->output->Command(player, OUTPUT_ADD, "audio");
1314                player->output->Command(player, OUTPUT_ADD, "video");
1315                player->output->Command(player, OUTPUT_ADD, "subtitle");
1316#ifndef EXTEPLAYER3
1317                //for subtitle
1318//              SubtitleOutputDef_t subout;
1319
1320//              subout.screen_width = skinfb->width;
1321//              subout.screen_height = skinfb->height;
1322//              subout.framebufferFD = skinfb->fd;
1323//              subout.destination = (uint32_t *)skinfb->fb;
1324//              subout.destStride = skinfb->pitch;
1325//              subout.shareFramebuffer = 1;
1326//              subout.framebufferBlit = blitfb1;
1327
1328//              player->output->subtitle->Command(player, (OutputCmd_t)OUTPUT_SET_SUBTITLE_OUTPUT, (void*)&subout);
1329
1330                if(player->playback->Command(player, PLAYBACK_OPEN, tmpfile) < 0)
1331                {
1332                        free(player); player = NULL;
1333                        free(tmpfile);
1334                        return 1;
1335                }
1336#else
1337            player->manager->video->Command(player, MANAGER_REGISTER_UPDATED_TRACK_INFO, UpdateVideoTrack);
1338            if (strncmp(file, "rtmp", 4) && strncmp(file, "ffrtmp", 4))
1339            {
1340                player->playback->noprobe = 1;
1341            }
1342       
1343                char* audioFile = NULL;
1344            PlayFiles_t playbackFiles = {tmpfile, NULL};
1345            if('\0' != audioFile[0])
1346            {
1347                playbackFiles.szSecondFile = audioFile;
1348            }
1349
1350                //for subtitle
1351//              SubtitleOutputDef_t subout;
1352
1353//              subout.screen_width = skinfb->width;
1354//              subout.screen_height = skinfb->height;
1355//              subout.framebufferFD = skinfb->fd;
1356//              subout.destination = (uint32_t *)skinfb->fb;
1357//              subout.destStride = skinfb->pitch;
1358//              subout.shareFramebuffer = 1;
1359//              subout.framebufferBlit = blitfb1;
1360
1361//              player->output->subtitle->Command(player, (OutputCmd_t)OUTPUT_SET_SUBTITLE_OUTPUT, (void*)&subout);
1362
1363                if(player->playback->Command(player, PLAYBACK_OPEN, &playbackFiles) < 0)
1364                {
1365                        free(player); player = NULL;
1366                        free(tmpfile);
1367                        return 1;
1368                }
1369#endif         
1370
1371
1372                player->output->Command(player, OUTPUT_OPEN, NULL);
1373                player->playback->Command(player, PLAYBACK_PLAY, NULL);
1374
1375                free(tmpfile);
1376
1377                return 0;
1378#endif
1379
1380#ifdef EPLAYER4
1381                int flags = 0x47; //(GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_AUDIO | GST_PLAY_FLAG_NATIVE_VIDEO | GST_PLAY_FLAG_TEXT);
1382               
1383                if(pipeline != NULL)
1384                {
1385                        debug(150, "eplayer allready running");
1386                        playerstop();
1387                }
1388               
1389                if(ostrstr(file, "://") == NULL)
1390                        tmpfile = ostrcat("file://", file, 0, 0);
1391                else
1392                        tmpfile = ostrcat(file, NULL, 0, 0);
1393
1394                printf("[player.h] file: %s\n", file);
1395
1396                if(tmpfile == NULL)
1397                {
1398                        err("no mem");
1399                        free(pipeline); pipeline = NULL;
1400                        return 1;
1401                }
1402
1403                if(ostrstr(tmpfile, "file://") == NULL)
1404                        //status.playercan = 0x7E7F;
1405                        //status.playercan = 0x7EFF;
1406                        status.playercan = 0xFEFF;
1407                else
1408                        //status.playercan = 0x7E7F;
1409                        //status.playercan = 0x7EFF;
1410                        status.playercan = 0xFEFF;
1411               
1412                m_framerate = -1;
1413#if GST_VERSION_MAJOR < 1
1414                pipeline = gst_element_factory_make("playbin2", "playbin");
1415#else
1416                pipeline = gst_element_factory_make("playbin", "playbin");
1417#endif
1418
1419// enable buffersize start
1420                int size = getconfigint("playerbuffersize", NULL);
1421                printf("size: %d\n",size);
1422               
1423                if(size > 0 && ostrstr(tmpfile, "file://") == NULL)
1424                        status.prefillbuffer = 1;
1425
1426/*
1427        if (g_object_class_find_property(G_OBJECT_GET_CLASS(pipeline), "user-agent") != 0)
1428                        printf("11111111111111\n");
1429        if (g_object_class_find_property(G_OBJECT_GET_CLASS(pipeline), "cookie") != 0)
1430                        printf("22222222222222\n");
1431        if (g_object_class_find_property(G_OBJECT_GET_CLASS(pipeline), "extra-headers") != 0)
1432                        printf("33333333333333\n");
1433
1434                if(ostrstr(file, "|User-Agent=") != NULL || ostrstr(file, "|Cookie=") != NULL || ostrstr(file, "|Referer=") != NULL)
1435                {
1436                        char* tmpstr = NULL, *tmpstr1 = NULL;
1437                        tmpstr = ostrcat(file, NULL, 0, 0);
1438//                      tmpstr = string_replace("|User-Agent=", "|", tmpstr, 1);
1439                        int count1 = 0, i = 0;
1440                        struct splitstr* ret1 = NULL;
1441                        ret1 = strsplit(tmpstr, "|", &count1);
1442
1443                        int max = count1;
1444                        for(i = 0; i < max; i++)
1445                        {
1446                                if(ostrstr(ret1[i].part, "User-Agent=") != NULL)
1447                                {
1448                                        tmpstr1 = ostrcat(ret1[i].part, NULL, 0, 0);
1449                                        tmpstr1 = string_replace("User-Agent=", "", tmpstr1, 1);
1450                                        printf("[player.h] set user-agent: %s\n", tmpstr1);
1451                                        g_object_set(G_OBJECT(pipeline), "user-agent", tmpstr1, NULL);
1452                                        free(tmpstr1), tmpstr1 = NULL;
1453                                }
1454                                if(ostrstr(ret1[i].part, "Cookie=") != NULL)
1455                                {
1456                                        tmpstr1 = ostrcat(ret1[i].part, NULL, 0, 0);
1457                                        tmpstr1 = string_replace("Cookie=", "", tmpstr1, 1);
1458                                        printf("[player.h] set cookie: %s\n", tmpstr1);
1459
1460                                        gchar **cookie;
1461//                                      cookie = g_strsplit ("foo=1234,bar=9871615348162523726337x99FB", ",", -1);
1462                                        cookie = g_strsplit (tmpstr1, ",", -1);
1463                                        g_object_set (G_OBJECT(pipeline), "http-headers", cookie, NULL);
1464                                        g_strfreev (cookie);
1465                                        free(tmpstr1), tmpstr1 = NULL;
1466                                }
1467                                if(ostrstr(ret1[i].part, "Referer=") != NULL)
1468                                {
1469                                        tmpstr1 = ostrcat(ret1[i].part, NULL, 0, 0);
1470                                        tmpstr1 = string_replace("Referer=", "", tmpstr1, 1);
1471                                        printf("[player.h] set referer dummy: %s\n", tmpstr1);
1472                                        free(tmpstr1), tmpstr1 = NULL;
1473                                }
1474                        }
1475                        free(ret1), ret1 = NULL;
1476                        free(tmpstr), tmpstr = NULL;
1477//                      g_object_set(G_OBJECT(pipeline), "user-agent", "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:30.0) Gecko/20100101 Firefox/30.0", NULL);
1478                        stringreplacechar(tmpfile, '|', '\0');
1479                        printf("tmpfile changed: %s\n", tmpfile);
1480                }
1481*/
1482
1483// strip url
1484                stringreplacechar(tmpfile, '|', '\0');
1485
1486                g_object_set(G_OBJECT(pipeline), "buffer-duration", size * GST_SECOND, NULL);
1487                g_object_set(G_OBJECT(pipeline), "buffer-size", size, NULL);
1488// enable buffersizeend
1489
1490                g_object_set(G_OBJECT(pipeline), "uri", tmpfile, NULL);
1491                g_object_set(G_OBJECT(pipeline), "flags", flags, NULL);
1492                free(tmpfile); tmpfile = NULL;
1493
1494///////////////////
1495// srt subs start
1496                const char *filename = file;
1497                const char *ext = strrchr(filename, '.');
1498                if (!ext)
1499                        ext = filename + strlen(filename);
1500
1501                GstElement *subsink = gst_element_factory_make("subsink", "subtitle_sink");
1502                if (!subsink)
1503                        printf("sorry, can't play: missing gst-plugin-subsink\n");
1504                else
1505                {
1506//                      m_subs_to_pull_handler_id = g_signal_connect (subsink, "new-buffer", G_CALLBACK (gstCBsubtitleAvail), this);
1507                        g_signal_connect (subsink, "new-buffer", G_CALLBACK (playersubtitleAvail), NULL);
1508
1509                        g_object_set (G_OBJECT (subsink), "caps", gst_caps_from_string("text/plain; text/x-plain; text/x-raw; text/x-pango-markup; video/x-dvd-subpicture; subpicture/x-pgs"), NULL);
1510
1511#if GST_VERSION_MAJOR < 1
1512                        g_object_set (G_OBJECT (subsink), "caps", gst_caps_from_string("text/plain; text/x-plain; text/x-raw; text/x-pango-markup; video/x-dvd-subpicture; subpicture/x-pgs"), NULL);
1513#else
1514                        g_object_set (G_OBJECT (subsink), "caps", gst_caps_from_string("text/plain; text/x-plain; text/x-raw; text/x-pango-markup; subpicture/x-dvd; subpicture/x-pgs"), NULL);
1515#endif
1516
1517                        g_object_set (G_OBJECT (pipeline), "text-sink", subsink, NULL);
1518                        subtitleflag = 1;
1519                        //g_object_set (G_OBJECT (pipeline), "current-text", -1, NULL);
1520                }
1521
1522//////////////////////////
1523// enable soup user-agent / extra-headers
1524                g_signal_connect(G_OBJECT(pipeline), "notify::source", G_CALLBACK(playbinNotifySource), file);
1525//////////////////////////
1526
1527                printf("[player.h] file changed: %s\n", file);
1528
1529//gpointer this;
1530//memset (&this, 0, sizeof (this));
1531
1532                GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
1533#if GST_VERSION_MAJOR < 1
1534//              gst_bus_set_sync_handler(bus, gstBusSyncHandler, this);
1535                gst_bus_set_sync_handler(bus, GST_BUS_DROP, NULL);
1536#else
1537//              gst_bus_set_sync_handler(bus, gstBusSyncHandler, this, NULL);
1538                gst_bus_set_sync_handler(bus, GST_BUS_DROP, NULL, NULL);
1539#endif
1540
1541                gst_object_unref(bus);
1542                char srt_filename[ext - filename + 5];
1543                strncpy(srt_filename,filename, ext - filename);
1544                srt_filename[ext - filename] = '\0';
1545                strcat(srt_filename, ".srt");
1546
1547                if(access(srt_filename, R_OK) >= 0)
1548                {
1549                        printf("found srt1: %s\n",srt_filename);
1550                        printf("found srt2: %s\n",g_filename_to_uri(srt_filename, NULL, NULL));
1551                        g_object_set(G_OBJECT (pipeline), "suburi", g_filename_to_uri(srt_filename, NULL, NULL), NULL);
1552                }
1553// srt end     
1554
1555///////////////////
1556//              CustomData data;
1557                memset (&data, 0, sizeof (data));
1558                data.pipeline = pipeline;
1559//              GstBus *bus;
1560//              bus = gst_element_get_bus (pipeline);
1561               
1562                // Start playing //
1563
1564                GstStateChangeReturn ret;
1565                ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
1566                g_object_set (G_OBJECT (pipeline), "current-text", 0, NULL);
1567                if(ret == GST_STATE_CHANGE_FAILURE)
1568                {
1569                        g_printerr ("Unable to set the pipeline to the playing state.\n");
1570                        gst_object_unref (pipeline);
1571                        return -1;
1572                }
1573                else if(ret == GST_STATE_CHANGE_NO_PREROLL)
1574                {
1575                        data.is_live = TRUE;
1576                }
1577
1578                data.loop = g_main_loop_new (NULL, FALSE);
1579                data.pipeline = pipeline;
1580                gst_bus_add_signal_watch (bus);
1581//              g_signal_connect (bus, "message", G_CALLBACK (cb_message), &data);
1582//              status.prefillbuffer = 1;
1583
1584//analyze_streams(data);
1585
1586                int count = 0;
1587                m_gst_startpts = 0;
1588                while(m_gst_startpts == 0 && count < 5)
1589                {
1590                        count++;
1591                        sleep(1);
1592                        m_gst_startpts = playergetpts();
1593                }
1594
1595                return 0;
1596#endif
1597        }
1598       
1599        return 1;
1600}
1601
1602#ifdef EPLAYER4
1603int setBufferSize(int size)
1604{
1605        int m_buffer_size = size;
1606        g_object_set (G_OBJECT (pipeline), "buffer-size", m_buffer_size, NULL);
1607        return 0;
1608}
1609#endif
1610
1611void playerinit(int argc, char* argv[])
1612{
1613#ifdef EPLAYER4
1614//      GstBus *bus;
1615//      GstStateChangeReturn ret;
1616//      gint flags;
1617        gst_init(&argc, &argv);
1618#endif
1619}
1620
1621#ifdef EPLAYER4
1622int gstbuscall(GstBus *bus, GstMessage *msg, CustomData *data)
1623{
1624        int ret = 1;
1625        if(!pipeline) return 0;
1626        if(!msg) return ret;
1627
1628        gchar *sourceName = NULL;
1629        GstObject *source = GST_MESSAGE_SRC(msg);
1630
1631        if(!GST_IS_OBJECT(source)) return ret;
1632        sourceName = gst_object_get_name(source);
1633
1634        debug(150, "gst type: %s", GST_MESSAGE_TYPE_NAME(msg));
1635
1636        switch(GST_MESSAGE_TYPE(msg))
1637        {
1638                case GST_MESSAGE_EOS:
1639                        debug(150, "gst player eof");
1640                        ret = 0;
1641                        break;
1642                case GST_MESSAGE_STATE_CHANGED:
1643                        debug(150, "gst message state changed");
1644                        if(GST_MESSAGE_SRC(msg) != GST_OBJECT(pipeline))
1645                                break;
1646
1647                        GstState old_state, new_state, pending_state;
1648                        gst_message_parse_state_changed(msg, &old_state, &new_state, &pending_state);
1649                        if(GST_MESSAGE_SRC(msg) == GST_OBJECT(pipeline))
1650                        {
1651                                if(new_state == GST_STATE_PLAYING)
1652                                {
1653                                        /* Once we are in the playing state, analyze the streams */
1654                                        analyze_streams(data);
1655                                }
1656                        }
1657
1658                        if(old_state == new_state) break;
1659       
1660                        debug(150, "gst state change %s -> %s", gst_element_state_get_name(old_state), gst_element_state_get_name(new_state));
1661       
1662                        GstStateChange transition = (GstStateChange)GST_STATE_TRANSITION(old_state, new_state);
1663       
1664                        switch(transition)
1665                        {
1666                                case GST_STATE_CHANGE_NULL_TO_READY:
1667                                        break;
1668                                case GST_STATE_CHANGE_READY_TO_PAUSED:
1669/*
1670                                        GstElement *appsink = gst_bin_get_by_name(GST_BIN(pipeline), "subtitle_sink");
1671                                        if(appsink)
1672                                        {
1673                                                g_object_set(G_OBJECT(appsink), "max-buffers", 2, NULL);
1674                                                g_object_set(G_OBJECT(appsink), "sync", FALSE, NULL);
1675                                                g_object_set(G_OBJECT(appsink), "emit-signals", TRUE, NULL);
1676                                                gst_object_unref(appsink);
1677                                        }
1678*/
1679                                        break;
1680                                case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1681                                        //if(m_sourceinfo.is_streaming && m_streamingsrc_timeout )
1682                                                //m_streamingsrc_timeout->stop();
1683                                        break;
1684                                case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1685                                        break;
1686                                case GST_STATE_CHANGE_PAUSED_TO_READY:
1687                                        break;
1688                                case GST_STATE_CHANGE_READY_TO_NULL:
1689                                        ret = 0;
1690                                        break;
1691                        }
1692                        break;
1693                case GST_MESSAGE_ERROR:
1694                        debug(150, "gst player error");
1695
1696                        gchar *gdebug1;
1697                        GError *err;
1698
1699                        gst_message_parse_error(msg, &err, &gdebug1);
1700                        g_free(gdebug1);
1701
1702                        debug(150, "gst error: %s (%i) from %s", err->message, err->code, sourceName);
1703                        if(err->domain == GST_STREAM_ERROR)
1704                        {
1705                                if(err->code == GST_STREAM_ERROR_CODEC_NOT_FOUND )
1706                                {
1707                                        //if(g_strrstr(sourceName, "videosink"))
1708                                        //      m_event((iPlayableService*)this, evUser+11);
1709                                        //else if ( g_strrstr(sourceName, "audiosink") )
1710                                        //      m_event((iPlayableService*)this, evUser+10);
1711                                }
1712                        }
1713                        g_error_free(err);
1714                        break;
1715                case GST_MESSAGE_INFO:
1716                        debug(150, "gst player info");
1717
1718/*
1719                        gchar *gdebug2;
1720                        GError *inf;
1721       
1722                        gst_message_parse_info(msg, &inf, &gdebug2);
1723                        g_free(gdebug2);
1724                        if(inf->domain == GST_STREAM_ERROR && inf->code == GST_STREAM_ERROR_DECODE )
1725                        {
1726                                //if(g_strrstr(sourceName, "videosink"))
1727                                //      m_event((iPlayableService*)this, evUser+14);
1728                        }
1729                        g_error_free(inf);
1730*/
1731                        break;
1732                case GST_MESSAGE_TAG:
1733                        debug(150, "gst player tag");
1734                        break;
1735                //case GST_MESSAGE_ASYNC_DONE:
1736                //      debug(150, "gst player async done");
1737                //      break;
1738                case GST_MESSAGE_ELEMENT:
1739                        debug(150, "GST_MESSAGE_ELEMENT");
1740                        const GstStructure *msgstruct = gst_message_get_structure(msg);
1741                        if (msgstruct)
1742                        {
1743                                const gchar *eventname = gst_structure_get_name(msgstruct);
1744                                if (!strcmp(eventname, "eventFrameRateChanged") || !strcmp(eventname, "eventFrameRateAvail"))
1745                                {
1746                                        gst_structure_get_int (msgstruct, "frame_rate", &m_framerate);
1747                                }
1748                        }
1749                        debug(150, "gst player element");
1750                        break;
1751                case GST_MESSAGE_BUFFERING:
1752                        debug(150, "gst player buffering");
1753
1754/*
1755                        GstBufferingMode mode;
1756                        gst_message_parse_buffering(msg, &(m_bufferInfo.bufferPercent));
1757                        gst_message_parse_buffering_stats(msg, &mode, &(m_bufferInfo.avgInRate), &(m_bufferInfo.avgOutRate), &(m_bufferInfo.bufferingLeft));
1758                        //m_event((iPlayableService*)this, evBuffering);
1759*/
1760
1761// playback stream jerky on start
1762//                      if (data->is_live) break;
1763//                      gst_message_parse_buffering (msg, &status.bufferpercent);
1764
1765                        if(status.prefillbuffer == 1)
1766                        {
1767                                status.prefillbuffercount++;
1768                                if(status.prefillbuffercount >= 200 && status.bufferpercent < 2)
1769                                {
1770                                        printf("status.prefillbuffercount >= 200 set status.prefillbuffer=2\n");
1771                                        status.prefillbuffer = 2;
1772                                }
1773                        }
1774                        debug(150, "status.prefillbuffercount=%d status.cleaninfobar=%d status.prefillbuffer=%d status.bufferpercent=%d",status.prefillbuffercount , status.cleaninfobar, status.prefillbuffer, status.bufferpercent);
1775                       
1776                        if(status.prefillbuffer == 1)
1777                        {
1778//                              gint percent = 0;
1779                                if (data->is_live)
1780                                {
1781                                        printf("data->is_live break: status.cleaninfobar=%d status.prefillbuffer=%d status.bufferpercent=%d\n", status.cleaninfobar, status.prefillbuffer, status.bufferpercent);
1782                                        break;
1783                                }
1784
1785                                gst_message_parse_buffering (msg, &status.bufferpercent);
1786                                g_print ("Buffering (%3d%%)\r", status.bufferpercent);
1787
1788                                if (status.bufferpercent < 100)
1789                                {
1790                                        gst_element_set_state (data->pipeline, GST_STATE_PAUSED);
1791                                        struct skin* waitmsgbar = getscreen("waitmsgbar");
1792                                        struct skin* load = getscreen("loading");
1793       
1794                                        waitmsgbar->progresssize = status.bufferpercent;
1795                                        char* tmpstr = NULL;
1796                                        tmpstr = ostrcat(_("Buffering Stream - Cancel with Exit"), " (", 0, 0);
1797                                        tmpstr = ostrcat(tmpstr, oitoa(waitmsgbar->progresssize), 1, 0);
1798                                        tmpstr = ostrcat(tmpstr, "%)", 1, 0);
1799                                        changetext(waitmsgbar, tmpstr);
1800                                        free(tmpstr); tmpstr = NULL;
1801       
1802                                        drawscreen(load, 0, 0);
1803                                        drawscreen(waitmsgbar, 0, 0);
1804                                        status.cleaninfobar = 0;
1805                                }
1806                                else
1807                                {
1808                                        drawscreen(skin, 0, 0);
1809                                        gst_element_set_state (data->pipeline, GST_STATE_PLAYING);
1810                                        status.prefillbuffer = 0;
1811                                        status.cleaninfobar = 1;
1812                                }
1813       
1814                        }
1815                        else if(status.prefillbuffer == 2)
1816                        {
1817                                drawscreen(skin, 0, 0);
1818                                gst_element_set_state (data->pipeline, GST_STATE_PLAYING);
1819                                status.prefillbuffer = 0;
1820                                status.cleaninfobar = 1;
1821                        }
1822                        else if(status.cleaninfobar == 1)
1823                        {
1824                                drawscreen(skin, 0, 0);
1825                                status.cleaninfobar = 0;
1826                        }
1827                        else
1828                        {
1829//                      printf("else\n");
1830                                gst_message_parse_buffering (msg, &status.bufferpercent);
1831                                g_print ("Buffering (%3d%%)\r", status.bufferpercent);
1832//                              drawscreen(skin, 0, 0);
1833//                              status.cleaninfobar = 0;
1834                        }
1835                        break;
1836 
1837/*
1838                        GstBufferingMode mode;
1839                        gst_message_parse_buffering(msg, &(status.bufferpercent));
1840                        gst_message_parse_buffering_stats(msg, &mode, &(status.avgInRate), &(status.avgOutRate), &(status.bufferingLeft));
1841
1842//                      printf("#########################################################\n");
1843//                      printf("Buffering %u percent done\n", status.bufferpercent);
1844//                      printf("avgInRate %d\n", status.avgInRate);
1845//                      printf("avgOutRate %d\n", status.avgOutRate);
1846//                      printf("bufferingLeft %lld\n", status.bufferingLeft);
1847                                       
1848                        if(status.prefillbuffer == 1)
1849                        {
1850                                printf("status.prefillbuffer Buffering %u percent done\n", status.bufferpercent);
1851
1852                                if (status.bufferpercent == 100)
1853                                {
1854                                        GstState state;
1855                                        gst_element_get_state(pipeline, &state, NULL, 0LL);
1856                                        if (state != GST_STATE_PLAYING)
1857                                        {
1858                                                // eDebug("start playing");
1859                                                gst_element_set_state (pipeline, GST_STATE_PLAYING);
1860                                        }
1861//                                      m_ignore_buffering_messages = 5;
1862                                        status.prefillbuffer = 0;
1863                                }
1864                                else if (status.bufferpercent == 0)
1865                                {
1866                                        // eDebug("start pause");
1867                                        gst_element_set_state (pipeline, GST_STATE_PAUSED);
1868//                                      m_ignore_buffering_messages = 0;
1869                                }
1870                        }
1871*/
1872/*
1873                                GstBufferingMode mode;
1874                                printf("GST_STATE_PAUSED\n");
1875                                gst_element_set_state (pipeline, GST_STATE_PAUSED);
1876
1877
1878                                gst_message_parse_buffering(msg, &(m_bufferInfo.bufferPercent));
1879                                // eDebug("Buffering %u percent done", m_bufferInfo.bufferPercent);
1880                                gst_message_parse_buffering_stats(msg, &mode, &(m_bufferInfo.avgInRate), &(m_bufferInfo.avgOutRate), &(m_bufferInfo.bufferingLeft));
1881                                m_event((iPlayableService*)this, evBuffering);
1882                                if (m_use_prefillbuffer && !m_is_live && --m_ignore_buffering_messages <= 0)
1883                                {
1884                                        if (m_bufferInfo.bufferPercent == 100)
1885                                        {
1886                                                GstState state;
1887                                                gst_element_get_state(pipeline, &state, NULL, 0LL);
1888                                                if (state != GST_STATE_PLAYING)
1889                                                {
1890                                                        // eDebug("start playing");
1891                                                        gst_element_set_state (pipeline, GST_STATE_PLAYING);
1892                                                }
1893                                                m_ignore_buffering_messages = 5;
1894                                        }
1895                                        else if (m_bufferInfo.bufferPercent == 0)
1896                                        {
1897                                                // eDebug("start pause");
1898                                                gst_element_set_state (pipeline, GST_STATE_PAUSED);
1899                                                m_ignore_buffering_messages = 0;
1900                                        }
1901                                        else
1902                                        {
1903                                                m_ignore_buffering_messages = 0;
1904                                        }
1905                                }
1906
1907*/
1908                        break;
1909                case GST_MESSAGE_STREAM_STATUS:
1910                        debug(150, "gst player stream status");
1911
1912/*
1913                        GstStreamStatusType type;
1914                        GstElement *owner;
1915
1916                        gst_message_parse_stream_status(msg, &type, &owner);
1917                        if(type == GST_STREAM_STATUS_TYPE_CREATE && m_sourceinfo.is_streaming)
1918                        {
1919                                if(GST_IS_PAD(source))
1920                                        owner = gst_pad_get_parent_element(GST_PAD(source));
1921                                else if(GST_IS_ELEMENT(source))
1922                                        owner = GST_ELEMENT(source);
1923                                else
1924                                        owner = NULL;
1925                                if(owner)
1926                                {
1927                                        GstElementFactory *factory = gst_element_get_factory(GST_ELEMENT(owner));
1928                                        const gchar *name = gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(factory));
1929                                        if (!strcmp(name, "souphttpsrc"))
1930                                        {
1931                                                //m_streamingsrc_timeout->start(10 * 1000, true);
1932                                                g_object_set(G_OBJECT(owner), "timeout", 10, NULL);
1933                                        }
1934                                       
1935                                }
1936                                if(GST_IS_PAD(source))
1937                                        gst_object_unref(owner);
1938                        }
1939*/
1940                        break;
1941                default:
1942                        debug(150, "gst player unknown message");
1943                        break;
1944        }
1945        g_free(sourceName);
1946        return ret;
1947}
1948#endif
1949
1950int playergetbuffersize()
1951{
1952        int ret = 0;
1953
1954#ifdef EPLAYER3
1955        if(player && player->container && player->container->selectedContainer)
1956                player->container->selectedContainer->Command(player, CONTAINER_GET_BUFFER_SIZE, (void*)&ret);
1957#endif
1958
1959        return ret;
1960}
1961
1962int playergetbufferstatus()
1963{
1964        int ret = 0;
1965
1966#ifdef EPLAYER3
1967        if(player && player->container && player->container->selectedContainer)
1968                player->container->selectedContainer->Command(player, CONTAINER_GET_BUFFER_STATUS, (void*)&ret);
1969#endif
1970
1971        return ret;
1972}
1973
1974int playerstopbuffer()
1975{
1976        int ret = 0;
1977
1978#ifdef EPLAYER3
1979        if(player && player->container && player->container->selectedContainer)
1980                player->container->selectedContainer->Command(player, CONTAINER_STOP_BUFFER, NULL);
1981#endif
1982
1983        return ret;
1984}
1985
1986int playerisplaying()
1987{
1988#ifdef SIMULATE
1989        return 1;
1990#endif
1991
1992#ifdef EPLAYER3
1993        if(player != NULL && player->playback != NULL && player->playback->isPlaying)
1994                return 1;
1995#endif
1996
1997#ifdef EPLAYER4
1998        int ret = 1;
1999
2000        if(pipeline)
2001        {
2002                GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
2003                GstMessage *message = NULL;
2004//use global variale, with static var crash
2005//              CustomData *data = NULL;
2006                while((message = gst_bus_pop(bus)))
2007                {
2008                        ret = gstbuscall(bus, message, &data);
2009                        gst_message_unref(message);
2010
2011                }               
2012// fix buffering on filenuke
2013                if(status.cleaninfobar == 0 && status.prefillbuffer == 1 && status.bufferpercent == 0)
2014                        gst_element_set_state (pipeline, GST_STATE_PAUSED);
2015                       
2016// eof workaround for some mp4 files.
2017                gint64 pts = 0, len = 0, rest = 0;
2018                gint64 nanos_pts = 0, nanos_len = 0;
2019
2020                len = playergetlength();
2021                nanos_len = len * 1000000000;
2022                if(nanos_len < 0) nanos_len = 0;
2023
2024                pts = playergetpts();
2025                nanos_pts = pts * 11111;
2026
2027                rest = nanos_len - nanos_pts;
2028//              printf("rest: %lld\n", nanos_len - nanos_pts);
2029
2030                debug(150, "status.pause=%d status.playspeed=%d status.slowspeed=%d status.prefillbuffer=%d rest=%lld", status.pause, status.playspeed, status.slowspeed, status.prefillbuffer, rest);
2031                if(rest > 4000000000LL || status.pts != pts || pts == 0 || status.pause == 1 || status.playspeed != 0 || status.slowspeed != 0 /*|| status.prefillbuffer == 1*/)
2032                {
2033//                      debug(150, "status.pts=%llu / pts=%llu\n", status.pts, pts);
2034                        status.pts = pts;
2035                }
2036                else
2037                {
2038                        debug(150, "gst player eof - workaround (rest=%lld)", rest);
2039                        ret = 0;
2040                }
2041// eof workaround done
2042        }
2043        else
2044                ret = 0;
2045
2046        return ret;
2047#endif
2048        return 0;
2049}
2050
2051void playerplay()
2052{
2053#ifdef EPLAYER3
2054        if(player && player->playback)
2055                player->playback->Command(player, PLAYBACK_PLAY, NULL);
2056#endif
2057
2058#ifdef EPLAYER4
2059        if(pipeline)
2060                gst_element_set_state(pipeline, GST_STATE_PLAYING);
2061        if(subtitleflag == 2)
2062                subtitleflag = 1;
2063#endif
2064}
2065
2066int playerstop()
2067{
2068#ifdef EPLAYER3
2069        if(player && player->playback)
2070                player->playback->Command(player, PLAYBACK_STOP, NULL);
2071        if(player && player->container && player->container->selectedContainer)
2072                player->container->selectedContainer->Command(player, CONTAINER_STOP, NULL);
2073        if(player && player->output)
2074        {
2075                player->output->Command(player, OUTPUT_CLOSE, NULL);
2076                player->output->Command(player, OUTPUT_DEL, (void*)"audio");
2077                player->output->Command(player, OUTPUT_DEL, (void*)"video");
2078                player->output->Command(player, OUTPUT_DEL, (void*)"subtitle");
2079        }
2080        if(player && player->playback)
2081                player->playback->Command(player, PLAYBACK_CLOSE, NULL);
2082
2083        free(player);
2084        player = NULL;
2085// move to mc
2086//      set_player_sound(1);
2087#endif
2088
2089#ifdef EPLAYER4
2090        subtitleflag = 0;
2091        if(subtitlethread != 0)
2092                subtitlethread->aktion = STOP;
2093        if(video_sink)
2094        {
2095                gst_object_unref (video_sink);
2096                video_sink = NULL;
2097        }
2098        if(pipeline)
2099        {
2100                gst_element_set_state(pipeline, GST_STATE_NULL);
2101                gst_object_unref(GST_OBJECT(pipeline));
2102                pipeline = NULL;
2103        }
2104#endif
2105
2106        writesysint("/proc/sys/vm/drop_caches", 3, 0);
2107        return 0;
2108}
2109
2110void playerafterend()
2111{
2112#ifdef EPLAYER3
2113        if(player != NULL && player->playback != NULL)
2114                playerstop();
2115#endif
2116
2117#ifdef EPLAYER4
2118        if(pipeline)
2119                playerstop();
2120#endif
2121}
2122
2123void playerpause()
2124{
2125#ifdef EPLAYER3
2126        if(player && player->playback)
2127                player->playback->Command(player, PLAYBACK_PAUSE, NULL);
2128#endif
2129
2130#ifdef EPLAYER4
2131        if(pipeline)
2132                gst_element_set_state(pipeline, GST_STATE_PAUSED);
2133#endif
2134}
2135
2136void playercontinue()
2137{
2138#ifdef EPLAYER3
2139        if(player && player->playback)
2140                player->playback->Command(player, PLAYBACK_CONTINUE, NULL);
2141#endif
2142
2143#ifdef EPLAYER4
2144        if(pipeline)
2145        {
2146                if(status.playspeed != 0 || status.slowspeed != 0)
2147                {
2148                        //subtitle sync bug... start
2149                        gint64 time_nanoseconds = 0;
2150                        GstFormat fmt = GST_FORMAT_TIME;
2151#if GST_VERSION_MAJOR < 1
2152                        if (!gst_element_query_position(pipeline, &fmt, &time_nanoseconds))
2153#else
2154                        if (!gst_element_query_position(pipeline, fmt, &time_nanoseconds))
2155#endif
2156                        {
2157                                err("gst_element_query_position failed");
2158                                return;
2159                        }
2160                        time_nanoseconds = time_nanoseconds - 90000;
2161                        if (!gst_element_seek (pipeline, 1, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT),GST_SEEK_TYPE_SET, time_nanoseconds,GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE))
2162                                printf("seekTo failed");
2163                        //subtitle sync bug... end
2164
2165                        //playersend_ff_fr_event(1);
2166                }               
2167                gst_element_set_state(pipeline, GST_STATE_PLAYING);
2168                if(subtitleflag == 2)
2169                        subtitleflag = 1;
2170        }
2171#endif
2172}
2173
2174void playerff(int speed)
2175{
2176#ifdef EPLAYER3
2177        int speedmap = 0;
2178
2179        if (speed < 1) speed = 1;
2180        if (speed > 7) speed = 7;
2181
2182        switch(speed)
2183        {
2184                case 1: speedmap = 1; break;
2185                case 2: speedmap = 3; break;
2186                case 3: speedmap = 7; break;
2187                case 4: speedmap = 15; break;
2188                case 5: speedmap = 31; break;
2189                case 6: speedmap = 63; break;
2190                case 7: speedmap = 127; break;
2191        }
2192
2193        if(player && player->playback)
2194                player->playback->Command(player, PLAYBACK_FASTFORWARD, &speedmap);
2195#ifdef MIPSEL
2196        if(player && player->playback)
2197                player->playback->Command(player, PLAYBACK_CONTINUE, NULL);
2198#endif
2199#endif
2200
2201#ifdef EPLAYER4
2202        gdouble rate = 0;
2203        subtitleflag = 2;
2204        if (speed < 1) speed = 1;
2205        if (speed > 7) speed = 7;
2206
2207        switch(speed)
2208        {
2209                case 1: rate = 2; break;
2210                case 2: rate = 4; break;
2211                case 3: rate = 8; break;
2212                case 4: rate = 16; break;
2213                case 5: rate = 32; break;
2214                case 6: rate = 64; break;
2215                case 7: rate = 128; break;
2216        }
2217        playersend_ff_fr_event(rate);
2218#endif
2219}
2220
2221void playerslow(int speed)
2222{
2223#ifdef EPLAYER3
2224        int speedmap = 0;
2225#ifdef EXTEPLAYER3
2226        if (speed < 2) speed = 2;
2227        if (speed > 8) speed = 8;
2228
2229        switch(speed)
2230        {
2231                case 2: speedmap = 2; break;
2232                case 4: speedmap = 4; break;
2233                case 8: speedmap = 8; break;
2234        }
2235#else
2236        if (speed < 1) speed = 1;
2237        if (speed > 7) speed = 7;
2238
2239        switch(speed)
2240        {
2241                case 1: speedmap = 1; break;
2242                case 2: speedmap = 3; break;
2243                case 3: speedmap = 7; break;
2244                case 4: speedmap = 15; break;
2245                case 5: speedmap = 31; break;
2246                case 6: speedmap = 63; break;
2247                case 7: speedmap = 127; break;
2248        }
2249#endif
2250        if(player && player->playback)
2251                player->playback->Command(player, PLAYBACK_SLOWMOTION, &speedmap);
2252
2253#ifdef MIPSEL
2254        if(player && player->playback)
2255                player->playback->Command(player, PLAYBACK_CONTINUE, NULL);
2256#endif
2257#endif
2258
2259#ifdef EPLAYER4
2260        gdouble rate = 0;
2261        if (speed < 1) speed = 1;
2262        if (speed > 7) speed = 7;
2263               
2264        switch(speed)
2265        {
2266                case 1: rate = 0.8; break;
2267                case 2: rate = 0.7; break;
2268                case 3: rate = 0.6; break;
2269                case 4: rate = 0.5; break;
2270                case 5: rate = 0.3; break;
2271                case 6: rate = 0.2; break;
2272                case 7: rate = 0.1; break;
2273        }
2274        gst_element_set_state(pipeline, GST_STATE_PLAYING);
2275        playersend_ff_fr_event(rate);
2276       
2277#endif
2278
2279}
2280
2281void playerfr(int speed)
2282{
2283#ifdef EPLAYER3
2284        int speedmap = 0;
2285
2286        if (speed > -1) speed = -1;
2287        if (speed < -7) speed = -7;
2288
2289        switch(speed)
2290        {
2291                case -1: speedmap = -5; break;
2292                case -2: speedmap = -10; break;
2293                case -3: speedmap = -20; break;
2294                case -4: speedmap = -40; break;
2295                case -5: speedmap = -80; break;
2296                case -6: speedmap = -160; break;
2297                case -7: speedmap = -320; break;
2298        }
2299
2300        if(player && player->playback)
2301                player->playback->Command(player, PLAYBACK_FASTBACKWARD, &speedmap);
2302
2303#ifdef MIPSEL
2304        if(player && player->playback)
2305                player->playback->Command(player, PLAYBACK_CONTINUE, NULL);
2306#endif
2307#endif
2308
2309#ifdef EPLAYER4
2310        gdouble rate = 0;
2311       
2312        if (speed > -1) speed = -1;
2313        if (speed < -7) speed = -7;
2314
2315        switch(speed)
2316        {
2317                case -1: rate = -2; break;
2318                case -2: rate = -4; break;
2319                case -3: rate = -8; break;
2320                case -4: rate = -16; break;
2321                case -5: rate = -32; break;
2322                case -6: rate = -64; break;
2323                case -7: rate = -128; break;
2324        }
2325        playersend_ff_fr_event(rate);
2326#endif
2327}
2328
2329void playerseek(float sec)
2330{
2331#ifdef EPLAYER3
2332#ifdef EXTEPLAYER3
2333        int64_t sectmp = (int64_t)sec;
2334        if(player && player->playback) 
2335                player->playback->Command(player, PLAYBACK_SEEK, (void*)&sectmp);
2336#else
2337        if(player && player->playback)
2338                player->playback->Command(player, PLAYBACK_SEEK, (void*)&sec);
2339#endif
2340#endif
2341
2342#ifdef EPLAYER4
2343        gint64 nanos_pts = 0, nanos_len = 0;
2344        gint64 pts = 0, len = 0;
2345        //GstFormat fmt = GST_FORMAT_TIME;
2346               
2347        if(pipeline)
2348        {
2349                len = playergetlength();
2350                nanos_len = len * 1000000000;
2351                if(nanos_len < 0) nanos_len = 0;
2352
2353                pts = playergetpts();
2354                nanos_pts = pts * 11111;
2355                nanos_pts = nanos_pts + (sec * 1000000000);
2356                if(nanos_pts < 0) nanos_pts = 0;
2357
2358                if(nanos_pts >= nanos_len)
2359                {
2360                        debug(150, "gst skip seeking");
2361//                      playerstop();
2362                }
2363                else
2364                        gst_element_seek(pipeline, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, nanos_pts, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
2365        }
2366#endif
2367}
2368
2369#ifdef EPLAYER4
2370audiotype_t gstCheckAudioPad(GstStructure* structure)
2371{
2372        if(!structure)
2373                return atUnknown;
2374
2375        if(gst_structure_has_name(structure, "audio/mpeg"))
2376        {
2377                gint mpegversion, layer = -1;
2378                if(!gst_structure_get_int (structure, "mpegversion", &mpegversion))
2379                        return atUnknown;
2380
2381                switch(mpegversion)
2382                {
2383                        case 1:
2384                                {
2385                                        gst_structure_get_int(structure, "layer", &layer);
2386                                        if(layer == 3)
2387                                                return atMP3;
2388                                        else
2389                                                return atMPEG;
2390                                        break;
2391                                }
2392                        case 2:
2393                                return atAAC;
2394                        case 4:
2395                                return atAAC;
2396                        default:
2397                                return atUnknown;
2398                }
2399        }
2400
2401        else if(gst_structure_has_name(structure, "audio/x-ac3") || gst_structure_has_name(structure, "audio/ac3"))
2402                return atAC3;
2403        else if(gst_structure_has_name(structure, "audio/x-dts") || gst_structure_has_name(structure, "audio/dts"))
2404                return atDTS;
2405#if GST_VERSION_MAJOR < 1
2406        else if(gst_structure_has_name(structure, "audio/x-raw-int"))
2407#else
2408        else if(gst_structure_has_name(structure, "audio/x-raw"))
2409#endif
2410                return atPCM;
2411
2412        return atUnknown;
2413}
2414
2415
2416subtype_t getSubtitleType(GstPad* pad, gchar *g_codec)
2417{
2418g_codec = NULL;
2419        subtype_t type = stUnknown;
2420#if GST_VERSION_MAJOR < 1
2421        GstCaps* caps = gst_pad_get_negotiated_caps(pad);
2422#else
2423        GstCaps* caps = gst_pad_get_current_caps(pad);
2424#endif
2425        if (!caps && !g_codec)
2426        {
2427                caps = gst_pad_get_allowed_caps(pad);
2428        }
2429
2430        if (caps && !gst_caps_is_empty(caps))
2431        {
2432                GstStructure* str = gst_caps_get_structure(caps, 0);
2433                if (str)
2434                {
2435                        const gchar *g_type = gst_structure_get_name(str);
2436                        // eDebug("getSubtitleType::subtitle probe caps type=%s", g_type ? g_type : "(null)");
2437                        if (g_type)
2438                        {
2439#if GST_VERSION_MAJOR < 1
2440                                if ( !strcmp(g_type, "video/x-dvd-subpicture") )
2441#else
2442                                if ( !strcmp(g_type, "subpicture/x-dvd") )
2443#endif
2444                                        type = stVOB;
2445                                else if ( !strcmp(g_type, "text/x-pango-markup") )
2446                                        type = stSRT;
2447                                else if ( !strcmp(g_type, "text/plain") || !strcmp(g_type, "text/x-plain") || !strcmp(g_type, "text/x-raw") )
2448                                        type = stPlainText;
2449                                else if ( !strcmp(g_type, "subpicture/x-pgs") )
2450                                        type = stPGS;
2451                                else
2452                                        printf("getSubtitleType::unsupported subtitle caps %s (%s)\n", g_type, g_codec ? g_codec : "(null)");
2453//                                      eDebug("getSubtitleType::unsupported subtitle caps %s (%s)", g_type, g_codec ? g_codec : "(null)");
2454                        }
2455                }
2456        }
2457        else if ( g_codec )
2458        {
2459                // eDebug("getSubtitleType::subtitle probe codec tag=%s", g_codec);
2460                if ( !strcmp(g_codec, "VOB") )
2461                        type = stVOB;
2462                else if ( !strcmp(g_codec, "SubStation Alpha") || !strcmp(g_codec, "SSA") )
2463                        type = stSSA;
2464                else if ( !strcmp(g_codec, "ASS") )
2465                        type = stASS;
2466                else if ( !strcmp(g_codec, "SRT") )
2467                        type = stSRT;
2468                else if ( !strcmp(g_codec, "UTF-8 plain text") )
2469                        type = stPlainText;
2470                else
2471                        printf("getSubtitleType::unsupported subtitle codec %s\n", g_codec);
2472        }
2473        else
2474                printf("getSubtitleType::unidentifiable subtitle stream!\n");
2475
2476        return type;
2477}
2478
2479#endif
2480
2481void playerfreetracklist(char** TrackList)
2482{
2483        int i = 0;
2484
2485        if(TrackList != NULL)
2486        {
2487                while(TrackList[i] != NULL)
2488                {
2489                        free(TrackList[i]);
2490                        free(TrackList[i + 1]);
2491                        i += 2;
2492                }
2493        }
2494}
2495
2496char** playergettracklist(int type)
2497{
2498#ifdef EXTEPLAYER3
2499#ifdef EPLAYER3
2500        TrackDescription_t *TrackList = NULL;
2501        char ** TrackList2 = NULL;
2502#else
2503        char ** TrackList = NULL;
2504#endif
2505#else
2506        char ** TrackList = NULL;
2507#endif
2508
2509#ifdef EPLAYER3
2510        if(player && player->manager)
2511        {
2512                switch(type)
2513                {
2514                        case 1:
2515                                if(player->manager->audio)
2516                                {
2517                                        player->manager->audio->Command(player, MANAGER_LIST, &TrackList);
2518                                        debug(150, "Audio Track List");
2519                                }
2520                                break;
2521                        case 2:
2522                                if(player->manager->subtitle)
2523                                {
2524                                        player->manager->subtitle->Command(player, MANAGER_LIST, &TrackList);
2525                                        debug(150, "Subtitle Track List");
2526                                }
2527                                break;
2528                        default:
2529                                if(player->manager->video)
2530                                {
2531                                        player->manager->video->Command(player, MANAGER_LIST, &TrackList);
2532                                        debug(150, "Video Track List");
2533                                }
2534                }
2535
2536#ifdef EXTEPLAYER3
2537                TrackList2 = calloc(1, sizeof(char *) * ((100 * 2) + 1));
2538
2539                char* tmpstr = NULL;
2540        if( NULL != TrackList)
2541        {
2542                        debug(150, "Track List");
2543
2544            int i = 0;
2545            for (i = 0; TrackList[i].Id >= 0; ++i)
2546            {
2547                                tmpstr = ostrcat(oitoa(TrackList[i].Id), ": ", 1, 0);
2548                                tmpstr = ostrcat(tmpstr, TrackList[i].Name, 1, 0);
2549                                TrackList2[i * 2] = ostrcat(tmpstr, NULL, 0, 0);
2550                                TrackList2[(i * 2) + 1] = strdup(TrackList[i].Encoding);
2551                free(TrackList[i].Encoding);
2552                free(TrackList[i].Name);
2553                                debug(150, "%s - %s", TrackList2[i * 2], TrackList2[i * 2 + 1]);
2554            }
2555            free(TrackList);
2556        }
2557        free(tmpstr), tmpstr = NULL;
2558#else
2559                int i = 0;
2560                if(TrackList != NULL)
2561                {
2562                        while(TrackList[i] != NULL)
2563                        {
2564                                string_newline(TrackList[i]);
2565                                i += 2;
2566                        }
2567                       
2568                        debug(150, "Track List");
2569                        i = 0;
2570                        while(TrackList[i] != NULL)
2571                        {
2572                                debug(150, "%s - %s", TrackList[i], TrackList[i + 1]);
2573                                i += 2;
2574                        }
2575                }
2576#endif
2577        }
2578#endif
2579
2580//////////////////////////////NEUER CODE //////////////////////////////
2581#ifdef EPLAYER4
2582        TrackList = calloc(1, sizeof(char *) * ((100 * 2) + 1));
2583       
2584        if(pipeline != NULL)
2585        {
2586                gint i, n_video = 0, n_audio = 0, n_text = 0;
2587               
2588                g_object_get(pipeline, "n-video", &n_video, NULL);
2589                g_object_get(pipeline, "n-audio", &n_audio, NULL);
2590                g_object_get(pipeline, "n-text", &n_text, NULL);
2591
2592                switch(type)
2593                {
2594                        case 1:
2595                                for(i = 0; i < n_audio; i++)
2596                                {
2597                                        GstTagList *tags = NULL;
2598                                        gchar *g_codec = NULL, *g_lang = NULL;
2599                                        char* tmpstr = NULL;
2600                                        GstPad* pad = 0;
2601                                       
2602                                        g_signal_emit_by_name (pipeline, "get-audio-pad", i, &pad);
2603#if GST_VERSION_MAJOR < 1
2604                                        GstCaps* caps = gst_pad_get_negotiated_caps(pad);
2605#else
2606                                        GstCaps* caps = gst_pad_get_current_caps(pad);
2607#endif
2608                                        if(!caps)
2609                                                continue;
2610                                       
2611                                        GstStructure* str = gst_caps_get_structure(caps, 0);
2612                                        const gchar *g_type = gst_structure_get_name(str);
2613
2614                                        g_signal_emit_by_name(pipeline, "get-audio-tags", i, &tags);
2615
2616#if GST_VERSION_MAJOR < 1
2617                                        if(tags && gst_is_tag_list(tags))
2618#else
2619                                        if(tags && GST_IS_TAG_LIST(tags))
2620#endif
2621                                        {
2622                                                if(gst_tag_list_get_string(tags, GST_TAG_AUDIO_CODEC, &g_codec))
2623                                                {
2624                                                        printf("Audio Codec: %s\n", g_codec);
2625       
2626                                                        tmpstr = ostrcat(oitoa(i), ": ", 1, 0);
2627                                                        tmpstr = ostrcat(tmpstr, g_codec, 1, 0);
2628                                                        if(g_codec != NULL && g_type != NULL)
2629                                                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
2630                                                        tmpstr = ostrcat(tmpstr, (gchar*)g_type, 1, 0);
2631                                                        if(g_codec != NULL && g_type != NULL)
2632                                                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
2633
2634                                                        printf("Tracklist tmpstr: %s\n", tmpstr);
2635
2636                                                        TrackList[i * 2] = ostrcat(tmpstr, NULL, 0, 0);
2637                                                        g_free(tmpstr); tmpstr = NULL;
2638                                                        g_free(g_codec); g_codec = NULL;
2639                                                }
2640                                                if(gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &g_lang))
2641                                                {
2642                                                        printf("Audio Lang: %s\n", g_lang);
2643                                                        TrackList[(i * 2) + 1] = ostrcat(g_lang, NULL, 0, 0);
2644                                                        g_free(g_lang); g_lang = NULL;
2645                                                }
2646                                                gst_tag_list_free(tags);
2647                                        }
2648                                        else
2649                                        {
2650                                                printf("Audio Codec: %s\n", g_codec);
2651                                               
2652                                                tmpstr = ostrcat(oitoa(i), ": ", 1, 0);
2653                                                tmpstr = ostrcat(tmpstr, g_codec, 1, 0);
2654                                                if(g_codec != NULL && g_type != NULL)
2655                                                        tmpstr = ostrcat(tmpstr, " (", 1, 0);
2656                                                tmpstr = ostrcat(tmpstr, (gchar*)g_type, 1, 0);
2657                                                if(g_codec != NULL && g_type != NULL)
2658                                                        tmpstr = ostrcat(tmpstr, ")", 1, 0);
2659
2660                                                printf("Tracklist tmpstr: %s\n", tmpstr);                               
2661                                                TrackList[i * 2] = ostrcat(tmpstr, NULL, 0, 0);
2662
2663                                                g_free(tmpstr); tmpstr = NULL;
2664                                                g_free(g_codec); g_codec = NULL;
2665                                        }
2666                                }
2667                                break;
2668                        case 2:
2669                                for(i = 0; i < n_text; i++)
2670                                {
2671                                        GstTagList *tags = NULL;
2672                                        gchar *g_codec = NULL, *g_lang = NULL;
2673                                        GstPad* pad = 0;
2674                                        char* tmpstr = NULL;
2675
2676                                        g_signal_emit_by_name (pipeline, "get-text-pad", i, &pad);
2677                                        printf("SubTitle Type: %d\n", getSubtitleType(pad, g_codec));
2678
2679#if GST_VERSION_MAJOR < 1
2680                                        GstCaps* caps = gst_pad_get_negotiated_caps(pad);
2681#else
2682                                        GstCaps* caps = gst_pad_get_current_caps(pad);
2683#endif
2684                                        if (!caps && !g_codec)
2685                                        {
2686                                                caps = gst_pad_get_allowed_caps(pad);
2687                                        }
2688                                               
2689                                        GstStructure* str = gst_caps_get_structure(caps, 0);
2690                                        const gchar *g_type = gst_structure_get_name(str);
2691
2692                                        g_signal_emit_by_name(pipeline, "get-text-tags", i, &tags);
2693                                       
2694#if GST_VERSION_MAJOR < 1
2695                                        if (tags && gst_is_tag_list(tags))
2696#else
2697                                        if (tags && GST_IS_TAG_LIST(tags))
2698#endif
2699                                        {
2700                                                if(gst_tag_list_get_string(tags, GST_TAG_SUBTITLE_CODEC, &g_codec))
2701                                                {
2702                                                        printf("SubTitle Codec: %s\n", g_codec);
2703                                                        tmpstr = ostrcat(oitoa(i), ": ", 1, 0);
2704                                                        tmpstr = ostrcat(tmpstr, g_codec, 1, 0);
2705                                                        if(g_codec != NULL && g_type != NULL)
2706                                                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
2707                                                        tmpstr = ostrcat(tmpstr, (gchar*)g_type, 1, 0);
2708                                                        if(g_codec != NULL && g_type != NULL)
2709                                                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
2710
2711                                                        printf("Tracklist tmpstr: %s\n", tmpstr);
2712                                                        TrackList[i * 2] = ostrcat(tmpstr, NULL, 0, 0);
2713                                                        g_free(g_codec); g_codec = NULL;
2714                                                }
2715                                                if(gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &g_lang))
2716                                                {
2717                                                        printf("SubTitle Lang: %s\n", g_lang);
2718                                                        TrackList[(i * 2) + 1] = ostrcat(g_lang, NULL, 0, 0);
2719                                                        g_free(g_lang); g_lang = NULL;
2720                                                }
2721                                                gst_tag_list_free(tags);
2722                                        }
2723                                        else
2724                                        {
2725                                                printf("SubTitle Codec: %s\n", g_codec);
2726                                               
2727                                                tmpstr = ostrcat(oitoa(i), ": ", 1, 0);
2728                                                tmpstr = ostrcat(tmpstr, g_codec, 1, 0);
2729                                                if(g_codec != NULL && g_type != NULL)
2730                                                        tmpstr = ostrcat(tmpstr, " (", 1, 0);
2731                                                tmpstr = ostrcat(tmpstr, (gchar*)g_type, 1, 0);
2732                                                if(g_codec != NULL && g_type != NULL)
2733                                                        tmpstr = ostrcat(tmpstr, ")", 1, 0);
2734
2735                                                printf("Tracklist tmpstr: %s\n", tmpstr);               
2736                                                TrackList[i * 2] = ostrcat(tmpstr, NULL, 0, 0);
2737
2738                                                g_free(tmpstr); tmpstr = NULL;
2739                                                g_free(g_codec); g_codec = NULL;                               
2740                                        }
2741                                }
2742                                break;
2743                        default:
2744                                for(i = 0; i < n_video; i++)
2745                                {
2746                                        GstTagList *tags = NULL;
2747                                        gchar *g_codec = NULL, *g_lang = NULL;
2748                                       
2749                                        g_signal_emit_by_name(pipeline, "get-video-tags", i, &tags);
2750                                       
2751#if GST_VERSION_MAJOR < 1
2752                                        if (tags && gst_is_tag_list(tags))
2753#else
2754                                        if (tags && GST_IS_TAG_LIST(tags))
2755#endif
2756                                        {
2757                                                if(gst_tag_list_get_string(tags, GST_TAG_VIDEO_CODEC, &g_codec))
2758                                                {
2759                                                        printf("Video Codec: %s\n", g_codec);
2760                                                        TrackList[i * 2] = ostrcat(g_codec, NULL, 0, 0);
2761                                                        g_free(g_codec); g_codec = NULL;
2762                                                }
2763                                                if(gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &g_lang))
2764                                                {
2765                                                        printf("Video Lang: %s\n", g_lang);
2766                                                        TrackList[(i * 2) + 1] = ostrcat(g_lang, NULL, 0, 0);
2767                                                        g_free(g_lang); g_lang = NULL;
2768                                                }
2769                                                gst_tag_list_free(tags);
2770                                        }
2771                                }
2772                }
2773        }
2774#endif
2775//////////////////////////////NEUER CODE //////////////////////////////
2776
2777#ifdef EXTEPLAYER3
2778#ifdef EPLAYER3
2779        return TrackList2;
2780#else
2781        return TrackList;
2782#endif
2783#else
2784        return TrackList;
2785#endif
2786}
2787
2788//*CurTrackEncoding and *CurTrackName be freed
2789void playergetcurtrac(int type, int *CurTrackId, char** CurTrackEncoding, char** CurTrackName)
2790{
2791#ifdef EPLAYER3
2792        if(player && player->manager)
2793        {
2794                switch(type)
2795                {
2796                        case 1:
2797                                if(player->manager->audio)
2798                                {
2799                                        player->manager->audio->Command(player, MANAGER_GET, CurTrackId);
2800                                        player->manager->audio->Command(player, MANAGER_GETENCODING, CurTrackEncoding);
2801                                        player->manager->audio->Command(player, MANAGER_GETNAME, CurTrackName);
2802                                }
2803                                break;
2804                        case 2:
2805                                if(player->manager->subtitle)
2806                                {
2807                                        player->manager->subtitle->Command(player, MANAGER_GET, CurTrackId);
2808                                        player->manager->subtitle->Command(player, MANAGER_GETENCODING, CurTrackEncoding);
2809                                        player->manager->subtitle->Command(player, MANAGER_GETNAME, CurTrackName);
2810                                }
2811                                break;
2812                        default:
2813                                if(player->manager->video)
2814                                {
2815                                        player->manager->video->Command(player, MANAGER_GET, CurTrackId);
2816                                        player->manager->video->Command(player, MANAGER_GETENCODING, CurTrackEncoding);
2817                                        player->manager->video->Command(player, MANAGER_GETNAME, CurTrackName);
2818                                }
2819                }
2820
2821                if(CurTrackId != NULL)
2822                        debug(150, "Current Track ID: %d", *CurTrackId);
2823                if(*CurTrackEncoding != NULL)
2824                        debug(150, "Current Track Enc: %s", *CurTrackEncoding);
2825                if(*CurTrackName != NULL)
2826                        debug(150, "Current Track Name: %s", *CurTrackName);
2827        }
2828#endif
2829
2830#ifdef EPLAYER4
2831        if(pipeline != NULL)
2832        {
2833                switch(type)
2834                {
2835                        case 1:
2836                                g_object_get(G_OBJECT(pipeline), "current-audio", CurTrackId, NULL);
2837                                break;
2838                        case 2:
2839                                if(subtitleflag == 0)
2840                                        *CurTrackId = -1;
2841                                else
2842                                        g_object_get(G_OBJECT(pipeline), "current-text", CurTrackId, NULL);
2843                                break;
2844                }
2845                if(CurTrackId != NULL) {
2846                        debug(150, "Current Track ID: %d", *CurTrackId);
2847                }
2848        }
2849#endif
2850}
2851
2852unsigned long long playergetpts2()
2853{
2854        int64_t pts = 0;
2855        int64_t sec = 0;
2856        sec = 0;
2857
2858#ifdef EPLAYER3
2859        if(player && player->playback)
2860        {
2861                player->playback->Command(player, PLAYBACK_PTS, &pts);
2862                sec = pts / 90000;
2863                fprintf(stderr, "{\"J\":{\"ms\":%lld}}\n", pts / 90);
2864
2865                debug(150, "Pts = %02d:%02d:%02d (%lld sec)", (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
2866
2867        }
2868#endif
2869
2870        if(pts < 0) pts = 0;
2871        return pts;
2872}
2873
2874unsigned long long playergetpts()
2875{
2876#ifdef EXTEPLAYER3
2877#ifdef EPLAYER3
2878        int64_t pts = 0;
2879        int64_t sec = 0;
2880#else
2881        unsigned long long pts = 0;
2882        unsigned long long sec = 0;
2883#endif
2884#else
2885        unsigned long long pts = 0;
2886        unsigned long long sec = 0;
2887#endif
2888
2889#ifdef EPLAYER3
2890        if(player && player->playback)
2891        {
2892                player->playback->Command(player, PLAYBACK_PTS, &pts);
2893                sec = pts / 90000;
2894#ifdef EXTEPLAYER3
2895                debug(150, "Pts = %02d:%02d:%02d (%lld sec)", (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
2896#else
2897                debug(150, "Pts = %02d:%02d:%02d (%llu.0000 sec)", (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
2898#endif
2899        }
2900#endif
2901
2902#ifdef EPLAYER4
2903        GstFormat fmt = GST_FORMAT_TIME; //Returns time in nanosecs
2904       
2905/*
2906        if(pipeline)
2907        {
2908#if GST_VERSION_MAJOR < 1
2909                gst_element_query_position(pipeline, &fmt, (gint64*)&pts);
2910#else
2911                gst_element_query_position(pipeline, fmt, (gint64*)&pts);
2912#endif
2913                sec = pts / 1000000000;
2914                pts = sec * 90000;
2915                debug(150, "Pts = %02d:%02d:%02d (%llu.0000 sec)", (int)((sec / 60) / 60) % 60, (int)(sec / 60) % 60, (int)sec % 60, sec);
2916        }
2917*/
2918
2919        if(pipeline)
2920        {
2921                gint64 pos;
2922                GstElement *sink;
2923                pts = 0;
2924
2925                g_object_get(G_OBJECT (pipeline), "audio-sink", &sink, NULL);
2926
2927                if(!sink) g_object_get (G_OBJECT (pipeline), "video-sink", &sink, NULL);
2928                if(!sink) return 0;
2929
2930                gchar *name = gst_element_get_name(sink);
2931                gboolean use_get_decoder_time = ostrstr(name, "dvbaudiosink") || ostrstr(name, "dvbvideosink");
2932                g_free(name);
2933
2934                if(use_get_decoder_time) g_signal_emit_by_name(sink, "get-decoder-time", &pos);
2935
2936                gst_object_unref(sink);
2937
2938#if GST_VERSION_MAJOR < 1
2939                if(!use_get_decoder_time && !gst_element_query_position(pipeline, &fmt, &pos))
2940#else
2941                if(!use_get_decoder_time && !gst_element_query_position(pipeline, fmt, &pos))
2942#endif
2943                        return 0;
2944
2945                /* pos is in nanoseconds. we have 90 000 pts per second. */
2946                pts = pos / 11111;
2947                pts = pts - m_gst_startpts;
2948                sec = pts / 90000;
2949                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);
2950        }
2951#endif
2952
2953        if(pts < 0) pts = 0;
2954        return pts;
2955}
2956
2957double playergetlength2()
2958{
2959        int64_t length = 0;
2960
2961#ifdef EPLAYER3
2962        if(player && player->playback)
2963        {
2964                player->playback->Command(player, PLAYBACK_LENGTH, (void*)&length);
2965                if(length < 0) length = 0;
2966                debug(150, "Length = %02d:%02d:%02d (%.4f sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
2967                debug(150, "Length2 = %02d:%02d:%02d (%lld sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
2968
2969                fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%lld}}\n", length);
2970
2971        }
2972#endif
2973
2974        return length;
2975}
2976
2977double playergetlength()
2978{
2979#ifdef EXTEPLAYER3
2980#ifdef EPLAYER3
2981        int64_t length = 0;
2982#else
2983        double length = 0;
2984#endif
2985#else
2986        double length = 0;
2987#endif
2988
2989#ifdef EPLAYER3
2990        if(player && player->playback)
2991        {
2992                player->playback->Command(player, PLAYBACK_LENGTH, &length);
2993                if(length < 0) length = 0;
2994#ifdef EXTEPLAYER3
2995                debug(150, "Length = %02d:%02d:%02d (%lld sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
2996#else
2997                debug(150, "Length = %02d:%02d:%02d (%.4f sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
2998#endif
2999        }
3000#endif
3001
3002#ifdef EPLAYER4
3003        GstFormat fmt = GST_FORMAT_TIME; //Returns time in nanosecs
3004        gint64 len;
3005
3006        if(pipeline)
3007        {
3008#if GST_VERSION_MAJOR < 1
3009                gst_element_query_duration(pipeline, &fmt, &len);
3010#else
3011                gst_element_query_duration(pipeline, fmt, &len);
3012#endif
3013                length = len / 1000000000;
3014                if(length < 0) length = 0;
3015                debug(150, "Length = %02d:%02d:%02d (%.4f sec)", (int)((length / 60) / 60) % 60, (int)(length / 60) % 60, (int)length % 60, length);
3016        }
3017#endif
3018
3019        return length;
3020}
3021
3022char* playergetinfo(char* tag)
3023{
3024        char* ret = NULL;
3025
3026#ifdef EPLAYER3
3027        char *tags[] = {"Title", "Artist", "Album", "Year", "Genre", "Comment", "Track", "Copyright", "TestLibEplayer", NULL};
3028        int i = 0;
3029
3030        if(player && player->playback)
3031        {
3032                while(tags[i] != NULL)
3033                {
3034                        ret = tags[i];
3035                        if(ostrcmp(tag, ret) == 0)
3036                        {
3037                                player->playback->Command(player, PLAYBACK_INFO, &ret);
3038                                break;
3039                        }
3040
3041                        i++;
3042                }
3043        }
3044#endif
3045        return ret;
3046}
3047
3048void playerchangeaudiotrack(int num)
3049{
3050        debug(150, "change audiotrac to %d\n", num);
3051
3052#ifdef EPLAYER3
3053        if(player && player->playback)
3054                player->playback->Command(player, PLAYBACK_SWITCH_AUDIO, (void*)&num);
3055#endif
3056
3057#ifdef EPLAYER4
3058        if(pipeline != NULL)
3059                g_object_set(G_OBJECT(pipeline), "current-audio", num, NULL);   
3060#endif
3061}
3062
3063void playerchangesubtitletrack(int num)
3064{
3065#ifdef EPLAYER3
3066        if(player && player->playback)
3067                player->playback->Command(player, PLAYBACK_SWITCH_SUBTITLE, (void*)&num);
3068#endif
3069
3070#ifdef EPLAYER4
3071        printf("player: set subtitle: %d\n", num);
3072        if(pipeline != NULL)
3073                g_object_set(G_OBJECT(pipeline), "current-text", num, NULL);
3074        subtitleflag = 1;       
3075#endif
3076}
3077
3078void playerstopsubtitletrack()
3079{
3080#ifdef EPLAYER3
3081        if(player && player->output && player->output->subtitle)
3082                player->output->subtitle->Command(player, (OutputCmd_t)OUTPUT_STOP, NULL);
3083#ifndef EXTEPLAYER3
3084        if(player && player->container && player->container->assContainer)
3085        {
3086                player->container->assContainer->Command(player, CONTAINER_STOP, NULL);
3087                player->container->assContainer->Command(player, CONTAINER_INIT, NULL);
3088        }
3089        if(player && player->manager && player->manager->subtitle)
3090        {
3091                int onlycurrent = 1;
3092                player->manager->subtitle->Command(player, MANAGER_DEL, (void*)&onlycurrent);
3093        }
3094#endif
3095#endif
3096
3097#ifdef EPLAYER4
3098        printf("player: stop subtitle\n");
3099        subtitleflag = 0;
3100        //if(pipeline != NULL)
3101        //      g_object_set(G_OBJECT(pipeline), "current-text", -1, NULL);
3102        if(subtitlethread != NULL)
3103                subtitlethread->aktion = STOP;
3104#endif
3105}
3106
3107int playerjumpts(struct service* servicenode, int sekunden, int *startpts, off64_t *poslastpts, off64_t *bitrate, int vpid, int tssize)
3108{
3109        int adaptation = 0;
3110        int payload = 0;
3111        int pes = 0;
3112        int tspid = 0;
3113       
3114        off64_t pts  = 0;
3115        uint64_t aktpts = 0;
3116        long long unsigned int lenpts = 0;
3117        long long unsigned int startpts1 = 0;
3118        long long unsigned int endpts = 0;
3119        long long unsigned int aktbitrate = 0;
3120        off64_t ziehlpts = 0;
3121
3122        off64_t curpos = 0;
3123        off64_t newpos = 0;
3124        off64_t jump = 0;
3125
3126        int kleiner = 0;
3127        int groesser = 0;
3128        int gleich = 0;
3129        int len = 0;
3130        int i = 0;
3131        int ret = 0;
3132
3133        if(servicenode == NULL) return -1;
3134
3135        int buflen = tssize * 15000;
3136        char *buf = malloc(buflen);
3137        if(buf == NULL)
3138                return -1;
3139       
3140        curpos = lseek64(servicenode->recsrcfd, 0, SEEK_CUR);   
3141        int dupfd = open(servicenode->recname, O_RDONLY | O_LARGEFILE);
3142        newpos = lseek64(dupfd, curpos, SEEK_SET);
3143       
3144        if (*startpts == 0)
3145        {
3146                if(videogetpts(status.aktservice->videodev, &aktpts) == 0)
3147                {
3148                                ziehlpts = (aktpts / 90000) + sekunden;
3149                }
3150                else
3151                        return 1;
3152        }
3153        else
3154        {
3155                ziehlpts = *startpts + sekunden;
3156        }
3157        *startpts = ziehlpts;
3158
3159        if(*bitrate == 0)
3160        {
3161                lenpts = servicenode->lenpts;
3162                startpts1 = servicenode->startpts;
3163                endpts = servicenode->endpts;
3164                aktbitrate = servicenode->bitrate;
3165                ret = gettsinfo(dupfd, &lenpts, &startpts1, &endpts, &aktbitrate, servicenode->tssize);
3166                if(ret != 0)
3167                {
3168                        err("can't read ts info");
3169                }
3170                else
3171                        *bitrate = aktbitrate;
3172                newpos = lseek64(dupfd, curpos, SEEK_SET);
3173        }
3174        else
3175                aktbitrate = *bitrate;
3176               
3177        if(*poslastpts == 0)
3178                *poslastpts = curpos;
3179       
3180        if(sekunden > 0)
3181        {
3182                err("not implemented");
3183                return 1;
3184        }       
3185        else if(sekunden < 0)
3186        {
3187                sekunden = sekunden * -1;
3188                if(aktbitrate != 0)
3189                {
3190                        jump = (aktbitrate / 8) * sekunden;
3191                        jump = jump + (curpos - *poslastpts);
3192                        jump = jump + (jump % servicenode->tssize);
3193                        newpos = lseek64(dupfd, -jump, SEEK_CUR);
3194                }
3195                else
3196                        newpos = lseek64(dupfd, - buflen, SEEK_CUR);
3197                if(newpos < 0)
3198                        newpos = lseek64(dupfd, tssize, SEEK_SET);
3199        }
3200        len = read(dupfd, buf, buflen);
3201        for(i = 0; i < len; i = i + 1)
3202        {
3203                if (buf[i] == 0x47 && buf[i+tssize] == 0x47)
3204                {
3205                        newpos = lseek64(dupfd, newpos + i, SEEK_SET);
3206                        break;
3207                }
3208        }
3209        if(i >= len)
3210        {
3211                newpos = lseek64(dupfd, curpos, SEEK_SET);     
3212                return 1;
3213        }
3214        while(1)
3215        {
3216        len = read(dupfd, buf, buflen);
3217
3218                if(len > 0)
3219                {
3220                        for(i = 0; i <= len-tssize; i = i + tssize)
3221                        {
3222                                payload = 0;
3223
3224                                tspid = (buf[i+1] & 0x1F) << 8;
3225                                tspid = tspid + (buf[i+2] & 0xFF);
3226                                pes = buf[i+1] & 0x40;
3227
3228                                if(tspid == vpid)
3229                                {       
3230                                        adaptation = buf[i+3] & 0x30;
3231                                        if(adaptation == 16)
3232                                        {
3233                                                payload = 4;
3234                                        }
3235                                        if(adaptation == 32)
3236                                        {
3237                                                //printf("adaptation field only\n");
3238                                        }
3239                                        if(adaptation == 48)
3240                                        {
3241                                                payload = buf[i+4] & 0xFF;
3242                                                payload = payload + 5;
3243                                        }
3244                                        if(payload != 0)
3245                                        {
3246                                                if(pes == 64)
3247                                                {
3248                                                        if(buf[i+payload+7] & 0x80) //PTS
3249                                                        {
3250                                                                pts = ((unsigned long long)(buf[i+payload+9] & 0xE)) << 29;
3251                                                                pts |= ((unsigned long long)(buf[i+payload+10] & 0xFF)) << 22;
3252                                                                pts |= ((unsigned long long)(buf[i+payload+11] & 0xFE)) << 14;
3253                                                                pts |= ((unsigned long long)(buf[i+payload+12] & 0xFF)) << 7;
3254                                                                pts |= ((unsigned long long)(buf[i+payload+13] & 0xFE)) >> 1;
3255                                                               
3256                                                                if(pts / 90000 == ziehlpts)
3257                                                                {
3258                                                                        gleich = newpos + i;
3259                                                                        break;
3260                                                                }
3261                                                                else if(pts / 90000 > ziehlpts)
3262                                                                {                                                                       
3263                                                                        groesser = newpos + i;
3264                                                                        break;
3265                                                                }
3266                                                                else
3267                                                                {
3268                                                                        kleiner = newpos + i;
3269                                                                }
3270                                                        }
3271                                                }
3272                                        }
3273                                }
3274                        }
3275                        if(gleich != 0)
3276                        {
3277                                close(dupfd);
3278                                free(buf);buf = NULL;
3279                                *poslastpts = lseek64(servicenode->recsrcfd, gleich, SEEK_SET);
3280                                return 0;
3281                        }
3282                        else if(groesser != 0 && kleiner != 0)
3283                        {
3284                                close(dupfd);
3285                                free(buf);buf = NULL;
3286                                *poslastpts = lseek64(servicenode->recsrcfd, kleiner, SEEK_SET);
3287                                return 0;
3288                        }
3289                        else if(groesser != 0)
3290                        {
3291                                if((newpos - buflen)  < 0)
3292                                {
3293                                        close(dupfd);
3294                                        free(buf);buf = NULL;
3295                                        *poslastpts = 0;
3296                                        return -1       ;
3297                                }
3298                                else
3299                                {
3300                                        newpos = lseek64(dupfd, -(buflen * 2), SEEK_CUR);
3301                                }
3302                        }
3303                }
3304                else
3305                {
3306                        if(kleiner == 0)
3307                        {
3308                                close(dupfd);
3309                                free(buf);buf = NULL;
3310                                newpos = lseek64(servicenode->recsrcfd, curpos, SEEK_SET);
3311                                *poslastpts = 0;
3312                                return -1;
3313                        }
3314                        else
3315                        {
3316                                close(dupfd);
3317                                free(buf);buf = NULL;
3318                                *poslastpts = lseek64(servicenode->recsrcfd, kleiner, SEEK_SET);
3319                                return 0;
3320                        }
3321                }
3322        }
3323}
3324
3325//praez = 1 .... sekunden
3326//                      =       2 .... zehntel
3327//                      = 3 .... hundertstel
3328//                      = 4 .... volle Uebereinstimmung
3329//
3330//type  = 0 .... alle
3331//                      = 1 .... nur PCR
3332//                      = 2 .... nur Video
3333//                      = 3 .... nur Audio
3334//
3335//flag = 0 --> play ts
3336//flag = 1 --> timeshift
3337//flag = 2 --> timeshift, not in play mode (only recording)
3338//flag = 9 --> dataset mode
3339//
3340off64_t playergetptspos(unsigned long long fpts, off64_t pos, int dir, int praez, int type, int flag, char* dsn)
3341{
3342        unsigned long long pts;
3343        int ret = 0, dupfd = -1, left = 0, tssize = 0, recbsize = 0;
3344        unsigned char* buf = NULL;
3345        unsigned char *payload;
3346        int pid = 0, pusi = 0;
3347        unsigned char* packet;
3348        struct service* snode;
3349       
3350        if(type > 3)
3351        {
3352                printf("type %i nicht unterstützt\n", type);
3353                return -1;
3354        }
3355       
3356        if(flag == 2)
3357                snode = getservice(RECORDTIMESHIFT, 0);
3358        else if(flag != 9)
3359                snode = getservice(RECORDPLAY, 0);
3360               
3361        if(flag == 9)
3362        {
3363                tssize = 188;
3364                recbsize = tssize * 1024 * 10;
3365                dupfd = open(dsn, O_RDONLY | O_LARGEFILE );
3366        }
3367        else
3368        {
3369                tssize = snode->tssize;
3370                recbsize = snode->tssize * 1024 * 10;
3371                dupfd = open(snode->recname, O_RDONLY | O_LARGEFILE);
3372        }
3373
3374        if(dupfd < 0)
3375        {
3376                err("copy source fd not ok");
3377                return -1;
3378        }
3379
3380        buf = malloc(recbsize);
3381        if(buf == NULL)
3382        {
3383                err("no mem");
3384                return -1;
3385        }
3386        packet = buf;
3387        if(dir > 0) 
3388                pos = lseek64(dupfd, pos, SEEK_SET);
3389        else
3390                pos = lseek64(dupfd, pos - recbsize, SEEK_SET);
3391       
3392        ret = read(dupfd,  buf, recbsize);
3393        close(dupfd);
3394        left = 0;
3395       
3396        if(buf[0] != 0x47)
3397        {
3398                while(left < tssize)
3399                {
3400                        if(buf[left] == 0x47) break;
3401                        left++;
3402                }
3403                if(left >= tssize)
3404                {
3405                        free(buf);
3406                        return -1;
3407                }       
3408        }
3409        pts = 0;
3410        while(left <= recbsize - tssize)
3411        {
3412                if(pts != 0)
3413                {
3414                        switch( praez )
3415          {
3416        case 1 :        if(fpts / 90000 != pts / 90000)
3417                                                        pts = 0;
3418                                                break;
3419        case 2 :        if(fpts / 9000 != pts / 9000)
3420                                                        pts = 0;
3421                                                break;
3422        case 3 :        if(fpts / 900 != pts / 900)
3423                                                        pts = 0;
3424                                                break;         
3425        case 4 :        if(fpts != pts )
3426                                                        pts = 0;
3427                                                break;
3428                                default :       free(buf); return -1; break;
3429                        }
3430                        if(pts != 0)
3431                        {       
3432                                pos = pos + left - tssize;
3433                                free(buf);
3434                                return pos;
3435                        }
3436                }
3437                packet = buf + left;
3438                left = left + tssize;
3439                                               
3440                pid = ((packet[1] << 8) | packet[2]) & 0x1FFF;
3441                pusi = !!(packet[1] & 0x40);
3442                //check for adaption field
3443                if(packet[3] & 0x20)
3444                {
3445                        if(type > 1)continue;
3446                        if(packet[4] >= 183) continue;
3447                        if(packet[4])
3448                        {
3449                                if(packet[5] & 0x10) //PCR present
3450                                {
3451                                        pts = ((unsigned long long)(packet[6] & 0xFF)) << 25;
3452                                        pts |= ((unsigned long long)(packet[7] & 0xFF)) << 17;
3453                                        pts |= ((unsigned long long)(packet[8] & 0xFE)) << 9;
3454                                        pts |= ((unsigned long long)(packet[9] & 0xFF)) << 1;
3455                                        pts |= ((unsigned long long)(packet[10] & 0x80)) >> 7;
3456                                        continue;
3457                                }
3458                        }
3459                        payload = packet + packet[4] + 4 + 1;
3460                } else
3461                        payload = packet + 4;
3462               
3463                if(type == 1) continue;
3464                if(!pusi) continue;
3465               
3466                if (payload[0] || payload[1] || (payload[2] != 1))
3467                        continue;
3468               
3469                        //stream use extension mechanism def in ISO 13818-1 Amendment 2
3470                if(payload[3] == 0xFD)
3471                {
3472                        if(payload[7] & 1) //PES extension flag
3473                        {
3474                                int offs = 0;
3475                                if(payload[7] & 0x80) offs += 5; //pts avail
3476                                if(payload[7] & 0x40) offs += 5; //dts avail
3477                                if(payload[7] & 0x20) offs += 6; //escr avail
3478                                if(payload[7] & 0x10) offs += 3; //es rate
3479                                if(payload[7] & 0x8) offs += 1; //dsm trickmode
3480                                if(payload[7] & 0x4) offs += 1; //additional copy info
3481                                if(payload[7] & 0x2) offs += 2; //crc
3482                                if(payload[8] < offs) continue;
3483
3484                                uint8_t pef = payload[9 + offs++]; //pes extension field
3485                                if(pef & 1) //pes extension flag 2
3486                                {
3487                                        if(pef & 0x80) offs += 16; //private data flag
3488                                        if(pef & 0x40) offs += 1; //pack header field flag
3489                                        if(pef & 0x20) offs += 2; //program packet sequence counter flag
3490                                        if(pef & 0x10) offs += 2; //P-STD buffer flag
3491                                        if(payload[8] < offs) continue;
3492
3493                                        uint8_t stream_id_extension_len = payload[9 + offs++] & 0x7F;
3494                                        if(stream_id_extension_len >= 1)
3495                                        {
3496                                                if(payload[8] < (offs + stream_id_extension_len)) continue;
3497                                                //stream_id_extension_bit (should not set)
3498                                                if(payload[9 + offs] & 0x80) continue;
3499                                                switch(payload[9 + offs])
3500                                                {
3501                                                        case 0x55 ... 0x5f: break; //VC-1
3502                                                        case 0x71: break; //AC3 / DTS
3503                                                        case 0x72: break; //DTS - HD
3504                                                        default:
3505                                                                printf("skip unknwn stream_id_extension %02x\n", payload[9 + offs]);
3506                                                                continue;
3507                                                }
3508                                        }
3509                                        else
3510                                                continue;
3511                                }
3512                                else
3513                                        continue;
3514                        }
3515                        else
3516                                continue;
3517                }
3518                //drop non-audio, non-video packets because other streams
3519                //can be non-compliant.
3520                //0xC0 = audio, 0xE0 = video
3521                else if(((payload[3] & 0xE0) != 0xC0) && ((payload[3] & 0xF0) != 0xE0))
3522                        continue;
3523
3524                if((payload[7] & 0x80) && ((payload[3] & 0xF0) != 0xE0) && (type == 0 || type == 2)) //PTS video
3525                {
3526                        pts = ((unsigned long long)(payload[9] & 0xE)) << 29;
3527                        pts |= ((unsigned long long)(payload[10] & 0xFF)) << 22;
3528                        pts |= ((unsigned long long)(payload[11] & 0xFE)) << 14;
3529                        pts |= ((unsigned long long)(payload[12] & 0xFF)) << 7;
3530                        pts |= ((unsigned long long)(payload[13] & 0xFE)) >> 1;
3531                        continue;
3532                }
3533                if((payload[7] & 0x80) && ((payload[3] & 0xE0) != 0xC0) && (type == 0 || type == 3)) //PTS audio
3534                {
3535                        pts = ((unsigned long long)(payload[9] & 0xE)) << 29;
3536                        pts |= ((unsigned long long)(payload[10] & 0xFF)) << 22;
3537                        pts |= ((unsigned long long)(payload[11] & 0xFE)) << 14;
3538                        pts |= ((unsigned long long)(payload[12] & 0xFF)) << 7;
3539                        pts |= ((unsigned long long)(payload[13] & 0xFE)) >> 1;
3540                        continue;
3541                }
3542        }
3543        free(buf);
3544        return recbsize * -1;
3545}
3546
3547#ifdef EPLAYER4
3548/* Extract some metadata from the streams and print it on the screen */
3549static void analyze_streams(CustomData *data)
3550{
3551        gint i;
3552        GstTagList *tags;
3553        gchar *str;
3554        guint rate;
3555
3556        /* Read some properties */
3557        g_object_get(pipeline, "n-video", &data->n_video, NULL);
3558        g_object_get(pipeline, "n-audio", &data->n_audio, NULL);
3559        g_object_get(pipeline, "n-text", &data->n_text, NULL);
3560
3561        g_print("%d video stream(s), %d audio stream(s), %d text stream(s)\n", data->n_video, data->n_audio, data->n_text);
3562
3563        g_print ("\n");
3564        for(i = 0; i < data->n_video; i++)
3565        {
3566                tags = NULL;
3567                /* Retrieve the stream's video tags */
3568                g_signal_emit_by_name(pipeline, "get-video-tags", i, &tags);
3569                if(tags)
3570                {
3571                        g_print("video stream %d:\n", i);
3572                        gst_tag_list_get_string(tags, GST_TAG_VIDEO_CODEC, &str);
3573                        g_print("  codec: %s\n", str ? str : "unknown");
3574                        g_free(str);
3575                        gst_tag_list_free(tags);
3576                }
3577        }
3578
3579        g_print("\n");
3580        for(i = 0; i < data->n_audio; i++)
3581        {
3582                tags = NULL;
3583                g_signal_emit_by_name(pipeline, "get-audio-tags", i, &tags);
3584                if(tags)
3585                {
3586                        /* Retrieve the stream's audio tags */
3587                        g_print("audio stream %d:\n", i);
3588                        if(gst_tag_list_get_string (tags, GST_TAG_AUDIO_CODEC, &str))
3589                        {
3590                                g_print("  codec: %s\n", str);
3591                                g_free(str);
3592                        }
3593                        if(gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &str))
3594                        {
3595                                g_print("  language: %s\n", str);
3596                                g_free(str);
3597                        }
3598                        if(gst_tag_list_get_uint (tags, GST_TAG_BITRATE, &rate))
3599                        {
3600                                g_print("  bitrate: %d\n", rate);
3601                        }
3602                        gst_tag_list_free(tags);
3603                }
3604        }
3605
3606        g_print("\n");
3607        for(i = 0; i < data->n_text; i++)
3608        {
3609                tags = NULL;
3610                /* Retrieve the stream's subtitle tags */
3611                g_print("subtitle stream %d:\n", i);
3612                g_signal_emit_by_name(pipeline, "get-text-tags", i, &tags);
3613                if(tags)
3614                {
3615                        if(gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &str))
3616                        {
3617                                g_print("  language: %s\n", str);
3618                                g_free(str);
3619                        }
3620                        gst_tag_list_free(tags);
3621                }
3622                else
3623                {
3624                        g_print("  no tags found\n");
3625                }
3626        }
3627
3628        g_object_get(pipeline, "current-video", &data->current_video, NULL);
3629        g_object_get(pipeline, "current-audio", &data->current_audio, NULL);
3630        g_object_get(pipeline, "current-text", &data->current_text, NULL);
3631
3632        g_print("\n");
3633        g_print("Currently playing video stream %d, audio stream %d and subtitle stream %d\n", data->current_video, data->current_audio, data->current_text);
3634        g_print("Type any number and hit ENTER to select a different subtitle stream\n");
3635}
3636#endif
3637
3638#ifdef EPLAYER4
3639void playersend_ff_fr_event(gdouble rate) {
3640        gint64 position;
3641        GstFormat format = GST_FORMAT_TIME;
3642        GstEvent *seek_event;
3643   
3644        /* Obtain the current position, needed for the seek event */
3645#if GST_VERSION_MAJOR < 1
3646        if (!gst_element_query_position (pipeline, &format, &position)) {
3647#else
3648        if (!gst_element_query_position (pipeline, format, &position)) {
3649#endif
3650                g_printerr ("Unable to retrieve current position.\n");
3651                return;
3652        }
3653   
3654        /* Create the seek event */
3655        if (rate > 0)
3656        {       
3657                seek_event = gst_event_new_seek (rate, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,GST_SEEK_TYPE_SET, position, GST_SEEK_TYPE_NONE, 0);
3658  }
3659        else
3660        {
3661                seek_event = gst_event_new_seek (rate, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_SET, position);
3662        }
3663   
3664        if (video_sink == NULL) {
3665                /* If we have not done so, obtain the sink through which we will send the seek events */
3666                g_object_get (pipeline, "video-sink", &video_sink, NULL);
3667        }
3668   
3669        /* Send the event */
3670        gst_element_send_event (video_sink, seek_event);
3671   
3672        g_print ("Current rate: %g\n", rate);
3673}
3674#endif
3675
3676#ifdef EXTEPLAYER3
3677char* getsubtext()
3678{
3679        char* tmpstr = NULL;
3680        if(player && player->container && player->container->selectedContainer)
3681                player->container->selectedContainer->Command(player, CONTAINER_GET_SUBTEXT, (void*)&tmpstr);
3682
3683        char* duration = oregex(".*duration=(.*);pts=.*", tmpstr);
3684//      printf("[TITAN/getsubtext] duration %s\n", duration);
3685        debug(150, "duration %s\n", duration);
3686
3687        if(duration != NULL)
3688        {
3689//              printf("[TITAN/getsubtext] duration %d\n", atoi(duration));
3690                debug(150, "duration %d\n", atoi(duration));
3691                duration_ms = atoi(duration);
3692        }
3693
3694        char* pts = oregex(".*;pts=(.*);trackid=.*", tmpstr);
3695//      printf("[TITAN/getsubtext] pts %s\n", pts);
3696        debug(150, "pts %s\n", pts);
3697
3698        if(pts != NULL)
3699                printf("[TITAN/getsubtext] pts %d\n", atoi(pts));
3700
3701        char* trackid = oregex(".*;trackid=(.*);trackid=.*", tmpstr);
3702//      printf("[TITAN/getsubtext] trackid %s\n", trackid);
3703        debug(150, "trackid %s\n", trackid);
3704
3705        if(trackid != NULL)
3706        {
3707//              printf("[TITAN/getsubtext] trackid %d\n", atoi(trackid));
3708                debug(150, "subtext %d\n", atoi(trackid);
3709        }
3710
3711        subtext = oregex(".*;subtext=(.*).*", tmpstr);
3712//      printf("[TITAN/getsubtext] subtext %s\n", subtext);
3713        debug(150, "subtext %s\n", subtext);
3714
3715        if(subtitlethread == NULL)
3716                subtitlethread = addtimer(&playersubtitle_thread, START, 10000, 1, NULL, NULL, NULL);
3717
3718
3719        return subtext;
3720}
3721#endif
3722
3723#endif
Note: See TracBrowser for help on using the repository browser.