Context Navigation

source: titan/titan/player.h @ 41349

Last change on this file since 41349 was 41349, checked in by obi, 5 years ago
fix building
File size: 94.0 KB

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

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

Download in other formats: