source: titan/titan/player.h @ 44974

Last change on this file since 44974 was 44974, checked in by obi, 20 months ago

fix buffering

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