Context Navigation

source: titan/titan/player.h @ 44528

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

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

Download in other formats: