source: titan/titan/record.h @ 23983

Last change on this file since 23983 was 23807, checked in by nit, 11 years ago

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