Context Navigation

source: titan/titan/player.h @ 44518

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: