mirror of
https://github.com/vdr-projects/vdr.git
synced 2025-03-01 10:50:46 +00:00
8465398c6d
- Implemented a lock file to prevent more than one instance of VDR from removing
files from the video directory at the same time.
- The new setup parameter SplitEditedFiles can be used to control whether or
not the result of an editing process shall be written into separate files.
- Fixed handling repeat function when using LIRC (thanks to Matthias Weingart).
- The shutdown program (defined with the '-s' option) now also gets the channel
number and recording title of the timer (see INSTALL).
- New channel data for 'Premiere One', 'Premiere X-Action', 'Fox Kids Türkce'
and 'N24' (thanks to Andreas Share, Ulrich Röder, Uwe Scheffler and Simon
Bauschulte). Note that if you are using the default 'channels.conf' or
'channels.conf.cable' files you may need to check any exiting timers to see
whether they still use the correct channel number.
- Fixed the "EPG bugfix" (sometimes had duplicate information in Subtitle and
Extended Description).
- Fixed checking for valid video device when setting the video mode.
- The external command 'sort' is no longer required. VDR now sorts the list of
recordings itself, making sure that recordings that stem from repeating timers
are sorted chronologically. Sorting is done according to the setting of the
current locale, so you may want to make sure LC_COLLATE is set to the desired
value (see INSTALL).
- Fixed handling 'newline' characters in EPG texts (thanks to Rolf Hakenes for
an improved version of his 'libdtv').
Newline characters are always mapped to a single "blank" in VDR, because they
would otherwise disturb the Title and Subtitle layout in the channel display
(where these are assumed to be single line texts) and would have to be
specially handled in the 'epg.data' file and the LSTE command in SVDRP.
- Mapping ` ("backtick") characters in EPG texts to ' (single quote).
- Fixed timers starting and ending at unexpected times. 'localtime()' was not
thread safe, now using localtime_r().
- Removed the "system time seen..." message.
- Fixed a bug in the replay mode display when pressing the Green or Yellow
button while in trick mode (thanks to Stefan Huelswitt)
- Closing all open file descriptors when calling external programs.
- The menu timeout now also works when pressing the "Back" button during replay
to enter the "Recordings" menu.
- Updated 'channels.conf' for the "Bundesliga" channels of Premiere World
(thanks to Helmut Schächner).
- Fixed reading timers.conf and channels.conf that contain blanks after numeric
values.
- Fixed handling trick modes near the beginning and end of a recording.
- Pressing the "Back" button while replaying a DVD now leads to the DVD menu.
449 lines
17 KiB
C
449 lines
17 KiB
C
//////////////////////////////////////////////////////////////
|
|
/// ///
|
|
/// liblx.h: definitions necessary for the liblx package ///
|
|
/// ///
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
// $Revision: 1.2 $
|
|
// $Date: 2001/06/25 19:39:00 $
|
|
// $Author: hakenes $
|
|
//
|
|
// (C) 1992-2001 Rolf Hakenes <hakenes@hippomi.de>, under the GNU GPL.
|
|
//
|
|
// liblx is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2, or (at your option)
|
|
// any later version.
|
|
//
|
|
// liblx is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You may have received a copy of the GNU General Public License
|
|
// along with liblx; see the file COPYING. If not, write to the
|
|
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
// Boston, MA 02111-1307, USA.
|
|
|
|
#ifndef LIBLX_H
|
|
#define LIBLX_H
|
|
|
|
#ifndef NULL
|
|
#define NULL 0
|
|
#endif
|
|
|
|
|
|
/*
|
|
*
|
|
* list support structures
|
|
*
|
|
*/
|
|
struct NODE
|
|
{
|
|
struct NODE *Succ;
|
|
struct NODE *Pred;
|
|
char *Name;
|
|
unsigned short HashKey;
|
|
};
|
|
|
|
struct LIST
|
|
{
|
|
struct NODE *Head;
|
|
struct NODE *Tail;
|
|
char *Name;
|
|
unsigned long Size;
|
|
};
|
|
|
|
|
|
/*
|
|
*
|
|
* memory managment structures
|
|
*
|
|
*/
|
|
struct MEM_ENTRY
|
|
{
|
|
struct MEM_ENTRY *Succ;
|
|
struct MEM_ENTRY *Pred;
|
|
unsigned long Size;
|
|
};
|
|
|
|
struct MEM_CHUNK
|
|
{
|
|
struct MEM_CHUNK *Succ;
|
|
struct MEM_CHUNK *Pred;
|
|
unsigned long Size;
|
|
struct MEM_ENTRY *FirstFreeMemEntry;
|
|
struct MEM_ENTRY *FirstUsedMemEntry;
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*
|
|
*
|
|
* list functions (package xList)
|
|
*
|
|
*/
|
|
unsigned short xHashKey (char *);
|
|
struct LIST *xNewList (char *);
|
|
struct NODE *xNewNode (char *, unsigned long);
|
|
struct NODE *xFindName (struct LIST *, char *);
|
|
/*
|
|
*
|
|
* memory management
|
|
*
|
|
*/
|
|
void xMemAllo (unsigned long, unsigned char **);
|
|
void xMemFre (unsigned char *);
|
|
void xMemFreeAll (struct MEM_CHUNK **);
|
|
void xMemMerge (struct MEM_CHUNK **);
|
|
struct MEM_CHUNK **xGetRemember (void);
|
|
void xSetRemember (struct MEM_CHUNK **);
|
|
void xPrintMemList (struct MEM_CHUNK **);
|
|
unsigned long xGetMemSize (struct MEM_CHUNK **);
|
|
extern unsigned long xAllocatedMemory;
|
|
char *xSetText (char *);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
#define MEM_CHUNK_SIZE 65536
|
|
|
|
#define xMemAlloc(size, ptr) \
|
|
xMemAllo (((unsigned long)((size))), ((unsigned char **)((ptr))))
|
|
#define xMemFree(ptr) xMemFre (((unsigned char *)((ptr))))
|
|
/*
|
|
*
|
|
* list support macros
|
|
*
|
|
*/
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xCreateNode (NodeStruct,Name) allocates a correctly sized and |
|
|
| typed node struct. |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xCreateNode(NodeStruct,Name) \
|
|
(NodeStruct) = (void *) xNewNode(Name, sizeof(*(NodeStruct)))
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xSize (List) scans for the ->Size field of a list struct |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xSize(List) ((List) ? ((struct LIST *)(List))->Size : 0)
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xName (NodeStruct) scans for the ->Node.Name of a node struct |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xName(NodeStruct) (((struct NODE *)(NodeStruct))->Name)
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xSucc (NodeStruct) scans for the ->Node.Succ of a node struct |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xSucc(NodeStruct) (((struct NODE *)(NodeStruct))->Succ)
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xPred (NodeStruct) scans for the ->Node.Pred of a node struct |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xPred(NodeStruct) (((struct NODE *)(NodeStruct))->Pred)
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xForeach(List,NodeStruct) builds a loop to process each list |
|
|
| element. |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xForeach(List,NodeStruct) \
|
|
if (List) for ((NodeStruct) = (void *) ((struct LIST *)(List))->Head; \
|
|
(NodeStruct); (NodeStruct) = (void *) xSucc (NodeStruct))
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xForeachReverse(List,NodeStruct) builds a loop to process each |
|
|
| element in reverse order. |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xForeachReverse(List,NodeStruct) \
|
|
if (List) for ((NodeStruct) = (void *) ((struct LIST *)(List))->Tail; \
|
|
NodeStruct; (NodeStruct) = (void *) xPred (NodeStruct))
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
| |
|
|
| xRemove(List,NodeStruct) unchains a node struct out of a list. |
|
|
| |
|
|
*---------------------------------------------------------------------*/
|
|
#define xRemove(List,NodeStruct) \
|
|
do \
|
|
{ \
|
|
struct NODE *TmpNode; \
|
|
struct LIST *TmpList; \
|
|
\
|
|
TmpNode = ((struct NODE *)(NodeStruct)); \
|
|
TmpList = ((struct LIST *)(List)); \
|
|
\
|
|
if (TmpNode->Pred) \
|
|
(TmpNode->Pred)->Succ = TmpNode->Succ; \
|
|
else TmpList->Head = TmpNode->Succ; \
|
|
if (TmpNode->Succ) \
|
|
(TmpNode->Succ)->Pred = TmpNode->Pred; \
|
|
else TmpList->Tail = TmpNode->Pred; \
|
|
TmpList->Size --; \
|
|
} while (0)
|
|
|
|
|
|
/*************************************************************************
|
|
* *
|
|
* function : xAddHead *
|
|
* *
|
|
* arguments : List - pointer to a LIST structure *
|
|
* *
|
|
* Node - pointer to a NODE structure *
|
|
* *
|
|
*-----------------------------------------------------------------------*
|
|
* *
|
|
* xAddHead() inserts 'Node' at the head of 'List'. *
|
|
* *
|
|
*************************************************************************/
|
|
#define xAddHead(List, NodeStruct) \
|
|
do { \
|
|
struct NODE *TmpNode; \
|
|
struct LIST *TmpList; \
|
|
\
|
|
TmpNode = ((struct NODE *)(NodeStruct)); \
|
|
TmpList = ((struct LIST *)(List)); \
|
|
\
|
|
if (TmpList->Head) { \
|
|
TmpNode->Pred = NULL; \
|
|
TmpNode->Succ = TmpList->Head; \
|
|
(TmpList->Head)->Pred = TmpNode; \
|
|
TmpList->Head = TmpNode; } \
|
|
else { \
|
|
TmpList->Head = TmpNode; \
|
|
TmpList->Tail = TmpNode; \
|
|
TmpNode->Pred = NULL; \
|
|
TmpNode->Succ = NULL; } \
|
|
TmpList->Size++; \
|
|
} while (0)
|
|
|
|
|
|
/*************************************************************************
|
|
* *
|
|
* function : xAddTail *
|
|
* *
|
|
* arguments : List - pointer to a LIST structure *
|
|
* *
|
|
* Node - pointer to a NODE structure *
|
|
* *
|
|
*-----------------------------------------------------------------------*
|
|
* *
|
|
* xAddTail() inserts 'Node' at the tail of 'List'. *
|
|
* *
|
|
*************************************************************************/
|
|
#define xAddTail(List, NodeStruct) \
|
|
do { \
|
|
struct NODE *TmpNode; \
|
|
struct LIST *TmpList; \
|
|
\
|
|
TmpNode = ((struct NODE *)(NodeStruct)); \
|
|
TmpList = ((struct LIST *)(List)); \
|
|
\
|
|
if (TmpList->Head) { \
|
|
TmpNode->Succ = NULL; \
|
|
TmpNode->Pred = TmpList->Tail; \
|
|
(TmpList->Tail)->Succ = TmpNode; \
|
|
TmpList->Tail = TmpNode; } \
|
|
else { \
|
|
TmpList->Head = TmpNode; \
|
|
TmpList->Tail = TmpNode; \
|
|
TmpNode->Pred = NULL; \
|
|
TmpNode->Succ = NULL; } \
|
|
TmpList->Size++; \
|
|
} while (0)
|
|
|
|
|
|
/*************************************************************************
|
|
* *
|
|
* function : xRemHead *
|
|
* *
|
|
* arguments : List - pointer to a LIST structure *
|
|
* *
|
|
*-----------------------------------------------------------------------*
|
|
* *
|
|
* xRemHead() removes a Node from head of 'List'. *
|
|
* *
|
|
*************************************************************************/
|
|
#define xRemHead(List) \
|
|
do { \
|
|
struct LIST *TmpList; \
|
|
\
|
|
TmpList = ((struct LIST *)(List)); \
|
|
\
|
|
if (TmpList->Head) \
|
|
{ \
|
|
TmpList->Head = (TmpList->Head)->Succ; \
|
|
if (TmpList->Head) (TmpList->Head)->Pred = NULL; \
|
|
else TmpList->Tail = NULL; \
|
|
TmpList->Size--; \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/*************************************************************************
|
|
* *
|
|
* function : xRemTail *
|
|
* *
|
|
* arguments : List - pointer to a LIST structure *
|
|
* *
|
|
*-----------------------------------------------------------------------*
|
|
* *
|
|
* xRemTail() removes a Node from the tail of 'List'. *
|
|
* *
|
|
*************************************************************************/
|
|
#define xRemTail(List) \
|
|
do { \
|
|
struct LIST *TmpList; \
|
|
\
|
|
TmpList = ((struct LIST *)(List)); \
|
|
\
|
|
if (TmpList->Tail) \
|
|
{ \
|
|
TmpList->Tail = (TmpList->Tail)->Pred; \
|
|
if (TmpList->Tail) (TmpList->Tail)->Succ = NULL; \
|
|
else TmpList->Head = NULL; \
|
|
TmpList->Size--; \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/*************************************************************************
|
|
* *
|
|
* function : xConCat *
|
|
* *
|
|
* arguments : DestinationList - pointer to the destination *
|
|
* LIST structure *
|
|
* *
|
|
* SourceList - pointer to the source LIST structure *
|
|
* *
|
|
*-----------------------------------------------------------------------*
|
|
* *
|
|
* xConCat() concats 'SourceList' with 'DestinationList' and clears *
|
|
* 'SourceList'. *
|
|
* *
|
|
*************************************************************************/
|
|
#define xConCat(DestinationList, SourceList) \
|
|
do { \
|
|
struct LIST *SrcList; \
|
|
struct LIST *DstList; \
|
|
\
|
|
SrcList = ((struct LIST *)(SourceList)); \
|
|
DstList = ((struct LIST *)(DestinationList)); \
|
|
\
|
|
if (DstList && SrcList) \
|
|
{ \
|
|
if (DstList->Head) { \
|
|
if (SrcList->Head) { \
|
|
(DstList->Tail)->Succ = SrcList->Head; \
|
|
(SrcList->Head)->Pred = DstList->Tail; \
|
|
DstList->Tail = SrcList->Tail; \
|
|
DstList->Size += SrcList->Size; \
|
|
SrcList->Size = 0; \
|
|
SrcList->Head = NULL; \
|
|
SrcList->Tail = NULL; } } \
|
|
else { \
|
|
DstList->Head = SrcList->Head; \
|
|
DstList->Tail = SrcList->Tail; \
|
|
DstList->Size += SrcList->Size; \
|
|
SrcList->Size = 0; \
|
|
SrcList->Head = NULL; \
|
|
SrcList->Tail = NULL; } \
|
|
} \
|
|
else if (SrcList) ((struct LIST *)(DestinationList)) = SrcList; \
|
|
} while (0)
|
|
|
|
|
|
|
|
#define xJoinList(SourceList, DestinationList, NodeStruct) \
|
|
do { \
|
|
struct NODE *KeyNode; \
|
|
struct NODE *TmpNode; \
|
|
struct LIST *SrcList; \
|
|
struct LIST *DstList; \
|
|
\
|
|
KeyNode = ((struct NODE *)(NodeStruct)); \
|
|
SrcList = ((struct LIST *)(SourceList)); \
|
|
DstList = ((struct LIST *)(DestinationList)); \
|
|
\
|
|
if (SrcList->Head) \
|
|
{ \
|
|
TmpNode = KeyNode->Succ; \
|
|
KeyNode->Succ = SrcList->Head; \
|
|
SrcList->Tail->Succ = TmpNode; \
|
|
SrcList->Head->Pred = KeyNode; \
|
|
if (!TmpNode) DstList->Tail = SrcList->Tail; \
|
|
else TmpNode->Pred = SrcList->Tail; \
|
|
DstList->Size += SrcList->Size; \
|
|
SrcList->Size = 0; \
|
|
SrcList->Head = NULL; \
|
|
SrcList->Tail = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define xJoin(SourceNode, DestinationList, NodeStruct) \
|
|
do { \
|
|
struct NODE *KeyNode; \
|
|
struct NODE *TmpNode; \
|
|
struct NODE *SrcNode; \
|
|
struct LIST *DstList; \
|
|
\
|
|
KeyNode = ((struct NODE *)(NodeStruct)); \
|
|
SrcNode = ((struct NODE *)(SourceNode)); \
|
|
DstList = ((struct LIST *)(DestinationList)); \
|
|
\
|
|
if (SrcNode) \
|
|
{ \
|
|
TmpNode = KeyNode->Succ; \
|
|
KeyNode->Succ = SrcNode; \
|
|
SrcNode->Succ = TmpNode; \
|
|
SrcNode->Pred = KeyNode; \
|
|
if (!TmpNode) DstList->Tail = SrcNode; \
|
|
else TmpNode->Pred = SrcNode; \
|
|
DstList->Size += 1; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define xClearList(SrcList) \
|
|
do { \
|
|
(SrcList)->Size = 0; \
|
|
(SrcList)->Head = NULL; \
|
|
(SrcList)->Tail = NULL; \
|
|
} while (0)
|
|
|
|
#define xSetName(nodestruct, name) \
|
|
do { \
|
|
struct NODE *TmpNode; \
|
|
\
|
|
TmpNode = (struct NODE *) (nodestruct); \
|
|
\
|
|
TmpNode->Name = xSetText (name); \
|
|
TmpNode->HashKey = xHashKey (name); \
|
|
} while (0)
|
|
|
|
#endif
|