mirror of
https://github.com/vdr-projects/vdr.git
synced 2025-03-01 10:50:46 +00:00
eb52e3004a
- In order to avoid problems on NPTL systems, VDR now checks for the presence of NPTL at program start, and if it is, exits and tells the user to do 'export LD_ASSUME_KERNEL=2.4.1' before starting VDR. - Revisited the "Fixed missing audio after replaying a DVD" change because it introduced a sound disturbance when switching between channels on the same transponder (thanks to Marco Schlüßler). - In order to avoid problems on UTF-8 systems, VDR now checks for the presence of UTF-8 at program start, and if it is, exits and tells the user to turn off UTF-8 before starting VDR (thanks to Ludwig Nussel for pointing out a problem with systems that are set to use UTF-8). There are also problems in case the video partition is mounted with "iocharset=utf8" (thanks to Jörg Knitter for reporting this one). Please also read the "IMPORTANT NOTES" section in the INSTALL file! - Some changes to the SPU decoder interface (thanks to Sven Goethel). - Some improvements in cOsd creation (thanks to some suggestions by Jouni Karvo). - Fixed calculating the OSD width and height (thanks to Olaf Henkel for reporting a problem with long event texts in the "Classic VDR" skin). - Fixed switching channels while an encrypted channel is being recorded, because the channel was switched if the new channel was on the same transponder and was a radio channel or an unencrypted channel (thanks to Martin Dauskardt for reporting this one). - No longer using the external 'find' command to scan the video directory for recordings (based on a suggestion by Mirko Dölle). - The list of recordings is now kept statically in memory to avoid long delays when opening the "Recordings" menu. As a side effect, external modifications to the video directory are no longer immediately reflected in the "Recordings" menu. If a plugin manipulates the video directory in any way, it can call the function Recordings.TriggerUpdate() to trigger an update of the list of recordings. If some external tool manipulates the video directory, it can touch the file '.update' in the video directory to trigger an update of the list of recordings. - Fixed a memory leak in theme description handling (thanks to Sascha Volkenandt). - Added cDevice::Flush() to make sure that all data in the video card's buffers has been processed (thanks to Reinhard Nissl). Currently this is not yet actually implemented for FF DVB cards. - Fixed handling the color button texts in cMenuEditStrItem (thanks to Maynard Cedric for reporting this one). - Fixed the description of cRingBufferLinear (thanks to Ludwig Nussel for pointing out this one). - Fixed cRingBufferLinear::Get() in case the buffer wraps around (thanks to Ludwig Nussel for reporting this one).
1210 lines
35 KiB
C
1210 lines
35 KiB
C
/*
|
||
* recording.c: Recording file handling
|
||
*
|
||
* See the main source file 'vdr.c' for copyright information and
|
||
* how to reach the author.
|
||
*
|
||
* $Id: recording.c 1.88 2004/06/13 20:25:19 kls Exp $
|
||
*/
|
||
|
||
#include "recording.h"
|
||
#include <dirent.h>
|
||
#include <errno.h>
|
||
#include <fcntl.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <sys/stat.h>
|
||
#include <unistd.h>
|
||
#include "channels.h"
|
||
#include "i18n.h"
|
||
#include "interface.h"
|
||
#include "remux.h" //XXX+ I_FRAME
|
||
#include "skins.h"
|
||
#include "tools.h"
|
||
#include "videodir.h"
|
||
|
||
#define RECEXT ".rec"
|
||
#define DELEXT ".del"
|
||
/* This was the original code, which works fine in a Linux only environment.
|
||
Unfortunately, because of Windows and its brain dead file system, we have
|
||
to use a more complicated approach, in order to allow users who have enabled
|
||
the VFAT compile time option to see their recordings even if they forget to
|
||
enable VFAT when compiling a new version of VDR... Gee, do I hate Windows.
|
||
(kls 2002-07-27)
|
||
#define DATAFORMAT "%4d-%02d-%02d.%02d:%02d.%02d.%02d" RECEXT
|
||
#define NAMEFORMAT "%s/%s/" DATAFORMAT
|
||
*/
|
||
// start of implementation for brain dead systems
|
||
#define DATAFORMAT "%4d-%02d-%02d.%02d%*c%02d.%02d.%02d" RECEXT
|
||
#ifdef VFAT
|
||
#define nameFORMAT "%4d-%02d-%02d.%02d.%02d.%02d.%02d" RECEXT
|
||
#else
|
||
#define nameFORMAT "%4d-%02d-%02d.%02d:%02d.%02d.%02d" RECEXT
|
||
#endif
|
||
#define NAMEFORMAT "%s/%s/" nameFORMAT
|
||
// end of implementation for brain dead systems
|
||
|
||
#define RESUMEFILESUFFIX "/resume%s%s.vdr"
|
||
#define SUMMARYFILESUFFIX "/summary.vdr"
|
||
#define MARKSFILESUFFIX "/marks.vdr"
|
||
|
||
#define MINDISKSPACE 1024 // MB
|
||
|
||
#define DELETEDLIFETIME 1 // hours after which a deleted recording will be actually removed
|
||
#define REMOVECHECKDELTA 3600 // seconds between checks for removing deleted files
|
||
#define DISKCHECKDELTA 100 // seconds between checks for free disk space
|
||
#define REMOVELATENCY 10 // seconds to wait until next check after removing a file
|
||
|
||
#define TIMERMACRO_TITLE "TITLE"
|
||
#define TIMERMACRO_EPISODE "EPISODE"
|
||
|
||
#define MAX_SUBTITLE_LENGTH 40
|
||
|
||
void RemoveDeletedRecordings(void)
|
||
{
|
||
static time_t LastRemoveCheck = 0;
|
||
if (time(NULL) - LastRemoveCheck > REMOVECHECKDELTA) {
|
||
// Make sure only one instance of VDR does this:
|
||
cLockFile LockFile(VideoDirectory);
|
||
if (!LockFile.Lock())
|
||
return;
|
||
// Remove the oldest file that has been "deleted":
|
||
cRecordings DeletedRecordings(true);
|
||
if (DeletedRecordings.Load()) {
|
||
cRecording *r = DeletedRecordings.First();
|
||
cRecording *r0 = r;
|
||
while (r) {
|
||
if (r->start < r0->start)
|
||
r0 = r;
|
||
r = DeletedRecordings.Next(r);
|
||
}
|
||
if (r0 && time(NULL) - r0->start > DELETEDLIFETIME * 3600) {
|
||
r0->Remove();
|
||
RemoveEmptyVideoDirectories();
|
||
LastRemoveCheck += REMOVELATENCY;
|
||
return;
|
||
}
|
||
}
|
||
LastRemoveCheck = time(NULL);
|
||
}
|
||
}
|
||
|
||
void AssertFreeDiskSpace(int Priority)
|
||
{
|
||
// With every call to this function we try to actually remove
|
||
// a file, or mark a file for removal ("delete" it), so that
|
||
// it will get removed during the next call.
|
||
static time_t LastFreeDiskCheck = 0;
|
||
int Factor = (Priority == -1) ? 10 : 1;
|
||
if (time(NULL) - LastFreeDiskCheck > DISKCHECKDELTA / Factor) {
|
||
if (!VideoFileSpaceAvailable(MINDISKSPACE)) {
|
||
// Make sure only one instance of VDR does this:
|
||
cLockFile LockFile(VideoDirectory);
|
||
if (!LockFile.Lock())
|
||
return;
|
||
// Remove the oldest file that has been "deleted":
|
||
isyslog("low disk space while recording, trying to remove a deleted recording...");
|
||
cRecordings DeletedRecordings(true);
|
||
if (DeletedRecordings.Load()) {
|
||
cRecording *r = DeletedRecordings.First();
|
||
cRecording *r0 = r;
|
||
while (r) {
|
||
if (r->start < r0->start)
|
||
r0 = r;
|
||
r = DeletedRecordings.Next(r);
|
||
}
|
||
if (r0 && r0->Remove()) {
|
||
LastFreeDiskCheck += REMOVELATENCY / Factor;
|
||
return;
|
||
}
|
||
}
|
||
// No "deleted" files to remove, so let's see if we can delete a recording:
|
||
isyslog("...no deleted recording found, trying to delete an old recording...");
|
||
if (Recordings.Load()) {
|
||
cRecording *r = Recordings.First();
|
||
cRecording *r0 = NULL;
|
||
while (r) {
|
||
if (!r->IsEdited() && r->lifetime < MAXLIFETIME) { // edited recordings and recordings with MAXLIFETIME live forever
|
||
if ((r->lifetime == 0 && Priority > r->priority) || // the recording has no guaranteed lifetime and the new recording has higher priority
|
||
(time(NULL) - r->start) / SECSINDAY > r->lifetime) { // the recording's guaranteed lifetime has expired
|
||
if (r0) {
|
||
if (r->priority < r0->priority || (r->priority == r0->priority && r->start < r0->start))
|
||
r0 = r; // in any case we delete the one with the lowest priority (or the older one in case of equal priorities)
|
||
}
|
||
else
|
||
r0 = r;
|
||
}
|
||
}
|
||
r = Recordings.Next(r);
|
||
}
|
||
if (r0 && r0->Delete()) {
|
||
Recordings.Del(r0);
|
||
return;
|
||
}
|
||
}
|
||
// Unable to free disk space, but there's nothing we can do about that...
|
||
isyslog("...no old recording found, giving up");
|
||
Interface->Confirm(tr("Low disk space!"), 30);
|
||
}
|
||
LastFreeDiskCheck = time(NULL);
|
||
}
|
||
}
|
||
|
||
// --- cResumeFile ------------------------------------------------------------
|
||
|
||
cResumeFile::cResumeFile(const char *FileName)
|
||
{
|
||
fileName = MALLOC(char, strlen(FileName) + strlen(RESUMEFILESUFFIX) + 1);
|
||
if (fileName) {
|
||
strcpy(fileName, FileName);
|
||
sprintf(fileName + strlen(fileName), RESUMEFILESUFFIX, Setup.ResumeID ? "." : "", Setup.ResumeID ? itoa(Setup.ResumeID) : "");
|
||
}
|
||
else
|
||
esyslog("ERROR: can't allocate memory for resume file name");
|
||
}
|
||
|
||
cResumeFile::~cResumeFile()
|
||
{
|
||
free(fileName);
|
||
}
|
||
|
||
int cResumeFile::Read(void)
|
||
{
|
||
int resume = -1;
|
||
if (fileName) {
|
||
struct stat st;
|
||
if (stat(fileName, &st) == 0) {
|
||
if ((st.st_mode & S_IWUSR) == 0) // no write access, assume no resume
|
||
return -1;
|
||
}
|
||
int f = open(fileName, O_RDONLY);
|
||
if (f >= 0) {
|
||
if (safe_read(f, &resume, sizeof(resume)) != sizeof(resume)) {
|
||
resume = -1;
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
close(f);
|
||
}
|
||
else if (errno != ENOENT)
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
return resume;
|
||
}
|
||
|
||
bool cResumeFile::Save(int Index)
|
||
{
|
||
if (fileName) {
|
||
int f = open(fileName, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
|
||
if (f >= 0) {
|
||
if (safe_write(f, &Index, sizeof(Index)) < 0)
|
||
LOG_ERROR_STR(fileName);
|
||
close(f);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void cResumeFile::Delete(void)
|
||
{
|
||
if (fileName) {
|
||
if (remove(fileName) < 0 && errno != ENOENT)
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
}
|
||
|
||
// --- cRecording ------------------------------------------------------------
|
||
|
||
#define RESUME_NOT_INITIALIZED (-2)
|
||
|
||
struct tCharExchange { char a; char b; };
|
||
tCharExchange CharExchange[] = {
|
||
{ '~', '/' },
|
||
{ ' ', '_' },
|
||
{ '\'', '\x01' },
|
||
{ '/', '\x02' },
|
||
{ 0, 0 }
|
||
};
|
||
|
||
static char *ExchangeChars(char *s, bool ToFileSystem)
|
||
{
|
||
char *p = s;
|
||
while (*p) {
|
||
#ifdef VFAT
|
||
// The VFAT file system can't handle all characters, so we
|
||
// have to take extra efforts to encode/decode them:
|
||
if (ToFileSystem) {
|
||
switch (*p) {
|
||
// characters that can be used "as is":
|
||
case '!':
|
||
case '@':
|
||
case '$':
|
||
case '%':
|
||
case '&':
|
||
case '(':
|
||
case ')':
|
||
case '+':
|
||
case ',':
|
||
case '-':
|
||
case ';':
|
||
case '=':
|
||
case '0' ... '9':
|
||
case 'a' ... 'z':
|
||
case 'A' ... 'Z':
|
||
case '<EFBFBD>': case '<EFBFBD>':
|
||
case '<EFBFBD>': case '<EFBFBD>':
|
||
case '<EFBFBD>': case '<EFBFBD>':
|
||
case '<EFBFBD>':
|
||
break;
|
||
// characters that can be mapped to other characters:
|
||
case ' ': *p = '_'; break;
|
||
case '~': *p = '/'; break;
|
||
// characters that have to be encoded:
|
||
default:
|
||
if (*p != '.' || !*(p + 1) || *(p + 1) == '~') { // Windows can't handle '.' at the end of directory names
|
||
int l = p - s;
|
||
s = (char *)realloc(s, strlen(s) + 10);
|
||
p = s + l;
|
||
char buf[4];
|
||
sprintf(buf, "#%02X", (unsigned char)*p);
|
||
memmove(p + 2, p, strlen(p) + 1);
|
||
strncpy(p, buf, 3);
|
||
p += 2;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
switch (*p) {
|
||
// mapped characters:
|
||
case '_': *p = ' '; break;
|
||
case '/': *p = '~'; break;
|
||
// encodes characters:
|
||
case '#': {
|
||
if (strlen(p) > 2) {
|
||
char buf[3];
|
||
sprintf(buf, "%c%c", *(p + 1), *(p + 2));
|
||
unsigned char c = strtol(buf, NULL, 16);
|
||
*p = c;
|
||
memmove(p + 1, p + 3, strlen(p) - 2);
|
||
}
|
||
}
|
||
break;
|
||
// backwards compatibility:
|
||
case '\x01': *p = '\''; break;
|
||
case '\x02': *p = '/'; break;
|
||
case '\x03': *p = ':'; break;
|
||
}
|
||
}
|
||
#else
|
||
for (struct tCharExchange *ce = CharExchange; ce->a && ce->b; ce++) {
|
||
if (*p == (ToFileSystem ? ce->a : ce->b)) {
|
||
*p = ToFileSystem ? ce->b : ce->a;
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
p++;
|
||
}
|
||
return s;
|
||
}
|
||
|
||
cRecording::cRecording(cTimer *Timer, const char *Title, const char *Subtitle, const char *Summary)
|
||
{
|
||
resume = RESUME_NOT_INITIALIZED;
|
||
titleBuffer = NULL;
|
||
sortBuffer = NULL;
|
||
fileName = NULL;
|
||
name = NULL;
|
||
// set up the actual name:
|
||
const char *OriginalSubtitle = Subtitle;
|
||
char SubtitleBuffer[MAX_SUBTITLE_LENGTH];
|
||
if (isempty(Title))
|
||
Title = Timer->Channel()->Name();
|
||
if (isempty(Subtitle))
|
||
Subtitle = " ";
|
||
else if (strlen(Subtitle) > MAX_SUBTITLE_LENGTH) {
|
||
// let's make sure the Subtitle doesn't produce too long a file name:
|
||
strn0cpy(SubtitleBuffer, Subtitle, MAX_SUBTITLE_LENGTH);
|
||
Subtitle = SubtitleBuffer;
|
||
}
|
||
char *macroTITLE = strstr(Timer->File(), TIMERMACRO_TITLE);
|
||
char *macroEPISODE = strstr(Timer->File(), TIMERMACRO_EPISODE);
|
||
if (macroTITLE || macroEPISODE) {
|
||
name = strdup(Timer->File());
|
||
name = strreplace(name, TIMERMACRO_TITLE, Title);
|
||
name = strreplace(name, TIMERMACRO_EPISODE, Subtitle);
|
||
if (Timer->IsSingleEvent()) {
|
||
Timer->SetFile(name); // this was an instant recording, so let's set the actual data
|
||
Timers.Save();
|
||
}
|
||
}
|
||
else if (Timer->IsSingleEvent() || !Setup.UseSubtitle)
|
||
name = strdup(Timer->File());
|
||
else
|
||
asprintf(&name, "%s~%s", Timer->File(), Subtitle);
|
||
// substitute characters that would cause problems in file names:
|
||
strreplace(name, '\n', ' ');
|
||
start = Timer->StartTime();
|
||
priority = Timer->Priority();
|
||
lifetime = Timer->Lifetime();
|
||
// handle summary:
|
||
summary = !isempty(Timer->Summary()) ? strdup(Timer->Summary()) : NULL;
|
||
if (!summary) {
|
||
Subtitle = OriginalSubtitle;
|
||
if (isempty(Subtitle))
|
||
Subtitle = "";
|
||
if (isempty(Summary))
|
||
Summary = "";
|
||
if (*Subtitle || *Summary)
|
||
asprintf(&summary, "%s\n\n%s%s%s", Title, Subtitle, (*Subtitle && *Summary) ? "\n\n" : "", Summary);
|
||
}
|
||
}
|
||
|
||
cRecording::cRecording(const char *FileName)
|
||
{
|
||
resume = RESUME_NOT_INITIALIZED;
|
||
titleBuffer = NULL;
|
||
sortBuffer = NULL;
|
||
fileName = strdup(FileName);
|
||
FileName += strlen(VideoDirectory) + 1;
|
||
char *p = strrchr(FileName, '/');
|
||
|
||
name = NULL;
|
||
summary = NULL;
|
||
if (p) {
|
||
time_t now = time(NULL);
|
||
struct tm tm_r;
|
||
struct tm t = *localtime_r(&now, &tm_r); // this initializes the time zone in 't'
|
||
t.tm_isdst = -1; // makes sure mktime() will determine the correct DST setting
|
||
if (7 == sscanf(p + 1, DATAFORMAT, &t.tm_year, &t.tm_mon, &t.tm_mday, &t.tm_hour, &t.tm_min, &priority, &lifetime)) {
|
||
t.tm_year -= 1900;
|
||
t.tm_mon--;
|
||
t.tm_sec = 0;
|
||
start = mktime(&t);
|
||
name = MALLOC(char, p - FileName + 1);
|
||
strncpy(name, FileName, p - FileName);
|
||
name[p - FileName] = 0;
|
||
name = ExchangeChars(name, false);
|
||
}
|
||
// read an optional summary file:
|
||
char *SummaryFileName = NULL;
|
||
asprintf(&SummaryFileName, "%s%s", fileName, SUMMARYFILESUFFIX);
|
||
int f = open(SummaryFileName, O_RDONLY);
|
||
if (f >= 0) {
|
||
struct stat buf;
|
||
if (fstat(f, &buf) == 0) {
|
||
int size = buf.st_size;
|
||
summary = MALLOC(char, size + 1); // +1 for terminating 0
|
||
if (summary) {
|
||
int rbytes = safe_read(f, summary, size);
|
||
if (rbytes >= 0) {
|
||
summary[rbytes] = 0;
|
||
if (rbytes != size)
|
||
esyslog("%s: expected %d bytes but read %d", SummaryFileName, size, rbytes);
|
||
}
|
||
else {
|
||
LOG_ERROR_STR(SummaryFileName);
|
||
free(summary);
|
||
summary = NULL;
|
||
}
|
||
|
||
}
|
||
else
|
||
esyslog("can't allocate %d byte of memory for summary file '%s'", size + 1, SummaryFileName);
|
||
close(f);
|
||
}
|
||
else
|
||
LOG_ERROR_STR(SummaryFileName);
|
||
}
|
||
else if (errno != ENOENT)
|
||
LOG_ERROR_STR(SummaryFileName);
|
||
free(SummaryFileName);
|
||
}
|
||
}
|
||
|
||
cRecording::~cRecording()
|
||
{
|
||
free(titleBuffer);
|
||
free(sortBuffer);
|
||
free(fileName);
|
||
free(name);
|
||
free(summary);
|
||
}
|
||
|
||
char *cRecording::StripEpisodeName(char *s)
|
||
{
|
||
char *t = s, *s1 = NULL, *s2 = NULL;
|
||
while (*t) {
|
||
if (*t == '/') {
|
||
if (s1) {
|
||
if (s2)
|
||
s1 = s2;
|
||
s2 = t;
|
||
}
|
||
else
|
||
s1 = t;
|
||
}
|
||
t++;
|
||
}
|
||
if (s1 && s2)
|
||
memmove(s1 + 1, s2, t - s2 + 1);
|
||
return s;
|
||
}
|
||
|
||
char *cRecording::SortName(void)
|
||
{
|
||
if (!sortBuffer) {
|
||
char *s = StripEpisodeName(strdup(FileName() + strlen(VideoDirectory) + 1));
|
||
int l = strxfrm(NULL, s, 0);
|
||
sortBuffer = MALLOC(char, l);
|
||
strxfrm(sortBuffer, s, l);
|
||
free(s);
|
||
}
|
||
return sortBuffer;
|
||
}
|
||
|
||
int cRecording::GetResume(void) const
|
||
{
|
||
if (resume == RESUME_NOT_INITIALIZED) {
|
||
cResumeFile ResumeFile(FileName());
|
||
resume = ResumeFile.Read();
|
||
}
|
||
return resume;
|
||
}
|
||
|
||
bool cRecording::operator< (const cListObject &ListObject)
|
||
{
|
||
cRecording *r = (cRecording *)&ListObject;
|
||
return strcasecmp(SortName(), r->SortName()) < 0;
|
||
}
|
||
|
||
const char *cRecording::FileName(void) const
|
||
{
|
||
if (!fileName) {
|
||
struct tm tm_r;
|
||
struct tm *t = localtime_r(&start, &tm_r);
|
||
name = ExchangeChars(name, true);
|
||
asprintf(&fileName, NAMEFORMAT, VideoDirectory, name, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, priority, lifetime);
|
||
name = ExchangeChars(name, false);
|
||
}
|
||
return fileName;
|
||
}
|
||
|
||
const char *cRecording::Title(char Delimiter, bool NewIndicator, int Level) const
|
||
{
|
||
char New = NewIndicator && IsNew() ? '*' : ' ';
|
||
free(titleBuffer);
|
||
titleBuffer = NULL;
|
||
if (Level < 0 || Level == HierarchyLevels()) {
|
||
struct tm tm_r;
|
||
struct tm *t = localtime_r(&start, &tm_r);
|
||
char *s;
|
||
if (Level > 0 && (s = strrchr(name, '~')) != NULL)
|
||
s++;
|
||
else
|
||
s = name;
|
||
asprintf(&titleBuffer, "%02d.%02d%c%02d:%02d%c%c%s",
|
||
t->tm_mday,
|
||
t->tm_mon + 1,
|
||
Delimiter,
|
||
t->tm_hour,
|
||
t->tm_min,
|
||
New,
|
||
Delimiter,
|
||
s);
|
||
// let's not display a trailing '~':
|
||
stripspace(titleBuffer);
|
||
s = &titleBuffer[strlen(titleBuffer) - 1];
|
||
if (*s == '~')
|
||
*s = 0;
|
||
}
|
||
else if (Level < HierarchyLevels()) {
|
||
const char *s = name;
|
||
const char *p = s;
|
||
while (*++s) {
|
||
if (*s == '~') {
|
||
if (Level--)
|
||
p = s + 1;
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
titleBuffer = MALLOC(char, s - p + 3);
|
||
*titleBuffer = Delimiter;
|
||
*(titleBuffer + 1) = Delimiter;
|
||
strn0cpy(titleBuffer + 2, p, s - p + 1);
|
||
}
|
||
else
|
||
return "";
|
||
return titleBuffer;
|
||
}
|
||
|
||
const char *cRecording::PrefixFileName(char Prefix)
|
||
{
|
||
const char *p = PrefixVideoFileName(FileName(), Prefix);
|
||
if (p) {
|
||
free(fileName);
|
||
fileName = strdup(p);
|
||
return fileName;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
int cRecording::HierarchyLevels(void) const
|
||
{
|
||
const char *s = name;
|
||
int level = 0;
|
||
while (*++s) {
|
||
if (*s == '~')
|
||
level++;
|
||
}
|
||
return level;
|
||
}
|
||
|
||
bool cRecording::IsEdited(void) const
|
||
{
|
||
const char *s = strrchr(name, '~');
|
||
s = !s ? name : s + 1;
|
||
return *s == '%';
|
||
}
|
||
|
||
bool cRecording::WriteSummary(void)
|
||
{
|
||
if (summary) {
|
||
char *SummaryFileName = NULL;
|
||
asprintf(&SummaryFileName, "%s%s", fileName, SUMMARYFILESUFFIX);
|
||
FILE *f = fopen(SummaryFileName, "w");
|
||
if (f) {
|
||
if (fputs(summary, f) < 0)
|
||
LOG_ERROR_STR(SummaryFileName);
|
||
fclose(f);
|
||
}
|
||
else
|
||
LOG_ERROR_STR(SummaryFileName);
|
||
free(SummaryFileName);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool cRecording::Delete(void)
|
||
{
|
||
bool result = true;
|
||
char *NewName = strdup(FileName());
|
||
char *ext = strrchr(NewName, '.');
|
||
if (strcmp(ext, RECEXT) == 0) {
|
||
strncpy(ext, DELEXT, strlen(ext));
|
||
if (access(NewName, F_OK) == 0) {
|
||
// the new name already exists, so let's remove that one first:
|
||
isyslog("removing recording %s", NewName);
|
||
RemoveVideoFile(NewName);
|
||
}
|
||
isyslog("deleting recording %s", FileName());
|
||
result = RenameVideoFile(FileName(), NewName);
|
||
}
|
||
free(NewName);
|
||
return result;
|
||
}
|
||
|
||
bool cRecording::Remove(void)
|
||
{
|
||
// let's do a final safety check here:
|
||
if (!endswith(FileName(), DELEXT)) {
|
||
esyslog("attempt to remove recording %s", FileName());
|
||
return false;
|
||
}
|
||
isyslog("removing recording %s", FileName());
|
||
return RemoveVideoFile(FileName());
|
||
}
|
||
|
||
// --- cRecordings -----------------------------------------------------------
|
||
|
||
cRecordings Recordings;
|
||
|
||
cRecordings::cRecordings(bool Deleted)
|
||
{
|
||
deleted = Deleted;
|
||
lastUpdate = 0;
|
||
}
|
||
|
||
bool cRecordings::ScanVideoDir(const char *DirName)
|
||
{
|
||
DIR *d = opendir(DirName);
|
||
if (d) {
|
||
struct dirent *e;
|
||
while ((e = readdir(d)) != NULL) {
|
||
if (strcmp(e->d_name, ".") && strcmp(e->d_name, "..")) {
|
||
char *buffer;
|
||
asprintf(&buffer, "%s/%s", DirName, e->d_name);
|
||
struct stat st;
|
||
if (stat(buffer, &st) == 0) {
|
||
if (S_ISLNK(st.st_mode)) {
|
||
free(buffer);
|
||
buffer = ReadLink(buffer);
|
||
if (!buffer)
|
||
return false;
|
||
if (stat(buffer, &st) != 0) {
|
||
LOG_ERROR_STR(DirName);
|
||
return false;
|
||
}
|
||
}
|
||
if (S_ISDIR(st.st_mode)) {
|
||
if (endswith(buffer, deleted ? DELEXT : RECEXT)) {
|
||
cRecording *r = new cRecording(buffer);
|
||
if (r->Name())
|
||
Add(r);
|
||
else
|
||
delete r;
|
||
}
|
||
else if (!ScanVideoDir(buffer))
|
||
return false;
|
||
}
|
||
}
|
||
else {
|
||
LOG_ERROR_STR(DirName);
|
||
return false;
|
||
}
|
||
free(buffer);
|
||
}
|
||
}
|
||
closedir(d);
|
||
}
|
||
else {
|
||
LOG_ERROR_STR(DirName);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool cRecordings::NeedsUpdate(void)
|
||
{
|
||
return lastUpdate <= LastModifiedTime(AddDirectory(VideoDirectory, ".update"));
|
||
}
|
||
|
||
bool cRecordings::Load(void)
|
||
{
|
||
lastUpdate = time(NULL); // doing this first to make sure we don't miss anything
|
||
Clear();
|
||
ScanVideoDir(VideoDirectory);
|
||
Sort();
|
||
return Count() > 0;
|
||
}
|
||
|
||
cRecording *cRecordings::GetByName(const char *FileName)
|
||
{
|
||
for (cRecording *recording = First(); recording; recording = Next(recording)) {
|
||
if (strcmp(recording->FileName(), FileName) == 0)
|
||
return recording;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void cRecordings::AddByName(const char *FileName)
|
||
{
|
||
cRecording *recording = GetByName(FileName);
|
||
if (!recording) {
|
||
recording = new cRecording(FileName);
|
||
Add(recording);
|
||
}
|
||
}
|
||
|
||
void cRecordings::DelByName(const char *FileName)
|
||
{
|
||
cRecording *recording = GetByName(FileName);
|
||
if (recording)
|
||
Del(recording);
|
||
}
|
||
|
||
// --- cMark -----------------------------------------------------------------
|
||
|
||
char *cMark::buffer = NULL;
|
||
|
||
cMark::cMark(int Position, const char *Comment)
|
||
{
|
||
position = Position;
|
||
comment = Comment ? strdup(Comment) : NULL;
|
||
}
|
||
|
||
cMark::~cMark()
|
||
{
|
||
free(comment);
|
||
}
|
||
|
||
const char *cMark::ToText(void)
|
||
{
|
||
free(buffer);
|
||
asprintf(&buffer, "%s%s%s\n", IndexToHMSF(position, true), comment ? " " : "", comment ? comment : "");
|
||
return buffer;
|
||
}
|
||
|
||
bool cMark::Parse(const char *s)
|
||
{
|
||
free(comment);
|
||
comment = NULL;
|
||
position = HMSFToIndex(s);
|
||
const char *p = strchr(s, ' ');
|
||
if (p) {
|
||
p = skipspace(p);
|
||
if (*p)
|
||
comment = strdup(p);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool cMark::Save(FILE *f)
|
||
{
|
||
return fprintf(f, ToText()) > 0;
|
||
}
|
||
|
||
// --- cMarks ----------------------------------------------------------------
|
||
|
||
bool cMarks::Load(const char *RecordingFileName)
|
||
{
|
||
const char *MarksFile = AddDirectory(RecordingFileName, MARKSFILESUFFIX);
|
||
if (cConfig<cMark>::Load(MarksFile)) {
|
||
Sort();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void cMarks::Sort(void)
|
||
{
|
||
for (cMark *m1 = First(); m1; m1 = Next(m1)) {
|
||
for (cMark *m2 = Next(m1); m2; m2 = Next(m2)) {
|
||
if (m2->position < m1->position) {
|
||
swap(m1->position, m2->position);
|
||
swap(m1->comment, m2->comment);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
cMark *cMarks::Add(int Position)
|
||
{
|
||
cMark *m = Get(Position);
|
||
if (!m) {
|
||
cConfig<cMark>::Add(m = new cMark(Position));
|
||
Sort();
|
||
}
|
||
return m;
|
||
}
|
||
|
||
cMark *cMarks::Get(int Position)
|
||
{
|
||
for (cMark *mi = First(); mi; mi = Next(mi)) {
|
||
if (mi->position == Position)
|
||
return mi;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
cMark *cMarks::GetPrev(int Position)
|
||
{
|
||
for (cMark *mi = Last(); mi; mi = Prev(mi)) {
|
||
if (mi->position < Position)
|
||
return mi;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
cMark *cMarks::GetNext(int Position)
|
||
{
|
||
for (cMark *mi = First(); mi; mi = Next(mi)) {
|
||
if (mi->position > Position)
|
||
return mi;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
// --- cRecordingUserCommand -------------------------------------------------
|
||
|
||
const char *cRecordingUserCommand::command = NULL;
|
||
|
||
void cRecordingUserCommand::InvokeCommand(const char *State, const char *RecordingFileName)
|
||
{
|
||
if (command) {
|
||
char *cmd;
|
||
asprintf(&cmd, "%s %s \"%s\"", command, State, strescape(RecordingFileName, "\"$"));
|
||
isyslog("executing '%s'", cmd);
|
||
SystemExec(cmd);
|
||
free(cmd);
|
||
}
|
||
}
|
||
|
||
// --- XXX+
|
||
|
||
//XXX+ somewhere else???
|
||
// --- cIndexFile ------------------------------------------------------------
|
||
|
||
#define INDEXFILESUFFIX "/index.vdr"
|
||
|
||
// The number of frames to stay off the end in case of time shift:
|
||
#define INDEXSAFETYLIMIT 150 // frames
|
||
|
||
// The maximum time to wait before giving up while catching up on an index file:
|
||
#define MAXINDEXCATCHUP 8 // seconds
|
||
|
||
// The minimum age of an index file for considering it no longer to be written:
|
||
#define MININDEXAGE 3600 // seconds
|
||
|
||
cIndexFile::cIndexFile(const char *FileName, bool Record)
|
||
:resumeFile(FileName)
|
||
{
|
||
f = -1;
|
||
fileName = NULL;
|
||
size = 0;
|
||
last = -1;
|
||
index = NULL;
|
||
if (FileName) {
|
||
fileName = MALLOC(char, strlen(FileName) + strlen(INDEXFILESUFFIX) + 1);
|
||
if (fileName) {
|
||
strcpy(fileName, FileName);
|
||
char *pFileExt = fileName + strlen(fileName);
|
||
strcpy(pFileExt, INDEXFILESUFFIX);
|
||
int delta = 0;
|
||
if (access(fileName, R_OK) == 0) {
|
||
struct stat buf;
|
||
if (stat(fileName, &buf) == 0) {
|
||
delta = buf.st_size % sizeof(tIndex);
|
||
if (delta) {
|
||
delta = sizeof(tIndex) - delta;
|
||
esyslog("ERROR: invalid file size (%ld) in '%s'", buf.st_size, fileName);
|
||
}
|
||
last = (buf.st_size + delta) / sizeof(tIndex) - 1;
|
||
if (!Record && last >= 0) {
|
||
size = last + 1;
|
||
index = MALLOC(tIndex, size);
|
||
if (index) {
|
||
f = open(fileName, O_RDONLY);
|
||
if (f >= 0) {
|
||
if ((int)safe_read(f, index, buf.st_size) != buf.st_size) {
|
||
esyslog("ERROR: can't read from file '%s'", fileName);
|
||
free(index);
|
||
index = NULL;
|
||
close(f);
|
||
f = -1;
|
||
}
|
||
// we don't close f here, see CatchUp()!
|
||
}
|
||
else
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
else
|
||
esyslog("ERROR: can't allocate %d bytes for index '%s'", size * sizeof(tIndex), fileName);
|
||
}
|
||
}
|
||
else
|
||
LOG_ERROR;
|
||
}
|
||
else if (!Record)
|
||
isyslog("missing index file %s", fileName);
|
||
if (Record) {
|
||
if ((f = open(fileName, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) >= 0) {
|
||
if (delta) {
|
||
esyslog("ERROR: padding index file with %d '0' bytes", delta);
|
||
while (delta--)
|
||
writechar(f, 0);
|
||
}
|
||
}
|
||
else
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
}
|
||
else
|
||
esyslog("ERROR: can't copy file name '%s'", FileName);
|
||
}
|
||
}
|
||
|
||
cIndexFile::~cIndexFile()
|
||
{
|
||
if (f >= 0)
|
||
close(f);
|
||
free(fileName);
|
||
free(index);
|
||
}
|
||
|
||
bool cIndexFile::CatchUp(int Index)
|
||
{
|
||
// returns true unless something really goes wrong, so that 'index' becomes NULL
|
||
if (index && f >= 0) {
|
||
cMutexLock MutexLock(&mutex);
|
||
for (int i = 0; i <= MAXINDEXCATCHUP && (Index < 0 || Index >= last); i++) {
|
||
struct stat buf;
|
||
if (fstat(f, &buf) == 0) {
|
||
if (time(NULL) - buf.st_mtime > MININDEXAGE) {
|
||
// apparently the index file is not being written any more
|
||
close(f);
|
||
f = -1;
|
||
break;
|
||
}
|
||
int newLast = buf.st_size / sizeof(tIndex) - 1;
|
||
if (newLast > last) {
|
||
if (size <= newLast) {
|
||
size *= 2;
|
||
if (size <= newLast)
|
||
size = newLast + 1;
|
||
}
|
||
index = (tIndex *)realloc(index, size * sizeof(tIndex));
|
||
if (index) {
|
||
int offset = (last + 1) * sizeof(tIndex);
|
||
int delta = (newLast - last) * sizeof(tIndex);
|
||
if (lseek(f, offset, SEEK_SET) == offset) {
|
||
if (safe_read(f, &index[last + 1], delta) != delta) {
|
||
esyslog("ERROR: can't read from index");
|
||
free(index);
|
||
index = NULL;
|
||
close(f);
|
||
f = -1;
|
||
break;
|
||
}
|
||
last = newLast;
|
||
}
|
||
else
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
else
|
||
esyslog("ERROR: can't realloc() index");
|
||
}
|
||
}
|
||
else
|
||
LOG_ERROR_STR(fileName);
|
||
if (Index < last - (i ? 2 * INDEXSAFETYLIMIT : 0) || Index > 10 * INDEXSAFETYLIMIT) // keep off the end in case of "Pause live video"
|
||
break;
|
||
sleep(1);
|
||
}
|
||
}
|
||
return index != NULL;
|
||
}
|
||
|
||
bool cIndexFile::Write(uchar PictureType, uchar FileNumber, int FileOffset)
|
||
{
|
||
if (f >= 0) {
|
||
tIndex i = { FileOffset, PictureType, FileNumber, 0 };
|
||
if (safe_write(f, &i, sizeof(i)) < 0) {
|
||
LOG_ERROR_STR(fileName);
|
||
close(f);
|
||
f = -1;
|
||
return false;
|
||
}
|
||
last++;
|
||
}
|
||
return f >= 0;
|
||
}
|
||
|
||
bool cIndexFile::Get(int Index, uchar *FileNumber, int *FileOffset, uchar *PictureType, int *Length)
|
||
{
|
||
if (CatchUp(Index)) {
|
||
if (Index >= 0 && Index < last) {
|
||
*FileNumber = index[Index].number;
|
||
*FileOffset = index[Index].offset;
|
||
if (PictureType)
|
||
*PictureType = index[Index].type;
|
||
if (Length) {
|
||
int fn = index[Index + 1].number;
|
||
int fo = index[Index + 1].offset;
|
||
if (fn == *FileNumber)
|
||
*Length = fo - *FileOffset;
|
||
else
|
||
*Length = -1; // this means "everything up to EOF" (the buffer's Read function will act accordingly)
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
int cIndexFile::GetNextIFrame(int Index, bool Forward, uchar *FileNumber, int *FileOffset, int *Length, bool StayOffEnd)
|
||
{
|
||
if (CatchUp()) {
|
||
int d = Forward ? 1 : -1;
|
||
for (;;) {
|
||
Index += d;
|
||
if (Index >= 0 && Index < last - ((Forward && StayOffEnd) ? INDEXSAFETYLIMIT : 0)) {
|
||
if (index[Index].type == I_FRAME) {
|
||
if (FileNumber)
|
||
*FileNumber = index[Index].number;
|
||
else
|
||
FileNumber = &index[Index].number;
|
||
if (FileOffset)
|
||
*FileOffset = index[Index].offset;
|
||
else
|
||
FileOffset = &index[Index].offset;
|
||
if (Length) {
|
||
// all recordings end with a non-I_FRAME, so the following should be safe:
|
||
int fn = index[Index + 1].number;
|
||
int fo = index[Index + 1].offset;
|
||
if (fn == *FileNumber)
|
||
*Length = fo - *FileOffset;
|
||
else {
|
||
esyslog("ERROR: 'I' frame at end of file #%d", *FileNumber);
|
||
*Length = -1;
|
||
}
|
||
}
|
||
return Index;
|
||
}
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int cIndexFile::Get(uchar FileNumber, int FileOffset)
|
||
{
|
||
if (CatchUp()) {
|
||
//TODO implement binary search!
|
||
int i;
|
||
for (i = 0; i < last; i++) {
|
||
if (index[i].number > FileNumber || (index[i].number == FileNumber) && index[i].offset >= FileOffset)
|
||
break;
|
||
}
|
||
return i;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// --- cFileName -------------------------------------------------------------
|
||
|
||
#include <errno.h>
|
||
#include <unistd.h>
|
||
#include "videodir.h"
|
||
|
||
#define MAXFILESPERRECORDING 255
|
||
#define RECORDFILESUFFIX "/%03d.vdr"
|
||
#define RECORDFILESUFFIXLEN 20 // some additional bytes for safety...
|
||
|
||
cFileName::cFileName(const char *FileName, bool Record, bool Blocking)
|
||
{
|
||
file = -1;
|
||
fileNumber = 0;
|
||
record = Record;
|
||
blocking = Blocking;
|
||
// Prepare the file name:
|
||
fileName = MALLOC(char, strlen(FileName) + RECORDFILESUFFIXLEN);
|
||
if (!fileName) {
|
||
esyslog("ERROR: can't copy file name '%s'", fileName);
|
||
return;
|
||
}
|
||
strcpy(fileName, FileName);
|
||
pFileNumber = fileName + strlen(fileName);
|
||
SetOffset(1);
|
||
}
|
||
|
||
cFileName::~cFileName()
|
||
{
|
||
Close();
|
||
free(fileName);
|
||
}
|
||
|
||
int cFileName::Open(void)
|
||
{
|
||
if (file < 0) {
|
||
int BlockingFlag = blocking ? 0 : O_NONBLOCK;
|
||
if (record) {
|
||
dsyslog("recording to '%s'", fileName);
|
||
file = OpenVideoFile(fileName, O_RDWR | O_CREAT | BlockingFlag);
|
||
if (file < 0)
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
else {
|
||
if (access(fileName, R_OK) == 0) {
|
||
dsyslog("playing '%s'", fileName);
|
||
file = open(fileName, O_RDONLY | BlockingFlag);
|
||
if (file < 0)
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
else if (errno != ENOENT)
|
||
LOG_ERROR_STR(fileName);
|
||
}
|
||
}
|
||
return file;
|
||
}
|
||
|
||
void cFileName::Close(void)
|
||
{
|
||
if (file >= 0) {
|
||
if ((record && CloseVideoFile(file) < 0) || (!record && close(file) < 0))
|
||
LOG_ERROR_STR(fileName);
|
||
file = -1;
|
||
}
|
||
}
|
||
|
||
int cFileName::SetOffset(int Number, int Offset)
|
||
{
|
||
if (fileNumber != Number)
|
||
Close();
|
||
if (0 < Number && Number <= MAXFILESPERRECORDING) {
|
||
fileNumber = Number;
|
||
sprintf(pFileNumber, RECORDFILESUFFIX, fileNumber);
|
||
if (record) {
|
||
if (access(fileName, F_OK) == 0) // file exists, let's try next suffix
|
||
return SetOffset(Number + 1);
|
||
else if (errno != ENOENT) { // something serious has happened
|
||
LOG_ERROR_STR(fileName);
|
||
return -1;
|
||
}
|
||
// found a non existing file suffix
|
||
}
|
||
if (Open() >= 0) {
|
||
if (!record && Offset >= 0 && lseek(file, Offset, SEEK_SET) != Offset) {
|
||
LOG_ERROR_STR(fileName);
|
||
return -1;
|
||
}
|
||
}
|
||
return file;
|
||
}
|
||
esyslog("ERROR: max number of files (%d) exceeded", MAXFILESPERRECORDING);
|
||
return -1;
|
||
}
|
||
|
||
int cFileName::NextFile(void)
|
||
{
|
||
return SetOffset(fileNumber + 1);
|
||
}
|
||
|
||
// --- Index stuff -----------------------------------------------------------
|
||
|
||
const char *IndexToHMSF(int Index, bool WithFrame)
|
||
{
|
||
static char buffer[16];
|
||
int f = (Index % FRAMESPERSEC) + 1;
|
||
int s = (Index / FRAMESPERSEC);
|
||
int m = s / 60 % 60;
|
||
int h = s / 3600;
|
||
s %= 60;
|
||
snprintf(buffer, sizeof(buffer), WithFrame ? "%d:%02d:%02d.%02d" : "%d:%02d:%02d", h, m, s, f);
|
||
return buffer;
|
||
}
|
||
|
||
int HMSFToIndex(const char *HMSF)
|
||
{
|
||
int h, m, s, f = 0;
|
||
if (3 <= sscanf(HMSF, "%d:%d:%d.%d", &h, &m, &s, &f))
|
||
return (h * 3600 + m * 60 + s) * FRAMESPERSEC + f - 1;
|
||
return 0;
|
||
}
|
||
|
||
int SecondsToFrames(int Seconds)
|
||
{
|
||
return Seconds * FRAMESPERSEC;
|
||
}
|
||
|
||
// --- ReadFrame -------------------------------------------------------------
|
||
|
||
int ReadFrame(int f, uchar *b, int Length, int Max)
|
||
{
|
||
if (Length == -1)
|
||
Length = Max; // this means we read up to EOF (see cIndex)
|
||
else if (Length > Max) {
|
||
esyslog("ERROR: frame larger than buffer (%d > %d)", Length, Max);
|
||
Length = Max;
|
||
}
|
||
int r = safe_read(f, b, Length);
|
||
if (r < 0)
|
||
LOG_ERROR;
|
||
return r;
|
||
}
|
||
|
||
|