498 lines
17 KiB
C++
498 lines
17 KiB
C++
#include <cerrno>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <mist/defines.h>
|
|
#include <mist/stream.h>
|
|
#include <string>
|
|
|
|
#include <mist/bitfields.h>
|
|
#include <mist/util.h>
|
|
|
|
#include "input_dtsc.h"
|
|
|
|
namespace Mist{
|
|
InputDTSC::InputDTSC(Util::Config *cfg) : Input(cfg){
|
|
capa["name"] = "DTSC";
|
|
capa["desc"] = "Load DTSC files as Video on Demand sources, or dtsc:// URLs from other "
|
|
"instances for live sources. This is the optimal method to pull live "
|
|
"sources from MistServer compatible instances.";
|
|
capa["priority"] = 9;
|
|
capa["source_match"].append("/*.dtsc");
|
|
capa["source_match"].append("dtsc://*");
|
|
capa["always_match"].append("dtsc://*"); // can be said to always-on mode
|
|
capa["source_file"] = "$source";
|
|
capa["codecs"]["video"].append("H264");
|
|
capa["codecs"]["video"].append("H263");
|
|
capa["codecs"]["video"].append("VP6");
|
|
capa["codecs"]["video"].append("theora");
|
|
capa["codecs"]["audio"].append("AAC");
|
|
capa["codecs"]["audio"].append("MP3");
|
|
capa["codecs"]["audio"].append("vorbis");
|
|
|
|
JSON::Value option;
|
|
option["arg"] = "integer";
|
|
option["long"] = "buffer";
|
|
option["short"] = "b";
|
|
option["help"] = "Live stream DVR buffer time in ms";
|
|
option["value"].append(50000);
|
|
config->addOption("bufferTime", option);
|
|
capa["optional"]["DVR"]["name"] = "Buffer time (ms)";
|
|
capa["optional"]["DVR"]["help"] =
|
|
"The target available buffer time for this live stream, in milliseconds. This is the time "
|
|
"available to seek around in, and will automatically be extended to fit whole keyframes as "
|
|
"well as the minimum duration needed for stable playback.";
|
|
capa["optional"]["DVR"]["option"] = "--buffer";
|
|
capa["optional"]["DVR"]["type"] = "uint";
|
|
capa["optional"]["DVR"]["default"] = 50000;
|
|
/*LTS-START*/
|
|
option.null();
|
|
option["arg"] = "integer";
|
|
option["long"] = "segment-size";
|
|
option["short"] = "S";
|
|
option["help"] = "Target time duration in milliseconds for segments";
|
|
option["value"].append(DEFAULT_FRAGMENT_DURATION);
|
|
config->addOption("segmentsize", option);
|
|
capa["optional"]["segmentsize"]["name"] = "Segment size (ms)";
|
|
capa["optional"]["segmentsize"]["help"] = "Target time duration in milliseconds for segments.";
|
|
capa["optional"]["segmentsize"]["option"] = "--segment-size";
|
|
capa["optional"]["segmentsize"]["type"] = "uint";
|
|
capa["optional"]["segmentsize"]["default"] = DEFAULT_FRAGMENT_DURATION;
|
|
/*LTS-END*/
|
|
|
|
F = NULL;
|
|
lockCache = false;
|
|
lockNeeded = false;
|
|
}
|
|
|
|
bool InputDTSC::needsLock(){
|
|
if (!lockCache){
|
|
lockNeeded =
|
|
config->getString("input").substr(0, 7) != "dtsc://" && config->getString("input") != "-";
|
|
lockCache = true;
|
|
}
|
|
return lockNeeded;
|
|
}
|
|
|
|
void parseDTSCURI(const std::string &src, std::string &host, uint16_t &port,
|
|
std::string &password, std::string &streamName){
|
|
host = "";
|
|
port = 4200;
|
|
password = "";
|
|
streamName = "";
|
|
std::deque<std::string> matches;
|
|
if (Util::stringScan(src, "%s:%s@%s/%s", matches)){
|
|
host = matches[0];
|
|
port = atoi(matches[1].c_str());
|
|
password = matches[2];
|
|
streamName = matches[3];
|
|
return;
|
|
}
|
|
// Using default streamname
|
|
if (Util::stringScan(src, "%s:%s@%s", matches)){
|
|
host = matches[0];
|
|
port = atoi(matches[1].c_str());
|
|
password = matches[2];
|
|
return;
|
|
}
|
|
// Without password
|
|
if (Util::stringScan(src, "%s:%s/%s", matches)){
|
|
host = matches[0];
|
|
port = atoi(matches[1].c_str());
|
|
streamName = matches[2];
|
|
return;
|
|
}
|
|
// Using default port
|
|
if (Util::stringScan(src, "%s@%s/%s", matches)){
|
|
host = matches[0];
|
|
password = matches[1];
|
|
streamName = matches[2];
|
|
return;
|
|
}
|
|
// Default port, no password
|
|
if (Util::stringScan(src, "%s/%s", matches)){
|
|
host = matches[0];
|
|
streamName = matches[1];
|
|
return;
|
|
}
|
|
// No password, default streamname
|
|
if (Util::stringScan(src, "%s:%s", matches)){
|
|
host = matches[0];
|
|
port = atoi(matches[1].c_str());
|
|
return;
|
|
}
|
|
// Default port and streamname
|
|
if (Util::stringScan(src, "%s@%s", matches)){
|
|
host = matches[0];
|
|
password = matches[1];
|
|
return;
|
|
}
|
|
// Default port and streamname, no password
|
|
if (Util::stringScan(src, "%s", matches)){
|
|
host = matches[0];
|
|
return;
|
|
}
|
|
}
|
|
|
|
void InputDTSC::parseStreamHeader(){
|
|
while (srcConn.connected() && config->is_active){
|
|
srcConn.spool();
|
|
if (!srcConn.Received().available(8)){
|
|
Util::sleep(100);
|
|
keepAlive();
|
|
continue;
|
|
}
|
|
|
|
if (srcConn.Received().copy(4) != "DTCM" && srcConn.Received().copy(4) != "DTSC"){
|
|
INFO_MSG("Received a wrong type of packet - '%s'", srcConn.Received().copy(4).c_str());
|
|
break;
|
|
}
|
|
// Command message
|
|
std::string toRec = srcConn.Received().copy(8);
|
|
uint32_t rSize = Bit::btohl(toRec.c_str() + 4);
|
|
if (!srcConn.Received().available(8 + rSize)){
|
|
keepAlive();
|
|
Util::sleep(100);
|
|
continue; // abort - not enough data yet
|
|
}
|
|
// Ignore initial DTCM message, as this is a "hi" message from the server
|
|
if (srcConn.Received().copy(4) == "DTCM"){
|
|
srcConn.Received().remove(8 + rSize);
|
|
continue;
|
|
}
|
|
std::string dataPacket = srcConn.Received().remove(8 + rSize);
|
|
DTSC::Packet metaPack(dataPacket.data(), dataPacket.size());
|
|
DTSC::Meta nM("", metaPack.getScan());
|
|
meta.reInit(streamName, false);
|
|
meta.merge(nM, true, false);
|
|
meta.setBootMsOffset(nM.getBootMsOffset());
|
|
std::set<size_t> validTracks = M.getMySourceTracks(getpid());
|
|
userSelect.clear();
|
|
for (std::set<size_t>::iterator it = validTracks.begin(); it != validTracks.end(); ++it){
|
|
userSelect[*it].reload(streamName, *it, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool InputDTSC::openStreamSource(){
|
|
std::string source = config->getString("input");
|
|
if (source == "-"){
|
|
srcConn.open(fileno(stdout), fileno(stdin));
|
|
return true;
|
|
}
|
|
if (source.find("dtsc://") == 0){source.erase(0, 7);}
|
|
std::string host;
|
|
uint16_t port;
|
|
std::string password;
|
|
std::string streamName;
|
|
parseDTSCURI(source, host, port, password, streamName);
|
|
std::string givenStream = config->getString("streamname");
|
|
if (streamName == ""){streamName = givenStream;}
|
|
srcConn.open(host, port, true);
|
|
if (!srcConn.connected()){return false;}
|
|
JSON::Value prep;
|
|
prep["cmd"] = "play";
|
|
prep["version"] = APPIDENT;
|
|
prep["stream"] = streamName;
|
|
srcConn.SendNow("DTCM");
|
|
char sSize[4] ={0, 0, 0, 0};
|
|
Bit::htobl(sSize, prep.packedSize());
|
|
srcConn.SendNow(sSize, 4);
|
|
prep.sendTo(srcConn);
|
|
return true;
|
|
}
|
|
|
|
void InputDTSC::closeStreamSource(){srcConn.close();}
|
|
|
|
bool InputDTSC::checkArguments(){
|
|
if (!needsLock()){return true;}
|
|
if (!config->getString("streamname").size()){
|
|
if (config->getString("output") == "-"){
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "Output to stdout not yet supported");
|
|
return false;
|
|
}
|
|
}else{
|
|
if (config->getString("output") != "-"){
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "File output in player mode not supported");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// open File
|
|
F = fopen(config->getString("input").c_str(), "r+b");
|
|
if (!F){
|
|
Util::logExitReason(ER_READ_START_FAILURE, "Could not open file %s", config->getString("input").c_str());
|
|
return false;
|
|
}
|
|
fseek(F, 0, SEEK_SET);
|
|
return true;
|
|
}
|
|
|
|
bool InputDTSC::needHeader(){
|
|
if (!needsLock()){return false;}
|
|
return Input::needHeader();
|
|
}
|
|
|
|
bool InputDTSC::readHeader(){
|
|
if (!F){
|
|
Util::logExitReason(ER_READ_START_FAILURE, "Reading header for '%s' failed: Could not open input stream", config->getString("input").c_str());
|
|
return false;
|
|
}
|
|
size_t moreHeader = 0;
|
|
do{
|
|
char hdr[8];
|
|
fseek(F, moreHeader, SEEK_SET);
|
|
if (fread(hdr, 8, 1, F) != 1){
|
|
Util::logExitReason(ER_READ_START_FAILURE, "Reading header for '%s' failed: Could not read header @ bpos %zu", config->getString("input").c_str(), moreHeader);
|
|
return false;
|
|
}
|
|
if (memcmp(hdr, DTSC::Magic_Header, 4)){
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "Reading header for '%s' failed: File does not have a DTSC header @ bpos %zu", config->getString("input").c_str(), moreHeader);
|
|
return false;
|
|
}
|
|
size_t pktLen = Bit::btohl(hdr + 4);
|
|
char *pkt = (char *)malloc(8 + pktLen * sizeof(char));
|
|
fseek(F, moreHeader, SEEK_SET);
|
|
if (fread(pkt, 8 + pktLen, 1, F) != 1){
|
|
free(pkt);
|
|
FAIL_MSG("Could not read packet @ bpos %zu", moreHeader);
|
|
}
|
|
DTSC::Scan S(pkt + 8, pktLen);
|
|
if (S.hasMember("moreheader") && S.getMember("moreheader").asInt()){
|
|
moreHeader = S.getMember("moreheader").asInt();
|
|
}else{
|
|
moreHeader = 0;
|
|
meta.reInit(isSingular() ? streamName : "", S);
|
|
}
|
|
|
|
free(pkt);
|
|
}while (moreHeader);
|
|
return meta;
|
|
}
|
|
|
|
void InputDTSC::getNext(size_t idx){
|
|
if (!needsLock()){
|
|
getNextFromStream(idx);
|
|
return;
|
|
}
|
|
if (!currentPositions.size()){
|
|
WARN_MSG("No seek positions set - returning empty packet.");
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
seekPos thisPos = *currentPositions.begin();
|
|
fseek(F, thisPos.bytePos, SEEK_SET);
|
|
if (feof(F)){
|
|
thisPacket.null();
|
|
Util::logExitReason(ER_CLEAN_EOF, "End of file reached");
|
|
return;
|
|
}
|
|
clearerr(F);
|
|
currentPositions.erase(currentPositions.begin());
|
|
lastreadpos = ftell(F);
|
|
if (fread(buffer, 4, 1, F) != 1){
|
|
if (feof(F)){
|
|
Util::logExitReason(ER_CLEAN_EOF, "End of file reached while seeking @ %" PRIu64, lastreadpos);
|
|
}else{
|
|
Util::logExitReason(ER_UNKNOWN, "Could not seek to next @ %" PRIu64, lastreadpos);
|
|
}
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
if (memcmp(buffer, DTSC::Magic_Header, 4) == 0){
|
|
seekNext(thisPacket.getTime(), thisPacket.getTrackId(), true);
|
|
getNext(idx);
|
|
return;
|
|
}
|
|
uint8_t version = 0;
|
|
if (memcmp(buffer, DTSC::Magic_Packet, 4) == 0){version = 1;}
|
|
if (memcmp(buffer, DTSC::Magic_Packet2, 4) == 0){version = 2;}
|
|
if (version == 0){
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "Invalid packet header @ %#" PRIx64 " - %.4s != %.4s @ %" PRIu64, lastreadpos,
|
|
buffer, DTSC::Magic_Packet2, lastreadpos);
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
if (fread(buffer + 4, 4, 1, F) != 1){
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "Could not read packet size @ %" PRIu64, lastreadpos);
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
std::string pBuf;
|
|
uint32_t packSize = Bit::btohl(buffer + 4);
|
|
pBuf.resize(8 + packSize);
|
|
memcpy((char *)pBuf.data(), buffer, 8);
|
|
if (fread((void *)(pBuf.data() + 8), packSize, 1, F) != 1){
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "Could not read packet @ %" PRIu64, lastreadpos);
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
thisPacket.reInit(pBuf.data(), pBuf.size());
|
|
thisTime = thisPacket.getTime();
|
|
thisIdx = thisPacket.getTrackId();
|
|
seekNext(thisPos.seekTime, thisPos.trackID);
|
|
fseek(F, thisPos.bytePos, SEEK_SET);
|
|
}
|
|
|
|
void InputDTSC::getNextFromStream(size_t idx){
|
|
thisPacket.reInit(srcConn);
|
|
while (config->is_active){
|
|
if (thisPacket.getVersion() == DTSC::DTCM){
|
|
// userClient.keepAlive();
|
|
std::string cmd;
|
|
thisPacket.getString("cmd", cmd);
|
|
if (cmd == "reset"){
|
|
// Read next packet
|
|
thisPacket.reInit(srcConn);
|
|
if (thisPacket.getVersion() != DTSC::DTSC_HEAD){
|
|
meta.clear();
|
|
continue;
|
|
}
|
|
DTSC::Meta nM("", thisPacket.getScan());
|
|
meta.merge(nM, true, false);
|
|
thisPacket.reInit(srcConn); // read the next packet before continuing
|
|
continue; // parse the next packet before returning
|
|
}
|
|
if (cmd == "error"){
|
|
thisPacket.getString("msg", cmd);
|
|
Util::logExitReason(ER_FORMAT_SPECIFIC, "%s", cmd.c_str());
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
if (cmd == "ping"){
|
|
thisPacket.reInit(srcConn);
|
|
JSON::Value prep;
|
|
prep["cmd"] = "ok";
|
|
prep["msg"] = "Pong!";
|
|
srcConn.SendNow("DTCM");
|
|
char sSize[4] ={0, 0, 0, 0};
|
|
Bit::htobl(sSize, prep.packedSize());
|
|
srcConn.SendNow(sSize, 4);
|
|
prep.sendTo(srcConn);
|
|
continue;
|
|
}
|
|
INFO_MSG("Unhandled command: %s", cmd.c_str());
|
|
thisPacket.reInit(srcConn);
|
|
continue;
|
|
}
|
|
if (thisPacket.getVersion() == DTSC::DTSC_HEAD){
|
|
DTSC::Meta nM("", thisPacket.getScan());
|
|
meta.merge(nM, false, false);
|
|
thisPacket.reInit(srcConn); // read the next packet before continuing
|
|
continue; // parse the next packet before returning
|
|
}
|
|
thisTime = thisPacket.getTime();
|
|
thisIdx = M.trackIDToIndex(thisPacket.getTrackId());
|
|
if (thisPacket.getFlag("keyframe") && M.trackValid(thisIdx)){
|
|
uint32_t shrtest_key = 0xFFFFFFFFul;
|
|
uint32_t longest_key = 0;
|
|
DTSC::Keys Mkeys(M.keys(thisIdx));
|
|
uint32_t firstKey = Mkeys.getFirstValid();
|
|
uint32_t endKey = Mkeys.getEndValid();
|
|
uint32_t checkKey = (endKey-firstKey <= 3)?firstKey:endKey-3;
|
|
for (uint32_t k = firstKey; k+1 < endKey; k++){
|
|
uint64_t kDur = Mkeys.getDuration(k);
|
|
if (!kDur){continue;}
|
|
if (kDur > longest_key && k >= checkKey){longest_key = kDur;}
|
|
if (kDur < shrtest_key){shrtest_key = kDur;}
|
|
}
|
|
if (longest_key > shrtest_key*2){
|
|
JSON::Value prep;
|
|
prep["cmd"] = "check_key_duration";
|
|
prep["id"] = (uint64_t)thisPacket.getTrackId();
|
|
prep["duration"] = longest_key;
|
|
srcConn.SendNow("DTCM");
|
|
char sSize[4] ={0, 0, 0, 0};
|
|
Bit::htobl(sSize, prep.packedSize());
|
|
srcConn.SendNow(sSize, 4);
|
|
prep.sendTo(srcConn);
|
|
INFO_MSG("Key duration %" PRIu32 " is quite long - confirming with upstream source", longest_key);
|
|
}
|
|
}
|
|
return; // we have a packet
|
|
}
|
|
}
|
|
|
|
void InputDTSC::seek(uint64_t seekTime, size_t idx){
|
|
currentPositions.clear();
|
|
if (idx != INVALID_TRACK_ID){
|
|
seekNext(seekTime, idx, true);
|
|
}else{
|
|
std::set<size_t> tracks = M.getValidTracks();
|
|
for (std::set<size_t>::iterator it = tracks.begin(); it != tracks.end(); it++){
|
|
seekNext(seekTime, *it, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputDTSC::seekNext(uint64_t ms, size_t trackIdx, bool forceSeek){
|
|
seekPos tmpPos;
|
|
tmpPos.trackID = trackIdx;
|
|
if (!forceSeek && thisPacket && ms >= thisPacket.getTime() && trackIdx >= thisPacket.getTrackId()){
|
|
tmpPos.seekTime = thisPacket.getTime();
|
|
tmpPos.bytePos = ftell(F);
|
|
}else{
|
|
tmpPos.seekTime = 0;
|
|
tmpPos.bytePos = 0;
|
|
}
|
|
if (feof(F)){
|
|
clearerr(F);
|
|
fseek(F, 0, SEEK_SET);
|
|
tmpPos.bytePos = 0;
|
|
tmpPos.seekTime = 0;
|
|
}
|
|
DTSC::Keys keys(M.keys(trackIdx));
|
|
uint32_t keyNum = M.getKeyNumForTime(trackIdx, ms);
|
|
if (keys.getTime(keyNum) > tmpPos.seekTime){
|
|
tmpPos.seekTime = keys.getTime(keyNum);
|
|
tmpPos.bytePos = keys.getBpos(keyNum);
|
|
}
|
|
bool foundPacket = false;
|
|
while (!foundPacket){
|
|
lastreadpos = ftell(F);
|
|
if (feof(F)){
|
|
WARN_MSG("Reached EOF during seek to %" PRIu64 " in track %zu - aborting @ %" PRIu64, ms,
|
|
trackIdx, lastreadpos);
|
|
return;
|
|
}
|
|
// Seek to first packet after ms.
|
|
fseek(F, tmpPos.bytePos, SEEK_SET);
|
|
lastreadpos = ftell(F);
|
|
// read the header
|
|
char header[20];
|
|
if (fread((void *)header, 20, 1, F) != 1){
|
|
WARN_MSG("Could not read header from file. Much sadface.");
|
|
return;
|
|
}
|
|
// check if packetID matches, if not, skip size + 8 bytes.
|
|
uint32_t packSize = Bit::btohl(header + 4);
|
|
uint32_t packID = Bit::btohl(header + 8);
|
|
if (memcmp(header, DTSC::Magic_Packet2, 4) != 0 || packID != trackIdx){
|
|
if (memcmp(header, "DT", 2) != 0){
|
|
WARN_MSG("Invalid header during seek to %" PRIu64 " in track %zu @ %" PRIu64
|
|
" - resetting bytePos from %" PRIu64 " to zero",
|
|
ms, trackIdx, lastreadpos, tmpPos.bytePos);
|
|
tmpPos.bytePos = 0;
|
|
continue;
|
|
}
|
|
tmpPos.bytePos += 8 + packSize;
|
|
continue;
|
|
}
|
|
// get timestamp of packet, if too large, break, if not, skip size bytes.
|
|
uint64_t myTime = Bit::btohll(header + 12);
|
|
tmpPos.seekTime = myTime;
|
|
if (myTime >= ms){
|
|
foundPacket = true;
|
|
}else{
|
|
tmpPos.bytePos += 8 + packSize;
|
|
continue;
|
|
}
|
|
}
|
|
// HIGH_MSG("Seek to %u:%d resulted in %lli", trackIdx, ms, tmpPos.seekTime);
|
|
if (tmpPos.seekTime > 0xffffffffffffff00ll){tmpPos.seekTime = 0;}
|
|
currentPositions.insert(tmpPos);
|
|
return;
|
|
}
|
|
}// namespace Mist
|