/*

* recording.c: Recording file handling

*

* See the main source file 'vdr.c' for copyright information and

* how to reach the author.

*

* $Id: recording.c 2.22 2010/01/16 11:18:30 kls Exp $

*/

#include "recording.h"

#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <math.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"

#include "ringbuffer.h"

#include "skins.h"

#include "tools.h"

#include "videodir.h"

#define SUMMARYFALLBACK

#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 command line option to see their recordings even if they forget to

enable --vfat when restarting VDR... Gee, do I hate Windows.

(kls 2002-07-27)

#define DATAFORMAT "M-d-d.d:d.d.d" RECEXT

#define NAMEFORMAT "%s/%s/" DATAFORMAT

*/

#define DATAFORMATPES "M-d-d.d%*cd.d.d" RECEXT

#define NAMEFORMATPES "%s/%s/" "M-d-d.d.d.d.d" RECEXT

#define DATAFORMATTS "M-d-d.d.d.%d-%d" RECEXT

#define NAMEFORMATTS "%s/%s/" DATAFORMATTS

#define RESUMEFILESUFFIX "/resume%s%s"

#ifdef SUMMARYFALLBACK

#define SUMMARYFILESUFFIX "/summary.vdr"

#endif

#define INFOFILESUFFIX "/info"

#define MARKSFILESUFFIX "/marks"

#define MINDISKSPACE 1024 // MB

#define REMOVECHECKDELTA 60 // seconds between checks for removing deleted files

#define DELETEDLIFETIME 300 // seconds after which a deleted recording will be actually removed

#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

#define MAX_LINK_LEVEL 6

bool VfatFileSystem = false;

int InstanceId = 0;

cRecordings DeletedRecordings(true);

// --- cRemoveDeletedRecordingsThread ----------------------------------------

class cRemoveDeletedRecordingsThread : public cThread {

protected:

virtual void Action(void);

public:

cRemoveDeletedRecordingsThread(void);

};

cRemoveDeletedRecordingsThread::cRemoveDeletedRecordingsThread(void)

:cThread("remove deleted recordings")

{

}

void cRemoveDeletedRecordingsThread::Action(void)

{

SetPriority(19);

SetIOPriority(7);

// Make sure only one instance of VDR does this:

cLockFile LockFile(VideoDirectory);

if (LockFile.Lock()) {

bool deleted = false;

cThreadLock DeletedRecordingsLock(&DeletedRecordings);

for (cRecording *r = DeletedRecordings.First(); r; ) {

if (r->deleted && time(NULL) - r->deleted > DELETEDLIFETIME) {

cRecording *next = DeletedRecordings.Next(r);

r->Remove();

DeletedRecordings.Del(r);

r = next;

deleted = true;

continue;

}

r = DeletedRecordings.Next(r);

}

if (deleted)

RemoveEmptyVideoDirectories();

}

}

static cRemoveDeletedRecordingsThread RemoveDeletedRecordingsThread;

// ---

void RemoveDeletedRecordings(void)

{

static time_t LastRemoveCheck = 0;

if (time(NULL) - LastRemoveCheck > REMOVECHECKDELTA) {

if (!RemoveDeletedRecordingsThread.Active()) {

cThreadLock DeletedRecordingsLock(&DeletedRecordings);

for (cRecording *r = DeletedRecordings.First(); r; r = DeletedRecordings.Next(r)) {

if (r->deleted && time(NULL) - r->deleted > DELETEDLIFETIME) {

RemoveDeletedRecordingsThread.Start();

break;

}

}

}

LastRemoveCheck = time(NULL);

}

}

void AssertFreeDiskSpace(int Priority, bool Force)

