ts.h

/*
Copyright (C) 2006  Adam Charrett

This program 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
of the License, or (at your option) any later version.

This program 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 should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

ts.h

Transport stream processing and filter management.

*/
#ifndef _TS_H
#define _TS_H

#include <stdint.h>
#include <pthread.h>

#include "types.h"
#include "dvb.h"
#include "services.h"
#include "multiplexes.h"
#include "list.h"

/*------ Transport Stream Packet Structures and macros ----*/
#define TSPACKET_SIZE (188)

typedef struct TSPacket_t
{
    uint8_t header[4];                  
    uint8_t payload[TSPACKET_SIZE - 4]; 
}
TSPacket_t;

#define TSPACKET_GETPID(packet) \
    (((((packet).header[1] & 0x1f) << 8) | ((packet).header[2] & 0xff)))

#define TSPACKET_SETPID(packet, pid) \
    do{ \
        (packet).header[1] = ((packet).header[1] & 0xe0) | ((pid >> 8) & 0x1f); \
        (packet).header[2] = pid & 0xff; \
    }while(0)

#define TSPACKET_GETCOUNT(packet) \
    ((packet).header[3] & 0x0f)

#define TSPACKET_SETCOUNT(packet, count) \
    ((packet).header[3] = ((packet).header[3] & 0xf0) | ((count) & 0x0f))

#define TSPACKET_ISPAYLOADUNITSTART(packet) \
    (((packet).header[1] & 0x40) == 0x40)

#define TSPACKET_ISVALID(packet) \
    (((packet).header[1] & 0x80) == 0x00)

#define TSPACKET_GETPRIORITY(packet) \
    (((packet).header[1] & 0x20) >> 4)

#define TSPACKET_SETPRIORITY(packet, priority) \
    ((packet).header[1] = ((packet).header[1] & 0xdf) | (((priority) << 4) & 0x20))

#define TSPACKET_GETADAPTATION(packet) \
    (((packet).header[3] & 0x30) >> 4)

#define TSPACKET_SETADAPTATION(packet, adaptation) \
    ((packet).header[3] = ((packet).header[3] & 0xcf) | (((adaptation) << 4) & 0x30))

#define TSPACKET_GETADAPTATION_LEN(packet) \
    ((packet).payload[0])


struct PIDFilter_s;

/*---- Filter function pointer type----*/
typedef void (*MultiplexChanged)(struct PIDFilter_s *pidfilter, void *userarg, Multiplex_t *multiplex);

typedef void (*TSStructureChanged)(struct PIDFilter_s *pidfilter, void *userarg);

typedef int (*PacketFilter)(struct PIDFilter_s *pidfilter, void *userarg, uint16_t pid, TSPacket_t* packet);

typedef TSPacket_t* (*PacketProcessor)(struct PIDFilter_s *pidfilter, void *userarg, TSPacket_t* packet);

typedef void (*PacketOutput)(struct PIDFilter_s *pidfilter, void *userarg, TSPacket_t* packet);

/*---- PID Filter Structures ----*/
typedef struct PIDFilter_s
{
    char *name;                            
    char *type;                            
    struct TSFilter_t *tsFilter;           
    volatile bool enabled;                 
    MultiplexChanged multiplexChanged;     
    void *mcArg;                           
    TSStructureChanged tsStructureChanged; 
    void *tscArg;                          
    PacketFilter filterPacket;             
    void *fpArg;                           
    PacketProcessor processPacket;         
    void *ppArg;                           
    PacketOutput outputPacket;             
    void *opArg;                           
    /* Variables for statistics */
    volatile unsigned long long packetsFiltered;          
    volatile unsigned long long packetsProcessed;         
    volatile unsigned long long packetsOutput;            
}PIDFilter_t;

extern char PSISIPIDFilterType[];

/*---- Simple PID Filter structures ---*/
#define MAX_PIDS 20

typedef struct PIDFilterSimpleFilter_t
{
    int pidcount;            
    uint16_t pids[MAX_PIDS]; 
}
PIDFilterSimpleFilter_t;

/*---- Transport Stream Filter structure ----*/
#define MAX_FILTERS 20

#define MAX_PACKETS 20

typedef struct TSFilter_t
{
    bool quit;                          
    TSPacket_t readBuffer[MAX_PACKETS]; 
    DVBAdapter_t *adapter;              
    pthread_t thread;                   
    bool enabled;                       
    pthread_mutex_t mutex;              
    bool multiplexChanged;              
    Multiplex_t *multiplex;             
    bool tsStructureChanged;            
    volatile unsigned long long totalPackets; 
    volatile unsigned long bitrate;     
    List_t *pidFilters;                 
}
TSFilter_t;

TSFilter_t* TSFilterCreate(DVBAdapter_t *adapter);

void TSFilterDestroy(TSFilter_t * tsfilter);

void TSFilterEnable(TSFilter_t * tsfilter, bool enable);

void TSFilterZeroStats(TSFilter_t *tsfilter);

void TSFilterMultiplexChanged(TSFilter_t *tsfilter, Multiplex_t *newmultiplex);

#define TSFilterLock(tsfilter)   pthread_mutex_lock(&(tsfilter)->mutex)

#define TSFilterUnLock(tsfilter) pthread_mutex_unlock(&(tsfilter)->mutex)

PIDFilter_t* TSFilterFindPIDFilter(TSFilter_t *tsfilter, const char *name, const char *type);

PIDFilter_t* PIDFilterAllocate(TSFilter_t* tsfilter);
void PIDFilterFree(PIDFilter_t * pidfilter);

PIDFilter_t *PIDFilterSetup(TSFilter_t *tsfilter,
                            PacketFilter filterpacket,     void *fparg,
                            PacketProcessor processpacket, void *pparg,
                            PacketOutput outputpacket,     void *oparg);

#define PIDFilterFilterPacketSet(_pidfilter, _callback, _arg) \
    do{ (_pidfilter)->fpArg = _arg; (_pidfilter)->filterPacket = _callback; } while(0)

#define PIDFilterProcessPacketSet(_pidfilter, _callback, _arg) \
    do{ (_pidfilter)->ppArg = _arg; (_pidfilter)->processPacket = _callback; } while(0)

#define PIDFilterOutputPacketSet(_pidfilter, _callback, _arg) \
    do{ (_pidfilter)->opArg = _arg; (_pidfilter)->outputPacket = _callback; } while(0)

#define PIDFilterTSStructureChangeSet(_pidfilter, _callback, _arg) \
    do{ (_pidfilter)->tscArg = _arg; (_pidfilter)->tsStructureChanged = _callback; } while(0)

#define PIDFilterMultiplexChangeSet(_pidfilter, _callback, _arg) \
    do{ (_pidfilter)->mcArg = _arg; (_pidfilter)->multiplexChanged = _callback; } while(0)

int PIDFilterSimpleFilter(PIDFilter_t *pidfilter, void *arg, uint16_t pid, TSPacket_t *packet);

#endif

---