mirrors/recycled-ni-neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-fork-migrations/recycled-ni-neutrino.git synced 2025-09-01 01:41:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dvbsi++' of ssh://coolstreamtech.de/cst-public-gui-neutrino into dvbsi++

Browse Source 
Origin commit data
------------------
Commit: de5004bd86
Author: Jacek Jendrzej <overx300@gmail.com>
Date: 2012-11-08 (Thu, 08 Nov 2012)
This commit is contained in:
Jacek Jendrzej
2012-11-08 16:19:47 +01:00
parent 4c735e8e66 c70d2995ee
commit 411fb6a506
10 changed files with 713 additions and 511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/driver/Makefile.am
View File

@@ -26,7 +26,7 @@ libneutrino_driver_a_SOURCES = \
file.cpp \
fontrenderer.cpp \
framebuffer.cpp \
genpsi.c \
genpsi.cpp \
radiotext.cpp \
radiotools.cpp \
rcinput.cpp \

2
src/driver/file.h
View File

@@ -37,7 +37,7 @@
in __USE_FILE_OFFSET64 mode */
#ifndef __USE_FILE_OFFSET64
#error not using 64 bit file offsets
#define __USE_FILE_OFFSET64
#endif /* __USE_FILE__OFFSET64 */
#include <sys/types.h>

207
src/driver/genpsi.c → src/driver/genpsi.cpp
View File

