int
main(int argc, char **argv)
{
time_t cur_time;
pthread_t signal_thread;
pthread_t reader_thread;
pthread_t ipc_thread;
QUEUE_T *p_queue = create_queue(MAX_QUEUE);
BUFSZ *bufptr;
decoder *decoder = NULL;
splitter *splitter = NULL;
static thread_data tdata;
decoder_options dopt = {
4, /* round */
0, /* strip */
0 /* emm */
};
tdata.dopt = &dopt;
tdata.lnb = 0;
tdata.tfd = -1;
int result;
int option_index;
struct option long_options[] = {
#ifdef HAVE_LIBARIB25
{ "b25", 0, NULL, 'b'},
{ "B25", 0, NULL, 'b'},
{ "round", 1, NULL, 'r'},
{ "strip", 0, NULL, 's'},
{ "emm", 0, NULL, 'm'},
{ "EMM", 0, NULL, 'm'},
#endif
{ "LNB", 1, NULL, 'n'},
{ "lnb", 1, NULL, 'n'},
{ "udp", 0, NULL, 'u'},
{ "addr", 1, NULL, 'a'},
{ "port", 1, NULL, 'p'},
{ "http", 1, NULL, 'H'},
{ "dev", 1, NULL, 'd'},
{ "help", 0, NULL, 'h'},
{ "version", 0, NULL, 'v'},
{ "sid", 1, NULL, 'i'},
{ "tsid", 1, NULL, 't'},
{ "lch", 0, NULL, 'c'},
{0, 0, NULL, 0} /* terminate */
};
boolean use_b25 = FALSE;
boolean use_udp = FALSE;
boolean use_http = FALSE;
boolean fileless = FALSE;
boolean use_stdout = FALSE;
boolean use_splitter = FALSE;
boolean use_lch = FALSE;
char *host_to = NULL;
int port_to = 1234;
int port_http = 12345;
sock_data *sockdata = NULL;
int dev_num = 0;
int val;
char *voltage[] = {"0V", "11V", "15V"};
char *sid_list = NULL;
unsigned int tsid = 0;
int connected_socket, listening_socket;
unsigned int len;
char *channel, *pch = NULL;
while((result = getopt_long(argc, argv, "br:smn:ua:H:p:d:hvitcl:",
long_options, &option_index)) != -1) {
switch(result) {
case 'b':
use_b25 = TRUE;
fprintf(stderr, "using B25...¥n");
break;
case 's':
dopt.strip = TRUE;
fprintf(stderr, "enable B25 strip¥n");
break;
case 'm':
dopt.emm = TRUE;
fprintf(stderr, "enable B25 emm processing¥n");
break;
case 'u':
use_udp = TRUE;
host_to = "localhost";
fprintf(stderr, "enable UDP broadcasting¥n");
break;
case 'H':
use_http = TRUE;
port_http = atoi(optarg);
fprintf(stderr, "creating a http daemon¥n");
break;
case 'h':
fprintf(stderr, "¥n");
show_usage(argv[0]);
fprintf(stderr, "¥n");
show_options();
fprintf(stderr, "¥n");
exit(0);
break;
case 'v':
fprintf(stderr, "%s %s¥n", argv[0], version);
fprintf(stderr, "recorder command for DVB tuner.¥n");
exit(0);
break;
/* following options require argument */
case 'n':
val = atoi(optarg);
switch(val) {
case 11:
tdata.lnb = 1;
break;
case 15:
tdata.lnb = 2;
break;
default:
tdata.lnb = 0;
break;
}
fprintf(stderr, "LNB = %s¥n", voltage[tdata.lnb]);
break;
case 'r':
dopt.round = atoi(optarg);
fprintf(stderr, "set round %d¥n", dopt.round);
break;
case 'a':
use_udp = TRUE;
host_to = optarg;
fprintf(stderr, "UDP destination address: %s¥n", host_to);
break;
case 'p':
port_to = atoi(optarg);
fprintf(stderr, "UDP port: %d¥n", port_to);
break;
case 'd':
dev_num = atoi(optarg);
fprintf(stderr, "using device: /dev/dvb/adapter%d¥n", dev_num);
break;
case 'i':
use_splitter = TRUE;
sid_list = optarg;
break;
case 't':
tsid = atoi(optarg);
if(strlen(optarg) > 2){
if((optarg[0] == '0') && ((optarg[1] == 'X') ||(optarg[1] == 'x'))){
sscanf(optarg+2, "%x", &tsid);
}
}
fprintf(stderr, "tsid = 0x%x¥n", tsid);
break;
case 'c':
use_lch = TRUE;
break;
}
}
if(use_http){ // http-server add-
fprintf(stderr, "run as a daemon..¥n");
if(daemon(1,1)){
perror("failed to start");
return 1;
}
fprintf(stderr, "pid = %d¥n", getpid());
struct sockaddr_in sin;
int ret;
int sock_optval = 1;
listening_socket = socket(AF_INET, SOCK_STREAM, 0);
if ( listening_socket == -1 ){
perror("socket");
return 1;
}
if ( setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR,
&sock_optval, sizeof(sock_optval)) == -1 ){
perror("setsockopt");
return 1;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(port_http);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if ( bind(listening_socket, (struct sockaddr *)&sin, sizeof(sin)) < 0 ){
perror("bind");
return 1;
}
ret = listen(listening_socket, SOMAXCONN);
if ( ret == -1 ){
perror("listen");
return 1;
}
fprintf(stderr,"listening at port %d¥n", port_http);
//set rectime to the infinite
if(parse_time("-",&tdata.recsec) != 0){
return 1;
}
if(tdata.recsec == -1)
tdata.indefinite = TRUE;
}else{ // -http-server add
if(argc - optind < 3) {
if(argc - optind == 2 && use_udp) {
fprintf(stderr, "Fileless UDP broadcasting¥n");
fileless = TRUE;
tdata.wfd = -1;
}
else {
fprintf(stderr, "Some required parameters are missing!¥n");
fprintf(stderr, "Try '%s --help' for more information.¥n", argv[0]);
return 1;
}
}
fprintf(stderr, "pid = %d¥n", getpid());
if(use_lch){
set_lch(argv[optind], &pch, &sid_list, &tsid);
if(sid_list) use_splitter = TRUE;
fprintf(stderr, "tsid = 0x%x¥n", tsid);
}
if(pch == NULL) pch = argv[optind];
/* tune */
if(tune(pch, &tdata, dev_num, tsid) != 0)
return 1;
/* set recsec */
if(parse_time(argv[optind + 1], &tdata.recsec) != 0) // no other thread --yaz
return 1;
if(tdata.recsec == -1)
tdata.indefinite = TRUE;
/* open output file */
char *destfile = argv[optind + 2];
if(destfile && !strcmp("-", destfile)) {
use_stdout = TRUE;
tdata.wfd = 1; /* stdout */
}
else {
if(!fileless) {
int status;
char *path = strdup(argv[optind + 2]);
char *dir = dirname(path);
status = mkpath(dir, 0777);
if(status == -1)
perror("mkpath");
free(path);
tdata.wfd = open(argv[optind + 2], (O_RDWR | O_CREAT | O_TRUNC), 0666);
if(tdata.wfd < 0) {
fprintf(stderr, "Cannot open output file: %s¥n",
argv[optind + 2]);
return 1;
}
}
}
} // http-server add
/* initialize decoder */
if(use_b25) {
decoder = b25_startup(&dopt);
if(!decoder) {
fprintf(stderr, "Cannot start b25 decoder¥n");
fprintf(stderr, "Fall back to encrypted recording¥n");
use_b25 = FALSE;
}
}
while(1){ // http-server add-
if(use_http){
struct hostent *peer_host;
struct sockaddr_in peer_sin;
pch = NULL;
sid_list = NULL;
len = sizeof(peer_sin);
connected_socket = accept(listening_socket, (struct sockaddr *)&peer_sin, &len);
if ( connected_socket == -1 ){
perror("accept");
return 1;
}
peer_host = gethostbyaddr((char *)&peer_sin.sin_addr.s_addr,
sizeof(peer_sin.sin_addr), AF_INET);
if ( peer_host == NULL ){
fprintf(stderr, "gethostbyname failed¥n");
return 1;
}
fprintf(stderr,"connect from: %s [%s] port %d¥n", peer_host->h_name, inet_ntoa(peer_sin.sin_addr), ntohs(peer_sin.sin_port));
char buf[256];
read_line(connected_socket, buf);
fprintf(stderr,"request command is %s¥n",buf);
char s0[256],s1[256],s2[256];
sscanf(buf,"%s%s%s",s0,s1,s2);
char delim[] = "/";
channel = strtok(s1,delim);
char *sidflg = strtok(NULL,delim);
if(sidflg)
sid_list = sidflg;
if(use_lch)
set_lch(channel, &pch, &sid_list, &tsid);
if(pch == NULL) pch = channel;
fprintf(stderr,"channel is %s¥n",channel);
if(sid_list == NULL){
use_splitter = FALSE;
splitter = NULL;
}else if(!strcmp(sid_list,"all")){
use_splitter = FALSE;
splitter = NULL;
}else{
use_splitter = TRUE;
}
} // -http-server add
/* initialize splitter */
if(use_splitter) {
splitter = split_startup(sid_list);
if(splitter->sid_list == NULL) {
fprintf(stderr, "Cannot start TS splitter¥n");
return 1;
}
}
if(use_http){ // http-server add-
char header[100];
if(use_b25) {
strcpy(header, "HTTP/1.1 200 OK¥r¥nContent-Type: video/mpeg¥r¥nCache-Control: no-cache¥r¥n¥r¥n");
}else if(!strcmp(sid_list,"1seg")){
strcpy(header, "HTTP/1.1 200 OK¥r¥nContent-Type: video/mpeg¥r¥nCache-Control: no-cache¥r¥n¥r¥n");
}else{
strcpy(header, "HTTP/1.1 200 OK¥r¥nContent-Type: application/octet-stream¥r¥nCache-Control: no-cache¥r¥n¥r¥n");
}
write(connected_socket, header, strlen(header));
//set write target to http
tdata.wfd = connected_socket;
//tune
if(tune(pch, &tdata, dev_num, tsid) != 0){
fprintf(stderr, "Tuner cannot start recording¥n");
continue;
}
}else{ // -http-server add
/* initialize udp connection */
if(use_udp) {
sockdata = calloc(1, sizeof(sock_data));
struct in_addr ia;
ia.s_addr = inet_addr(host_to);
if(ia.s_addr == INADDR_NONE) {
struct hostent *hoste = gethostbyname(host_to);
if(!hoste) {
perror("gethostbyname");
return 1;
}
ia.s_addr = *(in_addr_t*) (hoste->h_addr_list[0]);
}
if((sockdata->sfd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket");
return 1;
}
sockdata->addr.sin_family = AF_INET;
sockdata->addr.sin_port = htons (port_to);
sockdata->addr.sin_addr.s_addr = ia.s_addr;
if(connect(sockdata->sfd, (struct sockaddr *)&sockdata->addr,
sizeof(sockdata->addr)) < 0) {
perror("connect");
return 1;
}
}
} // http-server add
/* prepare thread data */
tdata.queue = p_queue;
tdata.decoder = decoder;
tdata.splitter = splitter;
tdata.sock_data = sockdata;
tdata.tune_persistent = FALSE;
/* spawn signal handler thread */
init_signal_handlers(&signal_thread, &tdata);
/* spawn reader thread */
tdata.signal_thread = signal_thread;
pthread_create(&reader_thread, NULL, reader_func, &tdata);
/* spawn ipc thread */
key_t key;
key = (key_t)getpid();
if ((tdata.msqid = msgget(key, IPC_CREAT | 0666)) < 0) {
perror("msgget");
}
pthread_create(&ipc_thread, NULL, mq_recv, &tdata);
fprintf(stderr, "¥nRecording...¥n");
time(&tdata.start_time);
/* read from tuner */
while(1) {
if(f_exit)
break;
time(&cur_time);
bufptr = malloc(sizeof(BUFSZ));
if(!bufptr) {
f_exit = TRUE;
break;
}
bufptr->size = read(tdata.tfd, bufptr->buffer, MAX_READ_SIZE);
if(bufptr->size <= 0) {
if((cur_time - tdata.start_time) >= tdata.recsec && !tdata.indefinite) {
f_exit = TRUE;
enqueue(p_queue, NULL);
break;
}
else {
free(bufptr);
continue;
}
}
enqueue(p_queue, bufptr);
/* stop recording */
time(&cur_time);
if((cur_time - tdata.start_time) >= tdata.recsec && !tdata.indefinite) {
break;
}
}
/* delete message queue*/
msgctl(tdata.msqid, IPC_RMID, NULL);
pthread_kill(signal_thread, SIGUSR1);
/* wait for threads */
pthread_join(reader_thread, NULL);
pthread_join(signal_thread, NULL);
pthread_join(ipc_thread, NULL);
/* close tuner */
if(close_tuner(&tdata) != 0)
return 1;
/* release queue */
destroy_queue(p_queue);
if(use_http){ // http-server add-
//reset queue
p_queue = create_queue(MAX_QUEUE);
/* close http socket */
close(tdata.wfd);
fprintf(stderr,"connection closed. still listening at port %d¥n",port_http);
f_exit = FALSE;
}else{ // -http-server add
/* close output file */
if(!use_stdout){
fsync(tdata.wfd);
close(tdata.wfd);
}
/* free socket data */
if(use_udp) {
close(sockdata->sfd);
free(sockdata);
}
/* release decoder */
if(!use_http)
if(use_b25) {
b25_shutdown(decoder);
}
} // http-server add
if(use_splitter) {
split_shutdown(splitter);
}
if(!use_http) // http-server add
return 0;
} // http-server add
}
/** main */
int
main(int argc, char *argv[])
{
Args args = parseOption(argc, argv);
// 正常終了時戻り値
int result = 0;
boost::scoped_ptr<Recordable> tuner(NULL);
timeval tv_start;
#ifdef UDP
Udp udp;
#endif /* defined(UDP) */
#ifdef HTTP
int dest = 1; // stdout
int connected_socket = 0;
int listening_socket = 0;
#endif /* defined(HTTP) */
// 引数確認
if (!args.forever && args.recsec <= 0) {
std::cerr << "recsec must be (recsec > 0)." << std::endl;
exit(1);
}
// 録画時間の基準開始時間
time_t time_start = time(NULL);
// ログ出力先設定
std::ostream& log = args.stdout ? std::cerr : std::cout;
#ifdef HTTP
if( !args.http_mode ){
// 出力先ファイルオープン
if(!args.stdout) {
dest = open(args.destfile, (O_RDWR | O_CREAT | O_TRUNC), 0666);
if (0 > dest) {
std::cerr << "can't open file '" << args.destfile << "' to write." << std::endl;
exit(1);
}
}
}else{
struct sockaddr_in sin;
int sock_optval = 1;
int ret;
fprintf(stderr, "run as a daemon..\n");
if(daemon(1,1)){
perror("failed to start");
exit(1);
}
listening_socket = socket(AF_INET, SOCK_STREAM, 0);
if ( listening_socket == -1 ){
perror("socket");
exit(1);
}
if ( setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR, &sock_optval, sizeof(sock_optval)) == -1 ){
perror("setsockopt");
exit(1);
}
sin.sin_family = AF_INET;
sin.sin_port = htons(args.http_port);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if ( bind(listening_socket, (struct sockaddr *)&sin, sizeof(sin)) < 0 ){
perror("bind");
exit(1);
}
ret = listen(listening_socket, SOMAXCONN);
if ( ret == -1 ){
perror("listen");
exit(1);
}
fprintf(stderr,"listening at port %d\n", args.http_port);
}
while(1){
if ( args.http_mode ) {
struct sockaddr_in peer_sin;
int read_size;
unsigned int len;
char buffer[256];
char s0[256],s1[256],s2[256];
char delim[] = "/";
char *channel;
char *sidflg;
len = sizeof(peer_sin);
connected_socket = accept(listening_socket, (struct sockaddr *)&peer_sin, &len);
if ( connected_socket == -1 ) {
perror("accept");
exit(1);
}
int error;
char hbuf[NI_MAXHOST], nhbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
error = getnameinfo((struct sockaddr *)&peer_sin, sizeof(peer_sin), hbuf, sizeof(hbuf), NULL, 0, 0);
if (error) {
fprintf(stderr, "getnameinfo(): %s\n", gai_strerror(error));
exit(1);
}
error = getnameinfo((struct sockaddr *)&peer_sin, sizeof(peer_sin), nhbuf, sizeof(nhbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
if (error) {
fprintf(stderr, "getnameinfo(): %s\n", gai_strerror(error));
exit(1);
}
fprintf(stderr,"connect from: %s [%s] port %s\n", hbuf, nhbuf, sbuf);
read_size = read_line(connected_socket, buffer);
fprintf(stderr, "request command is %s\n", buffer);
// ex:GET /C8/333 HTTP/1.1
sscanf(buffer, "%s%s%s", s0, s1, s2);
channel = strtok(s1, delim);
if (channel != NULL) {
fprintf(stderr, "Channel: %s\n", channel);
parseChannel(&args, channel);
sidflg = strtok(NULL, delim);
if (sidflg != NULL) {
fprintf(stderr, "SID: %s\n", sidflg);
#ifdef TSSL
args.splitter = true;
args.sid_list = sidflg;
} else {
args.splitter = false;
args.sid_list = NULL;
#endif /* defined(TSSL) */
}
}
char header[] = "HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nCache-Control: no-cache\r\n\r\n";
write(connected_socket, header, strlen(header));
//set write target to http
dest = connected_socket;
}
#endif /* defined(HTTP) */
#ifdef B25
// B25初期化
B25Decoder b25dec;
if (args.b25) {
try {
b25dec.setRound(args.round);
b25dec.setStrip(args.strip);
b25dec.setEmmProcess(args.emm);
b25dec.open();
log << "B25Decoder initialized." << std::endl;
} catch (b25_error& e) {
std::cerr << e.what() << std::endl;
#ifdef HTTP
if (!args.http_mode) {
#endif /* defined(HTTP) */
// エラー時b25を行わず処理続行。終了ステータス1
std::cerr << "disable b25 decoding." << std::endl;
args.b25 = false;
result = 1;
#ifdef HTTP
}
#endif /* defined(HTTP) */
}
}
#endif /* defined(B25) */
#ifdef UDP
// UDP初期化
if( ! args.ip.empty() ){
try{
udp.setLog(&log);
udp.init( args.ip, args.port );
}
catch( const char* e ){
log << e << std::endl;
log << "disable UDP." << std::endl;
}
}
#endif /* defined(UDP) */
#ifdef TSSL
/* initialize splitter */
splitbuf_t splitbuf;
splitbuf.size = 0;
splitter *splitter = NULL;
int split_select_finish = TSS_ERROR;
int code;
if(args.splitter) {
splitter = split_startup(args.sid_list);
if(splitter->sid_list == NULL) {
fprintf(stderr, "Cannot start TS splitter\n");
return 1;
}
}
#endif /* defined(TSSL) */
// Tuner取得
tuner.reset(createRecordable(args.type));
#ifdef HDUS
if( args.type == TUNER_HDUS ) log << "Tuner type is HDUS." << std::endl;
else if( args.type == TUNER_HDP ) log << "Tuner type is HDP." << std::endl;
#endif /* defined(HDUS) */
// ログ出力先設定
tuner->setLog(&log);
// ロックファイル設定
if (args.lockfile != NULL) {
tuner->setDetectLockFile(args.lockfile);
}
// Tuner初期化
int retryCount = ERROR_RETRY_MAX;
while (0 < retryCount) {
try {
// チューナopen
bool r = tuner->open(args.lnb);
if (!r) {
std::cerr << "can't open tuner." << std::endl;
exit(1);
}
// チャンネル設定
tuner->setChannel(args.band, args.channel);
// 開始時SignalLevel出力
float lev_before = 0.0;
int lev_retry_count = SIGNALLEVEL_RETRY_MAX;
while (lev_before < SIGNALLEVEL_RETRY_THRESHOLD && 0 < lev_retry_count) {
lev_before = tuner->getSignalLevel();
log << "Signal level: " << lev_before << std::endl;
lev_retry_count--;
usleep(SIGNALLEVEL_RETRY_INTERVAL * 1000);
}
} catch (usb_error& e) {
// リトライ処理
retryCount--;
std::cerr << e.what();
if (retryCount <= 0) {
std::cerr << " abort." << std::endl;
exit(1);
}
std::cerr << " retry." << std::endl;
tuner->close();
usleep(ERROR_RETRY_INTERVAL * 1000);
continue;
}
break;
}
#ifndef HTTP
// 出力先ファイルオープン
FILE *dest = stdout;
if (!args.stdout) {
dest = fopen(args.destfile, "w");
if (NULL == dest) {
std::cerr << "can't open file '" << args.destfile << "' to write." << std::endl;
exit(1);
}
}
#endif /* !defined(HTTP) */
// 出力開始/時間計測
log << "Output ts file." << std::endl;
if (gettimeofday(&tv_start, NULL) < 0) {
std::cerr << "gettimeofday failed." << std::endl;
exit(1);
}
// SIGINT/SIGTERMキャッチ
struct sigaction sa;
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
struct sigaction saDefault;
memset(&saDefault, 0, sizeof(struct sigaction));
saDefault.sa_handler = SIG_DFL;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGPIPE, &sa, NULL);
uint8_t *buf = NULL;
int rlen;
// 受信スレッド起動
tuner->startStream();
// データ読み出し
uint32_t urb_error_cnt = 0;
while (!caughtSignal && (args.forever || time(NULL) <= time_start + args.recsec)) {
try {
rlen = tuner->getStream((const uint8_t **)&buf, 200);
if (0 == rlen) {
continue;
}
#ifdef B25
// B25を経由させる。
if (args.b25) {
static int f_b25_sync = 0;
try {
uint8_t *b25buf;
b25dec.put(buf, rlen);
rlen = b25dec.get((const uint8_t **)&b25buf);
if (0 == rlen) {
continue;
}
f_b25_sync = 1;
buf = b25buf;
} catch (b25_error& e) {
if( f_b25_sync == 0 && args.sync ){
log << "Wait for B25 sync" << std::endl;
continue;
}
log << "B25 Error: " << e.what() << std::endl;
log << "Continue recording without B25." << std::endl;
#ifdef HTTP
if (!args.http_mode) {
#endif /* defined(HTTP) */
// b25停止、戻り値エラー
args.b25 = false;
result = 1;
#ifdef HTTP
}
#endif /* defined(HTTP) */
}
}
#endif /* defined(B25) */
#ifdef TSSL
if (args.splitter) {
splitbuf.size = 0;
while (rlen) {
/* 分離対象PIDの抽出 */
if (split_select_finish != TSS_SUCCESS) {
split_select_finish = split_select(splitter, buf, rlen);
if (split_select_finish == TSS_NULL) {
/* mallocエラー発生 */
log << "split_select malloc failed" << std::endl;
args.splitter = false;
result = 1;
goto fin;
} else if (split_select_finish != TSS_SUCCESS) {
// 分離対象PIDが完全に抽出できるまで出力しない
// 1秒程度余裕を見るといいかも
time_t cur_time;
time(&cur_time);
if (cur_time - time_start > 4) {
args.splitter = false;
result = 1;
goto fin;
}
break;
}
}
/* 分離対象以外をふるい落とす */
code = split_ts(splitter, buf, rlen, &splitbuf);
if (code != TSS_SUCCESS) {
log << "split_ts failed" << std::endl;
break;
}
break;
}
rlen = splitbuf.size;
buf = splitbuf.buffer;
fin:
;
}
#endif /* defined(TSSL) */
#ifdef UDP
// UDP 配信
udp.send(buf, rlen);
#endif /* defined(UDP) */
#ifdef HTTP
while(rlen > 0) {
ssize_t wc;
int ws = rlen < SIZE_CHUNK ? rlen : SIZE_CHUNK;
while(ws > 0) {
wc = write(dest, buf, ws);
if(wc < 0) {
log << "write failed." << std::endl;
rlen = 0;
buf = NULL;
break;
}
ws -= wc;
rlen -= wc;
buf += wc;
}
}
#else
fwrite(buf, 1, rlen, dest);
#endif /* defined(HTTP) */
} catch (usb_error& e) {
if (urb_error_cnt <= URB_ERROR_MAX) {
log << e.what() << std::endl;
if (urb_error_cnt == URB_ERROR_MAX) {
log << "Too many URB error." << std::endl;
}
urb_error_cnt++;
}
}
}
if (caughtSignal) {
#ifdef HTTP
if( args.http_mode )
caughtSignal = false;
else
#endif /* defined(HTTP) */
log << "interrupted." << std::endl;
}
// 受信スレッド停止
tuner->stopStream();
// シグナルハンドラを戻す。
sigaction(SIGINT, &saDefault, NULL);
sigaction(SIGTERM, &saDefault, NULL);
sigaction(SIGPIPE, &saDefault, NULL);
rlen = 0;
buf = NULL;
#ifdef B25
// B25デコーダ内のデータを出力する。
if (args.b25) {
try {
b25dec.flush();
rlen = b25dec.get((const uint8_t **)&buf);
} catch (b25_error& e) {
log << "B25 Error: " << e.what() << std::endl;
result = 1;
}
}
#endif /* defined(B25) */
#ifdef TSSL
if (args.splitter) {
splitbuf.size = 0;
while (rlen) {
/* 分離対象PIDの抽出 */
if (split_select_finish != TSS_SUCCESS) {
split_select_finish = split_select(splitter, buf, rlen);
if (split_select_finish == TSS_NULL) {
/* mallocエラー発生 */
log << "split_select malloc failed" << std::endl;
args.splitter = false;
result = 1;
break;
} else if (split_select_finish != TSS_SUCCESS) {
// 分離対象PIDが完全に抽出できるまで出力しない
// 1秒程度余裕を見るといいかも
time_t cur_time;
time(&cur_time);
if (cur_time - time_start > 4) {
args.splitter = false;
result = 1;
}
break;
}
}
/* 分離対象以外をふるい落とす */
code = split_ts(splitter, buf, rlen, &splitbuf);
if (code != TSS_SUCCESS) {
log << "split_ts failed" << std::endl;
break;
}
break;
}
rlen = splitbuf.size;
buf = splitbuf.buffer;
split_shutdown(splitter);
}
#endif /* defined(TSSL) */
#ifdef HTTP
while(rlen > 0) {
ssize_t wc;
int ws = rlen < SIZE_CHUNK ? rlen : SIZE_CHUNK;
while(ws > 0) {
wc = write(dest, buf, ws);
if(wc < 0) {
log << "write failed." << std::endl;
rlen = 0;
buf = NULL;
break;
}
ws -= wc;
rlen -= wc;
buf += wc;
}
}
if( args.http_mode ){
/* close http socket */
close(dest);
fprintf(stderr,"connection closed. still listening at port %d\n", args.http_port);
}else
break;
}
#else
if (0 < rlen) {
fwrite(buf, 1, rlen, dest);
}
#endif /* defined(HTTP) */
// 時間計測
timeval tv_end;
if (gettimeofday(&tv_end, NULL) < 0) {
err(1, "gettimeofday failed.");
}
// 出力先ファイルクローズ
#ifdef HTTP
if (!args.stdout) {
close(dest);
}
#else
fflush(dest);
if (!args.stdout) {
fclose(dest);
}
#endif /* defined(HTTP) */
log << "done." << std::endl;
#ifdef UDP
// UDP クローズ
udp.shutdown();
#endif /* defined(UDP) */
// 録画時間出力
timeval rec_time;
timersub(&tv_end, &tv_start, &rec_time);
log << "Rec time: " << rec_time.tv_sec << "." << std::setfill('0') << std::setw(6) << rec_time.tv_usec << " sec." << std::endl;
// 終了時SignalLevel出力
try {
float lev_after = tuner->getSignalLevel();
log << "Signal level: " << lev_after << std::endl;
} catch (usb_error& e) {
log << e.what() << " ignored." << std::endl;
}
return result;
}
