frodovdr
/
vdr-plugin-streamdev
mirror of https://projects.vdr-developer.org/git/vdr-plugin-streamdev.git
1
0
Fork 0
Code Issues Releases Wiki Activity

- transfer

This commit is contained in:
lordjaxom 2005-02-11 16:44:14 +00:00
parent ab8f0c75f3
commit ad70fe8c64
15 changed files with 532 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -1,7 +1,7 @@
#
# Makefile for a Video Disk Recorder plugin
#
# $Id: Makefile,v 1.3 2005/02/10 22:24:26 lordjaxom Exp $
# $Id: Makefile,v 1.4 2005/02/11 16:44:14 lordjaxom Exp $
# The official name of this plugin.
# This name will be used in the '-P...' option of VDR to load the plugin.
@ -63,7 +63,7 @@ SERVEROBJS = $(PLUGIN)-server.o \
server/component.o server/suspend.o server/setup.o server/streamer.o \
server/livestreamer.o server/livefilter.o \
\
remux/tsremux.o remux/ts2ps.o remux/ts2es.o
remux/tsremux.o remux/ts2ps.o remux/ts2es.o remux/extern.o
ifdef DEBUG
DEFINES += -DDEBUG

27
common.c
View File

@ -1,5 +1,5 @@
/*
* $Id: common.c,v 1.3 2005/02/10 22:24:26 lordjaxom Exp $
* $Id: common.c,v 1.4 2005/02/11 16:44:14 lordjaxom Exp $
*/
#include <vdr/channels.h>
@ -18,6 +18,7 @@ const char *StreamTypes[st_Count] = {
"PES",
"PS",
"ES",
"Extern",
"", // used internally only
};
@ -47,23 +48,24 @@ char *GetNextLine(char *String, uint Length, uint &Offset) {
return NULL;
}
const cChannel *ChannelFromString(char *String, int *Apid) {
cChannel *channel = NULL;
const cChannel *ChannelFromString(const char *String, int *Apid) {
const cChannel *channel = NULL;
char *string = strdup(String);
char *ptr, *end;
int apididx = 0;
if ((ptr = strrchr(String, '+')) != NULL) {
if ((ptr = strrchr(string, '+')) != NULL) {
*(ptr++) = '\0';
apididx = strtoul(ptr, &end, 10);
Dprintf("found apididx: %d\n", apididx);
}
if (isnumber(String)) {
if (isnumber(string)) {
int temp = strtol(String, NULL, 10);
if (temp >= 1 && temp <= Channels.MaxNumber())
channel = Channels.GetByNumber(temp);
} else {
channel = Channels.GetByChannelID(tChannelID::FromString(String));
channel = Channels.GetByChannelID(tChannelID::FromString(string));
if (channel == NULL) {
int i = 1;
@ -78,22 +80,18 @@ const cChannel *ChannelFromString(char *String, int *Apid) {
if (channel != NULL && apididx > 0) {
int apid = 0, index = 1;
const int *apids = channel->Apids();
const int *dpids = channel->Dpids();
for (int i = 0; apids[i] != 0; ++i, ++index) {
Dprintf("checking apid %d\n", apids[i]);
for (int i = 0; channel->Apid(i) != 0; ++i, ++index) {
if (index == apididx) {
apid = apids[i];
apid = channel->Apid(i);
break;
}
}
if (apid == 0) {
for (int i = 0; dpids[i] != 0; ++i, ++index) {
Dprintf("checking dpid %d\n", dpids[i]);
for (int i = 0; channel->Dpid(i) != 0; ++i, ++index) {
if (index == apididx) {
apid = dpids[i];
apid = channel->Dpid(i);
break;
}
}
@ -103,6 +101,7 @@ const cChannel *ChannelFromString(char *String, int *Apid) {
*Apid = apid;
}
free(string);
return channel;
}

7
common.h
View File

@ -1,5 +1,5 @@
/*
* $Id: common.h,v 1.4 2005/02/10 22:24:26 lordjaxom Exp $
* $Id: common.h,v 1.5 2005/02/11 16:44:14 lordjaxom Exp $
*/
#ifndef VDR_STREAMDEV_COMMON_H
@ -42,7 +42,7 @@ class cChannel;
char *GetNextLine(char *String, uint Length, uint &Offset);
const cChannel *ChannelFromString(char *String, int *Apid = NULL);
const cChannel *ChannelFromString(const char *String, int *Apid = NULL);
/* Disable logging if BUFCOUNT buffer overflows occur within BUFOVERTIME
milliseconds. Enable logging again if there is no error within BUFOVERTIME
@ -65,9 +65,10 @@ enum eStreamType {
stPES,
stPS,
stES,
stExtern,
stTSPIDS,
#define st_CountSetup (stES+1)
#define st_CountSetup (stExtern+1)
#define st_Count (stTSPIDS+1)
};

91
remux/ts2es.c
View File

@ -1,4 +1,6 @@
#include "remux/ts2es.h"
#include "server/streamer.h"
#include "libdvbmpeg/transform.h"
#include "common.h"
// from VDR's remux.c
@ -8,40 +10,38 @@ class cTS2ES: public ipack {
friend void PutES(uint8_t *Buffer, int Size, void *Data);
private:
uint8_t *m_ResultBuffer;
int *m_ResultCount;
cRingBufferLinear *m_ResultBuffer;
public:
cTS2ES(uint8_t *ResultBuffer, int *ResultCount);
cTS2ES(cRingBufferLinear *ResultBuffer);
~cTS2ES();
void PutTSPacket(const uint8_t *Buffer);
};
void PutES(uint8_t *Buffer, int Size, void *Data) {
void PutES(uint8_t *Buffer, int Size, void *Data)
{
cTS2ES *This = (cTS2ES*)Data;
uint8_t payl = Buffer[8] + 9 + This->start - 1;
int count = Size - payl;
if (*This->m_ResultCount + count > RESULTBUFFERSIZE) {
esyslog("ERROR: result buffer overflow (%d + %d > %d)",
*This->m_ResultCount, count, RESULTBUFFERSIZE);
count = RESULTBUFFERSIZE - *This->m_ResultCount;
}
memcpy(This->m_ResultBuffer + *This->m_ResultCount, Buffer + payl, count);
*This->m_ResultCount += count;
int n = This->m_ResultBuffer->Put(Buffer + payl, count);
if (n != count)
esyslog("ERROR: result buffer overflow, dropped %d out of %d byte", count - n, count);
This->start = 1;
}
cTS2ES::cTS2ES(uint8_t *ResultBuffer, int *ResultCount) {
cTS2ES::cTS2ES(cRingBufferLinear *ResultBuffer)
{
m_ResultBuffer = ResultBuffer;
m_ResultCount = ResultCount;
init_ipack(this, IPACKS, PutES, 0);
data = (void*)this;
}
cTS2ES::~cTS2ES() {
cTS2ES::~cTS2ES()
{
free_ipack(this);
}
void cTS2ES::PutTSPacket(const uint8_t *Buffer) {
@ -73,16 +73,67 @@ void cTS2ES::PutTSPacket(const uint8_t *Buffer) {
}
cTS2ESRemux::cTS2ESRemux(int Pid):
cTSRemux(false) {
m_Pid = Pid;
m_Remux = new cTS2ES(m_ResultBuffer, &m_ResultCount);
m_Pid(Pid),
m_ResultBuffer(new cRingBufferLinear(WRITERBUFSIZE, IPACKS)),
m_Remux(new cTS2ES(m_ResultBuffer))
{
m_ResultBuffer->SetTimeouts(0, 100);
}
cTS2ESRemux::~cTS2ESRemux() {
cTS2ESRemux::~cTS2ESRemux()
{
delete m_Remux;
delete m_ResultBuffer;
}
void cTS2ESRemux::PutTSPacket(int Pid, const uint8_t *Data) {
if (Pid == m_Pid) m_Remux->PutTSPacket(Data);
int cTS2ESRemux::Put(const uchar *Data, int Count)
{
int used = 0;
// Make sure we are looking at a TS packet:
while (Count > TS_SIZE) {
if (Data[0] == TS_SYNC_BYTE && Data[TS_SIZE] == TS_SYNC_BYTE)
break;
Data++;
Count--;
used++;
}
if (used)
esyslog("ERROR: skipped %d byte to sync on TS packet", used);
// Convert incoming TS data into ES:
for (int i = 0; i < Count; i += TS_SIZE) {
if (Count - i < TS_SIZE)
break;
if (Data[i] != TS_SYNC_BYTE)
break;
if (m_ResultBuffer->Free() < 2 * IPACKS)
break; // A cTS2ES might write one full packet and also a small rest
int pid = cTSRemux::GetPid(Data + i + 1);
if (Data[i + 3] & 0x10) { // got payload
if (m_Pid == pid)
m_Remux->PutTSPacket(Data + i);
}
used += TS_SIZE;
}
/*
// Check if we're getting anywhere here:
if (!synced && skipped >= 0) {
if (skipped > MAXNONUSEFULDATA) {
esyslog("ERROR: no useful data seen within %d byte of video stream", skipped);
skipped = -1;
if (exitOnFailure)
cThread::EmergencyExit(true);
}
else
skipped += used;
}
*/
return used;
}

14
remux/ts2es.h
View File

@ -2,20 +2,24 @@
#define VDR_STREAMDEV_TS2ESREMUX_H
#include "remux/tsremux.h"
#include <vdr/ringbuffer.h>
class cTS2ES;
class cRingBufferLinear;
class cTS2ESRemux: public cTSRemux {
private:
int m_Pid;
cTS2ES *m_Remux;
protected:
virtual void PutTSPacket(int Pid, const uint8_t *Data);
int m_Pid;
cRingBufferLinear *m_ResultBuffer;
cTS2ES *m_Remux;
public:
cTS2ESRemux(int Pid);
virtual ~cTS2ESRemux();
int Put(const uchar *Data, int Count);
uchar *Get(int &Count) { return m_ResultBuffer->Get(Count); }
void Del(int Count) { m_ResultBuffer->Del(Count); }
};
#endif // VDR_STREAMDEV_TS2ESREMUX_H

196
remux/ts2ps.c
View File

@ -1,46 +1,49 @@
#include "remux/ts2ps.h"
#include "server/streamer.h"
#include <vdr/channels.h>
class cTS2PS {
friend void PutPES(uint8_t *Buffer, int Size, void *Data);
private:
ipack m_Ipack;
uint8_t *m_ResultBuffer;
int *m_ResultCount;
int m_Pid;
cRingBufferLinear *m_ResultBuffer;
public:
cTS2PS(uint8_t *ResultBuffer, int *ResultCount, uint8_t AudioCid = 0x00,
bool PS = false);
cTS2PS(cRingBufferLinear *ResultBuffer, int Pid, uint8_t AudioCid = 0x00);
~cTS2PS();
void PutTSPacket(const uint8_t *Buffer);
int Pid(void) const { return m_Pid; }
};
void PutPES(uint8_t *Buffer, int Size, void *Data) {
void PutPES(uint8_t *Buffer, int Size, void *Data)
{
cTS2PS *This = (cTS2PS*)Data;
if (*This->m_ResultCount + Size > RESULTBUFFERSIZE) {
esyslog("ERROR: result buffer overflow (%d + %d > %d)",
*This->m_ResultCount, Size, RESULTBUFFERSIZE);
Size = RESULTBUFFERSIZE - *This->m_ResultCount;
}
memcpy(This->m_ResultBuffer + *This->m_ResultCount, Buffer, Size);
*This->m_ResultCount += Size;
int n = This->m_ResultBuffer->Put(Buffer, Size);
if (n != Size)
esyslog("ERROR: result buffer overflow, dropped %d out of %d byte", Size - n, Size);
}
cTS2PS::cTS2PS(uint8_t *ResultBuffer, int *ResultCount, uint8_t AudioCid,
bool PS) {
cTS2PS::cTS2PS(cRingBufferLinear *ResultBuffer, int Pid, uint8_t AudioCid)
{
m_ResultBuffer = ResultBuffer;
m_ResultCount = ResultCount;
m_Pid = Pid;
init_ipack(&m_Ipack, IPACKS, PutPES, PS);
init_ipack(&m_Ipack, IPACKS, PutPES, false);
m_Ipack.cid = AudioCid;
m_Ipack.data = (void*)this;
}
cTS2PS::~cTS2PS() {
cTS2PS::~cTS2PS()
{
free_ipack(&m_Ipack);
}
void cTS2PS::PutTSPacket(const uint8_t *Buffer) {
void cTS2PS::PutTSPacket(const uint8_t *Buffer)
{
if (!Buffer)
return;
@ -68,37 +71,140 @@ void cTS2PS::PutTSPacket(const uint8_t *Buffer) {
instant_repack((uint8_t*)(Buffer + 4 + off), TS_SIZE - 4 - off, &m_Ipack);
}
cTS2PSRemux::cTS2PSRemux(int VPid, int APid1, int APid2, int DPid1,
int DPid2, bool PS) {
m_VPid = VPid;
m_APid1 = APid1;
m_APid2 = APid2;
m_DPid1 = DPid1;
m_DPid2 = DPid2;
m_VRemux = new cTS2PS(m_ResultBuffer, &m_ResultCount, 0x00, PS);
m_ARemux1 = new cTS2PS(m_ResultBuffer, &m_ResultCount, 0xC0, PS);
m_ARemux2 = APid2 ? new cTS2PS(m_ResultBuffer, &m_ResultCount, 0xC1, PS)
: NULL;
m_DRemux1 = DPid1 ? new cTS2PS(m_ResultBuffer, &m_ResultCount, 0x00, PS)
: NULL;
//XXX don't yet know how to tell apart primary and secondary DD data...
m_DRemux2 = /*XXX m_DPid2 ? new cTS2PS(m_ResultBuffer, &m_ResultCount,
0x00, PS) : XXX*/ NULL;
cTS2PSRemux::cTS2PSRemux(int VPid, const int *APids, const int *DPids, const int *SPids):
m_NumTracks(0),
m_ResultBuffer(new cRingBufferLinear(WRITERBUFSIZE, IPACKS)),
m_ResultSkipped(0),
m_Skipped(0),
m_Synced(false),
m_IsRadio(VPid == 0 || VPid == 1 || VPid == 0x1FFF)
{
m_ResultBuffer->SetTimeouts(0, 100);
if (VPid)
m_Remux[m_NumTracks++] = new cTS2PS(m_ResultBuffer, VPid);
if (APids) {
int n = 0;
while (*APids && m_NumTracks < MAXTRACKS && n < MAXAPIDS)
m_Remux[m_NumTracks++] = new cTS2PS(m_ResultBuffer, *APids++, 0xC0 + n++);
}
if (DPids) {
int n = 0;
while (*DPids && m_NumTracks < MAXTRACKS && n < MAXDPIDS)
m_Remux[m_NumTracks++] = new cTS2PS(m_ResultBuffer, *DPids++, 0x80 + n++);
}
}
cTS2PSRemux::~cTS2PSRemux() {
if (m_DRemux2) delete m_DRemux2;
if (m_DRemux1) delete m_DRemux1;
if (m_ARemux2) delete m_ARemux2;
delete m_ARemux1;
delete m_VRemux;
for (int i = 0; i < m_NumTracks; ++i)
delete m_Remux[i];
delete m_ResultBuffer;
}
void cTS2PSRemux::PutTSPacket(int Pid, const uint8_t *Data) {
if (Pid == m_VPid) m_VRemux->PutTSPacket(Data);
else if (Pid == m_APid1) m_ARemux1->PutTSPacket(Data);
else if (Pid == m_APid2 && m_ARemux2) m_ARemux2->PutTSPacket(Data);
else if (Pid == m_DPid1 && m_DRemux1) m_DRemux1->PutTSPacket(Data);
else if (Pid == m_DPid2 && m_DRemux2) m_DRemux2->PutTSPacket(Data);
int cTS2PSRemux::Put(const uchar *Data, int Count)
{
int used = 0;
// Make sure we are looking at a TS packet:
while (Count > TS_SIZE) {
if (Data[0] == TS_SYNC_BYTE && Data[TS_SIZE] == TS_SYNC_BYTE)
break;
Data++;
Count--;
used++;
}
if (used)
esyslog("ERROR: m_Skipped %d byte to sync on TS packet", used);
// Convert incoming TS data into multiplexed PS:
for (int i = 0; i < Count; i += TS_SIZE) {
if (Count - i < TS_SIZE)
break;
if (Data[i] != TS_SYNC_BYTE)
break;
if (m_ResultBuffer->Free() < 2 * IPACKS)
break; // A cTS2PS might write one full packet and also a small rest
int pid = GetPid(Data + i + 1);
if (Data[i + 3] & 0x10) { // got payload
for (int t = 0; t < m_NumTracks; t++) {
if (m_Remux[t]->Pid() == pid) {
m_Remux[t]->PutTSPacket(Data + i);
break;
}
}
}
used += TS_SIZE;
}
// Check if we're getting anywhere here:
if (!m_Synced && m_Skipped >= 0)
m_Skipped += used;
return used;
}
uchar *cTS2PSRemux::Get(int &Count)
{
// Remove any previously skipped data from the result buffer:
if (m_ResultSkipped > 0) {
m_ResultBuffer->Del(m_ResultSkipped);
m_ResultSkipped = 0;
}
// Special VPID case to enable recording radio channels:
if (m_IsRadio) {
// Force syncing of radio channels to avoid "no useful data" error
m_Synced = true;
return m_ResultBuffer->Get(Count);
}
// Check for frame borders:
Count = 0;
uchar *resultData = NULL;
int resultCount = 0;
uchar *data = m_ResultBuffer->Get(resultCount);
if (data) {
for (int i = 0; i < resultCount - 3; i++) {
if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1) {
int l = 0;
uchar StreamType = data[i + 3];
if (VIDEO_STREAM_S <= StreamType && StreamType <= VIDEO_STREAM_E) {
uchar pt = NO_PICTURE;
l = ScanVideoPacket(data, resultCount, i, pt);
if (l < 0)
return resultData;
if (pt != NO_PICTURE) {
if (pt < I_FRAME || B_FRAME < pt) {
esyslog("ERROR: unknown picture type '%d'", pt);
}
else if (!m_Synced) {
if (pt == I_FRAME) {
m_ResultSkipped = i; // will drop everything before this position
SetBrokenLink(data + i, l);
m_Synced = true;
}
}
else if (Count)
return resultData;
}
} else {
l = GetPacketLength(data, resultCount, i);
if (l < 0)
return resultData;
}
if (m_Synced) {
if (!Count)
resultData = data + i;
Count += l;
} else
m_ResultSkipped = i + l;
if (l > 0)
i += l - 1; // the loop increments, too
}
}
}
return resultData;
}

23
remux/ts2ps.h
View File

@ -2,21 +2,28 @@
#define VDR_STREAMDEV_TS2PESREMUX_H
#include "remux/tsremux.h"
#include <vdr/remux.h>
#include <vdr/ringbuffer.h>
class cTS2PS;
class cTS2PSRemux: public cTSRemux {
private:
int m_VPid, m_APid1, m_APid2, m_DPid1, m_DPid2;
cTS2PS *m_VRemux, *m_ARemux1, *m_ARemux2, *m_DRemux1, *m_DRemux2;
protected:
virtual void PutTSPacket(int Pid, const uint8_t *Data);
int m_NumTracks;
cTS2PS *m_Remux[MAXTRACKS];
cRingBufferLinear *m_ResultBuffer;
int m_ResultSkipped;
int m_Skipped;
bool m_Synced;
bool m_IsRadio;
public:
cTS2PSRemux(int VPid, int APid1, int APid2, int DPid1, int DPid2,
bool PS = false);
cTS2PSRemux(int VPid, const int *Apids, const int *Dpids, const int *Spids);
virtual ~cTS2PSRemux();
int Put(const uchar *Data, int Count);
uchar *Get(int &Count);
void Del(int Count) { m_ResultBuffer->Del(Count); }
};
#endif // VDR_STREAMDEV_TS2PESREMUX_H

212
remux/tsremux.c
View File

@ -1,176 +1,10 @@
#include "remux/tsremux.h"
// from VDR's remux.c
#define MAXNONUSEFULDATA (10*1024*1024)
#define SC_PICTURE 0x00 // "picture header"
#define VIDEO_STREAM_S 0xE0
cTSRemux::cTSRemux(bool Sync) {
m_ResultCount = 0;
m_ResultDelivered = 0;
m_Synced = false;
m_Skipped = 0;
m_Sync = Sync;
}
cTSRemux::~cTSRemux(void) {
}
uchar *cTSRemux::Process(const uchar *Data, int &Count, int &Result) {
// Remove any previously delivered data from the result buffer:
if (m_ResultDelivered) {
if (m_ResultDelivered < m_ResultCount)
memmove(m_ResultBuffer, m_ResultBuffer + m_ResultDelivered, m_ResultCount
- m_ResultDelivered);
m_ResultCount -= m_ResultDelivered;
m_ResultDelivered = 0;
}
int used = 0;
// Make sure we are looking at a TS packet:
while (Count > TS_SIZE) {
if (Data[0] == 0x47 && Data[TS_SIZE] == 0x47)
break;
Data++;
Count--;
used++;
}
if (used)
esyslog("ERROR: skipped %d byte to sync on TS packet", used);
// Convert incoming TS data
for (int i = 0; i < Count; i += TS_SIZE) {
if (Count - i < TS_SIZE)
break;
if (Data[i] != 0x47)
break;
int pid = get_pid((uint8_t*)(Data + i + 1));
if (Data[i + 3] & 0x10) // got payload
PutTSPacket(pid, Data + i);
/*if (pid == m_VPid) m_VRemux->ConvertTSPacket(Data + i);
else if (pid == m_APid1) m_ARemux1->ConvertTSPacket(Data + i);
else if (pid == m_APid2 && m_ARemux2) m_ARemux2->ConvertTSPacket(Data + i);
else if (pid == m_DPid1 && m_DRemux1) m_DRemux1->ConvertTSPacket(Data + i);
else if (pid == m_DPid2 && m_DRemux2) m_DRemux2->ConvertTSPacket(Data + i);*/
used += TS_SIZE;
if (m_ResultCount > (int)sizeof(m_ResultBuffer) / 2)
break;
}
Count = used;
// When we don't need to sync, we don't need to sync :-)
if (!m_Sync) {
Result = m_ResultDelivered = m_ResultCount;
return Result ? m_ResultBuffer : NULL;
}
// Check if we're getting anywhere here:
if (!m_Synced && m_Skipped >= 0) {
if (m_Skipped > MAXNONUSEFULDATA) {
esyslog("ERROR: no useful data seen within %d byte of video stream", m_Skipped);
m_Skipped = -1;
//if (exitOnFailure)
//cThread::EmergencyExit(true);
}
else
m_Skipped += Count;
}
// Check for frame borders:
if (m_ResultCount > 0) {
for (int i = 0; i < m_ResultCount; i++) {
if (m_ResultBuffer[i] == 0 && m_ResultBuffer[i + 1] == 0 && m_ResultBuffer[i + 2] == 1) {
switch (m_ResultBuffer[i + 3]) {
case VIDEO_STREAM_S ... VIDEO_STREAM_E:
{
uchar pt = NO_PICTURE;
int l = ScanVideoPacket(m_ResultBuffer, m_ResultCount, i, pt);
if (l < 0)
return NULL; // no useful data found, wait for more
if (pt != NO_PICTURE) {
if (pt < I_FRAME || B_FRAME < pt)
esyslog("ERROR: unknown picture type '%d'", pt);
else if (!m_Synced) {
if (pt == I_FRAME) {
m_ResultDelivered = i; // will drop everything before this position
SetBrokenLink(m_ResultBuffer + i, l);
m_Synced = true;
}
else {
m_ResultDelivered = i + l; // will drop everything before and including this packet
return NULL;
}
}
}
if (m_Synced) {
Result = l;
uchar *p = m_ResultBuffer + m_ResultDelivered;
m_ResultDelivered += l;
return p;
}
else {
m_ResultDelivered = i + l; // will drop everything before and including this packet
return NULL;
}
}
break;
case PRIVATE_STREAM1:
case AUDIO_STREAM_S ... AUDIO_STREAM_E:
{
int l = GetPacketLength(m_ResultBuffer, m_ResultCount, i);
if (l < 0)
return NULL; // no useful data found, wait for more
if (m_Synced) {
Result = l;
uchar *p = m_ResultBuffer + m_ResultDelivered;
m_ResultDelivered += l;
return p;
}
else {
m_ResultDelivered = i + l; // will drop everything before and including this packet
return NULL;
}
}
break;
}
}
}
}
return NULL; // no useful data found, wait for more
}
int cTSRemux::ScanVideoPacket(const uchar *Data, int Count, int Offset, uchar &PictureType) {
// Scans the video packet starting at Offset and returns its length.
// If the return value is -1 the packet was not completely in the buffer.
int Length = GetPacketLength(Data, Count, Offset);
if (Length > 0 && Offset + Length <= Count) {
int i = Offset + 8; // the minimum length of the video packet header
i += Data[i] + 1; // possible additional header bytes
for (; i < Offset + Length; i++) {
if (Data[i] == 0 && Data[i + 1] == 0 && Data[i + 2] == 1) {
switch (Data[i + 3]) {
case SC_PICTURE: PictureType = (Data[i + 5] >> 3) & 0x07;
return Length;
}
}
}
PictureType = NO_PICTURE;
return Length;
}
return -1;
}
int cTSRemux::GetPacketLength(const uchar *Data, int Count, int Offset) {
// Returns the entire length of the packet starting at offset, or -1 in case of error.
return (Offset + 5 < Count) ? (Data[Offset + 4] << 8) + Data[Offset + 5] + 6 : -1;
}
void cTSRemux::SetBrokenLink(uchar *Data, int Length) {
if (Length > 9 && Data[0] == 0 && Data[1] == 0 && Data[2] == 1 && (Data[3] & VIDEO_STREAM_S) == VIDEO_STREAM_S) {
void cTSRemux::SetBrokenLink(uchar *Data, int Length)
{
if (Length > 9 && Data[0] == 0 && Data[1] == 0 && Data[2] == 1 && (Data[3] & 0xF0) == VIDEO_STREAM_S) {
for (int i = Data[8] + 9; i < Length - 7; i++) { // +9 to skip video packet header
if (Data[i] == 0 && Data[i + 1] == 0 && Data[i + 2] == 1 && Data[i + 3] == 0xB8) {
if (!(Data[i + 7] & 0x40)) // set flag only if GOP is not closed
@ -183,3 +17,43 @@ void cTSRemux::SetBrokenLink(uchar *Data, int Length) {
else
dsyslog("SetBrokenLink: no video packet in frame");
}
int cTSRemux::GetPid(const uchar *Data)
{
return (((uint16_t)Data[0] & PID_MASK_HI) << 8) | (Data[1] & 0xFF);
}
int cTSRemux::GetPacketLength(const uchar *Data, int Count, int Offset)
{
// Returns the length of the packet starting at Offset, or -1 if Count is
// too small to contain the entire packet.
int Length = (Offset + 5 < Count) ? (Data[Offset + 4] << 8) + Data[Offset + 5] + 6 : -1;
if (Length > 0 && Offset + Length <= Count)
return Length;
return -1;
}
int cTSRemux::ScanVideoPacket(const uchar *Data, int Count, int Offset, uchar &PictureType)
{
// Scans the video packet starting at Offset and returns its length.
// If the return value is -1 the packet was not completely in the buffer.
int Length = GetPacketLength(Data, Count, Offset);
if (Length > 0) {
if (Length >= 8) {
int i = Offset + 8; // the minimum length of the video packet header
i += Data[i] + 1; // possible additional header bytes
for (; i < Offset + Length - 5; i++) {
if (Data[i] == 0 && Data[i + 1] == 0 && Data[i + 2] == 1) {
switch (Data[i + 3]) {
case SC_PICTURE: PictureType = (Data[i + 5] >> 3) & 0x07;
return Length;
}
}
}
}
PictureType = NO_PICTURE;
return Length;
}
return -1;
}

9
remux/tsremux.h
View File

@ -8,15 +8,13 @@
class cTSRemux {
protected:
uchar m_ResultBuffer[RESULTBUFFERSIZE];
/*uchar m_ResultBuffer[RESULTBUFFERSIZE];
int m_ResultCount;
int m_ResultDelivered;
int m_Synced;
int m_Skipped;
int m_Sync;
int GetPacketLength(const uchar *Data, int Count, int Offset);
int ScanVideoPacket(const uchar *Data, int Count, int Offset, uchar &PictureType);
virtual void PutTSPacket(int Pid, const uint8_t *Data) = 0;
@ -24,9 +22,12 @@ public:
cTSRemux(bool Sync = true);
virtual ~cTSRemux();
virtual uchar *Process(const uchar *Data, int &Count, int &Result);
virtual uchar *Process(const uchar *Data, int &Count, int &Result);*/
static void SetBrokenLink(uchar *Data, int Length);
static int GetPid(const uchar *Data);
static int GetPacketLength(const uchar *Data, int Count, int Offset);
static int ScanVideoPacket(const uchar *Data, int Count, int Offset, uchar &PictureType);
};
#endif // VDR_STREAMDEV_TSREMUX_H

193
server/connectionHTTP.c
View File

@ -1,75 +1,80 @@
/*
* $Id: connectionHTTP.c,v 1.6 2005/02/10 22:24:26 lordjaxom Exp $
* $Id: connectionHTTP.c,v 1.7 2005/02/11 16:44:15 lordjaxom Exp $
*/
#include "server/connectionHTTP.h"
#include "server/livestreamer.h"
#include "server/setup.h"
cConnectionHTTP::cConnectionHTTP(void): cServerConnection("HTTP") {
m_Channel = NULL;
m_Apid = 0;
m_ListChannel = NULL;
m_LiveStreamer = NULL;
m_Status = hsRequest;
m_StreamType = (eStreamType)StreamdevServerSetup.HTTPStreamType;
m_Startup = false;
cConnectionHTTP::cConnectionHTTP(void):
cServerConnection("HTTP"),
m_Status(hsRequest),
m_LiveStreamer(NULL),
m_Channel(NULL),
m_Apid(0),
m_StreamType((eStreamType)StreamdevServerSetup.HTTPStreamType),
m_ListChannel(NULL)
{
Dprintf("constructor hsRequest\n");
}
cConnectionHTTP::~cConnectionHTTP() {
if (m_LiveStreamer != NULL) delete m_LiveStreamer;
cConnectionHTTP::~cConnectionHTTP()
{
delete m_LiveStreamer;
}
void cConnectionHTTP::Detach(void) {
if (m_LiveStreamer != NULL) m_LiveStreamer->Detach();
}
void cConnectionHTTP::Attach(void) {
if (m_LiveStreamer != NULL) m_LiveStreamer->Attach();
}
bool cConnectionHTTP::Command(char *Cmd) {
bool cConnectionHTTP::Command(char *Cmd)
{
Dprintf("command %s\n", Cmd);
switch (m_Status) {
case hsRequest:
if (strncmp(Cmd, "GET ", 4) == 0) return CmdGET(Cmd + 4);
else {
DeferClose();
m_Status = hsTransfer; // Ignore following lines
return Respond("HTTP/1.0 400 Bad Request");
}
break;
Dprintf("Request\n");
m_Request = Cmd;
m_Status = hsHeaders;
return true;
case hsHeaders:
if (*Cmd == '\0') {
if (m_ListChannel != NULL) {
m_Status = hsListing;
return Respond("HTTP/1.0 200 OK")
&& Respond("Content-Type: text/html")
&& Respond("")
&& Respond("<html><head><title>VDR Channel Listing</title></head>")
&& Respond("<body><ul>");
} else if (m_Channel == NULL) {
m_Status = hsBody;
return ProcessRequest();
}
Dprintf("header\n");
return true;
}
return false; // ??? shouldn't happen
}
bool cConnectionHTTP::ProcessRequest(void) {
Dprintf("process\n");
if (m_Request.substr(0, 4) == "GET " && CmdGET(m_Request.substr(4))) {
switch (m_Job) {
case hjListing:
return Respond("HTTP/1.0 200 OK")
&& Respond("Content-Type: text/html")
&& Respond("")
&& Respond("<html><head><title>VDR Channel Listing</title></head>")
&& Respond("<body><ul>");
case hjTransfer:
if (m_Channel == NULL) {
DeferClose();
return Respond("HTTP/1.0 404 not found");
}
m_Status = hsTransfer;
m_LiveStreamer = new cStreamdevLiveStreamer(0);
cDevice *device = GetDevice(m_Channel, 0);
if (device != NULL) {
device->SwitchChannel(m_Channel, false);
if (m_LiveStreamer->SetChannel(m_Channel, m_StreamType, m_Apid)) {
m_LiveStreamer->SetDevice(device);
m_Startup = true;
if (m_StreamType == stES && (m_Channel->Vpid() == 0
|| m_Channel->Vpid() == 1 || m_Channel->Vpid() == 0x1FFF)) {
if (m_StreamType == stES && (m_Apid != 0 || ISRADIO(m_Channel))) {
return Respond("HTTP/1.0 200 OK")
&& Respond("Content-Type: audio/mpeg")
&& Respond((std::string)"icy-name: " + m_Channel->Name())
&& Respond("");
&& Respond("Content-Type: audio/mpeg")
&& Respond((std::string)"icy-name: " + m_Channel->Name())
&& Respond("");
} else {
return Respond("HTTP/1.0 200 OK")
&& Respond("Content-Type: video/mpeg")
&& Respond("");
&& Respond("Content-Type: video/mpeg")
&& Respond("");
}
}
}
@ -77,78 +82,110 @@ bool cConnectionHTTP::Command(char *Cmd) {
DeferClose();
return Respond("HTTP/1.0 409 Channel not available");
}
break;
default:
break;
}
return true;
DeferClose();
return Respond("HTTP/1.0 400 Bad Request");
}
void cConnectionHTTP::Flushed(void) {
if (m_Status == hsListing) {
std::string line;
if (m_Status != hsBody)
return;
switch (m_Job) {
case hjListing:
if (m_ListChannel == NULL) {
Respond("</ul></body></html>");
DeferClose();
m_Status = hsFinished;
return;
}
std::string line;
if (m_ListChannel->GroupSep())
line = (std::string)"<li>--- " + m_ListChannel->Name() + "---</li>";
else
else {
int index = 1;
line = (std::string)"<li><a href=\"http://" + LocalIp() + ":"
+ (const char*)itoa(StreamdevServerSetup.HTTPServerPort) + "/"
+ StreamTypes[m_StreamType] + "/"
+ (const char*)m_ListChannel->GetChannelID().ToString() + "\">"
+ m_ListChannel->Name() + "</a></li>";
+ m_ListChannel->Name() + "</a> ";
for (int i = 0; m_ListChannel->Apid(i) != 0; ++i, ++index) {
line += "<a href=\"http://" + LocalIp() + ":"
+ (const char*)itoa(StreamdevServerSetup.HTTPServerPort) + "/"
+ StreamTypes[m_StreamType] + "/"
+ (const char*)m_ListChannel->GetChannelID().ToString() + "+"
+ (const char*)itoa(index) + "\">("
+ m_ListChannel->Alang(i) + ")</a> ";
}
for (int i = 0; m_ListChannel->Dpid(i) != 0; ++i, ++index) {
line += "<a href=\"http://" + LocalIp() + ":"
+ (const char*)itoa(StreamdevServerSetup.HTTPServerPort) + "/"
+ StreamTypes[m_StreamType] + "/"
+ (const char*)m_ListChannel->GetChannelID().ToString() + "+"
+ (const char*)itoa(index) + "\">("
+ m_ListChannel->Dlang(i) + ")</a> ";
}
line += "</li>";
}
if (!Respond(line))
DeferClose();
m_ListChannel = Channels.Next(m_ListChannel);
} else if (m_Startup) {
break;
case hjTransfer:
Dprintf("streamer start\n");
m_LiveStreamer->Start(this);
m_Startup = false;
m_Status = hsFinished;
break;
}
}
bool cConnectionHTTP::CmdGET(char *Opts) {
bool cConnectionHTTP::CmdGET(const std::string &Opts) {
const char *sp = Opts.c_str(), *ptr = sp, *ep;
const cChannel *chan;
char *ep;
int apid = 0;
int apid = 0, pos;
Opts = skipspace(Opts);
while (*Opts == '/')
++Opts;
ptr = skipspace(ptr);
while (*ptr == '/')
++ptr;
if (strncasecmp(Opts, "PS/", 3) == 0) {
if (strncasecmp(ptr, "PS/", 3) == 0) {
m_StreamType = stPS;
Opts+=3;
} else if (strncasecmp(Opts, "PES/", 4) == 0) {
ptr += 3;
} else if (strncasecmp(ptr, "PES/", 4) == 0) {
m_StreamType = stPES;
Opts+=4;
} else if (strncasecmp(Opts, "TS/", 3) == 0) {
ptr += 4;
} else if (strncasecmp(ptr, "TS/", 3) == 0) {
m_StreamType = stTS;
Opts+=3;
} else if (strncasecmp(Opts, "ES/", 3) == 0) {
ptr += 3;
} else if (strncasecmp(ptr, "ES/", 3) == 0) {
m_StreamType = stES;
Opts+=3;
ptr += 3;
} else if (strncasecmp(ptr, "Extern/", 3) == 0) {
m_StreamType = stExtern;
ptr += 7;
}
while (*Opts == '/')
++Opts;
for (ep = Opts + strlen(Opts); ep >= Opts && !isspace(*ep); --ep)
while (*ptr == '/')
++ptr;
for (ep = ptr + strlen(ptr); ep >= ptr && !isspace(*ep); --ep)
;
*ep = '\0';
std::string filespec = Opts.substr(ptr - sp, ep - ptr);
Dprintf("substr: %s\n", filespec.c_str());
Dprintf("before channelfromstring\n");
if (strncmp(Opts, "channels.htm", 12) == 0) {
if (filespec == "" || filespec.substr(0, 12) == "channels.htm") {
m_ListChannel = Channels.First();
m_Status = hsHeaders;
} else if ((chan = ChannelFromString(Opts, &apid)) != NULL) {
m_Job = hjListing;
} else if ((chan = ChannelFromString(filespec.c_str(), &apid)) != NULL) {
m_Channel = chan;
m_Apid = apid;
Dprintf("Apid is %d\n", apid);
m_Status = hsHeaders;
m_Job = hjTransfer;
}
Dprintf("after channelfromstring\n");
return true;

39
server/connectionHTTP.h
View File

@ -1,11 +1,12 @@
/*
* $Id: connectionHTTP.h,v 1.2 2005/02/10 22:24:26 lordjaxom Exp $
* $Id: connectionHTTP.h,v 1.3 2005/02/11 16:44:15 lordjaxom Exp $
*/
#ifndef VDR_STREAMDEV_SERVERS_CONNECTIONHTTP_H
#define VDR_STREAMDEV_SERVERS_CONNECTIONHTTP_H
#include "connection.h"
#include "server/livestreamer.h"
#include <tools/select.h>
@ -17,27 +18,39 @@ private:
enum eHTTPStatus {
hsRequest,
hsHeaders,
hsTransfer,
hsListing,
hsBody,
hsFinished,
};
const cChannel *m_Channel;
int m_Apid;
const cChannel *m_ListChannel;
cStreamdevLiveStreamer *m_LiveStreamer;
eStreamType m_StreamType;
eHTTPStatus m_Status;
bool m_Startup;
enum eHTTPJob {
hjTransfer,
hjListing,
};
std::string m_Request;
//std::map<std::string,std::string> m_Headers; TODO: later?
eHTTPStatus m_Status;
eHTTPJob m_Job;
// job: transfer
cStreamdevLiveStreamer *m_LiveStreamer;
const cChannel *m_Channel;
int m_Apid;
eStreamType m_StreamType;
// job: listing
const cChannel *m_ListChannel;
protected:
bool ProcessRequest(void);
public:
cConnectionHTTP(void);
virtual ~cConnectionHTTP();
virtual void Detach(void);
virtual void Attach(void);
virtual void Attach(void) { if (m_LiveStreamer != NULL) m_LiveStreamer->Attach(); }
virtual void Detach(void) { if (m_LiveStreamer != NULL) m_LiveStreamer->Detach(); }
virtual bool Command(char *Cmd);
bool CmdGET(char *Opts);
bool CmdGET(const std::string &Opts);
virtual void Flushed(void);
};

75
server/livestreamer.c
View File

@ -3,6 +3,7 @@
#include "server/livestreamer.h"
#include "remux/ts2ps.h"
#include "remux/ts2es.h"
#include "remux/extern.h"
#include "common.h"
// --- cStreamdevLiveReceiver -------------------------------------------------
@ -37,15 +38,21 @@ cStreamdevLiveStreamer::cStreamdevLiveStreamer(int Priority):
m_Device(NULL),
m_Receiver(NULL),
m_PESRemux(NULL),
m_Remux(NULL)
m_ESRemux(NULL),
m_PSRemux(NULL),
m_ExtRemux(NULL)
{
}
cStreamdevLiveStreamer::~cStreamdevLiveStreamer()
{
Dprintf("Desctructing Live streamer\n");
Stop();
delete m_Receiver;
delete m_Remux;
delete m_PESRemux;
delete m_ESRemux;
delete m_PSRemux;
delete m_ExtRemux;
#if VDRVERSNUM >= 10300
//delete m_Filter; TODO
#endif
@ -104,7 +111,7 @@ bool cStreamdevLiveStreamer::SetChannel(const cChannel *Channel, eStreamType Str
int pid = ISRADIO(m_Channel) ? m_Channel->Apid(0) : m_Channel->Vpid();
if (Apid != 0)
pid = Apid;
m_Remux = new cTS2ESRemux(pid);
m_ESRemux = new cTS2ESRemux(pid);
return SetPid(pid, true);
}
@ -121,9 +128,15 @@ bool cStreamdevLiveStreamer::SetChannel(const cChannel *Channel, eStreamType Str
&& SetPid(m_Channel->Dpid(0), true);
case stPS:
m_Remux = new cTS2PSRemux(m_Channel->Vpid(), m_Channel->Apid(0), 0, 0, 0, true);
return SetPid(m_Channel->Vpid(), true)
&& SetPid(m_Channel->Apid(0), true);
m_PSRemux = new cTS2PSRemux(m_Channel->Vpid(), m_Channel->Apids(), m_Channel->Dpids(),
m_Channel->Spids());
if (Apid != 0)
return SetPid(m_Channel->Vpid(), true)
&& SetPid(Apid, true);
else
return SetPid(m_Channel->Vpid(), true)
&& SetPid(m_Channel->Apid(0), true)
&& SetPid(m_Channel->Dpid(0), true);
case stTS:
if (Apid != 0)
@ -134,6 +147,17 @@ bool cStreamdevLiveStreamer::SetChannel(const cChannel *Channel, eStreamType Str
&& SetPid(m_Channel->Apid(0), true)
&& SetPid(m_Channel->Dpid(0), true);
case stExtern:
m_ExtRemux = new cExternRemux(m_Channel->Vpid(), m_Channel->Apids(), m_Channel->Dpids(),
m_Channel->Spids());
if (Apid != 0)
return SetPid(m_Channel->Vpid(), true)
&& SetPid(Apid, true);
else
return SetPid(m_Channel->Vpid(), true)
&& SetPid(m_Channel->Apid(0), true)
&& SetPid(m_Channel->Dpid(0), true);
case stTSPIDS:
Dprintf("pid streaming mode\n");
return true;
@ -170,8 +194,17 @@ int cStreamdevLiveStreamer::Put(const uchar *Data, int Count)
case stPES:
return m_PESRemux->Put(Data, Count);
default:
abort();
case stES:
return m_ESRemux->Put(Data, Count);
case stPS:
return m_PSRemux->Put(Data, Count);
case stExtern:
return m_ExtRemux->Put(Data, Count);
default: // shouldn't happen???
return 0;
}
}
@ -184,9 +217,18 @@ uchar *cStreamdevLiveStreamer::Get(int &Count)
case stPES:
return m_PESRemux->Get(Count);
case stES:
return m_ESRemux->Get(Count);
default:
abort();
case stPS:
return m_PSRemux->Get(Count);
case stExtern:
return m_ExtRemux->Get(Count);
default: // shouldn't happen???
return 0;
}
}
@ -201,9 +243,18 @@ void cStreamdevLiveStreamer::Del(int Count)
case stPES:
m_PESRemux->Del(Count);
break;
case stES:
m_ESRemux->Del(Count);
break;
default:
abort();
case stPS:
m_PSRemux->Del(Count);
break;
case stExtern:
m_ExtRemux->Del(Count);
break;
}
}

12
server/livestreamer.h
View File

@ -8,7 +8,9 @@
#include "server/livefilter.h"
#include "common.h"
class cTSRemux;
class cTS2PSRemux;
class cTS2ESRemux;
class cExternRemux;
class cRemux;
// --- cStreamdevLiveReceiver -------------------------------------------------
@ -40,7 +42,9 @@ private:
cDevice *m_Device;
cStreamdevLiveReceiver *m_Receiver;
cRemux *m_PESRemux;
cTSRemux *m_Remux;
cTS2ESRemux *m_ESRemux;
cTS2PSRemux *m_PSRemux;
cExternRemux *m_ExtRemux;
public:
cStreamdevLiveStreamer(int Priority);
@ -55,7 +59,7 @@ public:
virtual uchar *Get(int &Count);
virtual void Del(int Count);
virtual void Attach(void) { Dprintf("attach %p\n", m_Device);m_Device->AttachReceiver(m_Receiver); }
virtual void Attach(void) { m_Device->AttachReceiver(m_Receiver); }
virtual void Detach(void) { m_Device->Detach(m_Receiver); }
// Statistical purposes:
@ -66,7 +70,7 @@ public:
inline void cStreamdevLiveReceiver::Activate(bool On)
{
Dprintf("LiveReceiver->Activate()\n");
Dprintf("LiveReceiver->Activate(%d)\n", On);
m_Streamer->Activate(On);
}

8
server/streamer.c
View File

@ -1,5 +1,5 @@
/*
* $Id: streamer.c,v 1.6 2005/02/10 22:24:26 lordjaxom Exp $
* $Id: streamer.c,v 1.7 2005/02/11 16:44:15 lordjaxom Exp $
*/
#include <vdr/ringbuffer.h>
@ -68,6 +68,7 @@ cStreamdevStreamer::cStreamdevStreamer(const char *Name):
cStreamdevStreamer::~cStreamdevStreamer()
{
Dprintf("Desctructing streamer\n");
Stop();
delete m_RingBuffer;
delete m_Writer;
@ -83,8 +84,8 @@ void cStreamdevStreamer::Start(cTBSocket *Socket)
void cStreamdevStreamer::Activate(bool On)
{
Dprintf("activate streamer\n");
if (On && !m_Active) {
Dprintf("activate streamer\n");
m_Writer->Start();
cThread::Start();
}
@ -93,10 +94,11 @@ void cStreamdevStreamer::Activate(bool On)
void cStreamdevStreamer::Stop(void)
{
if (m_Active) {
Dprintf("stopping live streamer\n");
Dprintf("stopping streamer\n");
m_Active = false;
Cancel(3);
}
DELETENULL(m_Writer);
}
void cStreamdevStreamer::Action(void)

4
server/streamer.h
View File

@ -1,5 +1,5 @@
/*
* $Id: streamer.h,v 1.4 2005/02/10 22:24:26 lordjaxom Exp $
* $Id: streamer.h,v 1.5 2005/02/11 16:44:15 lordjaxom Exp $
*/
#ifndef VDR_STREAMDEV_STREAMER_H
@ -13,7 +13,7 @@ class cTBSocket;
class cStreamdevStreamer;
#define STREAMERBUFSIZE MEGABYTE(4)
#define WRITERBUFSIZE KILOBYTE(192)
#define WRITERBUFSIZE KILOBYTE(256)
// --- cStreamdevWriter -------------------------------------------------------