@@ -1,10 +1,6 @@
/*
$Id: genpsi.c,v 1.2 2006/01/16 12:45:54 sat_man Exp $
Copyright (c) 2004 gmo18t, Germany. All rights reserved.
aktuelle Versionen gibt es hier:
$Source: /cvs/tuxbox/apps/tuxbox/neutrino/src/driver/genpsi.c,v $
Copyright (C) 2012 CoolStream International Ltd
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -22,7 +18,7 @@ $Id: genpsi.c,v 1.2 2006/01/16 12:45:54 sat_man Exp $
Mit diesem Programm koennen Neutrino TS Streams für das Abspielen unter Enigma gepatched werden
*/
//#include <mpegtools/transform.h>
#include <string.h>
#include <unistd.h>
#include <driver/genpsi.h>
@@ -40,17 +36,6 @@ $Id: genpsi.c,v 1.2 2006/01/16 12:45:54 sat_man Exp $
#define ES_TYPE_MPA 0x03
#define ES_TYPE_AC3 0x81
typedef struct
{
short nba;
uint16_t vpid;
uint8_t vtype;
uint16_t apid[10];
short isAC3[10];
} T_AV_PIDS;
T_AV_PIDS avPids;
static const uint32_t crc_table[256] = {
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
@@ -97,49 +82,6 @@ static const uint32_t crc_table[256] = {
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
uint32_t calc_crc32psi(uint8_t *dst, const uint8_t *src, uint32_t len)
{
uint32_t i;
uint32_t crc = 0xffffffff;
for (i=0; i<len; i++)
crc = (crc << 8) ^ crc_table[((crc >> 24) ^ *src++) & 0xff];
if (dst)
{
dst[0] = (crc >> 24) & 0xff;
dst[1] = (crc >> 16) & 0xff;
dst[2] = (crc >> 8) & 0xff;
dst[3] = (crc) & 0xff;
}
return crc;
}
void transfer_pids(uint16_t pid,uint16_t pidart,short isAC3)
{
switch(pidart)
{
case EN_TYPE_VIDEO:
avPids.vpid=pid;
avPids.vtype = ES_TYPE_MPEG12;
break;
case EN_TYPE_AVC:
avPids.vpid=pid;
avPids.vtype = ES_TYPE_AVC;
break;
case EN_TYPE_AUDIO:
avPids.apid[avPids.nba]=pid;
avPids.isAC3[avPids.nba]=isAC3;
avPids.nba++;
break;
case EN_TYPE_TELTEX:
break;
default:
break;
}
}
//-- special enigma stream description packet for --
//-- at least 1 video, 1 audo and 1 PCR-Pid stream --
//------------------------------------------------------------------------------------
@@ -177,13 +119,65 @@ static uint8_t pkt_pmt[] =
0x03, 0xE0, 0x00, 0xF0, 0x00 // (audio stream 1)
};
CGenPsi::CGenPsi()
{
nba = 0;
vpid = 0;
vtype = 0;
memset(apid, 0, sizeof(apid));
memset(atypes, 0, sizeof(atypes));
}
uint32_t CGenPsi::calc_crc32psi(uint8_t *dst, const uint8_t *src, uint32_t len)
{
uint32_t i;
uint32_t crc = 0xffffffff;
for (i=0; i<len; i++)
crc = (crc << 8) ^ crc_table[((crc >> 24) ^ *src++) & 0xff];
if (dst)
{
dst[0] = (crc >> 24) & 0xff;
dst[1] = (crc >> 16) & 0xff;
dst[2] = (crc >> 8) & 0xff;
dst[3] = (crc) & 0xff;
}
return crc;
}
void CGenPsi::addPid(uint16_t pid, uint16_t pidtype, short isAC3)
{
switch(pidtype)
{
case EN_TYPE_VIDEO:
vpid=pid;
vtype = ES_TYPE_MPEG12;
break;
case EN_TYPE_AVC:
vpid=pid;
vtype = ES_TYPE_AVC;
break;
case EN_TYPE_AUDIO:
apid[nba]=pid;
atypes[nba]=isAC3;
nba++;
break;
case EN_TYPE_TELTEX:
break;
default:
break;
}
}
//== setup a new TS packet with format ==
//== predefined with a template ==
//=======================================
#define COPY_TEMPLATE(dst, src) copy_template(dst, src, sizeof(src))
static int copy_template(uint8_t *dst, uint8_t *src, int len)
int CGenPsi::copy_template(uint8_t *dst, uint8_t *src, int len)
{
//-- reset buffer --
memset(dst, 0xFF, SIZE_TS_PKT);
@@ -192,92 +186,93 @@ static int copy_template(uint8_t *dst, uint8_t *src, int len)
return len;
}
int genpsi(int fd2)
int CGenPsi::genpsi(int fd)
{
// int bytes = 0;
uint8_t pkt[SIZE_TS_PKT];
int i, data_len, patch_len, ofs;
//-- copy "Enigma"-template --
//-- copy "Enigma"-template --
data_len = COPY_TEMPLATE(pkt, pkt_enigma);
//-- adjust len dependent to number of audio streams --
data_len += ((SIZE_ENIGMA_TAB_ROW+1) * (avPids.nba-1));
//-- adjust len dependent to number of audio streams --
data_len += ((SIZE_ENIGMA_TAB_ROW+1) * (nba-1));
patch_len = data_len - OFS_HDR_2 + 1;
pkt[OFS_HDR_2+1] |= (patch_len>>8);
pkt[OFS_HDR_2+2] = (patch_len & 0xFF);
//-- write row with desc. for video stream --
//-- write row with desc. for video stream --
ofs = OFS_ENIGMA_TAB;
pkt[ofs] = EN_TYPE_VIDEO;
pkt[ofs+1] = 0x02;
pkt[ofs+2] = (avPids.vpid>>8);
pkt[ofs+3] = (avPids.vpid & 0xFF);
//-- for each audio stream, write row with desc. --
pkt[ofs+2] = (vpid>>8);
pkt[ofs+3] = (vpid & 0xFF);
//-- for each audio stream, write row with desc. --
ofs += SIZE_ENIGMA_TAB_ROW;
for (i=0; i<avPids.nba; i++)
for (i=0; i<nba; i++)
{
pkt[ofs] = EN_TYPE_AUDIO;
pkt[ofs+1] = 0x03;
pkt[ofs+2] = (avPids.apid[i]>>8);
pkt[ofs+3] = (avPids.apid[i] & 0xFF);
pkt[ofs+4] = (avPids.isAC3[i]==1)? 0x01 : 0x00;
pkt[ofs+2] = (apid[i]>>8);
pkt[ofs+3] = (apid[i] & 0xFF);
pkt[ofs+4] = (atypes[i]==1)? 0x01 : 0x00;
ofs += (SIZE_ENIGMA_TAB_ROW + 1);
}
//-- write row with desc. for pcr stream (eq. video) --
//-- write row with desc. for pcr stream (eq. video) --
pkt[ofs] = EN_TYPE_PCR;
pkt[ofs+1] = 0x02;
pkt[ofs+2] = (avPids.vpid>>8);
pkt[ofs+3] = (avPids.vpid & 0xFF);
pkt[ofs+2] = (vpid>>8);
pkt[ofs+3] = (vpid & 0xFF);
//-- calculate CRC --
//-- calculate CRC --
calc_crc32psi(&pkt[data_len], &pkt[OFS_HDR_2], data_len-OFS_HDR_2 );
//-- write TS packet --
/*bytes +=*/ write(fd2, pkt, SIZE_TS_PKT);
//-- (II) build PAT --
//-- write TS packet --
write(fd, pkt, SIZE_TS_PKT);
//-- (II) build PAT --
data_len = COPY_TEMPLATE(pkt, pkt_pat);
//-- calculate CRC --
//-- calculate CRC --
calc_crc32psi(&pkt[data_len], &pkt[OFS_HDR_2], data_len-OFS_HDR_2 );
//-- write TS packet --
/*bytes +=*/ write(fd2, pkt, SIZE_TS_PKT);
//-- write TS packet --
write(fd, pkt, SIZE_TS_PKT);
//-- (III) build PMT --
//-- (III) build PMT --
data_len = COPY_TEMPLATE(pkt, pkt_pmt);
//-- adjust len dependent to count of audio streams --
data_len += (SIZE_STREAM_TAB_ROW * (avPids.nba-1));
//-- adjust len dependent to count of audio streams --
data_len += (SIZE_STREAM_TAB_ROW * (nba-1));
patch_len = data_len - OFS_HDR_2 + 1;
pkt[OFS_HDR_2+1] |= (patch_len>>8);
pkt[OFS_HDR_2+2] = (patch_len & 0xFF);
//-- patch pcr PID --
//-- patch pcr PID --
ofs = OFS_PMT_DATA;
pkt[ofs] |= (avPids.vpid>>8);
pkt[ofs+1] = (avPids.vpid & 0xFF);
//-- write row with desc. for ES video stream --
pkt[ofs] |= (vpid>>8);
pkt[ofs+1] = (vpid & 0xFF);
//-- write row with desc. for ES video stream --
ofs = OFS_STREAM_TAB;
pkt[ofs] = avPids.vtype;
pkt[ofs+1] = 0xE0 | (avPids.vpid>>8);
pkt[ofs+2] = (avPids.vpid & 0xFF);
pkt[ofs] = vtype;
pkt[ofs+1] = 0xE0 | (vpid>>8);
pkt[ofs+2] = (vpid & 0xFF);
pkt[ofs+3] = 0xF0;
pkt[ofs+4] = 0x00;
//-- for each ES audio stream, write row with desc. --
for (i=0; i<avPids.nba; i++)
//-- for each ES audio stream, write row with desc. --
for (i=0; i<nba; i++)
{
ofs += SIZE_STREAM_TAB_ROW;
pkt[ofs] = (avPids.isAC3[i]==1)? ES_TYPE_AC3 : ES_TYPE_MPA;
pkt[ofs+1] = 0xE0 | (avPids.apid[i]>>8);
pkt[ofs+2] = (avPids.apid[i] & 0xFF);
pkt[ofs] = (atypes[i]==1)? ES_TYPE_AC3 : ES_TYPE_MPA;
pkt[ofs+1] = 0xE0 | (apid[i]>>8);
pkt[ofs+2] = (apid[i] & 0xFF);
pkt[ofs+3] = 0xF0;
pkt[ofs+4] = 0x00;
}
//-- calculate CRC --
//-- calculate CRC --
calc_crc32psi(&pkt[data_len], &pkt[OFS_HDR_2], data_len-OFS_HDR_2 );
//-- write TS packet --
/*bytes +=*/ write(fd2, pkt, SIZE_TS_PKT);
//-- finish --
avPids.vpid=0;
avPids.nba=0;
fdatasync(fd2);
//-- write TS packet --
write(fd, pkt, SIZE_TS_PKT);
//-- finish --
vpid=0;
nba=0;
fdatasync(fd);
return 1;
}

24
src/driver/genpsi.h
View File

@@ -1,10 +1,7 @@
/*
$Id: genpsi.h,v 1.1 2005/08/15 14:47:52 metallica Exp $
Copyright (c) 2004 gmo18t, Germany. All rights reserved.
aktuelle Versionen gibt es hier:
$Source: /cvs/tuxbox/apps/tuxbox/neutrino/src/driver/genpsi.h,v $
Copyright (C) 2012 CoolStream International Ltd
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -26,13 +23,26 @@ $Id: genpsi.h,v 1.1 2005/08/15 14:47:52 metallica Exp $
#define __genpsi_h__
#include <inttypes.h>
int genpsi(int fd2);
void transfer_pids(uint16_t pid,uint16_t pidart,short isAC3);
#define EN_TYPE_VIDEO 0x00
#define EN_TYPE_AUDIO 0x01
#define EN_TYPE_TELTEX 0x02
#define EN_TYPE_PCR 0x03
#define EN_TYPE_AVC 0x04
class CGenPsi
{
private:
short nba;
uint16_t vpid;
uint8_t vtype;
uint16_t apid[10];
short atypes[10];
static int copy_template(uint8_t *dst, uint8_t *src, int len);
uint32_t calc_crc32psi(uint8_t *dst, const uint8_t *src, uint32_t len);
public:
CGenPsi();
void addPid(uint16_t pid,uint16_t pidtype, short isAC3);
int genpsi(int fd);
};
#endif

14
src/driver/record.cpp
View File

@@ -51,6 +51,7 @@
#include <driver/record.h>
#include <driver/streamts.h>
#include <zapit/capmt.h>
#include <zapit/channel.h>
#include <zapit/getservices.h>
@@ -156,15 +157,16 @@ record_error_msg_t CRecordInstance::Start(CZapitChannel * channel)
return RECORD_INVALID_DIRECTORY;
}
CGenPsi psi;
if (allpids.PIDs.vpid != 0)
transfer_pids(allpids.PIDs.vpid, recMovieInfo->VideoType ? EN_TYPE_AVC : EN_TYPE_VIDEO, 0);
psi.addPid(allpids.PIDs.vpid, recMovieInfo->VideoType ? EN_TYPE_AVC : EN_TYPE_VIDEO, 0);
numpids = 0;
for (unsigned int i = 0; i < recMovieInfo->audioPids.size(); i++) {
apids[numpids++] = recMovieInfo->audioPids[i].epgAudioPid;
transfer_pids(recMovieInfo->audioPids[i].epgAudioPid, EN_TYPE_AUDIO, recMovieInfo->audioPids[i].atype);
psi.addPid(recMovieInfo->audioPids[i].epgAudioPid, EN_TYPE_AUDIO, recMovieInfo->audioPids[i].atype);
}
genpsi(fd);
psi.genpsi(fd);
if ((StreamVTxtPid) && (allpids.PIDs.vtxtpid != 0))
apids[numpids++] = allpids.PIDs.vtxtpid;
@@ -1590,12 +1592,16 @@ bool CRecordManager::CutBackNeutrino(const t_channel_id channel_id, CFrontend *
* needed, if record frontend same as live, and its on different TP */
bool found = (live_fe != frontend) || SAME_TRANSPONDER(live_channel_id, channel_id);
if(found) {
/* stop stream for this channel */
CStreamManager::getInstance()->StopStream(channel_id);
ret = g_Zapit->zapTo_record(channel_id) > 0;
printf("%s found same tp, zapTo_record channel_id %llx result %d\n", __FUNCTION__, channel_id, ret);
}
else {
printf("%s mode %d last_mode %d getLastMode %d\n", __FUNCTION__, mode, last_mode, CNeutrinoApp::getInstance()->getLastMode());
StopAutoRecord(false);
/* stop all streams */
CStreamManager::getInstance()->StopStream();
if (mode != last_mode && (last_mode != NeutrinoMessages::mode_standby || mode != CNeutrinoApp::getInstance()->getLastMode())) {
CNeutrinoApp::getInstance()->handleMsg( NeutrinoMessages::CHANGEMODE , mode | NeutrinoMessages::norezap );
mode_changed = true;
@@ -1619,6 +1625,8 @@ bool CRecordManager::CutBackNeutrino(const t_channel_id channel_id, CFrontend *
g_Zapit->stopPlayBack();
if ((live_channel_id == channel_id) && g_Radiotext)
g_Radiotext->radiotext_stop();
/* in case channel_id == live_channel_id */
CStreamManager::getInstance()->StopStream(channel_id);
}
if(last_mode == NeutrinoMessages::mode_standby) {
//CNeutrinoApp::getInstance()->handleMsg( NeutrinoMessages::CHANGEMODE , NeutrinoMessages::mode_standby);

852
src/driver/streamts.cpp
View File

@@ -1,3 +1,29 @@
/*
Neutrino-GUI - DBoxII-Project
Copyright (C) 2011-2012 CoolStream International Ltd
based on code which is
Copyright (C) 2002 Andreas Oberritter <obi@tuxbox.org>
Copyright (C) 2001 TripleDES
Copyright (C) 2000, 2001 Marcus Metzler <marcus@convergence.de>
License: GPLv2
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;
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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
@@ -13,10 +39,8 @@
#include <poll.h>
#include <syscall.h>
/* work around for building with old kernel headers */
#ifndef POLLRDHUP
#define POLLRDHUP 0
#endif
#include <global.h>
#include <neutrino.h>
#ifdef HAVE_CONFIG_H
#include <config.h>
@@ -28,248 +52,231 @@
#include <dmx.h>
#include <zapit/capmt.h>
#include <zapit/zapit.h>
#include <zapit/pat.h>
#include <driver/streamts.h>
#include <driver/record.h>
#include <driver/genpsi.h>
/* experimental mode:
* stream not possible, if record running
* pids in url ignored, and added from channel, with fake PAT/PMT
* different channels supported, only from the same transponder - no zap is done,
* with url like http://coolstream:31339/id=c32400030070283e (channel id)
* TODO: multi-tuner support
*/
#define ENABLE_MULTI_CHANNEL
#define TS_SIZE 188
#define IN_SIZE (2048 * TS_SIZE)
//#define IN_SIZE (TS_SIZE * 362)
#define DMX_BUFFER_SIZE (2048*TS_SIZE)
#define IN_SIZE (250*TS_SIZE)
#define DMX_BUFFER_SIZE (2 * 3008 * 62)
/* maximum number of pes pids */
#define MAXPIDS 64
/* tcp packet data size */
//#define PACKET_SIZE 1448
#define PACKET_SIZE 7*TS_SIZE
//unsigned char * buf;
extern CCam *cam0;
//int demuxfd[MAXPIDS];
static unsigned char exit_flag = 0;
static unsigned int writebuf_size = 0;
static unsigned char writebuf[PACKET_SIZE];
void packet_stdout (int fd, unsigned char * buf, int count, void * /*p*/)
CStreamInstance::CStreamInstance(int clientfd, t_channel_id chid, stream_pids_t &_pids)
{
unsigned int size;
unsigned char * bp;
ssize_t written;
//printf("packet_stdout count %d\n", count);
/* ensure, that there is always at least one complete
* packet inside of the send buffer */
while (writebuf_size + count >= PACKET_SIZE) {
/* how many bytes are to be sent from the input buffer? */
size = PACKET_SIZE - writebuf_size;
/* send buffer is not empty, so copy from
input buffer to get a complete packet */
if (writebuf_size) {
memmove(writebuf + writebuf_size, buf, size);
bp = writebuf;
}
/* if send buffer is empty, then do not memcopy,
but send directly from input buffer */
else {
bp = buf;
}
/* write the packet, count the amount of really written bytes */
written = write(fd, bp, PACKET_SIZE);
/* exit on error */
if (written == -1) {
perror("write");
exit_flag = 1;
return;
}
/* if the packet could not be written completely, then
* how many bytes must be stored in the send buffer
* until the next packet is to be sent? */
writebuf_size = PACKET_SIZE - written;
/* move all bytes of the packet which were not sent
* to the beginning of the send buffer */
if (writebuf_size)
memmove(writebuf, bp + written, writebuf_size);
/* * advance in the input buffer */
buf += size;
/* * decrease the todo size */
count -= size;
}
/* if there are still some bytes left in the input buffer,
* then store them in the send buffer and increase send
* buffer size */
if (count) {
memmove(writebuf + writebuf_size, buf, count);
writebuf_size += count;
}
printf("CStreamInstance:: new channel %llx fd %d\n", chid, clientfd);
fds.insert(clientfd);
pids = _pids;
channel_id = chid;
running = false;
dmx = NULL;
buf = NULL;
}
int open_incoming_port (int port)
CStreamInstance::~CStreamInstance()
{
struct sockaddr_in socketAddr;
int socketOptActive = 1;
int handle;
if (!port)
return -1;
if ((handle = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
fprintf (stderr, "network port %u open: ", port);
perror ("socket");
return -1;
}
if (setsockopt (handle, SOL_SOCKET, SO_REUSEADDR, (const void *)&socketOptActive, sizeof (int)) < 0)
{
fprintf (stderr, "network port %u open: error setsockopt\n", port);
close (handle);
return -1;
}
socketAddr.sin_family = AF_INET;
socketAddr.sin_port = htons (port);
socketAddr.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (handle, (struct sockaddr *) &socketAddr, sizeof (socketAddr)) < 0)
{
fprintf (stderr, "network port %u open: ", port);
perror ("bind");
close (handle);
return -1;
}
if (listen (handle, 5) < 0)
{
fprintf (stderr, "network port %u open: ", port);
perror ("listen");
close (handle);
return -1;
}
return handle;
Stop();
Close();
}
void * streamts_live_thread(void *data);
int streamts_stop;
void streamts_main_thread(void * /*data*/)
bool CStreamInstance::Start()
{
struct sockaddr_in servaddr;
int clilen;
if (running)
return false;
struct pollfd pfd[128];
int poll_cnt, tcnt;
int listenfd;
int connfd = -1;
int pollres;
int i;
pthread_t st = 0;
printf("Starting STREAM thread keeper, tid %ld\n", syscall(__NR_gettid));
listenfd = open_incoming_port(31339);
if(listenfd < 0) {
printf("Open incoming port failed\n");
return;
buf = new unsigned char [IN_SIZE];
if (buf == NULL) {
perror("CStreamInstance::Start: buf");
return false;
}
printf("listenfd %d\n", listenfd);
clilen = sizeof (servaddr);
pfd[0].fd = listenfd;
pfd[0].events = (POLLIN | POLLPRI);
pfd[0].revents = 0;
tcnt = 1;
streamts_stop = 0;
while (!streamts_stop) {
poll_cnt = tcnt;
//printf("polling, count= %d\n", poll_cnt);
pollres = poll (pfd, poll_cnt, 1000);
if (pollres < 0) {
perror("streamts_main_thread poll");
continue;
}
if(pollres == 0)
continue;
for (i = poll_cnt - 1; i >= 0; i--) {
if (pfd[i].revents & (POLLIN | POLLPRI | POLLHUP | POLLRDHUP)) {
printf("fd %d has events %x\n", pfd[i].fd, pfd[i].revents);
if (pfd[i].fd == listenfd) {
connfd = accept (listenfd, (struct sockaddr *) &servaddr, (socklen_t *) & clilen);
printf("new connection, fd %d\n", connfd);
if(connfd < 0) {
perror("accept");
continue;
}
if(st != 0) {
printf("New connection, stopping stream thread\n");
exit_flag = 1;
pthread_join(st, NULL);
tcnt --;
}
pfd[tcnt].fd = connfd;
pfd[tcnt].events = POLLRDHUP | POLLHUP;
pfd[tcnt].revents = 0;
tcnt++;
exit_flag = 0;
pthread_create (&st, NULL, streamts_live_thread, (void *) connfd);
} else {
if (pfd[i].revents & (POLLHUP | POLLRDHUP)) {
connfd = -1;
printf("Client disconnected, stopping stream thread\n");
exit_flag = 1;
if(st)
pthread_join(st, NULL);
st = 0;
tcnt --;
}
}
}
}
}
printf("Stopping STREAM thread keeper\n");
close(listenfd);
if(st != 0) {
printf("Stopping stream thread\n");
exit_flag = 1;
pthread_join(st, NULL);
close(connfd);
}
return;
running = true;
printf("CStreamInstance::Start: %llx\n", channel_id);
return (OpenThreads::Thread::start() == 0);
}
void * streamts_live_thread(void *data)
bool CStreamInstance::Stop()
{
if (!running)
return false;
printf("CStreamInstance::Stop: %llx\n", channel_id);
running = false;
return (OpenThreads::Thread::join() == 0);
}
bool CStreamInstance::Send(ssize_t r)
{
mutex.lock();
for (stream_fds_t::iterator it = fds.begin(); it != fds.end(); ++it) {
int ret, i = 10;
do {
ret = send(*it, buf, r, MSG_DONTWAIT);
#if 0
if (ret != r)
usleep(100);
#endif
} while ((ret != r) && (i-- > 0));
if (ret != r) {
if (r < 0)
perror("send");
printf("send err, fd %d: %d\n", *it, r);
}
}
mutex.unlock();
return true;
}
void CStreamInstance::Close()
{
for (stream_fds_t::iterator fit = fds.begin(); fit != fds.end(); ++fit)
close(*fit);
fds.clear();
}
void CStreamInstance::AddClient(int clientfd)
{
mutex.lock();
fds.insert(clientfd);
printf("CStreamInstance::AddClient: %d (count %d)\n", clientfd, fds.size());
mutex.unlock();
}
void CStreamInstance::RemoveClient(int clientfd)
{
mutex.lock();
fds.erase(clientfd);
close(clientfd);
printf("CStreamInstance::RemoveClient: %d (count %d)\n", clientfd, fds.size());
mutex.unlock();
}
void CStreamInstance::run()
{
printf("CStreamInstance::run: %llx\n", channel_id);
dmx = new cDemux(STREAM_DEMUX);//FIXME
dmx->Open(DMX_TP_CHANNEL, NULL, DMX_BUFFER_SIZE);
/* pids here cannot be empty */
stream_pids_t::iterator it = pids.begin();
printf("CStreamInstance::run: add pid %x\n", *it);
dmx->pesFilter(*it);
++it;
for (; it != pids.end(); ++it) {
printf("CStreamInstance::run: add pid %x\n", *it);
dmx->addPid(*it);
}
#ifdef ENABLE_MULTI_CHANNEL
dmx->Start();//FIXME
#else
dmx->Start(true);//FIXME
#endif
CCamManager::getInstance()->Start(channel_id, CCamManager::STREAM);
while (running) {
ssize_t r = dmx->Read(buf, IN_SIZE, 100);
if(r > 0)
Send(r);
}
CCamManager::getInstance()->Stop(channel_id, CCamManager::STREAM);
printf("CStreamInstance::run: exiting %llx (%d fds)\n", channel_id, fds.size());
Close();
delete dmx;
delete []buf;
}
bool CStreamInstance::HasFd(int fd)
{
if (fds.find(fd) != fds.end())
return true;
return false;
}
/************************************************************************/
CStreamManager *CStreamManager::sm = NULL;
CStreamManager::CStreamManager()
{
enabled = true;
running = false;
listenfd = -1;
port = 31339;
}
CStreamManager::~CStreamManager()
{
Stop();
}
CStreamManager * CStreamManager::getInstance()
{
if (sm == NULL)
sm = new CStreamManager();
return sm;
}
bool CStreamManager::Start(int _port)
{
if (running)
return false;
if (_port)
port = _port;
if (!Listen())
return false;
running = true;
return (OpenThreads::Thread::start() == 0);
}
bool CStreamManager::Stop()
{
if (!running)
return false;
running = false;
return (OpenThreads::Thread::join() == 0);
}
bool CStreamManager::SetPort(int newport)
{
bool ret = false;
if (port != newport) {
port = newport;
#if 0
Stop();
ret = Start(newport);
#endif
mutex.lock();
if (listenfd >= 0)
close(listenfd);
ret = Listen();
mutex.unlock();
}
return ret;
}
bool CStreamManager::Parse(int fd, stream_pids_t &pids, t_channel_id &chid)
{
unsigned char * buf;
int pid;
int pids[MAXPIDS];
char cbuf[512];
char *bp;
int fd = (int) data;
unsigned char demuxfd_count = 0;
printf("Starting LIVE STREAM thread, fd %d\n", fd);
FILE * fp = fdopen(fd, "r+");
if(fp == NULL) {
perror("fdopen");
return 0;
return false;
}
writebuf_size = 0;
cbuf[0] = 0;
bp = &cbuf[0];
@@ -279,7 +286,7 @@ void * streamts_live_thread(void *data)
int res = read(fd, &c, 1);
if(res < 0) {
perror("read");
return 0;
return false;
}
if ((*bp++ = c) == '\n')
break;
@@ -288,7 +295,7 @@ void * streamts_live_thread(void *data)
*bp++ = 0;
bp = &cbuf[0];
printf("stream: got %s\n", cbuf);
printf("CStreamManager::Parse: got %s\n", cbuf);
/* send response to http client */
if (!strncmp(cbuf, "GET /", 5)) {
@@ -297,165 +304,256 @@ void * streamts_live_thread(void *data)
bp += 5;
} else {
printf("Received garbage\n");
return 0;
return false;
}
#ifndef ENABLE_MULTI_CHANNEL
/* parse stdin / url path, start dmx filters */
do {
int pid;
int res = sscanf(bp, "%x", &pid);
if(res == 1) {
printf("New pid: 0x%x\n", pid);
pids[demuxfd_count++] = pid;
pids.insert(pid);
}
}
while ((bp = strchr(bp, ',')) && (bp++) && (demuxfd_count < MAXPIDS));
if(demuxfd_count == 0) {
printf("No pids!\n");
CZapitChannel * channel = CZapit::getInstance()->GetCurrentChannel();
if(!channel)
return 0;
pids[demuxfd_count++] = 0;
pids[demuxfd_count++] = channel->getPmtPid();
pids[demuxfd_count++] = channel->getVideoPid();
for (int i = 0; i < channel->getAudioChannelCount(); i++)
pids[demuxfd_count++] = channel->getAudioChannel(i)->pid;
}
buf = new unsigned char [IN_SIZE];
if (buf == NULL) {
perror("NEW");
return 0;
}
cDemux * dmx = new cDemux(STREAM_DEMUX);//FIXME
dmx->Open(DMX_TP_CHANNEL, NULL, DMX_BUFFER_SIZE);
dmx->pesFilter(pids[0]);
for(int i = 1; i < demuxfd_count; i++)
dmx->addPid(pids[i]);
dmx->Start(true);//FIXME
CCamManager::getInstance()->Start(CZapit::getInstance()->GetCurrentChannelID(), CCamManager::STREAM);
ssize_t r;
while (!exit_flag) {
r = dmx->Read(buf, IN_SIZE, 100);
if(r > 0)
packet_stdout(fd, buf, r, NULL);
}
printf("Exiting LIVE STREAM thread, fd %d\n", fd);
CCamManager::getInstance()->Stop(CZapit::getInstance()->GetCurrentChannelID(), CCamManager::STREAM);
delete dmx;
delete []buf;
close(fd);
return 0;
}
#if 0
//never used
void streamts_file_thread(void *data)
{
int dvrfd;
unsigned char * buf;
char cbuf[512];
char *bp;
unsigned char mode = 0;
char tsfile[IN_SIZE];
int tsfilelen = 0;
int fileslice = 0;
int i = 0;
int fd = (int) data;
buf = (unsigned char *) malloc(IN_SIZE);
if (buf == NULL) {
perror("malloc");
return;
}
bp = &cbuf[0];
/* read one line */
while (bp - &cbuf[0] < IN_SIZE) {
unsigned char c;
read(fd, &c, 1);
if ((*bp++ = c) == '\n')
break;
}
*bp++ = 0;
bp = &cbuf[0];
/* send response to http client */
if (!strncmp(cbuf, "GET /", 5)) {
printf("HTTP/1.1 200 OK\r\nServer: streamts (%s)\r\n\r\n", "ts" /*&argv[1][1]*/);
fflush(stdout);
bp += 5;
}
/* ts filename */
int j = 0;
i = 0;
while (i < (int) strlen(bp) - 3)
{
if ((bp[i] == '.') && (bp[i + 1] == 't') && (bp[i + 2] == 's'))
{
tsfile[j] = bp[i];
tsfile[j + 1] = bp[i + 1];
tsfile[j + 2] = bp[i + 2];
tsfile[j + 3] = '\0';
break;
}
else
if ((bp[i] == '%') && (bp[i + 1] == '2') && (bp[i + 2] == '0'))
{
tsfile[j++] = ' ';
i += 3;
}
else
tsfile[j++] = bp[i++];
}
tsfilelen = strlen(tsfile);
/* open ts file */
if ((dvrfd = open(tsfile, O_RDONLY)) < 0) {
free(buf);
return;
}
size_t pos;
ssize_t r;
while (!exit_flag) {
/* always read IN_SIZE bytes */
for (pos = 0; pos < IN_SIZE; pos += r) {
r = read(dvrfd, buf + pos, IN_SIZE - pos);
if (r == -1) {
/* Error */
exit_flag = 1;
break;
} else if (r == 0) {
/* End of file */
if (mode == 3) {
close(dvrfd);
sprintf(&tsfile[tsfilelen], ".%03d", ++fileslice);
dvrfd = open(tsfile, O_RDONLY);
}
if ((dvrfd == -1) || (mode != 3)) {
exit_flag = 1;
break;
}
}
}
packet_stdout(fd, buf, pos, NULL);
}
close(dvrfd);
free(buf);
return;
}
while ((bp = strchr(bp, ',')) && (bp++));
#endif
chid = CZapit::getInstance()->GetCurrentChannelID();
CZapitChannel * channel = CZapit::getInstance()->GetCurrentChannel();
int mode = CNeutrinoApp::getInstance()->getMode();
if (mode == NeutrinoMessages::mode_standby && streams.empty()) {
printf("CStreamManager::Parse: wakeup zapit..\n");
g_Zapit->setStandby(false);
g_Zapit->getMode();
}
if(pids.empty()) {
#ifdef ENABLE_MULTI_CHANNEL
t_channel_id tmpid;
bp = &cbuf[5];
if (sscanf(bp, "id=%llx", &tmpid) == 1) {
printf("############################# channel_id %llx\n", tmpid);
CZapitChannel * tmpchan = CServiceManager::getInstance()->FindChannel(tmpid);
if (tmpchan && (tmpid != chid) && SAME_TRANSPONDER(tmpid, chid)) {
printf("############################# channel_id %llx -> zap\n", tmpid);
bool ret = g_Zapit->zapTo_record(tmpid) > 0;
if (ret) {
channel = tmpchan;
chid = tmpid;
}
}
}
if(CRecordManager::getInstance()->RecordingStatus(tmpid)) {
printf("CStreamManager::Parse: channel %llx recorded, aborting..\n", tmpid);
return false;
}
#endif
printf("CStreamManager::Parse: no pids in url, using channel %llx pids\n", chid);
if(!channel)
return false;
//pids.insert(0);
//pids.insert(channel->getPmtPid());
pids.insert(channel->getVideoPid());
for (int i = 0; i < channel->getAudioChannelCount(); i++)
pids.insert(channel->getAudioChannel(i)->pid);
}
CGenPsi psi;
for (stream_pids_t::iterator it = pids.begin(); it != pids.end(); ++it) {
if (*it == channel->getVideoPid()) {
printf("CStreamManager::Parse: genpsi vpid %x (%d)\n", *it, channel->type);
psi.addPid(*it, channel->type ? EN_TYPE_AVC : EN_TYPE_VIDEO, 0);
} else {
for (int i = 0; i < channel->getAudioChannelCount(); i++) {
if (*it == channel->getAudioChannel(i)->pid) {
CZapitAudioChannel::ZapitAudioChannelType atype = channel->getAudioChannel(i)->audioChannelType;
printf("CStreamManager::Parse: genpsi apid %x (%d)\n", *it, atype);
psi.addPid(*it, EN_TYPE_AUDIO, atype);
}
}
}
}
psi.genpsi(fd);
return !pids.empty();
}
void CStreamManager::run()
{
struct sockaddr_in servaddr;
int clilen = sizeof(servaddr);;
struct pollfd pfd[128];
int poll_cnt;
printf("Starting STREAM thread keeper, tid %ld\n", syscall(__NR_gettid));
while (running) {
mutex.lock();
pfd[0].fd = listenfd;
pfd[0].events = (POLLIN | POLLPRI);
pfd[0].revents = 0;
poll_cnt = 1;
for (streammap_iterator_t it = streams.begin(); it != streams.end(); ++it) {
stream_fds_t fds = it->second->GetFds();
for (stream_fds_t::iterator fit = fds.begin(); fit != fds.end(); ++fit) {
pfd[poll_cnt].fd = *fit;
pfd[poll_cnt].events = POLLRDHUP | POLLHUP;
pfd[poll_cnt].revents = 0;
poll_cnt++;
}
}
mutex.unlock();
//printf("polling, count= %d\n", poll_cnt);
int pollres = poll (pfd, poll_cnt, 1000);
if (pollres < 0) {
perror("CStreamManager::run(): poll");
continue;
}
if(pollres == 0)
continue;
for (int i = poll_cnt - 1; i >= 0; i--) {
if (pfd[i].revents & (POLLIN | POLLPRI | POLLHUP | POLLRDHUP)) {
printf("fd %d has events %x\n", pfd[i].fd, pfd[i].revents);
if (pfd[i].fd == listenfd) {
int connfd = accept (listenfd, (struct sockaddr *) &servaddr, (socklen_t *) & clilen);
printf("CStreamManager::run(): connection, fd %d\n", connfd);
if(connfd < 0) {
perror("CStreamManager::run(): accept");
continue;
}
stream_pids_t pids;
t_channel_id channel_id;
if (Parse(connfd, pids, channel_id)) {
mutex.lock();
streammap_iterator_t it = streams.find(channel_id);
if (it != streams.end()) {
it->second->AddClient(connfd);
} else {
CStreamInstance * stream = new CStreamInstance(connfd, channel_id, pids);
if (stream->Start())
streams.insert(streammap_pair_t(channel_id, stream));
else
delete stream;
}
mutex.unlock();
} else {
close(connfd);
}
} else {
if (pfd[i].revents & (POLLHUP | POLLRDHUP)) {
printf("CStreamManager::run(): POLLHUP, fd %d\n", pfd[i].fd);
mutex.lock();
for (streammap_iterator_t it = streams.begin(); it != streams.end(); ++it) {
if (it->second->HasFd(pfd[i].fd)) {
CStreamInstance *stream = it->second;
stream->RemoveClient(pfd[i].fd);
if (stream->GetFds().empty()) {
streams.erase(stream->GetChannelId());
delete stream;
}
break;
}
}
mutex.unlock();
}
}
}
}
}
printf("CStreamManager::run: stopping...\n");
close(listenfd);
listenfd = -1;
StopAll();
}
bool CStreamManager::StopAll()
{
bool ret = !streams.empty();
for (streammap_iterator_t it = streams.begin(); it != streams.end(); ++it) {
it->second->Stop();
delete it->second;
}
streams.clear();
return ret;
}
bool CStreamManager::StopStream(t_channel_id channel_id)
{
bool ret = false;
mutex.lock();
if (channel_id) {
streammap_iterator_t it = streams.find(channel_id);
if (it != streams.end()) {
delete it->second;
streams.erase(channel_id);
ret = true;
}
} else {
ret = StopAll();
}
mutex.unlock();
return ret;
}
bool CStreamManager::StreamStatus(t_channel_id channel_id)
{
bool ret;
mutex.lock();
if (channel_id)
ret = (streams.find(channel_id) != streams.end());
else
ret = !streams.empty();
mutex.unlock();
return ret;
}
bool CStreamManager::Listen()
{
struct sockaddr_in socketAddr;
int socketOptActive = 1;
int sendsize = 10*IN_SIZE;
unsigned int m = sizeof(sendsize);
if ((listenfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
fprintf (stderr, "network port %u open: ", port);
perror ("socket");
return false;
}
if (setsockopt (listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&socketOptActive, sizeof (int)) < 0) {
fprintf (stderr, "network port %u open: error setsockopt\n", port);
perror ("setsockopt");
goto _error;
}
socketAddr.sin_family = AF_INET;
socketAddr.sin_port = htons (port);
socketAddr.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (listenfd, (struct sockaddr *) &socketAddr, sizeof (socketAddr)) < 0) {
fprintf (stderr, "network port %u open: ", port);
perror ("bind");
goto _error;
}
if (listen (listenfd, 5) < 0) {
fprintf (stderr, "network port %u open: ", port);
perror ("listen");
goto _error;
}
#if 1
setsockopt(listenfd, SOL_SOCKET, SO_SNDBUF, (void *)&sendsize, m);
sendsize = 0;
getsockopt(listenfd, SOL_SOCKET, SO_SNDBUF, (void *)&sendsize, &m);
printf("CStreamManager::Listen: on %d, fd %d (%d)\n", port, listenfd, sendsize);
#endif
return true;
_error:
close (listenfd);
return false;
}

96
src/driver/streamts.h Normal file
View File

@@ -0,0 +1,96 @@
/*
Neutrino-GUI - DBoxII-Project
Copyright (C) 2011-2012 CoolStream International Ltd
License: GPLv2
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;
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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __streamts_h__
#define __streamts_h__
#include <OpenThreads/Thread>
#include <OpenThreads/Condition>
#include <dmx.h>
#include <zapit/client/zapittypes.h>
#include <set>
#include <map>
typedef std::set<int> stream_pids_t;
typedef std::set<int> stream_fds_t;
class CStreamInstance : public OpenThreads::Thread
{
private:
bool running;
cDemux * dmx;
OpenThreads::Mutex mutex;
unsigned char * buf;
t_channel_id channel_id;
stream_pids_t pids;
stream_fds_t fds;
bool Send(ssize_t r);
void Close();
void run();
public:
CStreamInstance(int clientfd, t_channel_id chid, stream_pids_t &pids);
~CStreamInstance();
bool Start();
bool Stop();
void AddClient(int clientfd);
void RemoveClient(int clientfd);
bool HasFd(int fd);
stream_fds_t & GetFds() { return fds; }
t_channel_id GetChannelId() { return channel_id; }
};
typedef std::pair<t_channel_id, CStreamInstance*> streammap_pair_t;
typedef std::map<t_channel_id, CStreamInstance*> streammap_t;
typedef streammap_t::iterator streammap_iterator_t;
class CStreamManager : public OpenThreads::Thread
{
private:
bool enabled;
bool running;
int listenfd;
int port;
OpenThreads::Mutex mutex;
static CStreamManager * sm;
streammap_t streams;
bool Listen();
bool Parse(int fd, stream_pids_t &pids, t_channel_id &chid);
bool StopAll();
void run();
CStreamManager();
public:
~CStreamManager();
static CStreamManager * getInstance();
bool Start(int port = 0);
bool Stop();
bool StopStream(t_channel_id channel_id = 0);
bool StreamStatus(t_channel_id channel_id = 0);
bool SetPort(int newport);
int GetPort() { return port; }
};
#endif

14
src/gui/start_wizard.cpp
View File

@@ -99,12 +99,6 @@ int CStartUpWizard::exec(CMenuTarget* parent, const string & /*actionKey*/)
res = CNetworkSetup::getInstance()->exec(NULL, "");
CNetworkSetup::getInstance()->setWizardMode(CNetworkSetup::N_SETUP_MODE_WIZARD_NO);
}
if(res != menu_return::RETURN_EXIT_ALL)
{
CScanSetup::getInstance()->setWizardMode(CScanSetup::SCAN_SETUP_MODE_WIZARD);
res = CScanSetup::getInstance()->exec(NULL, "");
CScanSetup::getInstance()->setWizardMode(CScanSetup::SCAN_SETUP_MODE_WIZARD_NO);
}
bool init_settings = false;
if (g_info.delivery_system == DVB_S)
init_settings = file_exists("/var/tuxbox/config/initial/");
@@ -119,10 +113,14 @@ int CStartUpWizard::exec(CMenuTarget* parent, const string & /*actionKey*/)
CZapit::getInstance()->PrepareChannels();
}
}
if(res != menu_return::RETURN_EXIT_ALL)
{
CScanSetup::getInstance()->setWizardMode(CScanSetup::SCAN_SETUP_MODE_WIZARD);
res = CScanSetup::getInstance()->exec(NULL, "");
CScanSetup::getInstance()->setWizardMode(CScanSetup::SCAN_SETUP_MODE_WIZARD_NO);
}
}
killBackgroundLogo();
return res;
}

