source: titan/titan/record.h @ 25916

Last change on this file since 25916 was 25916, checked in by obi, 10 years ago

fix record translate
File size: 36.0 KB
Line 
1#ifndef RECORD_H
2#define RECORD_H
3
4int recordcheckcrypt(struct dvbdev* fenode, int servicetype)
5{
6        struct service* servicenode = service;
7
8        while(servicenode != NULL)
9        {
10                if(fenode == servicenode->fedev && servicenode->channel != NULL && servicenode->channel->crypt > 0)
11                {
12                        if(servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER) return 1;
13                        if(servicetype == RECORDSTREAM && servicenode->type == RECORDTIMESHIFT) return 1;
14                        if(servicetype == CHANNEL && servicenode->type == RECORDTIMESHIFT) return 1;
15                }
16                servicenode = servicenode->next;
17        }
18        return 0;
19}
20
21//flag bit 0 = with timeout
22//flag bit 1 = show textbox
23//flag bit 2 = print debug
24//flag bit 3 = return text
25char* recordcheckret(struct stimerthread* timernode, int ret, int flag)
26{
27        char* tmpstr = NULL;
28        int timeout = 0;
29        if(checkbit(flag, 0) == 1)
30                timeout = 10;
31
32        if(ret != 0)
33        {
34                switch(ret)
35                {
36                        case 1:
37                                tmpstr = ostrcat(_("HDD not configured\ncan't find record path"), NULL, 0, 0);
38                                break;
39                        case 2:
40                                tmpstr = ostrcat(_("Not enought space"), NULL, 0, 0);
41                                break;
42                        case 3:
43                                tmpstr = ostrcat(_("Error create filename"), NULL, 0, 0);
44                                break;
45                        case 4:
46                                tmpstr = ostrcat(_("Can't open file"), NULL, 0, 0);
47                                break;
48                        case 5:
49                                tmpstr = ostrcat(_("Can't open FRONTEND device"), NULL, 0, 0);
50                                break;
51                        case 6:
52                                tmpstr = ostrcat(_("Can't open DMX device"), NULL, 0, 0);
53                                break;
54                        case 7:
55                                tmpstr = ostrcat(_("Pid's not ok"), NULL, 0, 0);
56                                break;
57                        case 8:
58                                tmpstr = ostrcat(_("Channel or Transponder is empty"), NULL, 0, 0);
59                                break;
60                        case 9:
61                                tmpstr = ostrcat(_("Write error"), NULL, 0, 0);
62                                break;
63                        case 10:
64                                tmpstr = ostrcat(_("No memory"), NULL, 0, 0);
65                                break;
66                        case 11:
67                                tmpstr = ostrcat(_("Failed open split file"), NULL, 0, 0);
68                                break;
69                        case 12:
70                                tmpstr = ostrcat(_("Frontend type unknown"), NULL, 0, 0);
71                                break;
72                        case 13:
73                                tmpstr = ostrcat(_("Tune to channel failed"), NULL, 0, 0);
74                                break;
75                        case 14:
76                                break;
77                        case 15:
78                                tmpstr = ostrcat(_("To many read error or end of file"), NULL, 0, 0);
79                                break;
80                        case 16:
81                                tmpstr = ostrcat(_("Can't create service"), NULL, 0, 0);
82                                break;
83                        case 17:
84                                tmpstr = ostrcat(_("No space left on device"), NULL, 0, 0);
85                                break;
86                }
87                if(tmpstr != NULL)
88                {
89                        if(checkbit(flag, 2) == 1) err("%s", tmpstr);
90                        if(checkbit(flag, 1) == 1) textbox(_("Record / Timeshift / Stream"), tmpstr, _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, NULL, 0, 800, 200, timeout, 0);
91                }
92        }
93        if(checkbit(flag, 3) == 0)
94        {
95                free(tmpstr);
96                tmpstr = NULL;
97        }
98        return tmpstr;
99}
100
101void recordwriteepg(char* filename, struct channel* chnode, struct rectimer* rectimernode)
102{
103        struct epg* epgnode = NULL;
104        FILE *fd = NULL;
105        int ret = 0, count = 0;
106        char* tmpstr = NULL, *epgfilename = NULL, *buf = NULL;
107        struct tm *loctime = NULL;
108
109        if(filename == NULL)
110        {
111                err("epg record filename = NULL");
112                return;
113        }
114
115        epgfilename = changefilenameext(filename, ".epg");
116       
117        //check if epg is in rectimer time
118        if(rectimernode != NULL)
119        {
120                epgnode = getepgakt(chnode);
121                while(epgnode != NULL && (epgnode->starttime < rectimernode->begin || epgnode->starttime >= rectimernode->end))
122                        epgnode = epgnode->next;
123        }
124        else
125                epgnode = getepgbytime(chnode, time(NULL) + 60);
126       
127        if(epgnode != NULL)
128        {
129                fd = fopen(epgfilename, "w");
130                if(fd == NULL)
131                {
132                        perr("open %s", epgfilename);
133                        free(epgfilename);
134                        return;
135                }
136                chmod(epgfilename, 0666);
137
138                if(epgnode->title != NULL)
139                {
140                        buf = malloc(MINMALLOC);
141                        loctime = localtime(&epgnode->starttime);
142                        strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
143                        ret += fwrite(buf, strlen(buf), 1, fd);
144                        ret += fwrite(" - ", 3, 1, fd);
145                        ret += fwrite(epgnode->title, strlen(epgnode->title), 1, fd);
146                        ret += fwrite("\n", 1, 1, fd);
147                        count += 4;
148                        free(buf); buf = NULL;
149                }
150                if(epgnode->subtitle != NULL)
151                {
152                        ret += fwrite(epgnode->subtitle, strlen(epgnode->subtitle), 1, fd);
153                        ret += fwrite("\n\n", 2, 1, fd);
154                        count += 2;
155                }
156                if(epgnode->desc != NULL)
157                {
158                        tmpstr = epgdescunzip(epgnode);
159                        if(tmpstr != NULL)
160                        {
161                                ret += fwrite(tmpstr, strlen(tmpstr), 1, fd);
162                                count++;
163                                free(tmpstr); tmpstr = NULL;
164                        }
165                }
166
167                if(ret != count)
168                {
169                        err("writting record epg file ret=%d, count=%d", ret, count);
170                }
171
172                fclose(fd);
173        }
174        free(epgfilename);
175}
176
177void createrecthumblastthread(struct stimerthread* self, char* dname, char* filename)
178{
179        if(status.mediadbthread != NULL || self == NULL) return;
180
181        debug(777, "createrecthumbfirst thread (record thumb) start");
182
183        status.mediadbthreadstatus = 1;
184        status.mediadbthread = self;
185        status.mediadbsavetime = 1;
186
187        if(dname != NULL && filename != NULL)
188        {
189                readmediadb(getconfig("mediadbfile", NULL), 0, 0);
190
191                debug(133, "path: %s",dname);
192                debug(133, "file: %s",filename);
193                debug(133, "type: 2");
194       
195                addconfigtmp("mediadbscantimeout", "0");
196                mediadbfindfilecb(dname, filename, 0, NULL, 0);
197                delconfigtmp("mediadbscantimeout");
198        }
199
200        free(dname); dname = NULL;
201        free(filename); filename = NULL;
202        status.mediadbsavetime = 0;
203        status.mediadbthread = NULL;
204        status.mediadbthreadstatus = 0;
205
206        debug(777, "createrecthumbfirst thread (record thumb) end");
207}
208
209void createrecthumbfirstthread(struct stimerthread* self, char* dname, char* filename)
210{
211        debug(777, "createrecthumblast thread (record thumb) start");
212       
213        int count = 0;
214
215        while(count < 600)
216        {
217                sleep(1);
218                count++;
219        }
220
221        if(status.recording > 0)
222        {
223                char* cmd = NULL;
224                cmd = ostrcat("/sbin/grab -v -j 100 -r 1280:720 /tmp/screenshot_backdrop1.jpg", NULL, 0, 0);
225       
226                if(cmd != NULL)
227                        system(cmd);
228                debug(777, "cmd: %s", cmd);
229
230                free(cmd);
231        }
232
233        count = 0;
234        while(count < 60)
235        {
236                sleep(1);
237                count++;
238        }
239
240        if(status.recording > 0)
241        {
242                char* cmd = NULL;
243                cmd = ostrcat("/sbin/grab -v -j 100 -r 500:400 /tmp/screenshot_cover.jpg", NULL, 0, 0);
244       
245                if(cmd != NULL)
246                        system(cmd);
247                debug(777, "cmd: %s", cmd);
248
249                free(cmd);
250        }
251
252        count = 0;
253        while(count < 10)
254        {
255                sleep(1);
256                count++;
257        }
258
259        if(status.recording > 0)
260        {
261                char* cmd = NULL;
262                cmd = ostrcat("/sbin/grab -v -j 100 -r 160:120 /tmp/screenshot_thumb.jpg", NULL, 0, 0);
263       
264                if(cmd != NULL)
265                        system(cmd);
266                debug(777, "cmd: %s", cmd);
267
268                free(cmd);
269        }
270
271        debug(777, "createrecthumblast thread (record thumb) end");
272
273}
274
275void recordstop(struct service* node, int ret)
276{
277        struct stimerthread *recthumblastthread = NULL;
278        struct rectimer* rectimernode = NULL;
279        int afterevent = 1, type = -1;
280
281        if(node != NULL)
282        {
283                type = node->type;
284
285                if(node->fedev != NULL && node->type != RECORDTIMESHIFT)
286                        node->fedev->felock--;
287
288                m_lock(&status.rectimermutex, 1);
289                rectimernode = getrectimerbyservice(node);
290                if(rectimernode != NULL && node->recendtime != 2) //2 = manuall rec stop
291                        afterevent = rectimernode->afterevent;
292                m_unlock(&status.rectimermutex, 1);
293
294                char* dname = NULL, *filename = NULL;
295
296                if(type != RECORDSTREAM && type != RECORDTIMESHIFT && type != RECORDPLAY)
297                {
298                        dname = ostrcat(node->recname, NULL, 0, 0);
299                        dname = dirname(dname);
300                        filename = ostrcat(basename(node->recname), NULL, 0, 0);
301                }
302                       
303                delservice(node, 0);
304
305                if(type == RECORDSTREAM)
306                        status.streaming--;
307                else if(type == RECORDTIMESHIFT)
308                {
309                        if(ret != 0) // on error stop timeshift
310                                timeshiftstop(2);
311                        status.timeshift = 0;
312                }
313                else if(type == RECORDPLAY)
314                        status.playing = 0;
315                else
316                        status.recording--;
317       
318                deltranspondertunablestatus();
319
320                if(dname != NULL && filename != NULL && getconfigint("recordpicture", NULL) == 1)
321                        recthumblastthread = addtimer(&createrecthumblastthread, START, 1000, 1, (void*)ostrcat(dname, NULL, 0, 0), (void*)ostrcat(filename, NULL, 0, 0), NULL);
322
323                free(dname); dname = NULL;
324                free(filename); filename = NULL;
325
326                //afterevent: 0 = auto
327                //afterevent: 1 = nothing
328                //afterevent: 2 = standby
329                //afterevent: 3 = poweroff
330                if(afterevent == 0)
331                {
332                        //not needed
333                        //if(status.startmode == 1) afterevent = 2;
334                        //else
335                        if(getwaswakuptimer() == 1) afterevent = 3;
336                }
337                if(afterevent == 2 && status.standby == 0)
338                {
339                        status.standby = 2;
340                        screenstandby();
341                }
342                if(afterevent == 3)
343                {
344                        if(status.recording < 1)
345                        {
346                                //wait for recthumblastthread end before shutdown
347                                int count = 0;
348                                while(gettimer(recthumblastthread) != NULL && count < 60)
349                                {
350                                        sleep(1);
351                                        count++;
352                                }
353                                int ret = 0;
354                                if(status.standby == 0)
355                                        ret = textbox(_("Message"), _("Box recording finished poweroff in 30sec !"), _("EXIT"), getrcconfigint("rcexit", NULL), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, 900, 200, 30, 0);
356                                if(ret == 0 || ret == 2)
357                                        oshutdown(1, 3);
358                        }
359                }
360        }
361}
362
363//flag 0: record split
364//flag 1: play split
365int recordsplit(struct service* servicenode, int flag)
366{
367        int ret = 0;
368        char* filename = NULL;
369
370        filename = malloc(256);
371        if(filename == NULL)
372        {
373                err("no mem");
374                ret = 10;
375                servicenode->recendtime = 1;
376        }
377        else
378        {
379                if(flag == 0)
380                {
381                        fdatasync(servicenode->recdstfd);
382                        close(servicenode->recdstfd);
383                }
384                else
385                        close(servicenode->recsrcfd);
386
387                servicenode->rectotal = 0;
388                servicenode->reclastsync = 0;
389
390                if(servicenode->reccount < 2)
391                {
392                        if(strlen(servicenode->recname) > 3)
393                                servicenode->recname[strlen(servicenode->recname) - 3] = '\0';
394                }
395                else
396                {
397                        if(strlen(servicenode->recname) > 7)
398                                servicenode->recname[strlen(servicenode->recname) - 7] = '\0';
399                }
400                snprintf(filename, 255, "%s.%03d.ts", servicenode->recname, servicenode->reccount++);
401                free(servicenode->recname);
402                servicenode->recname = filename;
403
404                if(flag == 0)
405                {
406                        debug(250, "split record file - Recording to %s...", filename);
407                }
408                else
409                {
410                        debug(250, "split play file - Playing %s...", filename);
411                }
412
413                if(flag == 0)
414                        servicenode->recdstfd = open(filename, O_WRONLY | O_CREAT | O_LARGEFILE, 0644);
415                else
416                        servicenode->recsrcfd = open(filename, O_RDONLY | O_LARGEFILE | O_NONBLOCK);
417
418                if(flag == 0)
419                {
420                        if(servicenode->recdstfd < 0)
421                        {
422                                debug(250, "split record file - can't open recording file!");
423                                ret = 11;
424                                servicenode->recendtime = 1;
425                        }
426                        else
427                                posix_fadvise(servicenode->recdstfd, 0, 0, POSIX_FADV_RANDOM);
428                }
429                else
430                {
431                        if(servicenode->recsrcfd < 0)
432                        {
433                                debug(250, "split play file - can't open play file!");
434                                ret = 15;
435                                servicenode->recendtime = 1;
436                        }
437                }
438        }
439        return ret;
440}
441
442int readwritethread(struct stimerthread* stimer, struct service* servicenode, int flag)
443{
444        int readret = 0, writeret = 0, ret = 0, recbsize = 0, tmprecbsize = 0, i = 0, pktcount = 0, frbsize = 0, frmulti = 0, frmultiread = 0;
445        int readtimeout = -1, writetimeout = -1;
446        int recsync = 0, frcount = 0, count = 0;
447        unsigned char* buf = NULL, *tmpbuf = NULL;
448        char* retstr = NULL;
449
450        debug(250, "start read-write thread");
451
452        if(servicenode == NULL)
453        {
454                err("servicenode = NULL");
455                return 1;
456        }
457
458        recsync = getconfigint("recsync", NULL);
459        frbsize = servicenode->tssize * 3072; //aligned to 188 and 4096
460
461        if(servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER || servicenode->type == RECORDTIMESHIFT)
462        {
463                recbsize = servicenode->tssize * 1024; //aligned to 188 and 4096
464                readtimeout = 5000000;
465                writetimeout = 5000000; //5 sec
466        }
467               
468        if(servicenode->type == RECORDPLAY || servicenode->type == RECORDSTREAM)
469        {
470                if(servicenode->recdstfd < 0)
471                {
472                        err("destination fd not ok")
473                        return 1;
474                }
475                if(servicenode->type == RECORDPLAY)
476                {
477                        recbsize = servicenode->tssize * 188;
478                        tmprecbsize = 188 * 188;
479                }
480                readtimeout = 5000000;
481                writetimeout = 5000000;
482                if(servicenode->type == RECORDSTREAM)
483                {
484                        recbsize = servicenode->tssize * 1024; //aligned to 188 and 4096
485                        writetimeout = 60000000 * 30; // 30min if player is in pause
486                }
487        }
488       
489#ifdef SIMULATE
490        int fd = open("simulate/record.ts", O_RDONLY | O_LARGEFILE);
491        if(fd < 0)
492        {
493                perr("open simulate/record.ts");
494                return 1;
495        }
496#endif
497
498        buf = malloc(recbsize);
499        if(buf == NULL)
500        {
501                err("no mem");
502                return 1;
503        }
504       
505        if(servicenode->type == RECORDPLAY && servicenode->tssize == 192)
506        {
507                tmpbuf = malloc(tmprecbsize);
508                if(tmpbuf == NULL)
509                {
510                        err("no mem");
511                        return 1;
512                }
513        }
514       
515        if(servicenode->recdmxstart == 0)
516        {
517                dmxstart(servicenode->dmxvideodev);
518                servicenode->recdmxstart = 1;
519        }
520       
521        while(1)
522        {       
523#ifdef SIMULATE
524                servicenode->recsrcfd = fd;
525                readret = dvbreadfd(servicenode->recsrcfd, buf, 0, recbsize, readtimeout, 0);
526                usleep(1000);
527#else
528                if(servicenode->type == RECORDPLAY)
529                {
530                       
531                        if(status.playspeed != 0)
532                        {
533                                if(status.videosize.w > 720)
534                                {
535                                        frmulti = 16;
536                                        frmultiread = 8;
537                                }
538                                else
539                                {
540                                        frmulti = 8;
541                                        frmultiread = 4;
542                                }
543                                                               
544                                if(status.playspeed == -4)
545                                        frmulti = frmulti + (frmulti/2);
546                                else if(status.playspeed == -5)
547                                        frmulti = frmultiread * 4;
548                                else if(status.playspeed == -6)
549                                        frmulti = frmultiread * 8;
550                                else if(status.playspeed == 4)
551                                        frmulti = frmulti + frmultiread ;
552                                else if(status.playspeed == 5)
553                                        frmulti = frmultiread * 4;
554                                else if(status.playspeed == 6)
555                                        frmulti = frmultiread * 8;                             
556                        }                       
557                       
558                        if(frcount == 0 && (status.playspeed < 0 || status.playspeed > 3))
559                        {                               
560                                pthread_mutex_lock(&status.tsseekmutex);
561                                off64_t pos = 0;
562                                if(status.playspeed < 0)
563                                        pos = lseek64(servicenode->recsrcfd, -(frbsize * frmulti), SEEK_CUR);
564                                else if(status.playspeed == 4 || status.playspeed == 5 || status.playspeed == 6)
565                                        pos = lseek64(servicenode->recsrcfd, ((frbsize * frmulti) - ( frbsize * frmultiread )), SEEK_CUR);
566
567                                //begin of file
568                                if(pos <= 0)
569                                {
570                                        //videoclearbuffer(status.aktservice->videodev);
571                                        //audioclearbuffer(status.aktservice->audiodev);
572                                        playerpausets();
573                                        playercontinuets();
574                                        playerresetts();
575
576                                        status.playspeed = 0;
577                                        status.pause = 0;
578                                        status.play = 1;
579                                }
580                                else
581                                {
582                                        if(status.playspeed < 0)
583                                                videodiscontinuityskip(status.aktservice->videodev, -1);
584                                        else
585                                                videodiscontinuityskip(status.aktservice->videodev, 1);
586                                }
587                                pthread_mutex_unlock(&status.tsseekmutex);
588                        }
589
590                        if(frcount != 0 && status.playspeed == 0)
591                                frcount = 0;
592                       
593                        pthread_mutex_lock(&status.tsseekmutex);
594                        readret = dvbreadfd(servicenode->recsrcfd, buf, 0, recbsize, readtimeout, 1);
595                        if(readret <= 0 && status.timeshift > 0)
596                        {
597                                playerpausets();
598                                playercontinuets();
599                                //playerresetts();
600                                status.playspeed = 0;
601                                status.pause = 0;
602                                status.play = 1;
603                                playerseekts(servicenode, -3, 1);
604                                readret = dvbreadfd(servicenode->recsrcfd, buf, 0, recbsize, readtimeout, 1);
605                        }
606                        pthread_mutex_unlock(&status.tsseekmutex);                             
607               
608                        if(status.playspeed < 0 || status.playspeed > 0)
609                        {
610                                frcount += readret;
611                                if(frcount >= frbsize * frmultiread)
612                                        frcount = 0;
613                        }
614                }
615                else
616                        readret = dvbreadfd(servicenode->recsrcfd, buf, 0, recbsize, readtimeout, 0);
617#endif
618                if(readret > 0)
619                {
620                        if(servicenode->type == RECORDSTREAM)
621                                writeret = sockwrite(servicenode->recdstfd, buf, readret, writetimeout);
622                        else
623                        {
624                                if(servicenode->type == RECORDPLAY && servicenode->tssize == 192)
625                                {
626                                        // remove 4 bytes per paket from mts and m2ts streams
627                                        pktcount = readret / 192;
628                                        for(i = 0; i < pktcount; i++)
629                                                memcpy(tmpbuf + (i * 188), buf + (i * 192) + 4, 188);
630                                        writeret = dvbwrite(servicenode->recdstfd, tmpbuf, pktcount * 188, writetimeout);
631                                        writeret = writeret + (pktcount * 4);
632                                }
633                                else
634                                                writeret = dvbwrite(servicenode->recdstfd, buf, readret, writetimeout);
635
636                                //inject first pakets slower/smaler, so demux can start and read
637                                if(servicenode->type == RECORDPLAY && count < 20)
638                                {
639                                        if(status.timeshift == 0)
640                                                usleep(50000);
641                                        else
642                                                count = 19;
643                                        if(count == 19)
644                                        {
645                                                recbsize = servicenode->tssize * 1024; //aligned to 188 and 4096
646                                                tmprecbsize = 188 * 1024; //aligned to 188 and 4096
647
648                                                free(buf);
649                                                buf = malloc(recbsize);
650                                                if(buf == NULL)
651                                                {
652                                                        err("no mem");
653                                                        servicenode->recendtime = 1;
654                                                }
655
656                                                if(servicenode->tssize == 192)
657                                                {
658                                                        free(tmpbuf);
659                                                        tmpbuf = malloc(tmprecbsize);
660                                                        if(tmpbuf == NULL)
661                                                        {
662                                                                err("no mem");
663                                                                servicenode->recendtime = 1;
664                                                        }
665                                                }
666                                        }
667                                        count++;
668                                }
669                        }
670
671                        if(writeret < 1)
672                        {
673                                ret = 9;
674                                if(writeret == -ENOSPC) ret = 17;
675                                servicenode->recendtime = 1;
676                        }
677                        else if(readret != writeret)
678                        {
679                                debug(250, "not all data written read=%d, written=%d", readret, writeret);
680                        }
681
682                        if(servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER || servicenode->type == RECORDTIMESHIFT)
683                        {
684                                //sync
685                                if(recsync == 1)
686                                {
687                                        servicenode->reclastsync += writeret;
688                                        if(servicenode->reclastsync > 524288)
689                                        {
690                                                fdatasync(servicenode->recdstfd);
691                                                posix_fadvise64(servicenode->recdstfd, 0, 0, POSIX_FADV_DONTNEED);
692                                                servicenode->reclastsync = 0;
693                                        }
694                                }
695
696                                if(status.recsplitsize && servicenode->type != RECORDTIMESHIFT)
697                                {
698                                        servicenode->rectotal += writeret;
699                                        if(servicenode->rectotal > status.recsplitsize)
700                                                ret = recordsplit(servicenode, 0);
701                                }
702                        }
703                }
704                else if(readret <= 0)
705                {
706                        if(readret == 0 && servicenode->type == RECORDPLAY)
707                        {
708                                if(getconfigint("playsplitfiles", NULL) == 1)
709                                        ret = recordsplit(servicenode, 1);
710                                else
711                                {
712                                        ret = 15;
713                                        servicenode->recendtime = 1;
714                                }
715                        }
716                        else
717                        {
718                                ret = 15;
719                                servicenode->recendtime = 1;
720                        }
721
722                        if(readret < -1)
723                                perr("read");
724                }
725
726                if(servicenode->recendtime != 0 && servicenode->recendtime < time(NULL))
727                {
728                        if(servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER || servicenode->type == RECORDTIMESHIFT)
729                                fdatasync(servicenode->recdstfd);
730                        if(ret != 0) // error
731                        {
732                                if(servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER || servicenode->type == RECORDTIMESHIFT)
733                                        addtimer(&recordcheckret, START, 1000, 1, (void*)ret, (void*)3, NULL);
734                                retstr = recordcheckret(NULL, ret, 12);
735
736                                //if(servicenode->type == RECORDSTREAM)
737                                //      sockwrite(servicenode->recdstfd, (unsigned char*)retstr, strlen(retstr), -1);
738                                if(servicenode->type == RECORDTIMER)
739                                {
740                                        m_lock(&status.rectimermutex, 1);
741                                        struct rectimer* rectimernode = getrectimerbyservice(servicenode);
742                                        if(rectimernode != NULL)
743                                        {
744                                                rectimernode->status = 3;
745                                                free(rectimernode->errstr);
746                                                rectimernode->errstr = ostrcat(retstr, NULL, 0, 0);
747                                                status.writerectimer = 1;
748                                                writerectimer(getconfig("rectimerfile", NULL), 1);
749                                        }
750                                        m_unlock(&status.rectimermutex, 1);
751                                }
752                                free(retstr); retstr = NULL;
753                        }
754                        recordstop(servicenode, ret);
755                        break;
756                }
757        }
758
759#ifdef SIMULATE
760        close(fd);
761#endif
762        if(buf != NULL) free(buf);
763        if(tmpbuf != NULL) free(tmpbuf);
764        debug(250, "stop read-write thread");
765        return 0;
766}
767
768char* recordcreatefilename(char* path, char* channelname, char* moviename, int type)
769{
770        time_t sec;
771        struct tm *loctime;
772        char *buf = NULL, *buf1 = NULL;
773        char* tmpstr = NULL;
774        int recordnamefmt = getconfigint("recordnamefmt", NULL);
775
776        if(path == NULL)
777                return NULL;
778
779        tmpstr = ostrcat(path, "/", 0, 0);
780        if(type != RECTIMESHIFT && recordnamefmt == 0)
781        {
782                if(channelname == NULL || strlen(channelname) == 0)
783                        tmpstr = ostrcat(tmpstr, "unknown", 1, 0);
784                else
785                        tmpstr = ostrcat(tmpstr, channelname, 1, 0);
786                tmpstr = ostrcat(tmpstr, "-", 1, 0);
787        }
788
789        if(moviename == NULL || strlen(moviename) == 0)
790                tmpstr = ostrcat(tmpstr, "unknown", 1, 0);
791        else
792                tmpstr = ostrcat(tmpstr, moviename, 1, 0);
793
794        if(type != RECTIMESHIFT && recordnamefmt == 1)
795        {
796                tmpstr = ostrcat(tmpstr, "-", 1, 0);
797                if(channelname == NULL || strlen(channelname) == 0)
798                        tmpstr = ostrcat(tmpstr, "unknown", 1, 0);
799                else
800                        tmpstr = ostrcat(tmpstr, channelname, 1, 0);
801        }
802
803        sec = time(NULL);
804        loctime = localtime(&sec);
805
806        buf = malloc(MINMALLOC);
807        if(buf == NULL)
808        {
809                err("no memory");
810                return NULL;
811        }
812
813        strftime(buf, MINMALLOC, "%Y%m%d%H%M%S", loctime);
814        buf1 = ostrcat(buf, NULL, 1, 0);
815
816        tmpstr = ostrcat(tmpstr, "-", 1, 0);
817        tmpstr = ostrcat(tmpstr, buf1, 1, 1);
818        tmpstr = ostrcat(tmpstr, ".ts", 1, 0);
819
820        return tmpstr;
821}
822
823int recordstartreal(struct channel* chnode, int filefd, int recordfd, int type, time_t endtime, struct rectimer* rectimernode, int tssize)
824{
825        int ret = 0, fd = -1, servicetype = RECORDDIRECT, festatus = 0, pcrpidmatch = 0;
826        char* path = NULL, *chname = NULL, *filename = NULL, *moviename = NULL;
827        unsigned char* patbuf = NULL, *pmtbuf = NULL;
828        struct epg* epgnode = NULL;
829        struct service* servicenode = NULL;
830        struct dvbdev* fenode = NULL, *dmxnode = NULL;
831        struct audiotrack* atrack = NULL;
832        struct subtitle *subnode = NULL;
833        char* tmpstr = NULL;
834        struct transponder* tpnode = NULL;
835        int input = DMX_IN_FRONTEND;
836
837        if(chnode == NULL && filefd < 0)
838        {
839                ret = 8;
840                goto end;
841        }
842
843        if(filefd < 0)
844        {
845                tpnode = chnode->transponder;
846                if(tpnode == NULL)
847                {
848                        ret = 8;
849                        goto end;
850                }
851        }
852
853        switch(type)
854        {
855                case RECPLAY:
856                        servicetype = RECORDPLAY;
857                        fd = recordfd;
858                        break;
859                case RECSTREAM:
860                        servicetype = RECORDSTREAM;
861                        fd = recordfd;
862                        break;
863                case RECTIMESHIFT:
864                        servicetype = RECORDTIMESHIFT;
865                        path = getconfig("rec_timeshiftpath", NULL);
866                        moviename = "timeshift";
867                        break;
868                case RECTIMER:
869                        servicetype = RECORDTIMER;
870                        if(rectimernode != NULL && rectimernode->recpath != NULL)
871                                path = rectimernode->recpath;
872                        else
873                                path = getconfig("rec_timerpath", NULL);
874                        if(chnode != NULL)
875                        {
876                                chname = strstrip(chnode->name);
877                                delspezchar(chname, 2);
878                        }
879                        if(rectimernode != NULL && rectimernode->name != NULL)
880                        {
881                                moviename = strstrip(rectimernode->name);
882                                delspezchar(moviename, 2);
883                        }
884                        break;
885                default:
886                        servicetype = RECORDDIRECT;
887                        path = getconfig("rec_path", NULL);
888                        if(chnode != NULL)
889                        {
890                                chname = strstrip(chnode->name);
891                                delspezchar(chname, 2);
892                        }
893                        epgnode = getepgbytime(status.aktservice->channel, time(NULL) + 60);
894                        if(epgnode != NULL)
895                        {
896                                moviename = strstrip(epgnode->title);
897                                delspezchar(moviename, 2);
898                        }
899                        break;
900        }
901
902        if(type != RECSTREAM && type != RECPLAY)
903        {
904                if(!isdir(path))
905                {
906                        ret = 1;
907                        goto end;
908                }
909
910                //check HDD free space
911                //deaktivate, on my 500GB FAT32 HDD, this takes mor then 10 min
912/*
913                if(getfreespace(path) < getconfigint("recordfreespace", NULL) * 1024 * 1024)
914                {
915                        ret = 2;
916                        goto end;
917                }
918*/
919
920                filename = recordcreatefilename(path, chname, moviename, type);
921                if(filename == NULL)
922                {
923                        ret = 3;
924                        goto end;
925                }
926
927                fd = open(filename, O_WRONLY | O_CREAT | O_LARGEFILE, 0666);
928                if(fd < 0)
929                {
930                        char* fn = strrchr(filename, '/');
931                        if(fn == NULL)
932                                delspezchar(filename, 0);
933                        else
934                                delspezchar(fn + 1, 0);
935       
936                        fd = open(filename, O_WRONLY | O_CREAT | O_LARGEFILE, 0666);
937                        if(fd < 0)
938                        {
939                                ret = 4;
940                                goto end;
941                        }
942                }
943                posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM); //turn off kernel cache
944        }
945
946        servicenode = addservice(NULL);
947        if(servicenode == NULL)
948        {
949                ret = 16;
950                goto end;
951        }
952        servicenode->tssize = tssize;
953        servicenode->recdstfd = fd;
954        servicenode->channel = chnode;
955        servicenode->transponder = tpnode;
956        if(rectimernode != NULL) servicenode->rectimestamp = ostrcat(rectimernode->timestamp, NULL, 0, 0);
957
958        if(filefd < 0)
959        {
960                //got frontend dev
961                fenode = fegetfree(tpnode, 2, NULL);
962                if(fenode == NULL)
963                {
964                        if(status.standby == 0 && type == RECSTREAM)
965                        {
966                                ret = 5;
967                                goto end;
968                        }
969                        else
970                        {
971                                if(status.standby == 0 && textbox(_("Message"), _("Can't find free Tuner for Record.\nSwitch to Recording/Timeshift Channel ?"), _("EXIT"), getrcconfigint("rcexit", NULL), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, 800, 200, 10, 0) == 1)
972                                {
973                                        ret = 14;
974                                        goto end;
975                                }
976                                else
977                                {
978                                        if(rectimernode != NULL)
979                                                servicestart(chnode, rectimernode->channellist, rectimernode->pincode, 0);
980                                        else
981                                                servicestart(chnode, NULL, NULL, 0);
982                                       
983                                        if(status.standby > 0) servicestop(status.aktservice, 1, 0);   
984                                       
985                                        fenode = fegetfree(tpnode, 2, NULL);
986                                        if(fenode == NULL)
987                                        {
988                                                ret = 5;
989                                                goto end;
990                                        }
991                                }
992                        }
993                }
994                if(type != RECTIMESHIFT) fenode->felock++;
995
996                //frontend tune
997                if(fenode != status.aktservice->fedev || (status.standby > 0 && getconfigint("standbytuneroff", NULL) == 1))
998                {
999                        if(fenode->feinfo->type == FE_QPSK)
1000                        {
1001                                feset(fenode, tpnode);
1002                                fetunedvbs(fenode, tpnode);
1003                        }
1004                        else if(fenode->feinfo->type == FE_QAM)
1005                                fetunedvbc(fenode, tpnode);
1006                        else if(fenode->feinfo->type == FE_OFDM)
1007                                fetunedvbt(fenode, tpnode);
1008                        else
1009                        {
1010                                ret = 12;
1011                                if(type != RECTIMESHIFT) fenode->felock--;
1012                                goto end;
1013                        }
1014
1015                        festatus = fewait(fenode);
1016                        if(debug_level == 200) fereadstatus(fenode);
1017                        if(festatus != 0)
1018                        {
1019                                ret = 13;
1020                                if(type != RECTIMESHIFT) fenode->felock--;
1021                                goto end;
1022                        }
1023                }
1024
1025                servicenode->fedev = fenode;
1026
1027                //demux  start
1028                dmxnode = dmxopen(fenode);
1029                if(dmxnode != NULL && dmxnode->fd >= 0)
1030                {
1031                        servicenode->recsrcfd = dmxnode->fd;
1032                        if(type == RECTIMESHIFT)
1033                                dmxsetbuffersize(dmxnode, getconfigint("dmxtimeshiftbuffersize", NULL));
1034                        else if(type == RECSTREAM)
1035                                dmxsetbuffersize(dmxnode, getconfigint("dmxstreambuffersize", NULL));
1036                        else
1037                                dmxsetbuffersize(dmxnode, getconfigint("dmxrecordbuffersize", NULL));
1038                        servicenode->dmxaudiodev = dmxnode;
1039                        servicenode->dmxvideodev = dmxnode;
1040                        dmxsetsource(dmxnode, fenode->fedmxsource);
1041#if DVB_API_VERSION > 3
1042                        dmxsetpesfilter(dmxnode, 0, input, DMX_OUT_TSDEMUX_TAP, DMX_PES_OTHER, 1);
1043#else
1044                        dmxsetpesfilter(dmxnode, 0, input, DMX_OUT_TAP, 0, 1);
1045#endif
1046                        patbuf = dvbgetpat(fenode, -1);
1047                        chnode->pmtpid = dvbgetpmtpid(patbuf, chnode->serviceid);
1048
1049                        m_lock(&status.servicemutex, 2);
1050                        if(status.aktservice->channel != chnode)
1051                        {
1052                                //reset channel info
1053                                serviceresetchannelinfo(chnode);
1054                                pmtbuf = dvbgetpmt(fenode, patbuf, chnode->serviceid, &chnode->pmtpid, NULL, -1, 0);
1055                                dvbgetinfo(pmtbuf, chnode);
1056                        }
1057                        if(status.pmtmode == 1)
1058                        {
1059                                if(recordcheckcrypt(fenode, servicetype) == 0)
1060                                        dvbwritepmt(servicenode, pmtbuf);
1061                                else
1062                                        debug(250, "don't write pmt.tmp, another crypt channel use this frontend");
1063                        }
1064                        else
1065                                sendcapmt(servicenode, 0, 3);
1066                        m_unlock(&status.servicemutex, 2);
1067
1068                        free(pmtbuf); pmtbuf = NULL;
1069                        free(patbuf); patbuf = NULL;
1070                        if((chnode->audiopid < 1 && chnode->videopid < 1) || chnode->pmtpid < 1)
1071                        {
1072#ifndef SIMULATE
1073                                ret = 7;
1074                                if(type != RECTIMESHIFT) fenode->felock--;
1075                                goto end;
1076#endif
1077                        }
1078                        if(chnode->audiopid > 0) dmxaddpid(dmxnode, chnode->audiopid);
1079                        if(chnode->videopid > 0) dmxaddpid(dmxnode, chnode->videopid);
1080                        dmxaddpid(dmxnode, chnode->pmtpid);
1081                        //add all audiotracks
1082                        atrack = chnode->audiotrack;
1083                        while(atrack != NULL)
1084                        {
1085                                if(atrack->audiopid > 0 && atrack->audiopid != chnode->audiopid)
1086                                        dmxaddpid(dmxnode, atrack->audiopid);
1087                                if(atrack->audiopid == chnode->pcrpid) pcrpidmatch = 1;
1088                                atrack = atrack->next;
1089                        }
1090                        if(chnode->pcrpid > 0 && chnode->pcrpid != chnode->videopid && chnode->pcrpid != chnode->audiopid && pcrpidmatch == 0) dmxaddpid(dmxnode, chnode->pcrpid);
1091                       
1092                        //add all subtitle
1093                        m_lock(&status.subtitlemutex, 8);
1094                        subnode = chnode->subtitle;
1095                        while(subnode != NULL)
1096                        {
1097                                if(subnode->pid > 0)
1098                                        dmxaddpid(dmxnode, subnode->pid);
1099                                subnode = subnode->next;
1100                        }
1101                        m_unlock(&status.subtitlemutex, 8);
1102                       
1103                        //add epg pid
1104                        if(getconfigint("epg2record", NULL) == 1) dmxaddpid(dmxnode, 0x12);     
1105                }
1106                else
1107                {
1108                        ret = 6;
1109                        if(type != RECTIMESHIFT) fenode->felock--;
1110                        goto end;
1111                }
1112        }
1113
1114        if(rectimernode != NULL)
1115                rectimernode->servicenode = servicenode;
1116
1117        servicenode->recendtime = endtime;
1118        servicenode->reccount = 1;
1119        servicenode->type = servicetype;
1120
1121        if(filefd < 0)
1122                deltranspondertunablestatus();
1123        else
1124                servicenode->recsrcfd = filefd;
1125
1126        if(type == RECSTREAM)
1127        {
1128                status.streaming++;
1129                servicenode->recname = ostrcat("stream ", oitoa(recordfd), 0, 1);
1130        }
1131        else if(type == RECTIMESHIFT)
1132        {
1133                status.timeshift = 1;
1134                servicenode->recname = ostrcat(filename, NULL, 0, 0);
1135        }
1136        else if(type == RECPLAY)
1137        {
1138                status.playing = 1;
1139                servicenode->recdmxstart = 1;
1140        }
1141        else if(type == RECDIRECT || type == RECTIMER)
1142        {
1143                status.recording++;
1144                servicenode->recname = ostrcat(filename, NULL, 0, 0);
1145                if(VFD_Recordthread == NULL && getconfigint("vfdisplayrecord", NULL) != 0)
1146                        VFD_Recordthread = addtimer(&vfdrecordthread, START, 10000, 1, NULL, NULL, NULL);
1147        }
1148
1149        if(type != RECSTREAM && type != RECTIMESHIFT && type != RECPLAY)
1150                recordwriteepg(filename, chnode, rectimernode);
1151
1152        //start readwrite thread
1153        addtimer(&readwritethread, START, 1000, 1, (void*)servicenode, NULL, NULL);
1154
1155        if(type == RECTIMER && status.standby == 0)
1156        {
1157                tmpstr = ostrcat(_("Timer Record start !\n"), filename, 0, 0);
1158                textbox(_("Message"), tmpstr, _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, NULL, 0, 800, 200, 4, 0);
1159                free(tmpstr); tmpstr = NULL;
1160        }
1161       
1162        if(filename != NULL) debug(250, "rec filename = %s\n", filename);
1163
1164end:
1165        if(ret > 0)
1166        {
1167                delservice(servicenode, 1);
1168                if(filename != NULL) unlink(filename);
1169        }
1170        free(filename); filename = NULL;
1171        return ret;
1172}
1173
1174int recordstart(struct channel* chnode, int filefd, int recordfd, int type, time_t endtime, struct rectimer* rectimernode)
1175{
1176        return recordstartreal(chnode, filefd, recordfd, type, endtime, rectimernode, 188);
1177}
1178
1179struct service* getrecordbyname(char* recname, int type)
1180{
1181        struct service* servicenode = service;
1182
1183        if(recname == NULL)
1184        {
1185                err("NULL detect");
1186                return NULL;
1187        }
1188
1189        while(servicenode != NULL)
1190        {
1191                if((type == -1 && (servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER || servicenode->type == RECORDTIMESHIFT)) || type == servicenode->type)
1192                {
1193                        if(servicenode->recname != NULL)
1194                        {
1195                                if(ostrstr(recname, servicenode->recname) != NULL)
1196                                        return servicenode;
1197                        }
1198                }
1199                servicenode = servicenode->next;
1200        }
1201
1202        return NULL;
1203}
1204
1205int screenrecordduration(int minutes, int nextmin)
1206{
1207                int rcret = 0, ret = 0;
1208                struct skin* recordduration = getscreen("recordduration");
1209                struct skin* b1 = getscreennode(recordduration, "b1");
1210                char* tmpnr = NULL;
1211
1212                if(nextmin == 0)
1213                        b1->hidden = YES;
1214                else
1215                {
1216                        if(nextmin > 9999) nextmin = 9999;
1217                        b1->hidden = NO;
1218                }
1219
1220                changemask(recordduration, "0000");
1221                if(minutes < 0) minutes = 0;
1222                if(minutes > 9999) minutes = 9999;
1223                tmpnr = malloc(5);
1224                snprintf(tmpnr, 5, "%04d", minutes);
1225                changeinput(recordduration, tmpnr);
1226                free(tmpnr); tmpnr = NULL;
1227
1228                drawscreen(recordduration, 0, 0);
1229                addscreenrc(recordduration, recordduration);
1230
1231                while(1)
1232                {
1233                        rcret = waitrc(recordduration, 0, 0);
1234                        if(nextmin > 0 && rcret == getrcconfigint("rcred", NULL))
1235                        {
1236                                changemask(recordduration, "0000");
1237                                tmpnr = malloc(5);
1238                                snprintf(tmpnr, 5, "%04d", nextmin);
1239                                changeinput(recordduration, tmpnr);
1240                                changeret(recordduration, tmpnr);
1241                                free(tmpnr); tmpnr = NULL;
1242                                drawscreen(recordduration, 0, 0);
1243                        }
1244                        if(rcret == getrcconfigint("rcexit", NULL))
1245                        {
1246                                changeret(recordduration, NULL);
1247                                break;
1248                        }
1249                        if(rcret == getrcconfigint("rcok", NULL))
1250                                break;
1251                }
1252
1253                if(recordduration->ret != NULL && ostrcmp(recordduration->ret, "0") != 0)
1254                        ret = atoi(recordduration->ret);
1255
1256                delownerrc(recordduration);
1257                clearscreen(recordduration);
1258
1259                return ret;
1260}
1261
1262void screenrecordstop()
1263{
1264        char* tmpstr = NULL;
1265        struct service* servicenode = service;
1266        struct menulist* mlist = NULL, *mbox = NULL, *tmpmbox = NULL;
1267
1268        while(servicenode != NULL)
1269        {
1270                if((servicenode->type == RECORDDIRECT || servicenode->type == RECORDTIMER) && servicenode->recname != NULL)
1271                {
1272                        tmpstr = ostrcat(tmpstr, _("stop"), 1, 0);
1273                        tmpstr = ostrcat(tmpstr, " (", 1, 0);
1274                        tmpstr = ostrcat(tmpstr, servicenode->recname, 1, 0);
1275                        tmpstr = ostrcat(tmpstr, ")", 1, 0);
1276                       
1277                        tmpmbox = addmenulist(&mlist, tmpstr, NULL, NULL, 0, 0);
1278                        free(tmpstr); tmpstr = NULL;
1279                        if(tmpmbox != NULL)
1280                        {
1281                                tmpmbox->param = ostrcat(tmpmbox->param, _("stop"), 1, 0);
1282                                tmpmbox->param = ostrcat(tmpmbox->param, " (", 1, 0);
1283                                tmpmbox->param = ostrcat(tmpmbox->param, servicenode->recname, 1, 0);
1284                                tmpmbox->param = ostrcat(tmpmbox->param, ")", 1, 0);
1285                        }
1286                }
1287                servicenode = servicenode->next;
1288        }
1289
1290        mbox = menulistbox(mlist, "recordlist", _("Record"), NULL, NULL, 0, 0);
1291       
1292        if(mbox != NULL && mbox->param != NULL && ostrstr(mbox->param, _("stop")) == mbox->param)
1293        {
1294                servicenode = getrecordbyname(mbox->param, RECORDDIRECT);
1295                if(servicenode != NULL)
1296                        servicenode->recendtime = 2;
1297                else
1298                {
1299                        servicenode = getrecordbyname(mbox->param, RECORDTIMER);
1300                        if(servicenode != NULL)
1301                                servicenode->recendtime = 2;
1302                }
1303        }
1304       
1305        freemenulist(mlist, 1); mlist = NULL;
1306}
1307
1308void screenrecorddirect()
1309{
1310        char* tmpstr = NULL, *cmd = NULL;
1311        int ret = 0, ret1 = 0, newstart = 0;
1312        struct service* servicenode = service;
1313        struct epg* epgnode = NULL;
1314        struct menulist* mlist = NULL, *mbox = NULL, *tmpmbox = NULL;
1315        struct stimerthread *recthumbfirstthread = NULL;
1316
1317        cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
1318        cmd = ostrcat(cmd, " >/dev/null &", 1, 0);
1319        printf("cmd: %s\n", cmd);
1320        system(cmd);
1321        free(cmd), cmd = NULL;
1322       
1323        while(servicenode != NULL)
1324        {
1325                if(servicenode->type == RECORDDIRECT && servicenode->recname != NULL)
1326                {
1327                        tmpstr = ostrcat(tmpstr, _("stop"), 1, 0);
1328                        tmpstr = ostrcat(tmpstr, " (", 1, 0);
1329                        tmpstr = ostrcat(tmpstr, servicenode->recname, 1, 0);
1330                        tmpstr = ostrcat(tmpstr, ")", 1, 0);
1331                       
1332                        tmpmbox = addmenulist(&mlist, tmpstr, NULL, NULL, 0, 0);
1333                        free(tmpstr); tmpstr = NULL;
1334                        if(tmpmbox != NULL)
1335                        {
1336                                tmpmbox->param = ostrcat(tmpmbox->param, _("stop"), 1, 0);
1337                                tmpmbox->param = ostrcat(tmpmbox->param, " (", 1, 0);
1338                                tmpmbox->param = ostrcat(tmpmbox->param, servicenode->recname, 1, 0);
1339                                tmpmbox->param = ostrcat(tmpmbox->param, ")", 1, 0);
1340                        }
1341                       
1342                        tmpstr = ostrcat(tmpstr, _("change"), 1, 0);
1343                        tmpstr = ostrcat(tmpstr, " (", 1, 0);
1344                        tmpstr = ostrcat(tmpstr, servicenode->recname, 1, 0);
1345                        tmpstr = ostrcat(tmpstr, ")", 1, 0);
1346                       
1347                        tmpmbox = addmenulist(&mlist, tmpstr, NULL, NULL, 0, 0);
1348                        free(tmpstr); tmpstr = NULL;
1349                        if(tmpmbox != NULL)
1350                        {
1351                                tmpmbox->param = ostrcat(tmpmbox->param, _("change"), 1, 0);
1352                                tmpmbox->param = ostrcat(tmpmbox->param, " (", 1, 0);
1353                                tmpmbox->param = ostrcat(tmpmbox->param, servicenode->recname, 1, 0);
1354                                tmpmbox->param = ostrcat(tmpmbox->param, ")", 1, 0);
1355                        }
1356                }
1357                servicenode = servicenode->next;
1358        }
1359
1360        addmenulist(&mlist, _("add recording (stop after current event)"), NULL, NULL, 0, 0);
1361        addmenulist(&mlist, _("add recording (indefinitely)"), NULL, NULL, 0, 0);
1362        addmenulist(&mlist, _("add recording (enter duration)"), NULL, NULL, 0, 0);
1363
1364        mbox = menulistbox(mlist, _("recordlist"), _("Record"), NULL, NULL, 0, 0);
1365       
1366        if(mbox != NULL)
1367        {
1368                if(mbox->param != NULL && ostrstr(mbox->param, _("stop")) == mbox->param)
1369                {
1370                        servicenode = getrecordbyname(mbox->param, RECORDDIRECT);
1371                        if(servicenode != NULL)
1372                                servicenode->recendtime = 2;
1373                }
1374                if(mbox->param != NULL && ostrstr(mbox->param, _("change")) == mbox->param)
1375                {
1376                        servicenode = getrecordbyname(mbox->param, RECORDDIRECT);
1377                        if(servicenode != NULL)
1378                        {
1379                                int nextmin = 0;
1380                                epgnode = getepgbytime(servicenode->channel, time(NULL));
1381                                if(epgnode != NULL) epgnode = epgnode->next;
1382                                if(epgnode != NULL) nextmin = (epgnode->endtime - time(NULL)) / 60;
1383                                if(nextmin < 0) nextmin = 0;
1384                                ret1 = (servicenode->recendtime - time(NULL)) / 60;
1385                                ret1 = screenrecordduration(ret1, nextmin);
1386                                if(ret1 > 0)
1387                                        servicenode->recendtime = time(NULL) + (ret1 * 60);
1388                        }
1389                }
1390                if(ostrcmp(mbox->name, _("add recording (stop after current event)")) == 0)
1391                {
1392                        epgnode = getepgbytime(status.aktservice->channel, time(NULL) + 60);
1393#ifndef SIMULATE
1394                        if(epgnode != NULL && epgnode->endtime > time(NULL))
1395                                ret = recordstart(status.aktservice->channel, -1, 0, RECDIRECT, epgnode->endtime, NULL);
1396                        else
1397                                textbox(_("Message"), _("Can't get EPG time or EPG endtime not ok"), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, NULL, 0, 800, 200, 0, 0);
1398#else
1399                        ret = recordstart(status.aktservice->channel, -1,  0, RECDIRECT, time(NULL) + 5, NULL);
1400#endif
1401                        newstart = 1;
1402                }
1403                if(ostrcmp(mbox->name, _("add recording (indefinitely)")) == 0)
1404                {
1405                        ret = recordstart(status.aktservice->channel, -1, 0, RECDIRECT, 0, NULL);
1406                        newstart = 1;
1407                }
1408                if(ostrcmp(mbox->name, _("add recording (enter duration)")) == 0)
1409                {
1410                        ret1 = screenrecordduration(0, 0);
1411
1412                        if(ret1 > 0)
1413                        {
1414                                ret = recordstart(status.aktservice->channel, -1, 0, RECDIRECT, time(NULL) + (ret1 * 60), NULL);
1415                                newstart = 1;
1416                        }
1417                }
1418
1419                recordcheckret(NULL, ret, 6);
1420                if(ret == 0 && newstart == 1)
1421                {
1422                        textbox(_("Message"), _("Record started"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 7, 0);
1423                        if(getconfigint("recordpicture", NULL) == 1)
1424                                recthumbfirstthread = addtimer(&createrecthumbfirstthread, START, 1000, 1, NULL, NULL, NULL);
1425                }
1426        }
1427        freemenulist(mlist, 1); mlist = NULL;
1428}
1429
1430#endif
Note: See TracBrowser for help on using the repository browser.