{

static cMutex Mutex;

cMutexLock MutexLock(&Mutex);

// 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 (Force || 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...");

cThreadLock DeletedRecordingsLock(&DeletedRecordings);

if (DeletedRecordings.Count()) {

cRecording *r = DeletedRecordings.First();

cRecording *r0 = NULL;

while (r) {

if (IsOnVideoDirectoryFileSystem(r->FileName())) { // only remove recordings that will actually increase the free video disk space

if (!r0 || r->start < r0->start)

r0 = r;

}

r = DeletedRecordings.Next(r);

}

if (r0) {

if (r0->Remove())

LastFreeDiskCheck = REMOVELATENCY / Factor;

DeletedRecordings.Del(r0);

return;

}

}

else {

// DeletedRecordings was empty, so to be absolutely sure there are no

// deleted recordings we need to double check:

DeletedRecordings.Update(true);

if (DeletedRecordings.Count())

return; // the next call will actually remove it

}

// 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...");

cThreadLock RecordingsLock(&Recordings);

if (Recordings.Count()) {

cRecording *r = Recordings.First();

cRecording *r0 = NULL;

while (r) {

if (IsOnVideoDirectoryFileSystem(r->FileName())) { // only delete recordings that will actually increase the free video disk space

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

(r->lifetime > 0 && (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");

Skins.QueueMessage(mtWarning, tr("Low disk space!"), 5, -1);

}

LastFreeDiskCheck = time(NULL);

}

}

// --- cResumeFile -----------------------------------------------------------

cResumeFile::cResumeFile(const char *FileName, bool IsPesRecording)

{

isPesRecording = IsPesRecording;

const char *Suffix = isPesRecording ? RESUMEFILESUFFIX ".vdr" : RESUMEFILESUFFIX;

fileName = MALLOC(char, strlen(FileName) strlen(Suffix) 1);

if (fileName) {

strcpy(fileName, FileName);

sprintf(fileName strlen(fileName), Suffix, 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;

}

if (isPesRecording) {

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);

}

else {

FILE *f = fopen(fileName, "r");

if (f) {

cReadLine ReadLine;

char *s;

int line = 0;

while ((s = ReadLine.Read(f)) != NULL) {

line;

char *t = skipspace(s 1);

switch (*s) {

case 'I': resume = atoi(t);

break;

default: ;

}

}

fclose(f);

}

else if (errno != ENOENT)

LOG_ERROR_STR(fileName);

}

}

return resume;

}

bool cResumeFile::Save(int Index)

{

if (fileName) {

if (isPesRecording) {

int f = open(fileName, O_WRONLY | O_CREAT | O_TRUNC, DEFFILEMODE);

if (f >= 0) {

if (safe_write(f, &Index, sizeof(Index)) < 0)

LOG_ERROR_STR(fileName);

close(f);

Recordings.ResetResume(fileName);

return true;

}

}

else {

FILE *f = fopen(fileName, "w");

if (f) {

fprintf(f, "I %d\n", Index);

fclose(f);

Recordings.ResetResume(fileName);

}

else

LOG_ERROR_STR(fileName);

return true;

}

}

return false;

}

void cResumeFile::Delete(void)

{

if (fileName) {

if (remove(fileName) < 0 && errno != ENOENT)

LOG_ERROR_STR(fileName);

Recordings.ResetResume(fileName);

}

}

// --- cRecordingInfo --------------------------------------------------------

cRecordingInfo::cRecordingInfo(const cChannel *Channel, const cEvent *Event)

{

channelID = Channel ? Channel->GetChannelID() : tChannelID::InvalidID;

channelName = Channel ? strdup(Channel->Name()) : NULL;

ownEvent = Event ? NULL : new cEvent(0);

event = ownEvent ? ownEvent : Event;

aux = NULL;

framesPerSecond = DEFAULTFRAMESPERSECOND;

priority = MAXPRIORITY;

lifetime = MAXLIFETIME;

fileName = NULL;

if (Channel) {

// Since the EPG data's component records can carry only a single

// language code, let's see whether the channel's PID data has

// more information:

cComponents *Components = (cComponents *)event->Components();

if (!Components)

Components = new cComponents;

for (int i = 0; i < MAXAPIDS; i ) {

const char *s = Channel->Alang(i);

if (*s) {

tComponent *Component = Components->GetComponent(i, 2, 3);

if (!Component)

Components->SetComponent(Components->NumComponents(), 2, 3, s, NULL);

else if (strlen(s) > strlen(Component->language))

strn0cpy(Component->language, s, sizeof(Component->language));

}

}

// There's no "multiple languages" for Dolby Digital tracks, but

// we do the same procedure here, too, in case there is no component

// information at all:

for (int i = 0; i < MAXDPIDS; i ) {

const char *s = Channel->Dlang(i);

if (*s) {

tComponent *Component = Components->GetComponent(i, 4, 0); // AC3 component according to the DVB standard

if (!Component)

Component = Components->GetComponent(i, 2, 5); // fallback "Dolby" component according to the "Premiere pseudo standard"

if (!Component)

Components->SetComponent(Components->NumComponents(), 2, 5, s, NULL);

else if (strlen(s) > strlen(Component->language))

strn0cpy(Component->language, s, sizeof(Component->language));

}

}

// The same applies to subtitles:

for (int i = 0; i < MAXSPIDS; i ) {

const char *s = Channel->Slang(i);

if (*s) {

tComponent *Component = Components->GetComponent(i, 3, 3);

if (!Component)

Components->SetComponent(Components->NumComponents(), 3, 3, s, NULL);

else if (strlen(s) > strlen(Component->language))

strn0cpy(Component->language, s, sizeof(Component->language));

}

}

if (Components != event->Components())

((cEvent *)event)->SetComponents(Components);

}

}

cRecordingInfo::cRecordingInfo(const char *FileName)

{

channelID = tChannelID::InvalidID;

channelName = NULL;

ownEvent = new cEvent(0);

event = ownEvent;

aux = NULL;

framesPerSecond = DEFAULTFRAMESPERSECOND;

priority = MAXPRIORITY;

lifetime = MAXLIFETIME;

fileName = strdup(cString::sprintf("%s%s", FileName, INFOFILESUFFIX));

}

cRecordingInfo::~cRecordingInfo()

{

delete ownEvent;

free(aux);

free(channelName);

free(fileName);

}

void cRecordingInfo::SetData(const char *Title, const char *ShortText, const char *Description)

{

if (!isempty(Title))

((cEvent *)event)->SetTitle(Title);

if (!isempty(ShortText))

((cEvent *)event)->SetShortText(ShortText);

if (!isempty(Description))

((cEvent *)event)->SetDescription(Description);

}

void cRecordingInfo::SetAux(const char *Aux)

{

free(aux);

aux = Aux ? strdup(Aux) : NULL;

}

void cRecordingInfo::SetFramesPerSecond(double FramesPerSecond)

{

framesPerSecond = FramesPerSecond;

}

bool cRecordingInfo::Read(FILE *f)

{

if (ownEvent) {

cReadLine ReadLine;

char *s;

int line = 0;

while ((s = ReadLine.Read(f)) != NULL) {

line;

char *t = skipspace(s 1);

switch (*s) {

case 'C': {

char *p = strchr(t, ' ');

if (p) {

free(channelName);

channelName = strdup(compactspace(p));

*p = 0; // strips optional channel name

}

if (*t)

channelID = tChannelID::FromString(t);

}

break;

case 'E': {

unsigned int EventID;

time_t StartTime;

int Duration;

unsigned int TableID = 0;

unsigned int Version = 0xFF;

int n = sscanf(t, "%u %ld %d %X %X", &EventID, &StartTime, &Duration, &TableID, &Version);

if (n >= 3 && n <= 5) {

ownEvent->SetEventID(EventID);

ownEvent->SetStartTime(StartTime);

ownEvent->SetDuration(Duration);

ownEvent->SetTableID(uchar(TableID));

ownEvent->SetVersion(uchar(Version));

}

}

break;

case 'F': framesPerSecond = atof(t);

break;

case 'L': lifetime = atoi(t);

break;

case 'P': priority = atoi(t);

break;

case '@': free(aux);

aux = strdup(t);

break;

case '#': break; // comments are ignored

default: if (!ownEvent->Parse(s)) {

esyslog("ERROR: EPG data problem in line %d", line);

return false;

}

break;

}

}

return true;

}

return false;

}

bool cRecordingInfo::Write(FILE *f, const char *Prefix) const

{

if (channelID.Valid())

fprintf(f, "%sC %s%s%s\n", Prefix, *channelID.ToString(), channelName ? " " : "", channelName ? channelName : "");

event->Dump(f, Prefix, true);

fprintf(f, "%sF %.10g\n", Prefix, framesPerSecond);

fprintf(f, "%sP %d\n", Prefix, priority);

fprintf(f, "%sL %d\n", Prefix, lifetime);

if (aux)

fprintf(f, "%s@ %s\n", Prefix, aux);

return true;

}

bool cRecordingInfo::Read(void)

{

bool Result = false;

if (fileName) {

FILE *f = fopen(fileName, "r");

if (f) {

if (Read(f))

Result = true;

else

esyslog("ERROR: EPG data problem in file %s", fileName);

fclose(f);

}

else if (errno != ENOENT)

LOG_ERROR_STR(fileName);

}

return Result;

}

bool cRecordingInfo::Write(void) const

{

bool Result = false;

if (fileName) {

cSafeFile f(fileName);

if (f.Open()) {

if (Write(f))

Result = true;

f.Close();

}

else

LOG_ERROR_STR(fileName);

}

return Result;

}

// --- cRecording ------------------------------------------------------------

#define RESUME_NOT_INITIALIZED (-2)

struct tCharExchange { char a; char b; };

tCharExchange CharExchange[] = {

{ FOLDERDELIMCHAR, '/' },

{ '/', FOLDERDELIMCHAR },

{ ' ', '_' },

// backwards compatibility:

{ '\'', '\'' },

{ '\'', '\x01' },

{ '/', '\x02' },

{ 0, 0 }

};

char *ExchangeChars(char *s, bool ToFileSystem)

{

char *p = s;

while (*p) {

if (VfatFileSystem) {

// The VFAT file system can't handle all characters, so we

// have to take extra efforts to encode/decode them:

if (ToFileSystem) {

const char *InvalidChars = "\"\\/:*?|<>#";

switch (*p) {

// characters that can be mapped to other characters:

case ' ': *p = '_'; break;

case FOLDERDELIMCHAR: *p = '/'; break;

// characters that have to be encoded:

default:

if (strchr(InvalidChars, *p) || *p == '.' && (!*(p 1) || *(p 1) == FOLDERDELIMCHAR)) { // Windows can't handle '.' at the end of file/directory names

int l = p - s;

s = (char *)realloc(s, strlen(s) 10);

p = s l;

char buf[4];

sprintf(buf, "#X", (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 = FOLDERDELIMCHAR; break;

// encoded characters:

case '#': {

if (strlen(p) > 2 && isxdigit(*(p 1)) && isxdigit(*(p 2))) {

char buf[3];

sprintf(buf, "%c%c", *(p 1), *(p 2));

uchar c = uchar(strtol(buf, NULL, 16));

if (c) {

*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;

default: ;

}

}

}

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;

}

}

}

p ;

}

return s;

}

cRecording::cRecording(cTimer *Timer, const cEvent *Event)

{

resume = RESUME_NOT_INITIALIZED;

titleBuffer = NULL;

sortBuffer = NULL;

fileName = NULL;

name = NULL;

fileSizeMB = -1; // unknown

channel = Timer->Channel()->Number();

instanceId = InstanceId;

isPesRecording = false;

framesPerSecond = DEFAULTFRAMESPERSECOND;

deleted = 0;

// set up the actual name:

const char *Title = Event ? Event->Title() : NULL;

const char *Subtitle = Event ? Event->ShortText() : NULL;

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:

Utf8Strn0Cpy(SubtitleBuffer, Subtitle, MAX_SUBTITLE_LENGTH);

Subtitle = SubtitleBuffer;

}

const char *macroTITLE = strstr(Timer->File(), TIMERMACRO_TITLE);

const 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);

// avoid blanks at the end:

int l = strlen(name);

while (l-- > 2) {

if (name[l] == ' ' && name[l - 1] != FOLDERDELIMCHAR)

name[l] = 0;

else

break;

}

if (Timer->IsSingleEvent()) {

Timer->SetFile(name); // this was an instant recording, so let's set the actual data

Timers.SetModified();

}

}

else if (Timer->IsSingleEvent() || !Setup.UseSubtitle)

name = strdup(Timer->File());

else

name = strdup(cString::sprintf("%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 info:

info = new cRecordingInfo(Timer->Channel(), Event);

info->SetAux(Timer->Aux());

info->priority = priority;

info->lifetime = lifetime;

}

cRecording::cRecording(const char *FileName)

{

resume = RESUME_NOT_INITIALIZED;

fileSizeMB = -1; // unknown

channel = -1;

instanceId = -1;

priority = MAXPRIORITY; // assume maximum in case there is no info file

lifetime = MAXLIFETIME;

isPesRecording = false;

framesPerSecond = DEFAULTFRAMESPERSECOND;

deleted = 0;

titleBuffer = NULL;

sortBuffer = NULL;

FileName = fileName = strdup(FileName);

if (*(fileName strlen(fileName) - 1) == '/')

*(fileName strlen(fileName) - 1) = 0;

FileName = strlen(VideoDirectory) 1;

const char *p = strrchr(FileName, '/');

name = NULL;

info = new cRecordingInfo;

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, DATAFORMATTS, &t.tm_year, &t.tm_mon, &t.tm_mday, &t.tm_hour, &t.tm_min, &channel, &instanceId)

|| 7 == sscanf(p 1, DATAFORMATPES, &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);

isPesRecording = instanceId < 0;

}

else

return;

GetResume();

// read an optional info file:

cString InfoFileName = cString::sprintf("%s%s", fileName, isPesRecording ? INFOFILESUFFIX ".vdr" : INFOFILESUFFIX);

FILE *f = fopen(InfoFileName, "r");

if (f) {

if (!info->Read(f))

esyslog("ERROR: EPG data problem in file %s", *InfoFileName);

else if (!isPesRecording) {

priority = info->priority;

lifetime = info->lifetime;

framesPerSecond = info->framesPerSecond;

}

fclose(f);

}

else if (errno != ENOENT)

LOG_ERROR_STR(*InfoFileName);

#ifdef SUMMARYFALLBACK

// fall back to the old 'summary.vdr' if there was no 'info.vdr':

if (isempty(info->Title())) {

cString SummaryFileName = cString::sprintf("%s%s", fileName, SUMMARYFILESUFFIX);

FILE *f = fopen(SummaryFileName, "r");

if (f) {

int line = 0;

char *data[3] = { NULL };

cReadLine ReadLine;

char *s;

while ((s = ReadLine.Read(f)) != NULL) {

if (*s || line > 1) {

if (data[line]) {

int len = strlen(s);

len = strlen(data[line]) 1;

data[line] = (char *)realloc(data[line], len 1);

strcat(data[line], "\n");

strcat(data[line], s);

}

else

data[line] = strdup(s);

}

else

line ;

}

fclose(f);

if (!data[2]) {

data[2] = data[1];

data[1] = NULL;

}

else if (data[1] && data[2]) {

// if line 1 is too long, it can't be the short text,

// so assume the short text is missing and concatenate

// line 1 and line 2 to be the long text:

int len = strlen(data[1]);

if (len > 80) {

data[1] = (char *)realloc(data[1], len 1 strlen(data[2]) 1);

strcat(data[1], "\n");

strcat(data[1], data[2]);

free(data[2]);

data[2] = data[1];

data[1] = NULL;

}

}

info->SetData(data[0], data[1], data[2]);

for (int i = 0; i < 3; i )

free(data[i]);

}

else if (errno != ENOENT)

LOG_ERROR_STR(*SummaryFileName);

}

#endif

}

}

cRecording::~cRecording()

{

free(titleBuffer);

free(sortBuffer);

free(fileName);

free(name);

delete info;

}

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) const

