frodovdr/dddvb
1
0
Fork 0
mirror of https://github.com/DigitalDevices/dddvb.git synced 2023-10-10 13:37:43 +02:00
Code Issues Releases Wiki Activity
1ca4a8cea5
dddvb/apps/modtest.c
drmocm 1ca4a8cea5 more changes
2023-09-16 14:56:27 +02:00

1255 lines
31 KiB
C
Raw Blame History

// for systems without O_LARGEFILE
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif
#include <sys/ioctl.h>
#include <linux/dvb/frontend.h>
#include <linux/dvb/mod.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <getopt.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
typedef uint8_t u8;
typedef uint16_t u16;
typedef int16_t s16;
typedef uint32_t u32;
typedef uint64_t u64;
#include "../ddbridge/ddbridge-mci.h"
#include "../ddbridge/ddbridge-ioctl.h"
#define NIT_PID 0x0010
#define MAXNIT 1024
#define DEFAULT_BIT_RATE_C (50870588ULL)
#define DEFAULT_BIT_RATE_T (31668449ULL)
#define TS_SIZE (188)
#define START_FREQ_T (474000000)
#define START_FREQ_C (114000000)
static int adapt = 1;
static uint32_t start_freq = START_FREQ_C;
static int dvbt = 0;
static int writeNIT = 0;
int timest = 1;
typedef struct section_data_t {
uint8_t *section;
uint16_t sec_length;
uint16_t sec_pos;
uint8_t pack_num;
} section_data;
typedef struct transponder_{
uint16_t tpid;
uint8_t delsys;
uint32_t freq;
uint8_t qam;
uint32_t symbolrate;
uint8_t bandwidth;
uint8_t guard;
uint8_t code_rate;
uint8_t trans_mode;
} transponder;
typedef struct write_data_t {
int fd_in;
int *fd_out;
char *name;
int chans;
transponder tp[32];
} write_data;
#define ADAPT_FIELD 0x20
#define MAX_PCR (2576980377599ULL) // max pcr 2^33*300-1
#define PCR_FAC (2048ULL)
#define MAXPCR (MAX_PCR*PCR_FAC)
#define PCR_FLAG 0x10
#define OPCR_FLAG 0x08
//++++++++++++++++++++++++++++++++CRC+++++++++++++++++++++++++++++++++++++
static uint32_t dvb_crc_table[256] = {
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
uint32_t dvb_crc32(uint8_t *data, int len)
{
int i;
uint32_t crc=0xffffffff;
for (i=0; i<len; i++)
crc=(crc<< 8)^dvb_crc_table[((crc>>24)^(data[i]))&0xff];
return crc;
}
void dvb_set_crc32(uint8_t *data, int len)
{
uint32_t crc;
crc=dvb_crc32(data, len);
data[len] = (uint8_t)(crc>>24);
data[len+1] = (uint8_t)(crc>>16);
data[len+2] = (uint8_t)(crc>>8);
data[len+3] = (uint8_t)(crc);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++PCR++++++++++++++++++++++++++++++++++
uint16_t get_pid(uint8_t *pid)
{
uint16_t pp;
pp = (pid[0] & 0x1f) << 8;
pp |= pid[1] &0xff;
return pp;
}
void set_pid(uint16_t pid, uint8_t *p)
{
p[0] = (p[0] & 0xE0) | ((uint8_t) (pid >> 8 ) & 0x1F);
p[1] = (uint8_t) (pid);
}
int pcr_in_msecs(uint64_t pcr)
{
uint64_t PCR;
PCR = pcr/PCR_FAC;
return PCR/27000;
}
int check_pcr(uint8_t *buf)
{
if (buf[0] != 0x47) {
fprintf(stderr,"Not a TS packet header in check_pcr\n");
return -1;
}
if (buf[1] & 0x80) {
fprintf(stderr,"Corrupt packet in check_pcr\n");
return -1;
}
if (!(buf[3] & ADAPT_FIELD)){
// fprintf(stderr,"no adaptation field\n");
return 0; //no adapt. field
}
if (!buf[4]){
// fprintf(stderr,"no adaptation field length\n");
return 0; //No adaptation field length
}
if (! (buf[5] & PCR_FLAG) ){
// fprintf(stderr,"no PCR flag\n");
return 0; // no PCR FLAG
}
// fprintf(stderr,"Found pcr\n");
return 1;
}
uint8_t *get_pcr(uint8_t *buf)
{
return buf+6;
}
uint64_t convert_pcr(uint8_t *b){
uint64_t pcr;
pcr = ((uint64_t) b[0] << 25) | ((uint64_t) b[1] << 17) |
((uint64_t) b[2] << 9) | ((uint64_t) b[3] << 1) |
((uint64_t) b[4] >> 7);
pcr *= 300;
pcr += ((b[4] & 1) << 8) | b[5];
return pcr*PCR_FAC;
}
int find_pcr(uint8_t *buf, int l, int last)
{
int c = 0;
while (buf[c] != 0x47) c++;
if (last){
c+=((l-c)/TS_SIZE-1)*TS_SIZE;
while (buf[c] != 0x47) c--;
while (c >=0 && !check_pcr(buf+c)) c-=TS_SIZE;
if (check_pcr(buf+c)) return c;
else return -1;
} else {
while (c < l && !check_pcr(buf+c)) c+=TS_SIZE;
if (check_pcr(buf+c)) return c;
else return -1;
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++TS PACKETS+++++++++++++++++++++++++++
void write_filler(uint8_t *buf)
{
int j;
uint8_t *p;
p = buf;
*p++ = 0x47;
*p++ = 0x1F;
*p++ = 0xFF;
*p++ = 0x00;
for(j = 0; j < TS_SIZE-4; j+=1 ) *p++ = 0x00;
}
void setbcd(uint8_t *p, int freq, int b, int e)
{
int i;
int f = freq/e;
int r = b%2;
if (r){
p[b/2] = ( (f % 10) >> 4) & 0xF0;
f = f / 10;
}
for ( i= b/2; i > 0; i--){
p[i-1] = (f % 10) & 0x0F;
f = f / 10;
p[i-1] |= ( (f % 10) << 4) & 0xF0;
f = f / 10;
}
}
static int write_cable_delsys_descriptor (uint8_t *buf, int blength,
transponder *tp)
{
int length = 0;
uint8_t *p;
p = buf;
length = 11;
if (length > (int)(0xFF) || length+2 >blength){
fprintf(stderr,"Not enough space for cable delsys descriptor %d, %d\n",
length, blength);
return -1;
}
p[0]= 0x44; // cable delivery system descriptor
p[1]= 0x0B; // length always 11
setbcd(p+2, tp->freq, 8, 100);
p[6] = 0xFF; // reserved
p[7]= 0x02; // FEC_outer
p[8]= tp->qam; // QAM
setbcd(p+9,tp->symbolrate, 7, 100);
p[12]|= 0x0F;
return length+2;
}
static int write_terrestrial_delsys_descriptor (uint8_t *buf, int blength,
transponder *tp)
{
int length = 0;
uint8_t *p;
uint32_t freq = tp->freq/10;
p = buf;
length = 11;
if (length > (int)(0xFF) || length+2 >blength){
fprintf(stderr,"Not enough space for cable delsys descriptor %d, %d\n",
length, blength);
return -1;
}
p[0]= 0x5a; // terretrial delivery system descriptor
p[1]= 0x0B; // length always 11
p[2]= (freq >> 24) & 0xFF;
p[3]= (freq >> 16) & 0xFF;
p[4]= (freq >> 8) & 0xFF;
p[5]= freq & 0xFF;
p[6]= ((tp->bandwidth&0x7)<<5) |0x1f;
//bandwidth 8MHz 000,no priority 1,
//no time slice 1, no mpe-fce 1
p[7]= 0x00 |((tp->qam & 0x03) << 6) | (tp->code_rate &0x07);
//64-QAM 10, no hierarchy 000, 7/8 100
p[8]= 0x00 | ((tp->guard &0x03) <<3 )|((tp->trans_mode &0x03) << 1);
// no LP 000, 1/32 guard 00, 8k mode 01, no other freq 0
p[9]=0xff;
p[10]=0xff;
p[11]=0xff;
p[12]=0xff;
return length+2;
}
int CreateNIT(uint8_t *NIT, transponder *tp, int start, int stop,
char *nname, uint16_t nid, uint8_t secnum, uint8_t lastsec)
{
uint8_t *p,*lp;
int c = 0;
int cc;
int i;
uint16_t TableLen = 0;
int slen;
p = NIT;
p[0] = 0x40; // Table Id NIT = 0x40
p[1] = 0x00; // Table length determined at end
p[2] = 0x00;
p[3] = (nid >> 8) & 0xFF; // network id
p[4] = nid & 0xFF;
p[5] = 0xC3; // seq number
p[6] = secnum; // section number
p[7] = lastsec; // last section number
// Network descriptor
p[8] = 0xF0; // network descriptor length
p[9] = 0x00; // set later
TableLen = 7;
c = 10;
p[c] = 0x40; // Network name descriptor
slen = 0;
slen = strlen(nname);
p[c+1] = slen;
memcpy(p+c+2,nname,slen);
p[8] = 0xF0 | (((2+slen) >> 8) &0x0F);
p[9] = ((2+slen) & 0xFF);
TableLen += 2+slen;
c += 2+slen;
// Transport stream loop
p[c] = 0xF0; // transport stream loop length
p[c+1] = 0x00; // set later
cc = c+1;
TableLen += 2;
c += 2;
slen = 0;
for (i= start; i < stop; i++){
p[c] = (uint8_t)( tp[i].tpid >> 8 ); //transport stream id
p[c+1]= (uint8_t)( tp[i].tpid );
p[c+2]= (nid >> 8) &0xFF; // orig network id
p[c+3]= nid & 0xFF; // id
lp = p+c+4;
p[c+4]= 0xF0; // descriptor loop length
p[c+5]= 0x0D; // 13 for cable delivery descriptor
c += 6;
switch (tp->delsys){
case SYS_DVBC_ANNEX_A:
slen = write_cable_delsys_descriptor (p+c, MAXNIT-c, &tp[i]);
break;
case SYS_DVBT:
slen = write_terrestrial_delsys_descriptor (p+c, MAXNIT-c, &tp[i]);
break;
default:
slen = 0;
}
c+=slen;
lp[0] = 0xF0 | (((slen) >> 8) &0x0F);
lp[1] = ((slen) & 0xFF);
TableLen += 6+slen;
}
p[cc-1]= 0xF0 | (((c-cc-1) >> 8) &0x0F);
p[cc] = ((c-cc-1) & 0xFF);
TableLen += 4;
p[1] = 0xF0 | ((TableLen >> 8) & 0x0F);
p[2] = (uint8_t)(TableLen) & 0xFF;
dvb_set_crc32(NIT, TableLen + 3 -4 );
return TableLen+3;
}
void init_sec_data(section_data *s, uint8_t *sec, uint16_t seclength)
{
uint16_t seclen = 0;
s->section = sec;
seclen |= ((sec[1] & 0x0F) << 8);
seclen |= (sec[2] & 0xFF);
seclen += 3;
if (seclen > 3){
s->sec_length = seclen;
if(seclength && seclen != seclength)
fprintf(stderr,"Setting seclength (%d) %d\n",seclength, seclen);
} else s->sec_length = seclength;
s->sec_pos = 0;
s->pack_num = 0;
}
void write_sec_pack(section_data *s, uint8_t *ts_pack, uint16_t pid)
{
uint8_t *p = ts_pack;
uint16_t rest = 0;
uint16_t len = s->sec_length - s->sec_pos;
uint16_t pload = 0;
*p++ = 0x47;
set_pid(pid,p);
if (!s->sec_pos){
*p |= 0x40;
} else {
*p &= ~0x40;
}
p += 2;
*p++ = 0x10 | (s->pack_num & 0x0f);
s->pack_num += 1;
if (!s->sec_pos) *p++=0x00;
pload = TS_SIZE - (p - ts_pack);
if (pload > len) pload = len;
memcpy( p, s->section + s->sec_pos, pload);
p += pload;
rest = TS_SIZE - (p - ts_pack);
if (rest > 0)
memset(p, 0xff, rest);
s->sec_pos += pload;
if (s->sec_pos == s->sec_length){
s->sec_pos = 0;
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++MAIN ROUTINE++++++++++++++++++++++++++++
#define OBSIZE (672*TS_SIZE)
#define BSIZE (7*OBSIZE)
void write_mods(write_data *wd)
{
uint8_t NIT[MAXNIT];
section_data sec;
off64_t inflength,c=0;
uint8_t buffer[BSIZE];
uint8_t obuffer[OBSIZE];
int ci=0,w=0;
int isdvr=0;
int first = 0;
int last = 0;
uint64_t fpcr = 0;
uint64_t lpcr = 0;
uint64_t delta_pcr = 0;
uint64_t in_prate, out_prate;
int slen = 0;
if (dvbt){
out_prate = DEFAULT_BIT_RATE_T / (8*TS_SIZE);
} else {
out_prate = DEFAULT_BIT_RATE_C / (8*TS_SIZE);
}
slen = CreateNIT(NIT, wd->tp, 0, wd->chans, "DD", 1, 0, 0);
init_sec_data(&sec, NIT, slen);
in_prate = 0;
inflength = lseek64(wd->fd_in, 0, SEEK_END);
inflength = TS_SIZE*(inflength/TS_SIZE);
if (inflength <= 0){
if (inflength == 0 || errno == ESPIPE){
isdvr = 1;
fprintf(stderr,"Non seekable file, handling as dvr\n");
} else {
fprintf(stderr,"Error in lseek, aborting\n");
return;
}
}
if (!isdvr){
fprintf(stderr,"Input file length: %.2f MiB\n",inflength/1024./1024.);
lseek64(wd->fd_in,0,SEEK_SET);
}
fprintf(stderr,"Starting %s\n",wd->name);
while (1) {
int wc=0;
first = 0;
last = 0;
if ((ci=read(wd->fd_in,buffer,BSIZE))<0) return;
first = find_pcr(buffer, ci, 0);
last = find_pcr(buffer, ci, 1);
if (first == last){
fprintf(stderr,"Input buffer too small\n"
"first %d last %d length %d pidf 0x%x\n", first/TS_SIZE,
last/TS_SIZE,
ci/TS_SIZE, get_pid(buffer+first+1));
}
fpcr = convert_pcr(get_pcr(buffer+first));
lpcr = convert_pcr(get_pcr(buffer+last));
if (lpcr > fpcr) delta_pcr = lpcr - fpcr;
else delta_pcr = (MAXPCR-fpcr)+lpcr;
int packs = (last-first)/TS_SIZE;
in_prate = ((packs*10000/pcr_in_msecs(delta_pcr))+5)/10;
#if 0
fprintf(stderr,"delta_pcr %d ms npack %d packet_rate in: %d out: %d\n",
pcr_in_msecs(delta_pcr),
packs, in_prate, out_prate);
fprintf(stderr,"Input bitrate %.2f MBit output bitrate %.2f MBit\n",
(in_prate*TS_SIZE*8)/1000000.0,
(out_prate*TS_SIZE*8)/1000000.0);
#endif
if (in_prate > out_prate){
fprintf(stderr,"Input bitrate (%.2f MBit) larger than "
"possible output bitrate (%.2f MBit)\n",
(in_prate*TS_SIZE*8)/1000000.0,
(out_prate*TS_SIZE*8)/1000000.0);
exit(1);
}
int filler = (out_prate*10/in_prate+5)/10-1;
int d=0;
int rest=0;
for (int s = 0; s < ci; s+=TS_SIZE){
memcpy(obuffer+d, buffer+s, TS_SIZE*sizeof(uint8_t));
d+=TS_SIZE;
int fill = (OBSIZE - d)/TS_SIZE;
if (fill < filler) rest = filler - fill;
else fill = filler;
// fprintf(stderr,"d %d fill %d filler %d %d %d\n", d, fill,filler,s,ci);
int nit = 0;
for(int i=0;i < fill; i++){
if (writeNIT && nit < 4 ) {
write_sec_pack(&sec, obuffer+d, NIT_PID);
nit++;
} else write_filler(obuffer+d);
d+=TS_SIZE;
}
if (d >= OBSIZE){
for (int m = 0; m < wd->chans; m++){
int lc = 0;
while (lc < OBSIZE){
if ((w=write(wd->fd_out[m],obuffer+lc,OBSIZE-lc))<0){
fprintf(stderr,"Problem writing to modulator from %s (%d %d) %s\n",
wd->name, w, ci,strerror(errno));
return;
}
wc += w;
lc+=w;
d = 0;
}
}
}
for(int i=0;i < rest; i++){
write_filler(obuffer+d);
d+=TS_SIZE;
}
rest = 0;
}
if (inflength){
c+=ci;
fprintf(stderr,"written %d %d%%\n",(int)c,(int)((100*c)/inflength));
if (c >=inflength ){
fprintf(stderr,"Restarting stream %s\n",wd->name);
lseek64(wd->fd_in,0,SEEK_SET);
c = 0;
}
}
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++DVB DEVICES++++++++++++++++++++++++++++
#define DVB_TUNE 0
#define DVB_MOD 1
#define DVB_CA 2
#define MAX_ADAPT 32
typedef struct dvb_devices_t {
int adapters;
int dtype[MAX_ADAPT];
int ndevs[MAX_ADAPT];
uint64_t snr[MAX_ADAPT];
uint64_t hwid[MAX_ADAPT];
uint64_t devid0[MAX_ADAPT];
} dvb_devices;
static int check_tuner(int adapt)
{
char device[35];
int front = 0;
int done = 0;
while (!done) {
snprintf(device,34,"/dev/dvb/adapter%d/frontend%d",adapt,front);
// fprintf(stderr,"Checking for %s\n", device);
if(access(device, F_OK) < 0)
done=1;
else {
front++;
}
}
return front;
}
static int check_ca(int adapt)
{
char device[25];
int ca = 0;
int done = 0;
while (!done) {
snprintf(device,24,"/dev/dvb/adapter%d/ci%d",adapt,ca);
if(access(device, F_OK) < 0)
done=1;
else {
ca++;
}
}
return ca;
}
static int check_modulator(int adapt)
{
char device[25];
int mod = 0;
int done = 0;
while (!done) {
snprintf(device,24,"/dev/dvb/adapter%d/mod%d",adapt,mod);
if(access(device, F_OK) < 0)
done=1;
else {
mod++;
}
}
return mod;
}
static int check_dvb(dvb_devices *ddevices){
int done = 0;
int nadapt = 0;
int maxmod = 0;
int maxfront = 0;
int maxca = 0;
int i;
int adapter =0;
while ( nadapt < MAX_ADAPT && !done){
maxca = check_ca(nadapt);
maxmod = check_modulator(nadapt);
maxfront = check_tuner(nadapt);
if (maxmod){
ddevices->dtype[nadapt] = DVB_MOD;
ddevices->ndevs[nadapt] = maxmod;
maxmod = 0;
nadapt++;
} else {
if (maxfront) {
ddevices->dtype[nadapt] = DVB_TUNE;
ddevices->ndevs[nadapt] = maxfront;
maxfront = 0;
nadapt++;
} else {
if (maxca) {
ddevices->dtype[nadapt] = DVB_CA;
ddevices->ndevs[nadapt] = maxca;
maxca = 0;
nadapt++;
} else {
done = 1;
}
}
}
}
ddevices->adapters = nadapt;
if (!nadapt) return -1;
fprintf(stderr,"Found %d dvb adapters\n",nadapt);
for (i=0; i<nadapt; i++){
/*
if (check_sysfs(i,ddevices) < 0){
return -1;
}
*/
switch(ddevices->dtype[i]){
case DVB_TUNE:
fprintf(stderr," Adapter %d is a TUNER CARD with %d FRONTENDS\n", i, ddevices->ndevs[i]);
break;
case DVB_MOD:
fprintf(stderr," Adapter %d is a MODULATOR CARD with %d MODULATORS\n", i, ddevices->ndevs[i]);
adapter = i;
break;
case DVB_CA:
fprintf(stderr," Adapter %d is a CI CARD with %d CA \n",i,ddevices->ndevs[i]);
break;
}
}
return adapter;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++DVBT MOD++++++++++++++++++++++++++++++++
static int mci_cmd(int dev, struct mci_command *cmd)
{
int ret;
struct ddb_mci_msg msg;
uint8_t status;
memset(&msg, 0, sizeof(msg));
msg.link = 0;
memcpy(&msg.cmd, cmd, sizeof(msg.cmd));
//dump((uint8_t *) &msg.cmd, sizeof(msg.cmd));
ret = ioctl(dev, IOCTL_DDB_MCI_CMD, &msg);
if (ret < 0) {
dprintf(2, "mci_cmd error %s\n",strerror(errno));
return ret;
}
status = msg.res.status;
if (status == MCI_STATUS_OK)
return ret;
if (status == MCI_STATUS_UNSUPPORTED) {
dprintf(2, "Unsupported MCI command\n");
return ret;
}
if (status == MCI_STATUS_INVALID_PARAMETER) {
dprintf(2, "Invalid MCI parameters\n");
return ret;
}
return ret;
}
int mci_set_output(int fd, uint8_t connector, uint8_t nchannels, uint8_t unit,
int16_t power)
{
char con[14];
char un[6];
struct mci_command msg_output = {
.mod_command = MOD_SETUP_OUTPUT,
.mod_channel = 0,
.mod_stream = 0,
.mod_setup_output = {
.connector = MOD_CONNECTOR_F,
.num_channels = 14,
.unit = MOD_UNIT_DBUV,
.channel_power = 9000,
},
};
msg_output.mod_setup_output.connector = connector;
msg_output.mod_setup_output.num_channels = nchannels;
msg_output.mod_setup_output.unit = unit;
msg_output.mod_setup_output.channel_power = power;
switch (connector){
case MOD_CONNECTOR_F:
snprintf(con, 14, "F-Connector");
break;
case MOD_CONNECTOR_SMA:
snprintf(con, 14, "SMA-Connector");
break;
case MOD_CONNECTOR_OFF:
snprintf(con, 14, "off");
break;
default:
fprintf(stderr,"unknown connector in modulator setup\n");
return -1;
break;
}
switch (unit){
case MOD_UNIT_DBUV:
snprintf(un, 6, " dBuV");
break;
case MOD_UNIT_DBM:
snprintf(un, 6, " dBm");
break;
default:
fprintf(stderr,"unknow power unit in modulator setup\n");
return -1;
break;
}
fprintf(stderr,"Setting DVB Modulator output to %s, %d channels, power %f%s\n",
con, nchannels, (double)power/100, un );
return mci_cmd(fd,&msg_output);
}
int mci_set_output_simple(int adapt, uint8_t nchannels)
{
char fn[128];
int re = 0;
snprintf(fn, 127, "/dev/dvb/adapter%u/mod0", adapt);
int fd = open(fn, O_RDWR);
if (fd < 0) {
fprintf(stderr, "Could not open %s\n", fn);
return -1;
}
re = mci_set_output(fd, MOD_CONNECTOR_F, nchannels, MOD_UNIT_DBUV, 9000);
close(fd);
return re;
}
int mci_set_channels(int fd, uint32_t freq, uint8_t nchan, uint8_t standard,
uint32_t offset, uint32_t bandw)
{
char stand[25];
struct mci_command msg_channels = {
.mod_command = MOD_SETUP_CHANNELS,
.mod_channel = 0,
.mod_stream = 0,
.mod_setup_channels[0] = {
.flags = MOD_SETUP_FLAG_FIRST|MOD_SETUP_FLAG_LAST|MOD_SETUP_FLAG_VALID,
.standard = MOD_STANDARD_DVBT_8,
.num_channels = 25,
.frequency = 474000000,
},
};
msg_channels.mod_setup_channels[0].frequency = freq;
msg_channels.mod_setup_channels[0].num_channels = nchan;
msg_channels.mod_setup_channels[0].standard = standard;
if (standard == MOD_STANDARD_GENERIC){
msg_channels.mod_setup_channels[0].offset = offset;
msg_channels.mod_setup_channels[0].bandwidth = bandw;
}
switch(standard){
case MOD_STANDARD_GENERIC:
snprintf(stand, 24, "MOD_STANDARD_GENERIC");
break;
case MOD_STANDARD_DVBT_8:
snprintf(stand, 24, "MOD_STANDARD_DVBT_8");
break;
case MOD_STANDARD_DVBT_7:
snprintf(stand, 24, "MOD_STANDARD_DVBT_7");
break;
case MOD_STANDARD_DVBT_6:
snprintf(stand, 24, "MOD_STANDARD_DVBT_6");
break;
case MOD_STANDARD_DVBT_5:
snprintf(stand, 24, "MOD_STANDARD_DVBT_5");
break;
default:
fprintf(stderr,"unknown standard in channels setup\n");
return -1;
break;
}
fprintf(stderr,"Setting DVB Modulator channels to %d HZ, %d channels, %s\n",
freq, nchan, stand);
return mci_cmd(fd,&msg_channels);
}
int mci_set_channels_simple(int adapt, uint32_t freq, uint8_t nchan)
{
char fn[128];
int re = 0;
snprintf(fn, 127, "/dev/dvb/adapter%u/mod0", adapt);
int fd = open(fn, O_RDWR);
if (fd < 0) {
fprintf(stderr, "Could not open %s\n", fn);
return -1;
}
re = mci_set_channels(fd, freq, nchan, MOD_STANDARD_DVBT_8, 0, 0);
close(fd);
return re;
}
int mci_set_stream( int fd, uint8_t stream, uint8_t channel, uint8_t standard,
uint8_t stream_format, uint32_t symbol_rate,
uint8_t modulation, uint8_t rolloff,
uint8_t fft_size, uint8_t guard_interval,
uint8_t puncture_rate, uint8_t constellation,
uint16_t cell_identifier)
{
struct mci_command msg_stream = {
.mod_command = MOD_SETUP_STREAM,
.mod_channel = 0,
.mod_stream = 0,
.mod_setup_stream = {
.standard = MOD_STANDARD_DVBC_8,
},
};
msg_stream.mod_channel = channel;
msg_stream.mod_stream = stream;
msg_stream.mod_setup_stream.standard = standard;
msg_stream.mod_setup_stream.stream_format = stream_format;
if (symbol_rate)
msg_stream.mod_setup_stream.symbol_rate = symbol_rate;
if (modulation)
msg_stream.mod_setup_stream.qam.modulation = modulation;
if (rolloff)
msg_stream.mod_setup_stream.qam.rolloff = rolloff;
msg_stream.mod_setup_stream.ofdm.fft_size = fft_size;
msg_stream.mod_setup_stream.ofdm.guard_interval = guard_interval;
msg_stream.mod_setup_stream.ofdm.puncture_rate = puncture_rate;
msg_stream.mod_setup_stream.ofdm.constellation = constellation;
if (cell_identifier)
msg_stream.mod_setup_stream.ofdm.cell_identifier = cell_identifier;
fprintf(stderr,"Setting DVB Stream %d to channel %d\n",stream, channel);
return mci_cmd(fd,&msg_stream);
}
void set_dvb_mods(int adapt, int chans, uint32_t start_freq,
enum fe_delivery_system delsys, write_data *wd)
{
if ((mci_set_output_simple(adapt, chans) < 0)||
(mci_set_channels_simple(adapt, start_freq, chans)< 0))
{
fprintf(stderr,"Error setting up DVB Modulator\n");
exit(1);
}
wd->chans = chans;
wd->fd_out = (int *)malloc(chans*sizeof(int));
memset(wd->fd_out,0,chans*sizeof(int));
for (int i = 0; i < chans; i++){
char *device;
int fd;
wd->tp[i].tpid = i;
wd->tp[i].delsys = delsys;
wd->tp[i].freq = start_freq+8000000*i;
switch(delsys){
case SYS_DVBT:
wd->tp[i].qam = 2;
wd->tp[i].symbolrate = 0;
wd->tp[i].bandwidth = 0;
wd->tp[i].guard = 0;
wd->tp[i].code_rate = 4;
wd->tp[i].trans_mode = MOD_STANDARD_DVBT_8;
break;
case SYS_DVBC_ANNEX_A:
wd->tp[i].qam = QAM_256;
wd->tp[i].symbolrate = 6900000;
wd->tp[i].bandwidth = 0;
wd->tp[i].guard = 0;
wd->tp[i].code_rate = 0;
wd->tp[i].trans_mode = 0;
break;
}
device = malloc(sizeof(char)*40);
snprintf(device,35,"/dev/dvb/adapter%d/mod%d",adapt,i);
fd = open(device, O_RDWR);
if( fd < 0 )
{
fprintf(stderr,"Error opening %s : %s\n",device,strerror(errno));
free(device);
exit(1);
}
int re= 0;
uint8_t stream_format = 4; //format is ransport stream
uint8_t fft_size = wd->tp[i].trans_mode;
switch(delsys){
case SYS_DVBC_ANNEX_A:
re = mci_set_stream( fd, i, i, MOD_STANDARD_DVBC_8,
stream_format, wd->tp[i].symbolrate,
wd->tp[i].qam, 0, 0, 0, 0, 0, 0);
break;
case SYS_DVBT:
re = mci_set_stream( fd, i, i, MOD_STANDARD_DVBT_8,
stream_format, 0,
0, 0, fft_size, wd->tp[i].guard,
wd->tp[i].code_rate, wd->tp[i].qam,
0);
break;
default:
re = -1;
}
close(fd);
free(device);
}
}
//+++++++++++++++++++++++++++++CLI++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
static void usage(char *progname)
{
printf ("usage: %s [options] <input files>\n\n",progname);
printf ("options:\n");
printf (" --adapter <n>, -a <n> : adapter number <n> of modulator card (defaults to first found)\n");
printf (" --mods <n>, -m <n> : number <n> of modulators to use (default all)\n");
printf (" --file, -i : input filename (default test.ts)\n");
printf (" --frequency, -f : start frequency in MHz (default DVB_C 114MHz, DVB-T 474MHz)\n");
printf (" --dvbt, -t : modulator is DVB-T\n");
printf (" --NIT, -n : write a minimal NIT for faster scan\n");
printf (" --help, -h : print help message\n");
printf ("\n");
printf ("\n");
exit(1);
}
static int parse_cl(int argc, char * const argv[], char **filename, int *chans)
{
int c;
int fset = 0;
*filename = strdup("test.ts");
writeNIT = 0;
dvbt = 0;
while (1){
int option_index = 0;
static struct option long_options[] = {
{"help", no_argument , NULL, 'h'},
{"dvbt", no_argument , NULL, 't'},
{"NIT", no_argument , NULL, 'n'},
{"adapter", required_argument , NULL, 'a'},
{"mods", required_argument , NULL, 'm'},
{"file", required_argument , NULL, 'i'},
{"frequency", required_argument , NULL, 'f'},
{NULL, 0, NULL, 0}
};
c = getopt_long (argc, argv, "ha:i:f:ntm:",long_options,
&option_index);
if (c == -1)
break;
switch (c){
case 'a':
adapt = (int)strtol(optarg,(char **)NULL, 0);
break;
case 'm':
*chans = (int)strtol(optarg,(char **)NULL, 0);
break;
case 'f':
fset = 1;
start_freq = strtoul(optarg, NULL, 0)*1000000;
break;
case 'i':
if (*filename){
free(*filename);
}
*filename = strdup(optarg);
break;
case 'n':
writeNIT = 1;
break;
case 't':
if (!fset) start_freq = START_FREQ_T;
dvbt = 1;
break;
case 'h':
case '?':
default:
usage(argv[0]);
}
}
return adapt;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++MAIN++++++++++++++++++++++++++++++++
int main(int argc, char **argv)
{
const char *progn = "modtest";
int maxout = 0;
int mods = 0;
char *filename;
char *device;
dvb_devices ddevices;
write_data wd;
int fd_out;
int fd_in;
int chans = 0;
printf("%s \n\n", progn);
adapt = parse_cl(argc, argv, &filename, &chans);
if (check_dvb(&ddevices)<0){
fprintf(stderr,"No DVB devices found\n");
exit(1);
}
for (int i=0; i<ddevices.adapters; i++){
if ( ddevices.dtype[i] == DVB_MOD ) {
mods++;
maxout+= ddevices.ndevs[i];
}
}
if ( !mods || !maxout ){
fprintf(stdout,"No Modulator device found\n");
exit(1);
}
fprintf(stdout,"Found %d modulator devices with %d mods\n",mods, maxout);
if (ddevices.dtype[adapt] == DVB_MOD){
fprintf(stdout,"Using adapter %d\n",adapt);
} else {
fprintf(stdout,"Adapter %d is not a modulator\n",adapt);
int i=0;
while (i< ddevices.adapters && ddevices.dtype[i] != DVB_MOD){
i++;
}
adapt = i;
fprintf(stdout,"Using adapter %d instead\n",adapt);
}
if ((fd_in = open(filename ,O_RDONLY| O_LARGEFILE)) < 0){
fprintf(stderr,"\nError opening input file:%s\n",filename);
if (!strncmp(filename,"test.ts",7)) {
fprintf(stderr,"\nYou can create the default input file test.ts\n");
fprintf(stderr,"by executing: \"make test.ts\"\n");
}
exit(1);
}
if (chans<1 || chans >ddevices.ndevs[adapt] )
chans = ddevices.ndevs[adapt];
if (dvbt){
set_dvb_mods(adapt, chans, start_freq, SYS_DVBT, &wd);
} else {
set_dvb_mods(adapt, chans, start_freq, SYS_DVBC_ANNEX_A, &wd);
}
fprintf(stderr,"Reading from %s\n", filename);
device = malloc(sizeof(char)*40);
for (int m= 0; m < chans; m++){
snprintf(device,35,"/dev/dvb/adapter%d/mod%d",adapt,m);
fd_out = open(device, O_WRONLY);
wd.fd_out[m] = fd_out;
wd.fd_in = fd_in;
wd.name = filename;
}
write_mods(&wd);
exit(0);
}
Reference in New Issue View Git Blame Copy Permalink