mirror of
https://github.com/vdr-projects/vdr.git
synced 2025-03-01 10:50:46 +00:00
c84022554a
- Introduced the new function cPlugin::Initialize(), in order to be able to separate the startup of a plugin into an "early" (Initialize()) and "late" (Start()) phase (suggested by Andreas Schultz). Plugin authors should please read the section about "Getting started" in PLUGINS.html and adapt their code if applicable. - Implemented the CableDeliverySystemDescriptor and TerrestrialDeliverySystemDescriptor in libdtv (thanks to Sven Grothklags and Andreas Schultz). - Fixed keeping live video active in case the primary device doesn't have an MPEG decoder (thanks to Wolfgang Goeller for reporting this one). - Implemented cDevice::ActualDevice(), which returns the actual receiving device in case of 'Transfer Mode', or the primary device otherwise. This may be useful for plugins that want to attach a cReceiver to the device where the current live video is actually coming from. - Added VDRVERSNUM to config.h, which can be used by the preprocessor to check the actual VDR version (suggested by Stefan Huelswitt). - Removed the WaitForPut/WaitForGet stuff from cRingBuffer, since it appears to no longer be necessary due to the implementation of cNonBlockingFileReader in dvbplayer.c. Also, the long timeout in WaitForPut caused problems with cReceivers that use a ring buffer and didn't immediately return from their Receive() function if the buffer runs full (thanks to Sascha Volkenandt for reporting this one). - Fixed handling EPG data where the "extended event descriptor" comes before the "short event" or a "time shifted event" (thanks to Jonan Santiago). - Disabled the "Received stuffing section in EIT" log message. - Updated 'channels.conf.terr' for Berlin (thanks to Juri Haberland). - Avoiding short display of the "Main" menu when pressing the "Recordings" button or the "Back" button during replay. - Further increased the timeout until an index file is considerd no longer to be written. - Implemented separate PausePriority and PauseLifetime parameters for the recordings created when pausing live video (suggested by Alfred Zastrow). - Changed C++ style comments in libdtv into C style to avoid warnings in gcc 3.x (thanks to Andreas Schultz).
450 lines
16 KiB
C
450 lines
16 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
|