13
src/neutrino.cpp
View File

@@ -56,6 +56,7 @@
#include <driver/record.h>
#include <driver/screenshot.h>
#include <driver/volume.h>
#include <driver/streamts.h>
#include "gui/audioplayer.h"
#include "gui/bouquetlist.h"
@@ -133,10 +134,6 @@ t_channel_id standby_channel_id;
static pthread_t timer_thread;
void * timerd_main_thread(void *data);
extern int streamts_stop;
void * streamts_main_thread(void *data);
static pthread_t stream_thread ;
void * nhttpd_main_thread(void *data);
static pthread_t nhttpd_thread ;
@@ -1825,7 +1822,7 @@ TIMER_START();
pthread_create (&nhttpd_thread, NULL, nhttpd_main_thread, (void *) NULL);
pthread_create (&stream_thread, NULL, streamts_main_thread, (void *) NULL);
CStreamManager::getInstance()->Start();
#ifndef DISABLE_SECTIONSD
CSectionsdClient::epg_config config;
@@ -3105,7 +3102,8 @@ void CNeutrinoApp::standbyMode( bool bOnOff, bool fromDeepStandby )
g_Radiotext->radiotext_stop();
if(!fromDeepStandby && !CRecordManager::getInstance()->RecordingStatus()) {
bool stream_status = CStreamManager::getInstance()->StreamStatus();
if(!fromDeepStandby && !CRecordManager::getInstance()->RecordingStatus() && !stream_status) {
g_Zapit->setStandby(true);
} else {
g_Zapit->stopPlayBack();
@@ -3442,7 +3440,6 @@ bool CNeutrinoApp::changeNotify(const neutrino_locale_t OptionName, void * /*dat
**************************************************************************************/
void stop_daemons(bool stopall)
{
streamts_stop = 1;
dvbsub_close();
tuxtxt_stop();
tuxtxt_close();
@@ -3455,7 +3452,7 @@ void stop_daemons(bool stopall)
pthread_cancel(nhttpd_thread);
pthread_join(nhttpd_thread, NULL);
printf("httpd shutdown done\n");
pthread_join(stream_thread, NULL);
CStreamManager::getInstance()->Stop();
if(stopall) {
printf("timerd shutdown\n");
g_Timerd->shutdown();

2
src/zapit/src/capmt.cpp
View File

@@ -32,7 +32,7 @@
#include <dvbsi++/program_map_section.h>
#include <dvbsi++/ca_program_map_section.h>
#define DEBUG_CAPMT
//#define DEBUG_CAPMT
CCam::CCam()
{