Version 0.92vdr-0.92

- The "channel not sync'ed" log message now also lists the card number.
- Now using the EIT services from 'libdtv' (thanks to Rolf Hakenes), which
  provides EPG information for NVOD ("Near Video On Demand") channels.
- Doing some bug fixing on the EPG data (some tv stations apparently have
  their own idea on how to fill in the data...). The level up to which EPG
  bugs are fixed can be controlled with the EPGBugfixLevel parameter in the
  "Setup" menu (see MANUAL for details, and cEventInfo::FixEpgBugs() in eit.c
  for the actual implementation).
- Fixed broken recordings after a driver buffer overflow.
- Fixed the chirping sound after Pause/Play of a DVD (thanks to Andreas
  Schultz).

1 files changed, 448 insertions, 0 deletions

diff --git a/libdtv/liblx/liblx.h b/libdtv/liblx/liblx.h
new file mode 100644
index 0000000..f2527e7
--- /dev/null
+++ b/libdtv/liblx/liblx.h
@@ -0,0 +1,448 @@
+//////////////////////////////////////////////////////////////
+///                                                        ///
+/// liblx.h: definitions necessary for the liblx package   ///
+///                                                        ///
+//////////////////////////////////////////////////////////////
+
+// $Revision: 1.1 $
+// $Date: 2001/06/26 07:18:42 $
+// $Author: kls $
+//
+//   (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