{

if (!sortBuffer) {

char *s = StripEpisodeName(strdup(FileName() strlen(VideoDirectory) 1));

strreplace(s, '/', 'a'); // some locales ignore '/' when sorting

int l = strxfrm(NULL, s, 0) 1;

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(), isPesRecording);

resume = ResumeFile.Read();

}

return resume;

}

int cRecording::Compare(const cListObject &ListObject) const

{

cRecording *r = (cRecording *)&ListObject;

return strcasecmp(SortName(), r->SortName());

}

const char *cRecording::FileName(void) const

{

if (!fileName) {

struct tm tm_r;

struct tm *t = localtime_r(&start, &tm_r);

const char *fmt = isPesRecording ? NAMEFORMATPES : NAMEFORMATTS;

int ch = isPesRecording ? priority : channel;

int ri = isPesRecording ? lifetime : instanceId;

name = ExchangeChars(name, true);

fileName = strdup(cString::sprintf(fmt, VideoDirectory, name, t->tm_year 1900, t->tm_mon 1, t->tm_mday, t->tm_hour, t->tm_min, ch, ri));

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, FOLDERDELIMCHAR)) != NULL)

s ;

else

s = name;

titleBuffer = strdup(cString::sprintf("d.d.d%cd:d%c%c%s",

t->tm_mday,

t->tm_mon 1,

t->tm_year % 100,

Delimiter,

t->tm_hour,

t->tm_min,

New,

Delimiter,

s));

