hydrar/mistserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'development' into LTS_development

Browse source
This commit is contained in:
Erik Zandvliet 2017-07-19 17:43:11 +02:00 • committed by Thulinma
commit a2b83e0cd3
9 changed files with 675 additions and 687 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
lib/defines.h
View file

@ -37,6 +37,9 @@ static const char * DBG_LVL_LIST[] = {"NONE", "FAIL", "ERROR", "WARN", "INFO", "
#endif
#endif
#if defined(_WIN32) || defined(__CYGWIN__)
static inline void show_stackframe(){}
#else
#include <execinfo.h>
static inline void show_stackframe() {
void *trace[16];
@ -52,6 +55,7 @@ static inline void show_stackframe() {
DEBUG_MSG(0, "Backtrace[%d]: %s", i, messages[i]+p);
}
}
#endif
#else

37
lib/mp4.cpp
View file

@ -67,13 +67,25 @@ namespace MP4 {
}
}
void Box::copyFrom(const Box & rs){
clear();
if (data) {
free(data);
data = 0;
}
data = (char*)malloc(rs.data_size);
memcpy(data, rs.data, rs.data_size);
data_size = rs.data_size;
managed = true;
payloadOffset = rs.payloadOffset;
}
/// Returns the values at byte positions 4 through 7.
std::string Box::getType() {
return std::string(data + 4, 4);
}
/// Returns true if the given 4-byte boxtype is equal to the values at byte positions 4 through 7.
bool Box::isType(const char * boxType) {
bool Box::isType(const char * boxType) const {
return !memcmp(boxType, data + 4, 4);
}
@ -790,6 +802,29 @@ namespace MP4 {
return getBox(tempLoc);
}
Box containerBox::getChild(const char * boxName){
uint32_t count = getContentCount();
for (uint32_t i = 0; i < count; i++){
Box & thisChild = getContent(i);
if (thisChild.isType(boxName)){
return Box(thisChild.asBox(), false);
}
}
return Box((char*)"\000\000\000\010erro", false);
}
std::deque<Box> containerBox::getChildren(const char * boxName){
std::deque<Box> res;
uint32_t count = getContentCount();
for (uint32_t i = 0; i < count; i++){
Box & thisChild = getContent(i);
if (thisChild.isType(boxName)){
res.push_back(Box(thisChild.asBox(), false));
}
}
return res;
}
std::string containerBox::toPrettyString(uint32_t indent) {
std::stringstream r;
r << std::string(indent, ' ') << "[" << getType() << "] Container Box (" << boxedSize() << ")" << std::endl;

26
lib/mp4.h
View file

@ -26,10 +26,16 @@ namespace MP4 {
Box(const Box & rs);
Box & operator = (const Box & rs);
~Box();
operator bool() const {
return data && data_size >= 8 && !isType("erro");
}
void copyFrom(const Box & rs);
std::string getType();
bool isType(const char * boxType);
bool isType(const char * boxType) const;
bool read(FILE * newData);
bool read(std::string & newData);
uint64_t boxedSize();
uint64_t payloadSize();
char * asBox();
@ -84,6 +90,24 @@ namespace MP4 {
void setContent(Box & newContent, uint32_t no);
Box & getContent(uint32_t no, bool unsafe = false);
std::string toPrettyString(uint32_t indent = 0);
Box getChild(const char * boxName);
template <typename T>
T getChild(){
T a;
MP4::Box r = getChild(a.getType().c_str());
return (T&)r;
}
std::deque<Box> getChildren(const char * boxName);
template <typename T>
std::deque<T> getChildren(){
T a;
std::deque<Box> tmpRes = getChildren(a.getType().c_str());
std::deque<T> res;
for (std::deque<Box>::iterator it = tmpRes.begin(); it != tmpRes.end(); it++){
res.push_back((T&)*it);
}
return res;
}
};
class containerFullBox: public fullBox {

34
lib/mp4_generic.cpp
View file

@ -581,6 +581,26 @@ namespace MP4 {
return payload() + 8;
}
std::string AVCC::hexSPS(){
std::stringstream res;
char * data = getSPS();
uint32_t len = getSPSLen();
for (int i = 0; i < len; i++){
res << std::hex << std::setw(2) << std::setfill('0') << (int)data[i];
}
return res.str();
}
std::string AVCC::hexPPS(){
std::stringstream res;
char * data = getPPS();
uint32_t len = getPPSLen();
for (int i = 0; i < len; i++){
res << std::hex << std::setw(2) << std::setfill('0') << (int)data[i];
}
return res.str();
}
void AVCC::setPPSNumber(uint32_t newPPSNumber) {
int offset = 8 + getSPSLen();
setInt8(newPPSNumber, offset);
@ -617,9 +637,9 @@ namespace MP4 {
r << std::string(indent + 1, ' ') << "Compatible Profiles: " << getCompatibleProfiles() << std::endl;
r << std::string(indent + 1, ' ') << "Level: " << getLevel() << std::endl;
r << std::string(indent + 1, ' ') << "SPS Number: " << getSPSNumber() << std::endl;
r << std::string(indent + 2, ' ') << getSPSLen() << " of SPS data" << std::endl;
r << std::string(indent + 2, ' ') << getSPSLen() << " of SPS data: " << hexSPS() << std::endl;
r << std::string(indent + 1, ' ') << "PPS Number: " << getPPSNumber() << std::endl;
r << std::string(indent + 2, ' ') << getPPSLen() << " of PPS data" << std::endl;
r << std::string(indent + 2, ' ') << getPPSLen() << " of PPS data: " << hexPPS() << std::endl;
return r.str();
}
@ -634,7 +654,7 @@ namespace MP4 {
void AVCC::setPayload(std::string newPayload) {
if (!reserve(0, payloadSize(), newPayload.size())) {
DEBUG_MSG(DLVL_ERROR, "Cannot allocate enough memory for payload");
ERROR_MSG("Cannot allocate enough memory for payload");
return;
}
memcpy((char *)payload(), (char *)newPayload.c_str(), newPayload.size());
@ -842,7 +862,7 @@ namespace MP4 {
void HVCC::setPayload(std::string newPayload) {
if (!reserve(0, payloadSize(), newPayload.size())) {
DEBUG_MSG(DLVL_ERROR, "Cannot allocate enough memory for payload");
ERROR_MSG("Cannot allocate enough memory for payload");
return;
}
memcpy((char *)payload(), (char *)newPayload.c_str(), newPayload.size());
@ -1478,7 +1498,7 @@ namespace MP4 {
return r.str();
}
HDLR::HDLR(std::string & type, std::string name) {
HDLR::HDLR(const std::string & type, const std::string & name) {
memcpy(data + 4, "hdlr", 4);
//reserve an entire box, except for the string part at the end
if (!reserve(0, 8, 32)) {
@ -2571,9 +2591,7 @@ namespace MP4 {
for (unsigned int i = 0; i < getEntryCount(); i++) {
static STTSEntry temp;
temp = getSTTSEntry(i);
r << std::string(indent + 1, ' ') << "Entry[" << i << "]:" << std::endl;
r << std::string(indent + 2, ' ') << "SampleCount: " << temp.sampleCount << std::endl;
r << std::string(indent + 2, ' ') << "SampleDelta: " << temp.sampleDelta << std::endl;
r << std::string(indent + 1, ' ') << "Entry[" << i << "]: " << temp.sampleCount << " sample(s) of " << temp.sampleDelta << "ms each" << std::endl;
}
return r.str();

8
lib/mp4_generic.h
View file

@ -113,11 +113,13 @@ namespace MP4 {
void setSPS(std::string newSPS);
uint32_t getSPSLen();
char * getSPS();
std::string hexSPS();
void setPPSNumber(uint32_t newPPSNumber);
uint32_t getPPSNumber();
void setPPS(std::string newPPS);
uint32_t getPPSLen();
char * getPPS();
std::string hexPPS();
std::string asAnnexB();
void setPayload(std::string newPayload);
std::string toPrettyString(uint32_t indent = 0);
@ -333,7 +335,7 @@ namespace MP4 {
class HDLR: public Box {
public:
HDLR(std::string & type, std::string name);
HDLR(const std::string & type = "", const std::string & name = "");
void setHandlerType(const char * newHandlerType);
std::string getHandlerType();
void setName(std::string newName);
@ -472,7 +474,7 @@ namespace MP4 {
class TKHD: public fullBox {
public:
TKHD(uint32_t trackId, uint64_t duration, uint32_t width, uint32_t height);
TKHD(uint32_t trackId = 0, uint64_t duration = 0, uint32_t width = 0, uint32_t height = 0);
TKHD(DTSC::Track & track, bool fragmented);
void setCreationTime(uint64_t newCreationTime);
@ -506,7 +508,7 @@ namespace MP4 {
class MDHD: public fullBox {
public:
MDHD(uint64_t duration);
MDHD(uint64_t duration = 0);
void setCreationTime(uint64_t newCreationTime);
uint64_t getCreationTime();
void setModificationTime(uint64_t newModificationTime);

488
src/input/input_mp4.cpp
View file

@ -5,6 +5,7 @@
#include <cstdlib>
#include <cstdio>
#include <string>
#include <inttypes.h>
#include <mist/stream.h>
#include <mist/flv_tag.h>
#include <mist/defines.h>
@ -29,14 +30,12 @@ namespace Mist {
cttsBox.clear();
stszBox.clear();
stcoBox.clear();
co64Box.clear();
stco64 = false;
}
long unsigned int mp4TrackHeader::size(){
if (!stszBox.asBox()){
return 0;
}else{
return stszBox.getSampleCount();
}
uint64_t mp4TrackHeader::size(){
return (stszBox.asBox() ? stszBox.getSampleCount() : 0);
}
void mp4TrackHeader::read(MP4::TRAK & trakBox){
@ -44,80 +43,40 @@ namespace Mist {
std::string tmp;//temporary string for copying box data
MP4::Box trakLoopPeek;
timeScale = 1;
//for all in trak
for (uint32_t j = 0; j < trakBox.getContentCount(); j++){
trakLoopPeek = MP4::Box(trakBox.getContent(j).asBox(),false);
std::string trakBoxType = trakLoopPeek.getType();
if (trakBoxType == "mdia"){//fi tkhd & if mdia
MP4::Box mdiaLoopPeek;
//for all in mdia
for (uint32_t k = 0; k < ((MP4::MDIA&)trakLoopPeek).getContentCount(); k++){
mdiaLoopPeek = MP4::Box(((MP4::MDIA&)trakLoopPeek).getContent(k).asBox(),false);
std::string mdiaBoxType = mdiaLoopPeek.getType();
if (mdiaBoxType == "mdhd"){
timeScale = ((MP4::MDHD&)mdiaLoopPeek).getTimeScale();
}else if (mdiaBoxType == "minf"){//fi hdlr
//for all in minf
//get all boxes: stco stsz,stss
MP4::Box minfLoopPeek;
for (uint32_t l = 0; l < ((MP4::MINF&)mdiaLoopPeek).getContentCount(); l++){
minfLoopPeek = MP4::Box(((MP4::MINF&)mdiaLoopPeek).getContent(l).asBox(),false);
std::string minfBoxType = minfLoopPeek.getType();
///\todo more stuff here
if (minfBoxType == "stbl"){
MP4::Box stblLoopPeek;
for (uint32_t m = 0; m < ((MP4::STBL&)minfLoopPeek).getContentCount(); m++){
stblLoopPeek = MP4::Box(((MP4::STBL&)minfLoopPeek).getContent(m).asBox(),false);
std::string stblBoxType = stblLoopPeek.getType();
if (stblBoxType == "stts"){
tmp = std::string(stblLoopPeek.asBox() ,stblLoopPeek.boxedSize());
sttsBox.clear();
sttsBox.read(tmp);
}else if (stblBoxType == "ctts"){
///\todo this box should not have to be read, since its information is taken from the DTSH
tmp = std::string(stblLoopPeek.asBox() ,stblLoopPeek.boxedSize());
cttsBox.clear();
cttsBox.read(tmp);
hasCTTS = true;
}else if (stblBoxType == "stsz"){
tmp = std::string(stblLoopPeek.asBox() ,stblLoopPeek.boxedSize());
stszBox.clear();
stszBox.read(tmp);
}else if (stblBoxType == "stco" || stblBoxType == "co64"){
tmp = std::string(stblLoopPeek.asBox() ,stblLoopPeek.boxedSize());
stcoBox.clear();
stcoBox.read(tmp);
}else if (stblBoxType == "stsc"){
tmp = std::string(stblLoopPeek.asBox() ,stblLoopPeek.boxedSize());
stscBox.clear();
stscBox.read(tmp);
}
}//rof stbl
}//fi stbl
}//rof minf
}//fi minf
}//rof mdia
}//fi mdia
}//rof trak
MP4::MDIA mdiaBox = trakBox.getChild<MP4::MDIA>();
timeScale = mdiaBox.getChild<MP4::MDHD>().getTimeScale();
MP4::STBL stblBox = mdiaBox.getChild<MP4::MINF>().getChild<MP4::STBL>();
sttsBox.copyFrom(stblBox.getChild<MP4::STTS>());
cttsBox.copyFrom(stblBox.getChild<MP4::CTTS>());
stszBox.copyFrom(stblBox.getChild<MP4::STSZ>());
stcoBox.copyFrom(stblBox.getChild<MP4::STCO>());
co64Box.copyFrom(stblBox.getChild<MP4::CO64>());
stscBox.copyFrom(stblBox.getChild<MP4::STSC>());
stco64 = co64Box.isType("co64");
hasCTTS = cttsBox.isType("ctts");
}
void mp4TrackHeader::getPart(long unsigned int index, long long unsigned int & offset,unsigned int& size, long long unsigned int & timestamp, int32_t & timeOffset){
void mp4TrackHeader::getPart(uint64_t index, uint64_t & offset, uint32_t & size, uint64_t & timestamp, int32_t & timeOffset){
if (index < sampleIndex){
sampleIndex = 0;
stscStart = 0;
}
while (stscStart < stscBox.getEntryCount()){
uint64_t stscCount = stscBox.getEntryCount();
MP4::STSCEntry stscEntry;
while (stscStart < stscCount){
stscEntry = stscBox.getSTSCEntry(stscStart);
//check where the next index starts
unsigned long long nextSampleIndex;
if (stscStart + 1 < stscBox.getEntryCount()){
nextSampleIndex = sampleIndex + (stscBox.getSTSCEntry(stscStart+1).firstChunk - stscBox.getSTSCEntry(stscStart).firstChunk) * stscBox.getSTSCEntry(stscStart).samplesPerChunk;
uint64_t nextSampleIndex;
if (stscStart + 1 < stscCount){
nextSampleIndex = sampleIndex + (stscBox.getSTSCEntry(stscStart+1).firstChunk - stscEntry.firstChunk) * stscEntry.samplesPerChunk;
}else{
nextSampleIndex = stszBox.getSampleCount();
}
//if the next one is too far, we're in the right spot
if (nextSampleIndex > index){
break;
}
@ -126,19 +85,13 @@ namespace Mist {
}
if (sampleIndex > index){
FAIL_MSG("Could not complete seek - not in file (%llu > %lu)", sampleIndex, index);
FAIL_MSG("Could not complete seek - not in file (%" PRIu64 " > %" PRIu64 ")", sampleIndex, index);
}
long long unsigned stcoPlace = (stscBox.getSTSCEntry(stscStart).firstChunk - 1 ) + ((index - sampleIndex) / stscBox.getSTSCEntry(stscStart).samplesPerChunk);
long long unsigned stszStart = sampleIndex + (stcoPlace - (stscBox.getSTSCEntry(stscStart).firstChunk - 1)) * stscBox.getSTSCEntry(stscStart).samplesPerChunk;
//set the offset to the correct value
if (stcoBox.getType() == "co64"){
offset = ((MP4::CO64*)&stcoBox)->getChunkOffset(stcoPlace);
}else{
offset = stcoBox.getChunkOffset(stcoPlace);
}
uint64_t stcoPlace = (stscEntry.firstChunk - 1 ) + ((index - sampleIndex) / stscEntry.samplesPerChunk);
uint64_t stszStart = sampleIndex + (stcoPlace - (stscEntry.firstChunk - 1)) * stscEntry.samplesPerChunk;
offset = (stco64 ? co64Box.getChunkOffset(stcoPlace) : stcoBox.getChunkOffset(stcoPlace));
for (int j = stszStart; j < index; j++){
offset += stszBox.getEntrySize(j);
}
@ -150,14 +103,14 @@ namespace Mist {
}
MP4::STTSEntry tmpSTTS;
while (deltaIndex < sttsBox.getEntryCount()){
uint64_t sttsCount = sttsBox.getEntryCount();
while (deltaIndex < sttsCount){
tmpSTTS = sttsBox.getSTTSEntry(deltaIndex);
if ((index - deltaPos) < tmpSTTS.sampleCount){
break;
}else{
}
deltaTotal += tmpSTTS.sampleCount * tmpSTTS.sampleDelta;
deltaPos += tmpSTTS.sampleCount;
}
++deltaIndex;
}
timestamp = ((deltaTotal + ((index-deltaPos) * tmpSTTS.sampleDelta))*1000) / timeScale;
@ -169,20 +122,18 @@ namespace Mist {
}
if (hasCTTS){
MP4::CTTSEntry tmpCTTS;
while (offsetIndex < cttsBox.getEntryCount()){
uint32_t cttsCount = cttsBox.getEntryCount();
while (offsetIndex < cttsCount){
tmpCTTS = cttsBox.getCTTSEntry(offsetIndex);
if ((index - offsetPos) < tmpCTTS.sampleCount){
timeOffset = (tmpCTTS.sampleOffset*1000)/(int32_t)timeScale;
timeOffset = (tmpCTTS.sampleOffset*1000)/timeScale;
break;
}
offsetPos += tmpCTTS.sampleCount;
++offsetIndex;
}
}
//next lines are common for next-getting and seeking
size = stszBox.getEntrySize(index);
}
inputMP4::inputMP4(Util::Config * cfg) : Input(cfg) {
@ -220,6 +171,7 @@ namespace Mist {
std::cerr << "File output in player mode not supported" << std::endl;
return false;
}
streamName = config->getString("streamname");
}
//open File
@ -236,324 +188,230 @@ namespace Mist {
INFO_MSG("inFile failed!");
return false;
}
//make trackmap here from inFile
long long unsigned int trackNo = 0;
std::string tmp;//temp string for reading boxes.
uint32_t trackNo = 0;
//first we get the necessary header parts
while(!feof(inFile)){
std::string boxType = MP4::readBoxType(inFile);
if (boxType == "erro"){
break;
}
if (boxType=="moov"){
MP4::MOOV moovBox;
moovBox.read(inFile);
//for all box in moov
MP4::Box moovLoopPeek;
for (uint32_t i = 0; i < moovBox.getContentCount(); i++){
tmp = std::string(moovBox.getContent(i).asBox() ,moovBox.getContent(i).boxedSize());
moovLoopPeek.read(tmp);
//if trak
if (moovLoopPeek.getType() == "trak"){
//create new track entry here
trackNo ++;
headerData[trackNo].read((MP4::TRAK&)moovLoopPeek);
std::deque<MP4::TRAK> trak = moovBox.getChildren<MP4::TRAK>();
for (std::deque<MP4::TRAK>::iterator trakIt = trak.begin(); trakIt != trak.end(); trakIt++){
headerData[++trackNo].read(*trakIt);
}
continue;
}
}else if (boxType == "erro"){
break;
}else{
if (!MP4::skipBox(inFile)){//moving on to next box
DEBUG_MSG(DLVL_FAIL,"Error in skipping box, exiting");
FAIL_MSG("Error in skipping box, exiting");
return false;
}
}//fi moov
}//when at the end of the file
//seek file to 0;
}
fseeko(inFile,0,SEEK_SET);
//See whether a separate header file exists.
if (readExistingHeader()){return true;}
HIGH_MSG("Not read existing header");
trackNo = 0;
//Create header file from MP4 data
while(!feof(inFile)){
std::string boxType = MP4::readBoxType(inFile);
if (boxType=="erro"){
break;
}
if (boxType=="moov"){
MP4::MOOV moovBox;
moovBox.read(inFile);
//for all box in moov
MP4::Box moovLoopPeek;
for (uint32_t i = 0; i < moovBox.getContentCount(); i++){
tmp = std::string(moovBox.getContent(i).asBox(), moovBox.getContent(i).boxedSize());
moovLoopPeek.read(tmp);
//if trak
if (moovLoopPeek.getType() == "trak"){
//create new track entry here
long long unsigned int trackNo = myMeta.tracks.size()+1;
std::deque<MP4::TRAK> trak = moovBox.getChildren<MP4::TRAK>();
HIGH_MSG("Obtained %zu trak Boxes", trak.size());
for (std::deque<MP4::TRAK>::iterator trakIt = trak.begin(); trakIt != trak.end(); trakIt++){
uint64_t trackNo = myMeta.tracks.size()+1;
myMeta.tracks[trackNo].trackID = trackNo;
MP4::Box trakLoopPeek;
unsigned long int timeScale = 1;
//for all in trak
for (uint32_t j = 0; j < ((MP4::TRAK&)moovLoopPeek).getContentCount(); j++){
tmp = std::string(((MP4::MOOV&)moovLoopPeek).getContent(j).asBox(),((MP4::MOOV&)moovLoopPeek).getContent(j).boxedSize());
trakLoopPeek.read(tmp);
std::string trakBoxType = trakLoopPeek.getType();
//note: per track: trackID codec, type (vid/aud), init
//if tkhd
if (trakBoxType == "tkhd"){
MP4::TKHD tkhdBox(0,0,0,0);///\todo: this can be done with casting
tmp = std::string(trakLoopPeek.asBox(), trakLoopPeek.boxedSize());
tkhdBox.read(tmp);
//remember stuff for decoding stuff later
MP4::TKHD tkhdBox = trakIt->getChild<MP4::TKHD>();
if (tkhdBox.getWidth() > 0){
myMeta.tracks[trackNo].width = tkhdBox.getWidth();
myMeta.tracks[trackNo].height = tkhdBox.getHeight();
}
}else if (trakBoxType == "mdia"){//fi tkhd & if mdia
MP4::Box mdiaLoopPeek;
//for all in mdia
for (uint32_t k = 0; k < ((MP4::MDIA&)trakLoopPeek).getContentCount(); k++){
tmp = std::string(((MP4::MDIA&)trakLoopPeek).getContent(k).asBox(),((MP4::MDIA&)trakLoopPeek).getContent(k).boxedSize());
mdiaLoopPeek.read(tmp);
std::string mdiaBoxType = mdiaLoopPeek.getType();
if (mdiaBoxType == "mdhd"){
timeScale = ((MP4::MDHD&)mdiaLoopPeek).getTimeScale();
myMeta.tracks[trackNo].lang = ((MP4::MDHD&)mdiaLoopPeek).getLanguage();
}else if (mdiaBoxType == "hdlr"){//fi mdhd
std::string handlerType = ((MP4::HDLR&)mdiaLoopPeek).getHandlerType();
if (handlerType != "vide" && handlerType !="soun" && handlerType != "sbtl"){
myMeta.tracks.erase(trackNo);
//skip meta boxes for now
MP4::MDIA mdiaBox = trakIt->getChild<MP4::MDIA>();
MP4::MDHD mdhdBox = mdiaBox.getChild<MP4::MDHD>();
uint64_t timescale = mdhdBox.getTimeScale();
myMeta.tracks[trackNo].lang = mdhdBox.getLanguage();
std::string hdlrType = mdiaBox.getChild<MP4::HDLR>().getHandlerType();
if (hdlrType != "vide" && hdlrType != "soun" && hdlrType != "stbl"){
break;
}
}else if (mdiaBoxType == "minf"){//fi hdlr
//for all in minf
//get all boxes: stco stsz,stss
MP4::Box minfLoopPeek;
for (uint32_t l = 0; l < ((MP4::MINF&)mdiaLoopPeek).getContentCount(); l++){
tmp = std::string(((MP4::MINF&)mdiaLoopPeek).getContent(l).asBox(),((MP4::MINF&)mdiaLoopPeek).getContent(l).boxedSize());
minfLoopPeek.read(tmp);
std::string minfBoxType = minfLoopPeek.getType();
///\todo more stuff here
if (minfBoxType == "stbl"){
MP4::Box stblLoopPeek;
MP4::STSS stssBox;
MP4::STTS sttsBox;
MP4::STSZ stszBox;
MP4::STCO stcoBox;
MP4::STSC stscBox;
MP4::CTTS cttsBox;//optional ctts box
bool hasCTTS = false;
for (uint32_t m = 0; m < ((MP4::STBL&)minfLoopPeek).getContentCount(); m++){
tmp = std::string(((MP4::STBL&)minfLoopPeek).getContent(m).asBox(),((MP4::STBL&)minfLoopPeek).getContent(m).boxedSize());
std::string stboxRead = tmp;
stblLoopPeek.read(tmp);
std::string stblBoxType = stblLoopPeek.getType();
if (stblBoxType == "stss"){
stssBox.read(stboxRead);
}else if (stblBoxType == "stts"){
sttsBox.read(stboxRead);
}else if (stblBoxType == "stsz"){
stszBox.read(stboxRead);
}else if (stblBoxType == "stco" || stblBoxType == "co64"){
stcoBox.read(stboxRead);
}else if (stblBoxType == "stsc"){
stscBox.read(stboxRead);
}else if (stblBoxType == "ctts"){
cttsBox.read(stboxRead);
hasCTTS = true;
}else if (stblBoxType == "stsd"){
//check for codec in here
MP4::Box & tmpBox = ((MP4::STSD&)stblLoopPeek).getEntry(0);
std::string tmpType = tmpBox.getType();
INFO_MSG("Found track of type %s", tmpType.c_str());
if (tmpType == "avc1" || tmpType == "h264" || tmpType == "mp4v"){
MP4::STBL stblBox = mdiaBox.getChild<MP4::MINF>().getChild<MP4::STBL>();
MP4::STSD stsdBox = stblBox.getChild<MP4::STSD>();
MP4::Box sEntryBox = stsdBox.getEntry(0);
std::string sType = sEntryBox.getType();
HIGH_MSG("Found track %zu of type %s", trackNo, sType.c_str());
if (sType == "avc1" || sType == "h264" || sType == "mp4v"){
MP4::VisualSampleEntry & vEntryBox = (MP4::VisualSampleEntry&)sEntryBox;
myMeta.tracks[trackNo].type = "video";
myMeta.tracks[trackNo].codec = "H264";
if (!myMeta.tracks[trackNo].width){
myMeta.tracks[trackNo].width = ((MP4::VisualSampleEntry&)tmpBox).getWidth();
myMeta.tracks[trackNo].height = ((MP4::VisualSampleEntry&)tmpBox).getHeight();
myMeta.tracks[trackNo].width = vEntryBox.getWidth();
myMeta.tracks[trackNo].height = vEntryBox.getHeight();
}
MP4::Box tmpBox2 = tmpBox;
MP4::Box tmpContent = ((MP4::VisualSampleEntry&)tmpBox2).getCLAP();
if (tmpContent.getType() == "avcC"){
myMeta.tracks[trackNo].init = std::string(tmpContent.payload(),tmpContent.payloadSize());
MP4::Box initBox = vEntryBox.getCLAP();
if (initBox.isType("avcC")){
myMeta.tracks[trackNo].init.assign(initBox.payload(), initBox.payloadSize());
}
tmpContent = ((MP4::VisualSampleEntry&)tmpBox2).getPASP();
if (tmpContent.getType() == "avcC"){
myMeta.tracks[trackNo].init = std::string(tmpContent.payload(),tmpContent.payloadSize());
initBox = vEntryBox.getPASP();
if (initBox.isType("avcC")){
myMeta.tracks[trackNo].init.assign(initBox.payload(), initBox.payloadSize());
}
///this is a hacky way around invalid FLV data (since it gets ignored nearly everywhere, but we do need correct data...
if (!myMeta.tracks[trackNo].width || !myMeta.tracks[trackNo].height || !myMeta.tracks[trackNo].fpks){
if (!myMeta.tracks[trackNo].width){
h264::sequenceParameterSet sps;
sps.fromDTSCInit(myMeta.tracks[trackNo].init);
h264::SPSMeta spsChar = sps.getCharacteristics();
myMeta.tracks[trackNo].width = spsChar.width;
myMeta.tracks[trackNo].height = spsChar.height;
}
}else if (tmpType == "hev1" || tmpType == "hvc1"){
}
if (sType == "hev1" || sType == "hvc1"){
MP4::VisualSampleEntry & vEntryBox = (MP4::VisualSampleEntry&)sEntryBox;
myMeta.tracks[trackNo].type = "video";
myMeta.tracks[trackNo].codec = "HEVC";
if (!myMeta.tracks[trackNo].width){
myMeta.tracks[trackNo].width = ((MP4::VisualSampleEntry&)tmpBox).getWidth();
myMeta.tracks[trackNo].height = ((MP4::VisualSampleEntry&)tmpBox).getHeight();
myMeta.tracks[trackNo].width = vEntryBox.getWidth();
myMeta.tracks[trackNo].height = vEntryBox.getHeight();
}
MP4::Box tmpBox2 = tmpBox;
MP4::Box tmpContent = ((MP4::VisualSampleEntry&)tmpBox2).getCLAP();
if (tmpContent.getType() == "hvcC"){
myMeta.tracks[trackNo].init = std::string(tmpContent.payload(),tmpContent.payloadSize());
MP4::Box initBox = vEntryBox.getCLAP();
if (initBox.isType("hvcC")){
myMeta.tracks[trackNo].init.assign(initBox.payload(), initBox.payloadSize());
}
tmpContent = ((MP4::VisualSampleEntry&)tmpBox2).getPASP();
if (tmpContent.getType() == "hvcC"){
myMeta.tracks[trackNo].init = std::string(tmpContent.payload(),tmpContent.payloadSize());
initBox = vEntryBox.getPASP();
if (initBox.isType("hvcC")){
myMeta.tracks[trackNo].init.assign(initBox.payload(), initBox.payloadSize());
}
}else if (tmpType == "mp4a" || tmpType == "aac " || tmpType == "ac-3"){
}
if (sType == "mp4a" || sType == "aac " || sType == "ac-3"){
MP4::AudioSampleEntry & aEntryBox = (MP4::AudioSampleEntry&)sEntryBox;
myMeta.tracks[trackNo].type = "audio";
myMeta.tracks[trackNo].channels = ((MP4::AudioSampleEntry&)tmpBox).getChannelCount();
myMeta.tracks[trackNo].rate = (long long int)(((MP4::AudioSampleEntry&)tmpBox).getSampleRate());
if (tmpType == "ac-3"){
myMeta.tracks[trackNo].channels = aEntryBox.getChannelCount();
myMeta.tracks[trackNo].rate = aEntryBox.getSampleRate();
if (sType == "ac-3"){
myMeta.tracks[trackNo].codec = "AC3";
}else{
MP4::Box esds = ((MP4::AudioSampleEntry&)tmpBox).getCodecBox();
myMeta.tracks[trackNo].codec = ((MP4::ESDS&)esds).getCodec();
myMeta.tracks[trackNo].init = ((MP4::ESDS&)esds).getInitData();
MP4::ESDS esdsBox = (MP4::ESDS&)(aEntryBox.getCodecBox());
myMeta.tracks[trackNo].codec = esdsBox.getCodec();
myMeta.tracks[trackNo].init = esdsBox.getInitData();
}
myMeta.tracks[trackNo].size = 16;///\todo this might be nice to calculate from mp4 file;
//get Visual sample entry -> esds -> startcodes
}else if (tmpType == "tx3g"){//plain text subtitles
}
if (sType == "tx3g"){//plain text subtitles
myMeta.tracks[trackNo].type = "subtitle";
myMeta.tracks[trackNo].codec = "TTXT";
}else{
myMeta.tracks.erase(trackNo);
}
}
}//rof stbl
MP4::STSS stssBox = stblBox.getChild<MP4::STSS>();
MP4::STTS sttsBox = stblBox.getChild<MP4::STTS>();
MP4::STSZ stszBox = stblBox.getChild<MP4::STSZ>();
MP4::STCO stcoBox = stblBox.getChild<MP4::STCO>();
MP4::CO64 co64Box = stblBox.getChild<MP4::CO64>();
MP4::STSC stscBox = stblBox.getChild<MP4::STSC>();
MP4::CTTS cttsBox = stblBox.getChild<MP4::CTTS>();//optional ctts box
bool stco64 = co64Box.isType("co64");
bool hasCTTS = cttsBox.isType("ctts");
uint64_t totaldur = 0;///\todo note: set this to begin time
mp4PartBpos BsetPart;
long long unsigned int entryNo = 0;
long long unsigned int sampleNo = 0;
MP4::STTSEntry tempSTTS;
tempSTTS = sttsBox.getSTTSEntry(entryNo);
long long unsigned int curSTSS = 0;
bool vidTrack = (myMeta.tracks[trackNo].type == "video");
//change to for over all samples
unsigned int stcoIndex = 0;
unsigned int stscIndex = 0;
unsigned int cttsIndex = 0;//current ctts Index we are reading
unsigned int cttsEntryRead = 0;//current part of ctts we are reading
MP4::CTTSEntry cttsEntry;
unsigned int fromSTCOinSTSC = 0;
long long unsigned int tempOffset;
bool stcoIs64 = (stcoBox.getType() == "co64");
if (stcoIs64){
tempOffset = ((MP4::CO64*)&stcoBox)->getChunkOffset(0);
}else{
tempOffset = stcoBox.getChunkOffset(0);
uint64_t entryNo = 0;
uint64_t sampleNo = 0;
uint64_t stssIndex = 0;
uint64_t stcoIndex = 0;
uint64_t stscIndex = 0;
uint64_t cttsIndex = 0;//current ctts Index we are reading
uint64_t cttsEntryRead = 0;//current part of ctts we are reading
uint64_t stssCount = stssBox.getEntryCount();
uint64_t stscCount = stscBox.getEntryCount();
uint64_t stszCount = stszBox.getSampleCount();
uint64_t stcoCount = (stco64 ? co64Box.getEntryCount() : stcoBox.getEntryCount());
MP4::STTSEntry sttsEntry = sttsBox.getSTTSEntry(0);
uint32_t fromSTCOinSTSC = 0;
uint64_t tmpOffset = (stco64 ? co64Box.getChunkOffset(0) : stcoBox.getChunkOffset(0));
uint64_t nextFirstChunk = (stscCount > 1 ? stscBox.getSTSCEntry(1).firstChunk - 1 : stcoCount);
for (uint64_t stszIndex = 0; stszIndex < stszCount; ++stszIndex){
if (stcoIndex >= nextFirstChunk){
++stscIndex;
nextFirstChunk = (stscIndex + 1 < stscCount ? stscBox.getSTSCEntry(stscIndex + 1).firstChunk - 1 : stcoCount);
}
long long unsigned int nextFirstChunk;
if (stscBox.getEntryCount() > 1){
nextFirstChunk = stscBox.getSTSCEntry(1).firstChunk - 1;
}else{
if (stcoIs64){
nextFirstChunk = ((MP4::CO64*)&stcoBox)->getEntryCount();
}else{
nextFirstChunk = stcoBox.getEntryCount();
}
}
for(long long unsigned int sampleIndex = 0; sampleIndex < stszBox.getSampleCount(); sampleIndex ++){
if (stcoIndex >= nextFirstChunk){//note
stscIndex ++;
if (stscIndex + 1 < stscBox.getEntryCount()){
nextFirstChunk = stscBox.getSTSCEntry(stscIndex + 1).firstChunk - 1;
}else{
if (stcoIs64){
nextFirstChunk = ((MP4::CO64*)&stcoBox)->getEntryCount();
}else{
nextFirstChunk = stcoBox.getEntryCount();
}
}
}
if (vidTrack && curSTSS < stssBox.getEntryCount() && sampleIndex + 1 == stssBox.getSampleNumber(curSTSS)){
BsetPart.keyframe = true;
curSTSS ++;
}else{
BsetPart.keyframe = false;
BsetPart.keyframe = (myMeta.tracks[trackNo].type == "video" && stssIndex < stssCount && stszIndex + 1 == stssBox.getSampleNumber(stssIndex));
if (BsetPart.keyframe){
++stssIndex;
}
//in bpos set
BsetPart.stcoNr = stcoIndex;
//bpos = chunkoffset[samplenr] in stco
BsetPart.bpos = tempOffset;
fromSTCOinSTSC ++;
BsetPart.bpos = tmpOffset;
++fromSTCOinSTSC;
if (fromSTCOinSTSC < stscBox.getSTSCEntry(stscIndex).samplesPerChunk){//as long as we are still in this chunk
tempOffset += stszBox.getEntrySize(sampleIndex);
tmpOffset += stszBox.getEntrySize(stszIndex);
}else{
stcoIndex ++;
++stcoIndex;
fromSTCOinSTSC = 0;
if (stcoIs64){
tempOffset = ((MP4::CO64*)&stcoBox)->getChunkOffset(stcoIndex);
}else{
tempOffset = stcoBox.getChunkOffset(stcoIndex);
tmpOffset = (stco64 ? co64Box.getChunkOffset(stcoIndex) : stcoBox.getChunkOffset(stcoIndex));
}
}
//time = totaldur + stts[entry][sample]
BsetPart.time = (totaldur*1000)/timeScale;
totaldur += tempSTTS.sampleDelta;
BsetPart.time = (totaldur*1000)/timescale;
totaldur += sttsEntry.sampleDelta;
sampleNo++;
if (sampleNo >= tempSTTS.sampleCount){
entryNo++;
if (sampleNo >= sttsEntry.sampleCount){
++entryNo;
sampleNo = 0;
if (entryNo < sttsBox.getEntryCount()){
tempSTTS = sttsBox.getSTTSEntry(entryNo);
sttsEntry = sttsBox.getSTTSEntry(entryNo);
}
}
//set time offset
if (hasCTTS){
cttsEntry = cttsBox.getCTTSEntry(cttsIndex);
if (hasCTTS){
MP4::CTTSEntry cttsEntry = cttsBox.getCTTSEntry(cttsIndex);
cttsEntryRead++;
if (cttsEntryRead >= cttsEntry.sampleCount){
cttsIndex++;
++cttsIndex;
cttsEntryRead = 0;
}
BsetPart.timeOffset = (cttsEntry.sampleOffset * 1000)/(int32_t)timeScale;
BsetPart.timeOffset = (cttsEntry.sampleOffset * 1000)/timescale;
}else{
BsetPart.timeOffset = 0;
}
myMeta.update(BsetPart.time, BsetPart.timeOffset, trackNo, stszBox.getEntrySize(sampleIndex), BsetPart.bpos, BsetPart.keyframe);
}//while over stsc
if (vidTrack){
//something wrong with the time formula, but the answer is right for some reason
/// \todo Fix this. This makes no sense whatsoever. This isn't frame per kilosecond, but milli-STCO-entries per second.
// (A single STCO entry may be more than 1 part, and 1 part may be a partial frame or multiple frames)
if (stcoIs64){
myMeta.tracks[trackNo].fpks = (((double)(((MP4::CO64*)&stcoBox)->getEntryCount()*1000))/((totaldur*1000)))*1000;
}else{
myMeta.tracks[trackNo].fpks = (((double)(stcoBox.getEntryCount()*1000))/((totaldur*1000)))*1000;
myMeta.update(BsetPart.time, BsetPart.timeOffset, trackNo, stszBox.getEntrySize(stszIndex), BsetPart.bpos, BsetPart.keyframe);
}
}
}//fi stbl
}//rof minf
}//fi minf
}//rof mdia
}//fi mdia
}//rof trak
}//endif trak
}//rof moov
}else if (boxType == "erro"){
break;
}else{
continue;
}
if (!MP4::skipBox(inFile)){//moving on to next box
DEBUG_MSG(DLVL_FAIL,"Error in Skipping box, exiting");
FAIL_MSG("Error in Skipping box, exiting");
return false;
}
}// if moov
}// end while file read
//for all in bpos set, find its data
}
clearerr(inFile);
//outputting dtsh file
@ -582,7 +440,7 @@ namespace Mist {
}
}
if (fseeko(inFile,curPart.bpos,SEEK_SET)){
DEBUG_MSG(DLVL_FAIL,"seek unsuccessful; bpos: %llu error: %s",curPart.bpos, strerror(errno));
FAIL_MSG("seek unsuccessful @bpos %" PRIu64 ": %s",curPart.bpos, strerror(errno));
thisPacket.null();
return;
}
@ -591,7 +449,7 @@ namespace Mist {
malSize = curPart.size;
}
if (fread(data, curPart.size, 1, inFile)!=1){
DEBUG_MSG(DLVL_FAIL,"read unsuccessful at %ld", ftell(inFile));
FAIL_MSG("read unsuccessful at %" PRIu64, ftell(inFile));
thisPacket.null();
return;
}

77
src/input/input_mp4.h
View file

@ -9,49 +9,41 @@ namespace Mist {
bool operator < (const mp4PartTime & rhs) const {
if (time < rhs.time){
return true;
}else{
if (time == rhs.time){
if (trackID < rhs.trackID){
return true;
}else{
if (trackID == rhs.trackID && bpos < rhs.bpos){
return true;
}
}
}
}
if (time > rhs.time){
return false;
}
long long unsigned int time;
if (trackID < rhs.trackID){
return true;
}
return (trackID == rhs.trackID && bpos < rhs.bpos);
}
uint64_t time;
int32_t offset;
unsigned int trackID;
long long unsigned int bpos;
unsigned int size;
long unsigned int index;
size_t trackID;
uint64_t bpos;
uint32_t size;
uint64_t index;
};
struct mp4PartBpos{
bool operator < (const mp4PartBpos & rhs) const {
if (time < rhs.time){
return true;
}else{
if (time == rhs.time){
if (trackID < rhs.trackID){
return true;
}else{
if (trackID == rhs.trackID && bpos < rhs.bpos){
return true;
}
}
}
}
if (time > rhs.time){
return false;
}
long long unsigned int time;
long long unsigned int trackID;
long long unsigned int bpos;
long long unsigned int size;
long long unsigned int stcoNr;
if (trackID < rhs.trackID){
return true;
}
return (trackID == rhs.trackID && bpos < rhs.bpos);
}
uint64_t time;
size_t trackID;
uint64_t bpos;
uint64_t size;
uint64_t stcoNr;
int32_t timeOffset;
bool keyframe;
};
@ -61,26 +53,29 @@ namespace Mist {
mp4TrackHeader();
void read(MP4::TRAK & trakBox);
MP4::STCO stcoBox;
MP4::CO64 co64Box;
MP4::STSZ stszBox;
MP4::STTS sttsBox;
bool hasCTTS;
MP4::CTTS cttsBox;
MP4::STSC stscBox;
long unsigned int timeScale;
void getPart(long unsigned int index, long long unsigned int & offset,unsigned int& size, long long unsigned int & timestamp, int32_t & timeOffset);
long unsigned int size();
uint64_t timeScale;
void getPart(uint64_t index, uint64_t & offset, uint32_t & size, uint64_t & timestamp, int32_t & timeOffset);
uint64_t size();
private:
bool initialised;
//next variables are needed for the stsc/stco loop
long long unsigned int stscStart;
long long unsigned int sampleIndex;
uint64_t stscStart;
uint64_t sampleIndex;
//next variables are needed for the stts loop
long long unsigned deltaIndex;///< Index in STTS box
long long unsigned deltaPos;///< Sample counter for STTS box
long long unsigned deltaTotal;///< Total timestamp for STTS box
uint64_t deltaIndex;///< Index in STTS box
uint64_t deltaPos;///< Sample counter for STTS box
uint64_t deltaTotal;///< Total timestamp for STTS box
//for CTTS box loop
long long unsigned offsetIndex;///< Index in CTTS box
long long unsigned offsetPos;///< Sample counter for CTTS box
uint64_t offsetIndex;///< Index in CTTS box
uint64_t offsetPos;///< Sample counter for CTTS box
bool stco64;
};
class inputMP4 : public Input {
@ -104,7 +99,7 @@ namespace Mist {
std::map <unsigned int, unsigned int> nextKeyframe;
//these next two variables keep a buffer for reading from filepointer inFile;
unsigned long long int malSize;
uint64_t malSize;
char* data;///\todo rename this variable to a more sensible name, it is a temporary piece of memory to read from files
};
}

471
src/output/output_progressive_mp4.cpp
View file

@ -5,6 +5,8 @@
#include <mist/bitfields.h>
#include "output_progressive_mp4.h"
#include <inttypes.h>
namespace Mist {
OutProgressiveMP4::OutProgressiveMP4(Socket::Connection & conn) : HTTPOutput(conn) {}
OutProgressiveMP4::~OutProgressiveMP4() {}
@ -29,8 +31,8 @@ namespace Mist {
//capa["canRecord"].append("m3u");
}
long long unsigned OutProgressiveMP4::estimateFileSize() {
long long unsigned retVal = 0;
uint64_t OutProgressiveMP4::estimateFileSize() {
uint64_t retVal = 0;
for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++) {
for (std::deque<unsigned long>::iterator keyIt = myMeta.tracks[*it].keySizes.begin(); keyIt != myMeta.tracks[*it].keySizes.end(); keyIt++) {
retVal += *keyIt;
@ -39,8 +41,96 @@ namespace Mist {
return retVal * 1.1;
}
uint64_t OutProgressiveMP4::mp4HeaderSize(uint64_t & fileSize, int fragmented) {
bool useLargeBoxes = !fragmented && (estimateFileSize() > 0xFFFFFFFFull);
uint64_t res = 36 // FTYP Box
+ 8 //MOOV box
+ 108; //MVHD Box
for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++){
DTSC::Track & thisTrack = myMeta.tracks[*it];
uint64_t tmpRes = 0;
uint64_t partCount = thisTrack.parts.size();
tmpRes += 8 //TRAK Box
+ 92 //TKHD Box
+ 36 //EDTS Box
+ 8 //MDIA Box
+ 32 //MDHD Box
+ 33 + thisTrack.getIdentifier().size() // HDLR Box
+ 8 //MINF Box
+ 36 //DINF Box
+ 8; // STBL Box
//These boxes are empty when generating fragmented output
tmpRes += 20 + (fragmented ? 0 : (partCount * 4));//STSZ
tmpRes += 16 + (fragmented ? 0 : (partCount * (useLargeBoxes ? 8 : 4)));//STCO
tmpRes += 16 + (fragmented ? 0 : (1 * 12));//STSC <-- Currently 1 entry, but might become more complex in near future
//Type-specific boxes
if (thisTrack.type == "video"){
tmpRes += 20//VMHD Box
+ 16 //STSD
+ 86 //AVC1
+ 8 + thisTrack.init.size();//avcC
if (!fragmented){
tmpRes += 16 + (thisTrack.keys.size() * 4);//STSS
}
}
if (thisTrack.type == "audio"){
tmpRes += 16//SMHD Box
+ 16//STSD
+ 36//MP4A
+ 37 + thisTrack.init.size();//ESDS
}
if (!fragmented){
//Unfortunately, for our STTS and CTTS boxes, we need to loop through all parts of the track
uint64_t sttsCount = 1;
uint64_t prevDur = thisTrack.parts[0].getDuration();
uint64_t prevOffset = thisTrack.parts[0].getOffset();
uint64_t cttsCount = 1;
fileSize += thisTrack.parts[0].getSize();
for (unsigned int part = 1; part < partCount; ++part){
uint64_t partDur = thisTrack.parts[part].getDuration();
uint64_t partOffset = thisTrack.parts[part].getOffset();
uint64_t partSize = thisTrack.parts[part].getSize();
if (prevDur != partDur){
prevDur = partDur;
++sttsCount;
}
if (partOffset != prevOffset){
prevOffset = partOffset;
++cttsCount;
}
fileSize += partSize;
}
if (cttsCount == 1 && ! prevOffset){
cttsCount = 0;
}
tmpRes += 16 + (sttsCount * 8);//STTS
if (cttsCount){
tmpRes += 16 + (cttsCount * 8);//CTTS
}
} else{
tmpRes += 16;//empty STTS, no CTTS
}
res += tmpRes;
}
if (fragmented){
res += 8 + (selectedTracks.size() * 32);//Mvex + trex boxes
res += 1; //Horrible horrible length fix;
}else{
res += 8; //mdat beginning
}
fileSize += res;
INFO_MSG("H size %llu, file: %llu", res, fileSize);
return res;
}
///\todo This function does not indicate errors anywhere... maybe fix this...
std::string OutProgressiveMP4::DTSCMeta2MP4Header(long long & size, int fragmented) {
std::string OutProgressiveMP4::DTSCMeta2MP4Header(uint64_t & size, int fragmented) {
if (myMeta.live){
needsLookAhead = 420;
}
@ -75,11 +165,11 @@ namespace Mist {
//Then override it only when we are not sending a fragmented file
if (!fragmented){
//calculating longest duration
long long unsigned firstms = 0xFFFFFFFFFFFFFFull;
long long unsigned lastms = 0;
uint64_t firstms = 0xFFFFFFFFFFFFFFull;
uint64_t lastms = 0;
for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++) {
lastms = std::max(lastms, myMeta.tracks[*it].lastms);
firstms = std::min(firstms, myMeta.tracks[*it].firstms);
lastms = std::max(lastms, (uint64_t)myMeta.tracks[*it].lastms);
firstms = std::min(firstms, (uint64_t)myMeta.tracks[*it].firstms);
}
mvhdBox.setDuration(lastms - firstms);
}
@ -89,6 +179,8 @@ namespace Mist {
for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++) {
DTSC::Track & thisTrack = myMeta.tracks[*it];
size_t partCount = thisTrack.parts.size();
uint64_t tDuration = thisTrack.lastms - thisTrack.firstms;
MP4::TRAK trakBox;
//Keep track of the current index within the moovBox
unsigned int trakOffset = 0;
@ -106,11 +198,7 @@ namespace Mist {
elstBox.setVersion(0);
elstBox.setFlags(0);
elstBox.setCount(1);
if (!fragmented){
elstBox.setSegmentDuration(0, thisTrack.lastms - thisTrack.firstms);
}else{
elstBox.setSegmentDuration(0, -1);
}
elstBox.setSegmentDuration(0, fragmented ? -1 : tDuration);
elstBox.setMediaTime(0, 0);
elstBox.setMediaRateInteger(0, 1);
elstBox.setMediaRateFraction(0, 0);
@ -118,10 +206,10 @@ namespace Mist {
trakBox.setContent(edtsBox, trakOffset++);
MP4::MDIA mdiaBox;
unsigned int mdiaOffset = 0;
size_t mdiaOffset = 0;
//Add the mandatory MDHD and HDLR boxes to the MDIA
MP4::MDHD mdhdBox(thisTrack.lastms - thisTrack.firstms);
MP4::MDHD mdhdBox(tDuration);
if (fragmented){
mdhdBox.setDuration(-1);
}
@ -131,7 +219,7 @@ namespace Mist {
mdiaBox.setContent(hdlrBox, mdiaOffset++);
MP4::MINF minfBox;
unsigned int minfOffset = 0;
size_t minfOffset = 0;
//Add a track-type specific box to the MINF box
if (thisTrack.type == "video") {
@ -151,7 +239,7 @@ namespace Mist {
MP4::STBL stblBox;
unsigned int stblOffset = 0;
size_t stblOffset = 0;
//Add STSD box
MP4::STSD stsdBox(0);
@ -164,30 +252,68 @@ namespace Mist {
}
stblBox.setContent(stsdBox, stblOffset++);
//Add STTS Box
//note: STTS is empty when fragmented
MP4::STTS sttsBox(0);
//Add STSZ Box
//note: STSZ is empty when fragmented
MP4::STSZ stszBox(0);
if (!fragmented) {
std::deque<std::pair<int, int> > sttsCounter;
for (unsigned int part = 0; part < thisTrack.parts.size(); ++part) {
MP4::CTTS cttsBox;
cttsBox.setVersion(0);
MP4::CTTSEntry tmpEntry;
tmpEntry.sampleCount = 0;
tmpEntry.sampleOffset = thisTrack.parts[0].getOffset();
std::deque<std::pair<size_t, size_t> > sttsCounter;
stszBox.setEntrySize(0, partCount - 1);//Speed up allocation
size_t totalEntries = 0;
for (size_t part = 0; part < partCount; ++part){
stats();
uint64_t partDur = thisTrack.parts[part].getDuration();
uint64_t partSize = thisTrack.parts[part].getSize();
uint64_t partOffset = thisTrack.parts[part].getOffset();
//Create a new entry with current duration if EITHER there is no entry yet, or this parts duration differs from the previous
if (!sttsCounter.size() || sttsCounter.rbegin()->second != thisTrack.parts[part].getDuration()){
//Set the counter to 0, so we don't have to handle this situation diffent when updating
sttsCounter.push_back(std::pair<int,int>(0, thisTrack.parts[part].getDuration()));
if (!sttsCounter.size() || sttsCounter.rbegin()->second != partDur){
sttsCounter.push_back(std::pair<size_t,size_t>(0, partDur));
}
//Then update the counter
//Update the counter
sttsCounter.rbegin()->first++;
stszBox.setEntrySize(partSize, part);
size += partSize;
if (partOffset != tmpEntry.sampleOffset) {
//If the offset of this and previous part differ, write current values and reset
cttsBox.setCTTSEntry(tmpEntry, totalEntries++);///\todo Again, rewrite for sanity. index FIRST, value SECOND
tmpEntry.sampleCount = 0;
tmpEntry.sampleOffset = partOffset;
}
tmpEntry.sampleCount++;
}
//Write all entries in reverse
for (unsigned int entry = sttsCounter.size(); entry > 0; --entry){
MP4::STTSEntry newEntry;
newEntry.sampleCount = sttsCounter[entry - 1].first;;
newEntry.sampleDelta = sttsCounter[entry - 1].second;
sttsBox.setSTTSEntry(newEntry, entry - 1);///\todo rewrite for sanity
MP4::STTSEntry sttsEntry;
sttsBox.setSTTSEntry(sttsEntry, sttsCounter.size() - 1);
size_t sttsIdx = 0;
for (std::deque<std::pair<size_t, size_t> >::iterator it2 = sttsCounter.begin(); it2 != sttsCounter.end(); it2++){
sttsEntry.sampleCount = it2->first;
sttsEntry.sampleDelta = it2->second;
sttsBox.setSTTSEntry(sttsEntry, sttsIdx++);
}
if (totalEntries || tmpEntry.sampleOffset) {
cttsBox.setCTTSEntry(tmpEntry, totalEntries++);
stblBox.setContent(cttsBox, stblOffset++);
}
}
stblBox.setContent(sttsBox, stblOffset++);
stblBox.setContent(stszBox, stblOffset++);
//Add STSS Box IF type is video and we are not fragmented
if (thisTrack.type == "video" && !fragmented) {
@ -209,63 +335,20 @@ namespace Mist {
}
stblBox.setContent(stscBox, stblOffset++);
bool containsOffsets = false;
//Add STSZ Box
//note: STSZ is empty when fragmented
MP4::STSZ stszBox(0);
if (!fragmented) {
if (thisTrack.parts.size()) {
std::deque<DTSC::Part>::reverse_iterator tmpIt = thisTrack.parts.rbegin();
for (unsigned int part = thisTrack.parts.size(); part > 0; --part) {
///\todo rewrite for sanity
stszBox.setEntrySize(tmpIt->getSize(), part - 1); //in bytes in file
size += tmpIt->getSize();
containsOffsets |= tmpIt->getOffset();
tmpIt++;
}
}
}
stblBox.setContent(stszBox, stblOffset++);
//Add CTTS Box only if the track contains time offsets
//note: CTTS will never exist in fragmented, since containsOffsets is set while generating the STSZ box
if (containsOffsets) {
MP4::CTTS cttsBox;
cttsBox.setVersion(0);
MP4::CTTSEntry tmpEntry;
tmpEntry.sampleCount = 0;
tmpEntry.sampleOffset = thisTrack.parts[0].getOffset();
unsigned int totalEntries = 0;
for (std::deque<DTSC::Part>::iterator tmpIt = thisTrack.parts.begin(); tmpIt != thisTrack.parts.end(); tmpIt++){
if (tmpIt->getOffset() != tmpEntry.sampleOffset) {
//If the offset of this and previous part differ, write current values and reset
cttsBox.setCTTSEntry(tmpEntry, totalEntries++);///\todo Again, rewrite for sanity. index FIRST, value SECOND
tmpEntry.sampleCount = 0;
tmpEntry.sampleOffset = tmpIt->getOffset();
}
tmpEntry.sampleCount++;
}
//set the last entry
cttsBox.setCTTSEntry(tmpEntry, totalEntries++);
stblBox.setContent(cttsBox, stblOffset++);
}
//Create STCO Box (either stco or co64)
//note: 64bit boxes will never be used in fragmented
//note: Inserting empty values on purpose here, will be fixed later.
if (useLargeBoxes) {
MP4::CO64 CO64Box;
CO64Box.setChunkOffset(0, thisTrack.parts.size() - 1);
CO64Box.setChunkOffset(0, partCount - 1);
stblBox.setContent(CO64Box, stblOffset++);
} else {
MP4::STCO stcoBox(0);
if (fragmented) {
stcoBox.setEntryCount(0);
} else {
stcoBox.setChunkOffset(0, thisTrack.parts.size() - 1);
stcoBox.setChunkOffset(0, partCount - 1);
}
stblBox.setContent(stcoBox, stblOffset++);
}
@ -289,95 +372,62 @@ namespace Mist {
moovBox.setContent(mvexBox, moovOffset++);
}else{ //if we are making a non fragmented MP4 and there are parts
//initial offset length ftyp, length moov + 8
unsigned long long int dataOffset = ftypBox.boxedSize() + moovBox.boxedSize() + 8;
//update all STCO or CO64 from the following maps;
std::map <long unsigned, MP4::STCO> checkStcoBoxes;
std::map <long unsigned, MP4::CO64> checkCO64Boxes;
//for all tracks
for (unsigned int i = 1; i < moovBox.getContentCount(); i++) {
//10 lines to get the STCO box.
MP4::TRAK checkTrakBox;
MP4::Box checkMdiaBox;
MP4::Box checkTkhdBox;
MP4::MINF checkMinfBox;
MP4::STBL checkStblBox;
//MP4::STCO checkStcoBox;
checkTrakBox = ((MP4::TRAK &)moovBox.getContent(i));
for (unsigned int j = 0; j < checkTrakBox.getContentCount(); j++) {
if (checkTrakBox.getContent(j).isType("mdia")) {
checkMdiaBox = checkTrakBox.getContent(j);
break;
}
if (checkTrakBox.getContent(j).isType("tkhd")) {
checkTkhdBox = checkTrakBox.getContent(j);
}
}
for (unsigned int j = 0; j < ((MP4::MDIA &)checkMdiaBox).getContentCount(); j++) {
if (((MP4::MDIA &)checkMdiaBox).getContent(j).isType("minf")) {
checkMinfBox = ((MP4::MINF &)((MP4::MDIA &)checkMdiaBox).getContent(j));
break;
}
}
for (unsigned int j = 0; j < checkMinfBox.getContentCount(); j++) {
if (checkMinfBox.getContent(j).isType("stbl")) {
checkStblBox = ((MP4::STBL &)checkMinfBox.getContent(j));
break;
}
}
for (unsigned int j = 0; j < checkStblBox.getContentCount(); j++) {
if (checkStblBox.getContent(j).isType("stco")) {
checkStcoBoxes.insert(std::pair<long unsigned, MP4::STCO>(((MP4::TKHD &)checkTkhdBox).getTrackID(), ((MP4::STCO &)checkStblBox.getContent(j))));
break;
}
if (checkStblBox.getContent(j).isType("co64")) {
checkCO64Boxes.insert(std::pair<long unsigned, MP4::CO64>(((MP4::TKHD &)checkTkhdBox).getTrackID(), ((MP4::CO64 &)checkStblBox.getContent(j))));
break;
}
uint64_t dataOffset = ftypBox.boxedSize() + moovBox.boxedSize() + 8;
std::map <size_t, MP4::STCO> checkStcoBoxes;
std::map <size_t, MP4::CO64> checkCO64Boxes;
std::deque<MP4::TRAK> trak = moovBox.getChildren<MP4::TRAK>();
for (std::deque<MP4::TRAK>::iterator trakIt = trak.begin(); trakIt != trak.end(); trakIt++){
MP4::TKHD tkhdBox = trakIt->getChild<MP4::TKHD>();
MP4::STBL stblBox = trakIt->getChild<MP4::MDIA>().getChild<MP4::MINF>().getChild<MP4::STBL>();
if (useLargeBoxes){
checkCO64Boxes.insert(std::pair<size_t, MP4::CO64>(tkhdBox.getTrackID(), stblBox.getChild<MP4::CO64>()));
}else{
checkStcoBoxes.insert(std::pair<size_t, MP4::STCO>(tkhdBox.getTrackID(), stblBox.getChild<MP4::STCO>()));
}
}
//inserting right values in the STCO box header
//total = 0;
//Keep track of the current size of the data within the mdat
long long unsigned int dataSize = 0;
uint64_t dataSize = 0;
//Current values are actual byte offset without header-sized offset
std::set <keyPart> sortSet;//filling sortset for interleaving parts
for (std::set<long unsigned int>::iterator subIt = selectedTracks.begin(); subIt != selectedTracks.end(); subIt++) {
keyPart temp;
temp.trackID = *subIt;
temp.time = myMeta.tracks[*subIt].firstms;//timeplace of frame
temp.endTime = myMeta.tracks[*subIt].firstms + myMeta.tracks[*subIt].parts[0].getDuration();
temp.size = myMeta.tracks[*subIt].parts[0].getSize();//bytesize of frame (alle parts all together)
temp.index = 0;
INFO_MSG("adding to sortSet: tid %lu time %llu", temp.trackID, temp.time);
INFO_MSG("adding to sortSet: tid %lu time %lu", temp.trackID, temp.time);
sortSet.insert(temp);
}
while (!sortSet.empty()) {
std::set<keyPart>::iterator keyBegin = sortSet.begin();
stats();
keyPart temp = *sortSet.begin();
sortSet.erase(sortSet.begin());
DTSC::Track & thisTrack = myMeta.tracks[temp.trackID];
//setting the right STCO size in the STCO box
if (useLargeBoxes){//Re-using the previously defined boolean for speedup
checkCO64Boxes[keyBegin->trackID].setChunkOffset(dataOffset + dataSize, keyBegin->index);
checkCO64Boxes[temp.trackID].setChunkOffset(dataOffset + dataSize, temp.index);
} else {
checkStcoBoxes[keyBegin->trackID].setChunkOffset(dataOffset + dataSize, keyBegin->index);
checkStcoBoxes[temp.trackID].setChunkOffset(dataOffset + dataSize, temp.index);
}
dataSize += keyBegin->size;
dataSize += thisTrack.parts[temp.index].getSize();
//add next keyPart to sortSet
DTSC::Track & thisTrack = myMeta.tracks[keyBegin->trackID];
if (keyBegin->index < thisTrack.parts.size() - 1) {//Only create new element, when there are new elements to be added
keyPart temp = *keyBegin;
temp.index ++;
temp.time = temp.endTime;
temp.endTime += thisTrack.parts[temp.index].getDuration();
temp.size = thisTrack.parts[temp.index].getSize();//bytesize of frame
if (temp.index + 1< thisTrack.parts.size()) {//Only create new element, when there are new elements to be added
temp.time += thisTrack.parts[temp.index].getDuration();
++temp.index;
sortSet.insert(temp);
}
//remove highest keyPart
sortSet.erase(keyBegin);
}
///\todo Update this thing for boxes >4G?
mdatSize = dataSize + 8;//+8 for mp4 header
}
header << std::string(moovBox.asBox(), moovBox.boxedSize());
if (!fragmented) { //if we are making a non fragmented MP4 and there are parts
@ -392,6 +442,7 @@ namespace Mist {
header << (char)(0);
}
size += header.str().size();
INFO_MSG("Header %llu, file: %llu", header.str().size(), size);
if (fragmented) {
realBaseOffset = header.str().size();
}
@ -400,7 +451,7 @@ namespace Mist {
/// Calculate a seekPoint, based on byteStart, metadata, tracks and headerSize.
/// The seekPoint will be set to the timestamp of the first packet to send.
void OutProgressiveMP4::findSeekPoint(long long byteStart, long long & seekPoint, unsigned int headerSize) {
void OutProgressiveMP4::findSeekPoint(uint64_t byteStart, uint64_t & seekPoint, uint64_t headerSize) {
seekPoint = 0;
//if we're starting in the header, seekPoint is always zero.
if (byteStart <= headerSize) {
@ -410,28 +461,33 @@ namespace Mist {
byteStart -= headerSize;
//forward through the file by headers, until we reach the point where we need to be
while (!sortSet.empty()) {
//find the next part and erase it
keyPart temp = *sortSet.begin();
DTSC::Track & thisTrack = myMeta.tracks[temp.trackID];
uint64_t partSize = thisTrack.parts[temp.index].getSize();
//record where we are
seekPoint = sortSet.begin()->time;
seekPoint = temp.time;
//substract the size of this fragment from byteStart
byteStart -= sortSet.begin()->size;
//if that put us past the point where we wanted to be, return right now
if (byteStart < 0) {
INFO_MSG("We're starting at time %lld, skipping %lld bytes", seekPoint, byteStart+sortSet.begin()->size);
if (partSize > byteStart) {
INFO_MSG("We're starting at time %" PRIu64 ", skipping %" PRIu64 " bytes", seekPoint, partSize - byteStart);
return;
}
byteStart -= partSize;
//otherwise, set currPos to where we are now and continue
currPos += sortSet.begin()->size;
//find the next part
keyPart temp;
temp.index = sortSet.begin()->index + 1;
temp.trackID = sortSet.begin()->trackID;
if (temp.index < myMeta.tracks[temp.trackID].parts.size()) { //only insert when there are parts left
temp.time = sortSet.begin()->endTime;//timeplace of frame
temp.endTime = sortSet.begin()->endTime + myMeta.tracks[temp.trackID].parts[temp.index].getDuration();
temp.size = myMeta.tracks[temp.trackID].parts[temp.index].getSize();//bytesize of frame
currPos += partSize;
if (temp.index + 1 < myMeta.tracks[temp.trackID].parts.size()){ //only insert when there are parts left
temp.time += thisTrack.parts[temp.index].getDuration();
++temp.index;
sortSet.insert(temp);
}
//remove highest keyPart
//Remove just-parsed element
sortSet.erase(sortSet.begin());
//wash, rinse, repeat
}
@ -442,10 +498,10 @@ namespace Mist {
/// Parses a "Range: " header, setting byteStart, byteEnd and seekPoint using data from metadata and tracks to do
/// the calculations.
/// On error, byteEnd is set to zero.
void OutProgressiveMP4::parseRange(std::string header, long long & byteStart, long long & byteEnd, long long & seekPoint, unsigned int headerSize) {
void OutProgressiveMP4::parseRange(std::string header, uint64_t & byteStart, uint64_t & byteEnd, uint64_t & seekPoint, uint64_t headerSize) {
if (header.size() < 6 || header.substr(0, 6) != "bytes=") {
byteEnd = 0;
DEBUG_MSG(DLVL_WARN, "Invalid range header: %s", header.c_str());
WARN_MSG("Invalid range header: %s", header.c_str());
return;
}
header.erase(0, 6);
@ -485,7 +541,7 @@ namespace Mist {
break;
}
if (header[i] != '-') {
DEBUG_MSG(DLVL_WARN, "Invalid range header: %s", header.c_str());
WARN_MSG("Invalid range header: %s", header.c_str());
byteEnd = 0;
return;
}
@ -505,14 +561,13 @@ namespace Mist {
} else {
byteEnd = size;
}
DEBUG_MSG(DLVL_MEDIUM, "Range request: %lli-%lli (%s)", byteStart, byteEnd, header.c_str());
MEDIUM_MSG("Range request: %" PRIu64 "-%" PRIu64 " (%s)", byteStart, byteEnd, header.c_str());
findSeekPoint(byteStart, seekPoint, headerSize);
return;
}
}
void OutProgressiveMP4::sendFragmentHeader() {
long unsigned int dataOffset = 0;
uint64_t mdatSize = 8;
MP4::MOOF moofBox;
MP4::MFHD mfhdBox;
@ -530,24 +585,23 @@ namespace Mist {
for (uint32_t i = it->second.firstPart; i <= it->second.lastPart; i++) {
keyPart temp;
temp.trackID = it->first;
temp.size = thisTrack.parts[i].getSize();
temp.duration = thisTrack.parts[i].getDuration();
temp.time = timeStamp;
timeStamp += temp.duration;
temp.endTime = timeStamp;
temp.timeOffset = thisTrack.parts[i].getOffset();//this will be changed soon, so now it is used for B-frame offset
temp.index = i;
timeStamp += thisTrack.parts[temp.index].getDuration();
trunOrder.insert(temp);
}
}
//now all the parts have been sorted, we make a relative ByteOffset
long unsigned int relativeOffset = 0;
uint64_t relativeOffset = 0;
for (std::set<keyPart>::iterator it = trunOrder.begin(); it != trunOrder.end(); it++) {
DTSC::Track & thisTrack = myMeta.tracks[it->trackID];
uint64_t partSize = thisTrack.parts[it->index].getSize();
//We have to make a copy, because altering the element inside the set would invalidate the iterators
keyPart temp = *it;
temp.byteOffset = relativeOffset;
relativeOffset += it->size;
DONTEVEN_MSG("Anticipating tid: %lu size: %lu", it->trackID, it->size);
relativeOffset += partSize;
DONTEVEN_MSG("Anticipating tid: %lu size: %lu", it->trackID, partSize);
sortSet.insert(temp);
}
trunOrder.clear();//erase the trunOrder set, to keep memory usage down
@ -591,20 +645,24 @@ namespace Mist {
unsigned int trafOffset = 1;
for (std::set<keyPart>::iterator trunIt = sortSet.begin(); trunIt != sortSet.end(); trunIt++) {
if (trunIt->trackID == tid) {
uint64_t partOffset = thisTrack.parts[trunIt->index].getOffset();
uint64_t partSize = thisTrack.parts[trunIt->index].getSize();
uint64_t partDur = thisTrack.parts[trunIt->index].getDuration();
MP4::TRUN trunBox;
trunBox.setFlags(MP4::trundataOffset | MP4::trunfirstSampleFlags | MP4::trunsampleSize | MP4::trunsampleDuration | (trunIt->timeOffset ? MP4::trunsampleOffsets : 0));
trunBox.setFlags(MP4::trundataOffset | MP4::trunfirstSampleFlags | MP4::trunsampleSize | MP4::trunsampleDuration | (partOffset ? MP4::trunsampleOffsets : 0));
//The value set here, will be updated afterwards to the correct value
trunBox.setDataOffset(trunIt->byteOffset);
trunBox.setFirstSampleFlags(MP4::isIPicture | (firstSample ? MP4::isKeySample : MP4::noKeySample));
firstSample = false;
mdatSize += trunIt->size;
mdatSize += partSize;
MP4::trunSampleInformation sampleInfo;
sampleInfo.sampleSize = trunIt->size;
sampleInfo.sampleDuration = trunIt->duration;
if (trunIt->timeOffset) {
sampleInfo.sampleOffset = trunIt->timeOffset;
sampleInfo.sampleSize = partSize;
sampleInfo.sampleDuration = partDur;
if (partOffset){
sampleInfo.sampleOffset = partOffset;
}
trunBox.setSampleInformation(sampleInfo, 0);
trafBox.setContent(trunBox, trafOffset++);
@ -706,9 +764,8 @@ namespace Mist {
//Check if the url contains .3gp --> if yes, we will send a 3gp header
sending3GP = (H.url.find(".3gp") != std::string::npos);
//For storing the header.
///\todo Do we really need this though?
std::string headerData = DTSCMeta2MP4Header(fileSize, myMeta.live);
fileSize = 0;
uint64_t headerSize = mp4HeaderSize(fileSize, myMeta.live);
seekPoint = 0;
if (myMeta.live) {
@ -726,21 +783,19 @@ namespace Mist {
keyPart temp;
temp.trackID = *subIt;
temp.time = myMeta.tracks[*subIt].firstms;//timeplace of frame
temp.endTime = myMeta.tracks[*subIt].firstms + myMeta.tracks[*subIt].parts[0].getDuration();
temp.size = myMeta.tracks[*subIt].parts[0].getSize();//bytesize of frame (alle parts all together)
temp.index = 0;
sortSet.insert(temp);
}
if (!myMeta.live) {
if (H.GetHeader("Range") != "") {
parseRange(H.GetHeader("Range"), byteStart, byteEnd, seekPoint, headerData.size());
parseRange(H.GetHeader("Range"), byteStart, byteEnd, seekPoint, headerSize);
rangeType = H.GetHeader("Range")[0];
}
}
H.Clean(); //make sure no parts of old requests are left in any buffers
H.setCORSHeaders();
H.SetHeader("Content-Type", "video/MP4"); //Send the correct content-type for MP4 files
if (!myMeta.live) {
if (myMeta.vod) {
H.SetHeader("Accept-Ranges", "bytes, parsec");
}
if (rangeType != ' ') {
@ -764,7 +819,7 @@ namespace Mist {
//H.StartResponse("206", "Partial content", HTTP_R, conn);
}
} else {
if (!myMeta.live) {
if (myMeta.vod) {
H.SetHeader("Content-Length", byteEnd - byteStart + 1);
}
/// \todo Switch to chunked?
@ -772,12 +827,12 @@ namespace Mist {
//HTTP_S.StartResponse(HTTP_R, conn);
}
leftOver = byteEnd - byteStart + 1;//add one byte, because range "0-0" = 1 byte of data
if (byteStart < (long long)headerData.size()) {
/// \todo Switch to chunked?
myConn.SendNow(headerData.data() + byteStart, std::min((long long)headerData.size(), byteEnd) - byteStart); //send MP4 header
leftOver -= std::min((long long)headerData.size(), byteEnd) - byteStart;
if (byteStart < headerSize) {
std::string headerData = DTSCMeta2MP4Header(fileSize, myMeta.live);
myConn.SendNow(headerData.data() + byteStart, std::min(headerSize, byteEnd) - byteStart); //send MP4 header
leftOver -= std::min(headerSize, byteEnd) - byteStart;
}
currPos += headerData.size();//we're now guaranteed to be past the header point, no matter what
currPos += headerSize;//we're now guaranteed to be past the header point, no matter what
}
///Builds up a datastructure that allows for access in the fragment send header function
@ -785,13 +840,14 @@ namespace Mist {
///We take the corresponding keyframe and interframes of the main video track and take concurrent frames from its secondary (audio) tracks
///\todo See if we can use something more elegant than a member variable...
void OutProgressiveMP4::buildFragment() {
DTSC::Key & currKey = myMeta.tracks[vidTrack].getKey(getKeyForTime(vidTrack, thisPacket.getTime()));
uint64_t startms = thisPacket.getTime();
if (!needsLookAhead){
needsLookAhead = 1000;
currentPartSet.clear();
return;
}
DTSC::Key & currKey = myMeta.tracks[vidTrack].getKey(getKeyForTime(vidTrack, thisPacket.getTime()));
uint64_t startms = thisPacket.getTime();
uint64_t endms = startms + needsLookAhead;
bool missingSome = true;
@ -829,7 +885,7 @@ namespace Mist {
//Make sure we always look ahead at least a single frame
if (pDur > needsLookAhead){
needsLookAhead = pDur;
INFO_MSG("Slow frame! Increasing lookAhead to %lums", needsLookAhead);
INFO_MSG("Slow frame! Increasing lookAhead to %ums", needsLookAhead);
}
thisRange.lastPart = i;
thisRange.lastTime = curMS;
@ -840,7 +896,7 @@ namespace Mist {
endms = thisTrack.lastms;
if (needsLookAhead != endms - startms){
needsLookAhead = endms - startms;
INFO_MSG("False start! Increasing lookAhead to %lums", needsLookAhead);
INFO_MSG("False start! Increasing lookAhead to %ums", needsLookAhead);
missingSome = true;
}
break;
@ -869,7 +925,7 @@ namespace Mist {
// (sync delay = ~1s, minimum lookAhead is 420ms -> ~600ms extra needed, we use 2000ms to be safe)
if (myMeta.sourceURI.find("http://") == std::string::npos || myMeta.sourceURI.find(".m3u") == std::string::npos){
if (fragSeqNum > 10 && thisPacket.getTime() + needsLookAhead + 2000 < mainTrk.keys.rbegin()->getTime() && mainTrk.lastms - mainTrk.keys.rbegin()->getTime() > needsLookAhead){
INFO_MSG("Skipping forward %llums (%llu ms LA)", mainTrk.keys.rbegin()->getTime() - thisPacket.getTime(), needsLookAhead);
INFO_MSG("Skipping forward %llums (%u ms LA)", mainTrk.keys.rbegin()->getTime() - thisPacket.getTime(), needsLookAhead);
seek(mainTrk.keys.rbegin()->getTime());
return;
}
@ -889,15 +945,17 @@ namespace Mist {
partListSent++;
}
if ((unsigned long)thisPacket.getTrackId() != sortSet.begin()->trackID || thisPacket.getTime() != sortSet.begin()->time || len != sortSet.begin()->size) {
if (thisPacket.getTime() > sortSet.begin()->time || (unsigned long)thisPacket.getTrackId() > sortSet.begin()->trackID) {
keyPart thisPart = *sortSet.begin();
uint64_t thisSize = myMeta.tracks[thisPart.trackID].parts[thisPart.index].getSize();
if ((unsigned long)thisPacket.getTrackId() != thisPart.trackID || thisPacket.getTime() != thisPart.time || len != thisSize){
if (thisPacket.getTime() > sortSet.begin()->time || thisPacket.getTrackId() > sortSet.begin()->trackID) {
if (perfect) {
WARN_MSG("Warning: input is inconsistent. Expected %lu:%llu but got %ld:%llu - cancelling playback", sortSet.begin()->trackID, sortSet.begin()->time, thisPacket.getTrackId(), thisPacket.getTime());
WARN_MSG("Warning: input is inconsistent. Expected %lu:%lu but got %ld:%llu - cancelling playback", thisPart.trackID, thisPart.time, thisPacket.getTrackId(), thisPacket.getTime());
perfect = false;
myConn.close();
}
} else {
WARN_MSG("Did not receive expected %lu:%llu (%lub) but got %ld:%llu (%lub) - throwing it away", sortSet.begin()->trackID, sortSet.begin()->time, sortSet.begin()->size, thisPacket.getTrackId(), thisPacket.getTime(), len);
WARN_MSG("Did not receive expected %lu:%lu (%lub) but got %ld:%llu (%ub) - throwing it away", thisPart.trackID, thisPart.time, thisSize, thisPacket.getTrackId(), thisPacket.getTime(), len);
}
return;
}
@ -909,35 +967,34 @@ namespace Mist {
}
if (currPos >= byteStart) {
myConn.SendNow(dataPointer, std::min(leftOver, (long long)len));
myConn.SendNow(dataPointer, std::min(leftOver, (int64_t)len));
leftOver -= len;
} else {
if (currPos + (long long)len > byteStart) {
myConn.SendNow(dataPointer + (byteStart - currPos), std::min(leftOver, (long long)(len - (byteStart - currPos))));
myConn.SendNow(dataPointer + (byteStart - currPos), std::min(leftOver, (int64_t)(len - (byteStart - currPos))));
leftOver -= len - (byteStart - currPos);
}
}
//keep track of where we are
if (!sortSet.empty()) {
keyPart temp;
temp.index = sortSet.begin()->index + 1;
temp.trackID = sortSet.begin()->trackID;
if (temp.index < myMeta.tracks[temp.trackID].parts.size()) { //only insert when there are parts left
temp.time = sortSet.begin()->endTime;//timeplace of frame
temp.endTime = sortSet.begin()->endTime + myMeta.tracks[temp.trackID].parts[temp.index].getDuration();
temp.size = myMeta.tracks[temp.trackID].parts[temp.index].getSize();//bytesize of frame
keyPart temp = *sortSet.begin();
sortSet.erase(sortSet.begin());
DTSC::Track & thisTrack = myMeta.tracks[temp.trackID];
currPos += thisTrack.parts[temp.index].getSize();
if (temp.index + 1 < thisTrack.parts.size()) { //only insert when there are parts left
temp.time += thisTrack.parts[temp.index].getDuration();
++temp.index;
sortSet.insert(temp);
}
currPos += sortSet.begin()->size;
//remove highest keyPart
sortSet.erase(sortSet.begin());
}
if (leftOver < 1) {
//stop playback, wait for new request
stop();
wantRequest = true;
@ -958,7 +1015,7 @@ namespace Mist {
}
}
if (reSeek){
INFO_MSG("Increased initial lookAhead of %lums", needsLookAhead);
INFO_MSG("Increased initial lookAhead of %ums", needsLookAhead);
initialSeek();
}
}else{

61
src/output/output_progressive_mp4.h
View file

@ -9,29 +9,23 @@ namespace Mist {
if (time < rhs.time){
return true;
}
if (time == rhs.time){
if (time > rhs.time){
return false;
}
if (trackID < rhs.trackID){
return true;
}
if (trackID == rhs.trackID){
return index < rhs.index;
return (trackID == rhs.trackID && index < rhs.index);
}
}
return false;
}
long unsigned int trackID;
long unsigned int size;
long long unsigned int time;
long long unsigned int endTime;
long long unsigned int byteOffset;//added for MP4 fragmented
long int timeOffset;//added for MP4 fragmented
long unsigned int duration;//added for MP4 fragmented
long unsigned int index;
size_t trackID;
uint64_t time;
uint64_t byteOffset;//Stores relative bpos for fragmented MP4
uint64_t index;
};
struct fragSet{
uint32_t firstPart;
uint32_t lastPart;
uint64_t firstPart;
uint64_t lastPart;
uint64_t firstTime;
uint64_t lastTime;
};
@ -40,42 +34,43 @@ namespace Mist {
OutProgressiveMP4(Socket::Connection & conn);
~OutProgressiveMP4();
static void init(Util::Config * cfg);
void parseRange(std::string header, long long & byteStart, long long & byteEnd, long long & seekPoint, unsigned int headerSize);
std::string DTSCMeta2MP4Header(long long & size, int fragmented = 0);
void parseRange(std::string header, uint64_t & byteStart, uint64_t & byteEnd, uint64_t & seekPoint, uint64_t headerSize);
uint64_t mp4HeaderSize(uint64_t & fileSize, int fragmented = 0);
std::string DTSCMeta2MP4Header(uint64_t & size, int fragmented = 0);
//int fragmented values: 0 = non fragmented stream, 1 = frag stream main header
void buildFragment();//this builds the structure of the fragment header and stores it in a member variable
void sendFragmentHeader();//this builds the moof box for fragmented MP4
void findSeekPoint(long long byteStart, long long & seekPoint, unsigned int headerSize);
void findSeekPoint(uint64_t byteStart, uint64_t & seekPoint, uint64_t headerSize);
void onHTTP();
void sendNext();
void sendHeader();
protected:
long long fileSize;
long long byteStart;
long long byteEnd;
long long leftOver;
long long currPos;
long long seekPoint;
uint64_t fileSize;
uint64_t byteStart;
uint64_t byteEnd;
int64_t leftOver;
uint64_t currPos;
uint64_t seekPoint;
//variables for standard MP4
std::set <keyPart> sortSet;//needed for unfragmented MP4, remembers the order of keyparts
//variables for fragmented
int fragSeqNum;//the sequence number of the next keyframe/fragment when producing fragmented MP4's
long unsigned int vidTrack;//the video track we use as fragmenting base
long long unsigned int realBaseOffset;//base offset for every moof packet
size_t fragSeqNum;//the sequence number of the next keyframe/fragment when producing fragmented MP4's
size_t vidTrack;//the video track we use as fragmenting base
uint64_t realBaseOffset;//base offset for every moof packet
//from sendnext
long unsigned int partListSent;//parts of current fragSet sent
long unsigned int partListLength;//amount of packets in current fragment
long int fragKeyNumberShift;//the difference between the first fragment Number and the first keyframe number
size_t partListSent;//parts of current fragSet sent
size_t partListLength;//amount of packets in current fragment
int64_t fragKeyNumberShift;//the difference between the first fragment Number and the first keyframe number
bool sending3GP;
bool chromeWorkaround;
long long unsigned estimateFileSize();
uint64_t estimateFileSize();
//This is a dirty solution... but it prevents copying and copying and copying again
std::map<long unsigned int, fragSet> currentPartSet;
std::map<size_t, fragSet> currentPartSet;
};
}