439 lines
17 KiB
C++
439 lines
17 KiB
C++
#include "input_ogg.h"
|
|
#include <cerrno>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <mist/bitstream.h>
|
|
#include <mist/defines.h>
|
|
#include <mist/ogg.h>
|
|
#include <mist/opus.h>
|
|
#include <mist/stream.h>
|
|
#include <string>
|
|
|
|
///\todo Whar be Opus support?
|
|
|
|
namespace Mist{
|
|
|
|
JSON::Value segment::toJSON(OGG::oggCodec myCodec){
|
|
JSON::Value retval;
|
|
retval["time"] = time;
|
|
retval["trackid"] = tid;
|
|
std::string tmpString = "";
|
|
for (size_t i = 0; i < parts.size(); i++){tmpString += parts[i];}
|
|
retval["data"] = tmpString;
|
|
retval["bpos"] = bytepos;
|
|
if (myCodec == OGG::THEORA){
|
|
if (!theora::isHeader(tmpString.data(), tmpString.size())){
|
|
theora::header tmpHeader((char *)tmpString.data(), tmpString.size());
|
|
if (tmpHeader.getFTYPE() == 0){retval["keyframe"] = 1;}
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
inputOGG::inputOGG(Util::Config *cfg) : Input(cfg){
|
|
capa["name"] = "OGG";
|
|
capa["desc"] = "This input allows streaming of OGG files as Video on Demand.";
|
|
capa["source_match"] = "/*.ogg";
|
|
capa["source_file"] = "$source";
|
|
capa["codecs"][0u][0u].append("theora");
|
|
capa["codecs"][0u][1u].append("vorbis");
|
|
capa["codecs"][0u][1u].append("opus");
|
|
}
|
|
|
|
bool inputOGG::checkArguments(){
|
|
if (config->getString("input") == "-"){
|
|
std::cerr << "Input from stream not yet supported" << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool inputOGG::preRun(){
|
|
// open File
|
|
inFile = fopen(config->getString("input").c_str(), "r");
|
|
if (!inFile){return false;}
|
|
return true;
|
|
}
|
|
|
|
///\todo check if all trackID (tid) instances are replaced with bitstream serial numbers
|
|
void inputOGG::parseBeginOfStream(OGG::Page &bosPage){
|
|
// long long int tid = snum2tid.size() + 1;
|
|
size_t tid = bosPage.getBitstreamSerialNumber();
|
|
size_t idx = M.trackIDToIndex(tid, getpid());
|
|
if (idx == INVALID_TRACK_ID){idx = meta.addTrack();}
|
|
if (memcmp(bosPage.getSegment(0) + 1, "theora", 6) == 0){
|
|
theora::header tmpHead((char *)bosPage.getSegment(0), bosPage.getSegmentLen(0));
|
|
oggTracks[idx].codec = OGG::THEORA;
|
|
oggTracks[idx].msPerFrame = (double)(tmpHead.getFRD() * 1000) / (double)tmpHead.getFRN(); // this should be: 1000/( tmpHead.getFRN()/ tmpHead.getFRD() )
|
|
oggTracks[idx].KFGShift = tmpHead.getKFGShift(); // store KFGShift for granule calculations
|
|
meta.setType(idx, "video");
|
|
meta.setCodec(idx, "theora");
|
|
meta.setID(idx, tid);
|
|
meta.setFpks(idx, (double)(tmpHead.getFRN() * 1000) / tmpHead.getFRD());
|
|
meta.setHeight(idx, tmpHead.getPICH());
|
|
meta.setWidth(idx, tmpHead.getPICW());
|
|
if (!M.getInit(idx).size()){
|
|
std::string init = " ";
|
|
Bit::htobs((char *)init.data(), bosPage.getPayloadSize());
|
|
init.append(bosPage.getSegment(0), bosPage.getSegmentLen(0));
|
|
meta.setInit(idx, init);
|
|
}
|
|
INFO_MSG("Track with id %zu is %s", tid, M.getCodec(tid).c_str());
|
|
}
|
|
if (memcmp(bosPage.getSegment(0) + 1, "vorbis", 6) == 0){
|
|
vorbis::header tmpHead((char *)bosPage.getSegment(0), bosPage.getSegmentLen(0));
|
|
|
|
oggTracks[idx].codec = OGG::VORBIS;
|
|
oggTracks[idx].msPerFrame = (double)1000.0f / tmpHead.getAudioSampleRate();
|
|
oggTracks[idx].channels = tmpHead.getAudioChannels();
|
|
oggTracks[idx].blockSize[0] = 1 << tmpHead.getBlockSize0();
|
|
oggTracks[idx].blockSize[1] = 1 << tmpHead.getBlockSize1();
|
|
DEVEL_MSG("vorbis trackID: %zu msperFrame %f ", tid, oggTracks[idx].msPerFrame);
|
|
// Abusing .contBuffer for temporarily storing the idHeader
|
|
bosPage.getSegment(0, oggTracks[idx].contBuffer);
|
|
|
|
meta.setType(idx, "audio");
|
|
meta.setCodec(idx, "vorbis");
|
|
meta.setRate(idx, tmpHead.getAudioSampleRate());
|
|
meta.setID(idx, tid);
|
|
meta.setChannels(idx, tmpHead.getAudioChannels());
|
|
INFO_MSG("Track with id %zu is %s", tid, M.getCodec(idx).c_str());
|
|
}
|
|
if (memcmp(bosPage.getSegment(0), "OpusHead", 8) == 0){
|
|
oggTracks[idx].codec = OGG::OPUS;
|
|
meta.setType(idx, "audio");
|
|
meta.setCodec(idx, "opus");
|
|
meta.setRate(idx, 48000);
|
|
meta.setID(idx, tid);
|
|
meta.setInit(idx, bosPage.getSegment(0), bosPage.getSegmentLen(0));
|
|
meta.setChannels(idx, M.getInit(idx)[9]);
|
|
INFO_MSG("Track with id %zu is %s", tid, M.getCodec(idx).c_str());
|
|
}
|
|
}
|
|
|
|
bool inputOGG::readHeader(){
|
|
meta.reInit(config->getString("streamname"), true);
|
|
OGG::Page myPage;
|
|
fseek(inFile, 0, SEEK_SET);
|
|
while (myPage.read(inFile)){// assumes all headers are sent before any data
|
|
size_t tid = myPage.getBitstreamSerialNumber();
|
|
size_t idx = M.trackIDToIndex(tid, getpid());
|
|
if (myPage.getHeaderType() & OGG::BeginOfStream){
|
|
parseBeginOfStream(myPage);
|
|
INFO_MSG("Read BeginOfStream for track %zu", tid);
|
|
continue; // Continue reading next pages
|
|
}
|
|
|
|
bool readAllHeaders = true;
|
|
for (std::map<size_t, OGG::oggTrack>::iterator it = oggTracks.begin(); it != oggTracks.end(); it++){
|
|
if (!it->second.parsedHeaders){
|
|
readAllHeaders = false;
|
|
break;
|
|
}
|
|
}
|
|
if (readAllHeaders){break;}
|
|
|
|
// Parsing headers
|
|
if (M.getCodec(idx) == "theora"){
|
|
for (size_t i = 0; i < myPage.getAllSegments().size(); i++){
|
|
size_t len = myPage.getSegmentLen(i);
|
|
theora::header tmpHead((char *)myPage.getSegment(i), len);
|
|
if (!tmpHead.isHeader()){// not copying the header anymore, should this check isHeader?
|
|
FAIL_MSG("Theora Header read failed!");
|
|
return false;
|
|
}
|
|
switch (tmpHead.getHeaderType()){
|
|
// Case 0 is being handled by parseBeginOfStream
|
|
case 1:{
|
|
std::string init = M.getInit(idx);
|
|
init += (char)((len >> 8) & 0xFF);
|
|
init += (char)(len & 0xFF);
|
|
init.append(myPage.getSegment(i), len);
|
|
meta.setInit(idx, init);
|
|
break;
|
|
}
|
|
case 2:{
|
|
std::string init = M.getInit(idx);
|
|
init += (char)((len >> 8) & 0xFF);
|
|
init += (char)(len & 0xFF);
|
|
init.append(myPage.getSegment(i), len);
|
|
meta.setInit(idx, init);
|
|
oggTracks[idx].lastGran = 0;
|
|
oggTracks[idx].parsedHeaders = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (M.getCodec(idx) == "vorbis"){
|
|
for (size_t i = 0; i < myPage.getAllSegments().size(); i++){
|
|
size_t len = myPage.getSegmentLen(i);
|
|
vorbis::header tmpHead((char *)myPage.getSegment(i), len);
|
|
if (!tmpHead.isHeader()){
|
|
FAIL_MSG("Header read failed!");
|
|
return false;
|
|
}
|
|
switch (tmpHead.getHeaderType()){
|
|
// Case 1 is being handled by parseBeginOfStream
|
|
case 3:{
|
|
// we have the first header stored in contBuffer
|
|
std::string init = M.getInit(idx);
|
|
init += (char)0x02;
|
|
// ID header size
|
|
for (size_t j = 0; j < (oggTracks[idx].contBuffer.size() / 255); j++){
|
|
init += (char)0xFF;
|
|
}
|
|
init += (char)(oggTracks[idx].contBuffer.size() % 255);
|
|
// Comment header size
|
|
for (size_t j = 0; j < (len / 255); j++){init += (char)0xFF;}
|
|
init += (char)(len % 255);
|
|
init += oggTracks[idx].contBuffer;
|
|
oggTracks[idx].contBuffer.clear();
|
|
init.append(myPage.getSegment(i), len);
|
|
meta.setInit(idx, init);
|
|
break;
|
|
}
|
|
case 5:{
|
|
std::string init = M.getInit(idx);
|
|
init.append(myPage.getSegment(i), len);
|
|
meta.setInit(idx, init);
|
|
oggTracks[idx].vModes = tmpHead.readModeDeque(oggTracks[idx].channels);
|
|
oggTracks[idx].parsedHeaders = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (M.getCodec(idx) == "opus"){oggTracks[idx].parsedHeaders = true;}
|
|
}
|
|
|
|
for (std::map<size_t, OGG::oggTrack>::iterator it = oggTracks.begin(); it != oggTracks.end(); it++){
|
|
fseek(inFile, 0, SEEK_SET);
|
|
INFO_MSG("Finding first data for track %zu", it->first);
|
|
position tmp = seekFirstData(it->first);
|
|
currentPositions.insert(tmp);
|
|
}
|
|
getNext();
|
|
while (thisPacket){
|
|
meta.update(thisPacket);
|
|
getNext();
|
|
}
|
|
|
|
meta.toFile(config->getString("input") + ".dtsh");
|
|
return true;
|
|
}
|
|
|
|
position inputOGG::seekFirstData(size_t idx){
|
|
fseek(inFile, 0, SEEK_SET);
|
|
position res;
|
|
res.time = 0;
|
|
res.trackID = idx;
|
|
res.segmentNo = 0;
|
|
bool readSuccesfull = true;
|
|
bool quitloop = false;
|
|
while (!quitloop){
|
|
quitloop = true;
|
|
res.bytepos = ftell(inFile);
|
|
readSuccesfull = oggTracks[idx].myPage.read(inFile);
|
|
if (!readSuccesfull){
|
|
quitloop = true; // break :(
|
|
break;
|
|
}
|
|
if (oggTracks[idx].myPage.getBitstreamSerialNumber() != M.getID(idx)){
|
|
quitloop = false;
|
|
continue;
|
|
}
|
|
if (oggTracks[idx].myPage.getHeaderType() != OGG::Plain){
|
|
quitloop = false;
|
|
continue;
|
|
}
|
|
if (oggTracks[idx].codec == OGG::OPUS){
|
|
if (std::string(oggTracks[idx].myPage.getSegment(0), 2) == "Op"){quitloop = false;}
|
|
}
|
|
if (oggTracks[idx].codec == OGG::VORBIS){
|
|
vorbis::header tmpHead((char *)oggTracks[idx].myPage.getSegment(0),
|
|
oggTracks[idx].myPage.getSegmentLen(0));
|
|
if (tmpHead.isHeader()){quitloop = false;}
|
|
}
|
|
if (oggTracks[idx].codec == OGG::THEORA){
|
|
theora::header tmpHead((char *)oggTracks[idx].myPage.getSegment(0),
|
|
oggTracks[idx].myPage.getSegmentLen(0));
|
|
if (tmpHead.isHeader()){quitloop = false;}
|
|
}
|
|
}
|
|
INFO_MSG("seek first bytepos: %" PRIu64 " tid: %zu oggTracks[idx].myPage.getHeaderType(): %d ",
|
|
res.bytepos, idx, oggTracks[idx].myPage.getHeaderType());
|
|
if (!readSuccesfull){res.trackID = 0;}
|
|
return res;
|
|
}
|
|
|
|
void inputOGG::getNext(size_t idx){
|
|
if (!currentPositions.size()){
|
|
thisPacket.null();
|
|
return;
|
|
}
|
|
bool lastCompleteSegment = false;
|
|
position curPos = *currentPositions.begin();
|
|
currentPositions.erase(currentPositions.begin());
|
|
segment thisSegment;
|
|
thisSegment.tid = curPos.trackID;
|
|
thisSegment.time = curPos.time;
|
|
thisSegment.bytepos = curPos.bytepos + curPos.segmentNo;
|
|
size_t oldSegNo = curPos.segmentNo;
|
|
fseek(inFile, curPos.bytepos, SEEK_SET);
|
|
OGG::Page curPage;
|
|
curPage.read(inFile);
|
|
thisSegment.parts.push_back(
|
|
std::string(curPage.getSegment(curPos.segmentNo), curPage.getSegmentLen(curPos.segmentNo)));
|
|
bool readFullPacket = false;
|
|
if (curPos.segmentNo == curPage.getAllSegments().size() - 1){
|
|
OGG::Page tmpPage;
|
|
uint64_t bPos;
|
|
while (!readFullPacket){
|
|
bPos = ftell(inFile); //<-- :(
|
|
if (!tmpPage.read(inFile)){break;}
|
|
if (tmpPage.getBitstreamSerialNumber() != thisSegment.tid){continue;}
|
|
curPos.bytepos = bPos;
|
|
curPos.segmentNo = 0;
|
|
if (tmpPage.getHeaderType() == OGG::Continued){
|
|
thisSegment.parts.push_back(std::string(tmpPage.getSegment(0), tmpPage.getSegmentLen(0)));
|
|
curPos.segmentNo = 1;
|
|
if (tmpPage.getAllSegments().size() == 1){continue;}
|
|
}else{
|
|
lastCompleteSegment = true; // if this segment ends on the page, use granule to sync video time
|
|
}
|
|
readFullPacket = true;
|
|
}
|
|
}else{
|
|
curPos.segmentNo++;
|
|
|
|
if ((oggTracks[curPos.trackID].codec == OGG::THEORA || oggTracks[curPos.trackID].codec == OGG::VORBIS) &&
|
|
curPage.getGranulePosition() != (0xFFFFFFFFFFFFFFFFull) &&
|
|
curPos.segmentNo == curPage.getAllSegments().size() -
|
|
1){// if the next segment is the last one on the page, the (theora) granule
|
|
// should be used to sync the time for the current segment
|
|
OGG::Page tmpPage;
|
|
while (tmpPage.read(inFile) && tmpPage.getBitstreamSerialNumber() != thisSegment.tid){}
|
|
if ((tmpPage.getBitstreamSerialNumber() == thisSegment.tid) && tmpPage.getHeaderType() == OGG::Continued){
|
|
lastCompleteSegment = true; // this segment should be used to sync time using granule
|
|
}
|
|
}
|
|
readFullPacket = true;
|
|
}
|
|
std::string tmpStr = thisSegment.toJSON(oggTracks[curPos.trackID].codec).toNetPacked();
|
|
thisPacket.reInit(tmpStr.data(), tmpStr.size());
|
|
|
|
if (oggTracks[curPos.trackID].codec == OGG::VORBIS){
|
|
size_t blockSize = 0;
|
|
Utils::bitstreamLSBF packet;
|
|
packet.append((char *)curPage.getSegment(oldSegNo), curPage.getSegmentLen(oldSegNo));
|
|
if (!packet.get(1)){
|
|
// Read index first
|
|
size_t vModeIndex = packet.get(vorbis::ilog(oggTracks[curPos.trackID].vModes.size() - 1));
|
|
blockSize =
|
|
oggTracks[curPos.trackID].blockSize[oggTracks[curPos.trackID].vModes[vModeIndex].blockFlag]; // almost
|
|
// readable.
|
|
}else{
|
|
WARN_MSG("Packet type != 0");
|
|
}
|
|
curPos.time += oggTracks[curPos.trackID].msPerFrame * (blockSize / oggTracks[curPos.trackID].channels);
|
|
}else if (oggTracks[curPos.trackID].codec == OGG::THEORA){
|
|
if (lastCompleteSegment == true && curPage.getGranulePosition() != (0xFFFFFFFFFFFFFFFFull)){// this segment should be used to sync time using granule
|
|
uint64_t parseGranuleUpper = curPage.getGranulePosition() >> oggTracks[curPos.trackID].KFGShift;
|
|
uint64_t parseGranuleLower(curPage.getGranulePosition() &
|
|
((1 << oggTracks[curPos.trackID].KFGShift) - 1));
|
|
thisSegment.time = oggTracks[curPos.trackID].msPerFrame * (parseGranuleUpper + parseGranuleLower - 1);
|
|
curPos.time = thisSegment.time;
|
|
std::string tmpStr = thisSegment.toJSON(oggTracks[curPos.trackID].codec).toNetPacked();
|
|
thisPacket.reInit(tmpStr.data(), tmpStr.size());
|
|
// INFO_MSG("thisTime: %d", thisPacket.getTime());
|
|
}
|
|
curPos.time += oggTracks[curPos.trackID].msPerFrame;
|
|
}else if (oggTracks[curPos.trackID].codec == OGG::OPUS){
|
|
if (thisSegment.parts.size()){
|
|
curPos.time += Opus::Opus_getDuration(thisSegment.parts.front().data());
|
|
}
|
|
}
|
|
if (readFullPacket){currentPositions.insert(curPos);}
|
|
}// getnext()
|
|
|
|
uint64_t inputOGG::calcGranuleTime(size_t tid, uint64_t granule){
|
|
size_t idx = M.trackIDToIndex(tid, getpid());
|
|
switch (oggTracks[idx].codec){
|
|
case OGG::VORBIS:
|
|
return granule * oggTracks[idx].msPerFrame; //= samples * samples per second
|
|
break;
|
|
case OGG::OPUS:
|
|
return granule / 48; // always 48kHz
|
|
break;
|
|
case OGG::THEORA:{
|
|
uint64_t parseGranuleUpper = granule >> oggTracks[idx].KFGShift;
|
|
uint64_t parseGranuleLower = (granule & ((1 << oggTracks[idx].KFGShift) - 1));
|
|
return (parseGranuleUpper + parseGranuleLower) * oggTracks[idx].msPerFrame; //= frames * msPerFrame
|
|
break;
|
|
}
|
|
default: WARN_MSG("Unknown codec, can not calculate time from granule"); break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#ifndef _GNU_SOURCE
|
|
void *memrchr(const void *s, int c, size_t n){
|
|
const unsigned char *cp;
|
|
if (n != 0){
|
|
cp = (unsigned char *)s + n;
|
|
do{
|
|
if (*(--cp) == (unsigned char)c) return ((void *)cp);
|
|
}while (--n != 0);
|
|
}
|
|
return ((void *)0);
|
|
}
|
|
#endif
|
|
|
|
void inputOGG::seek(uint64_t seekTime, size_t idx){
|
|
currentPositions.clear();
|
|
MEDIUM_MSG("Seeking to %" PRIu64 "ms", seekTime);
|
|
|
|
// for every track
|
|
for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); it++){
|
|
// find first keyframe before keyframe with ms > seektime
|
|
position tmpPos;
|
|
tmpPos.trackID = it->first;
|
|
DTSC::Keys keys(M.keys(it->first));
|
|
tmpPos.time = keys.getTime(keys.getFirstValid());
|
|
tmpPos.bytepos = keys.getBpos(keys.getFirstValid());
|
|
for (size_t i = keys.getFirstValid(); i < keys.getEndValid(); ++i){
|
|
if (keys.getTime(i) > seekTime){
|
|
break;
|
|
}else{
|
|
tmpPos.time = keys.getTime(i);
|
|
tmpPos.bytepos = keys.getBpos(i);
|
|
}
|
|
}
|
|
INFO_MSG("Found %" PRIu64 "ms for track %zu at %" PRIu64 " bytepos %" PRIu64, seekTime,
|
|
it->first, tmpPos.time, tmpPos.bytepos);
|
|
int backChrs = std::min((uint64_t)280, tmpPos.bytepos - 1);
|
|
fseek(inFile, tmpPos.bytepos - backChrs, SEEK_SET);
|
|
char buffer[300];
|
|
fread(buffer, 300, 1, inFile);
|
|
char *loc = buffer + backChrs + 2; // start at tmpPos.bytepos+2
|
|
while (loc && !(loc[0] == 'O' && loc[1] == 'g' && loc[2] == 'g' && loc[3] == 'S')){
|
|
loc = (char *)memrchr(buffer, 'O', (loc - buffer) - 1); // seek reverse
|
|
}
|
|
if (!loc){
|
|
INFO_MSG("Unable to find a page boundary starting @ %" PRIu64 ", track %zu", tmpPos.bytepos, it->first);
|
|
continue;
|
|
}
|
|
tmpPos.segmentNo = backChrs - (loc - buffer);
|
|
tmpPos.bytepos -= tmpPos.segmentNo;
|
|
INFO_MSG("Track %zu, segment %zu found at bytepos %" PRIu64, it->first, tmpPos.segmentNo,
|
|
tmpPos.bytepos);
|
|
|
|
currentPositions.insert(tmpPos);
|
|
}
|
|
}
|
|
}// namespace Mist
|