// let's not display a trailing FOLDERDELIMCHAR:

if (!NewIndicator)

stripspace(titleBuffer);

s = &titleBuffer[strlen(titleBuffer) - 1];

if (*s == FOLDERDELIMCHAR)

*s = 0;

}

else if (Level < HierarchyLevels()) {

const char *s = name;

const char *p = s;

while (* s) {

if (*s == FOLDERDELIMCHAR) {

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)

{

cString 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 == FOLDERDELIMCHAR)

level ;

}

return level;

}

bool cRecording::IsEdited(void) const

{

const char *s = strrchr(name, FOLDERDELIMCHAR);

s = !s ? name : s 1;

return *s == '%';

}

bool cRecording::WriteInfo(void)

{

cString InfoFileName = cString::sprintf("%s%s", fileName, isPesRecording ? INFOFILESUFFIX ".vdr" : INFOFILESUFFIX);

FILE *f = fopen(InfoFileName, "w");

if (f) {

info->Write(f);

fclose(f);

}

else

LOG_ERROR_STR(*InfoFileName);

return true;

}

bool cRecording::Delete(void)

{

bool result = true;

char *NewName = strdup(FileName());

char *ext = strrchr(NewName, '.');

if (ext && 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());

if (access(FileName(), F_OK) == 0)

result = RenameVideoFile(FileName(), NewName);

else {

isyslog("recording '%s' vanished", FileName());

result = true; // well, we were going to delete it, anyway

}

}

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());

}

bool cRecording::Undelete(void)

{

bool result = true;

char *NewName = strdup(FileName());

char *ext = strrchr(NewName, '.');

if (ext && strcmp(ext, DELEXT) == 0) {

strncpy(ext, RECEXT, strlen(ext));

if (access(NewName, F_OK) == 0) {

// the new name already exists, so let's not remove that one:

esyslog("ERROR: attempt to undelete '%s', while recording '%s' exists", FileName(), NewName);

result = false;

}

else {

isyslog("undeleting recording '%s'", FileName());

if (access(FileName(), F_OK) == 0)

result = RenameVideoFile(FileName(), NewName);

else {

isyslog("deleted recording '%s' vanished", FileName());

result = false;

}

}

}

free(NewName);

return result;

}