diff --git a/util/dtmi.cpp b/util/dtmi.cpp deleted file mode 100644 index a9d38299..00000000 --- a/util/dtmi.cpp +++ /dev/null @@ -1,248 +0,0 @@ -/// \file dtmi.cpp -/// Holds all code for DDVTECH MediaInfo parsing/generation. - -#include "dtmi.h" -#include //needed for stderr only - -/// Returns the std::string Indice for the current object, if available. -/// Returns an empty string if no indice exists. -std::string DTSC::DTMI::Indice(){return myIndice;}; - -/// Returns the DTSC::DTMItype AMF0 object type for this object. -DTSC::DTMItype DTSC::DTMI::GetType(){return myType;}; - -/// Returns the numeric value of this object, if available. -/// If this object holds no numeric value, 0 is returned. -uint64_t DTSC::DTMI::NumValue(){return numval;}; - -/// Returns the std::string value of this object, if available. -/// If this object holds no string value, an empty string is returned. -std::string DTSC::DTMI::StrValue(){return strval;}; - -/// Returns the C-string value of this object, if available. -/// If this object holds no string value, an empty C-string is returned. -const char * DTSC::DTMI::Str(){return strval.c_str();}; - -/// Returns a count of the amount of objects this object currently holds. -/// If this object is not a container type, this function will always return 0. -int DTSC::DTMI::hasContent(){return contents.size();}; - -/// Adds an DTSC::DTMI to this object. Works for all types, but only makes sense for container types. -void DTSC::DTMI::addContent(DTSC::DTMI c){contents.push_back(c);}; - -/// Returns a pointer to the object held at indice i. -/// Returns AMF::AMF0_DDV_CONTAINER of indice "error" if no object is held at this indice. -/// \param i The indice of the object in this container. -DTSC::DTMI* DTSC::DTMI::getContentP(int i){return &contents.at(i);}; - -/// Returns a copy of the object held at indice i. -/// Returns a AMF::AMF0_DDV_CONTAINER of indice "error" if no object is held at this indice. -/// \param i The indice of the object in this container. -DTSC::DTMI DTSC::DTMI::getContent(int i){return contents.at(i);}; - -/// Returns a pointer to the object held at indice s. -/// Returns NULL if no object is held at this indice. -/// \param s The indice of the object in this container. -DTSC::DTMI* DTSC::DTMI::getContentP(std::string s){ - for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ - if (it->Indice() == s){return &(*it);} - } - return 0; -}; - -/// Returns a copy of the object held at indice s. -/// Returns a AMF::AMF0_DDV_CONTAINER of indice "error" if no object is held at this indice. -/// \param s The indice of the object in this container. -DTSC::DTMI DTSC::DTMI::getContent(std::string s){ - for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ - if (it->Indice() == s){return *it;} - } - return DTSC::DTMI("error", DTMI::DTMI_ROOT); -}; - -/// Default constructor. -/// Simply fills the data with DTSC::DTMI("error", AMF0_DDV_CONTAINER) -DTSC::DTMI::DTMI(){ - *this = DTSC::DTMI("error", DTMI::DTMI_ROOT); -};//default constructor - -/// Constructor for numeric objects. -/// The object type is by default AMF::AMF0_NUMBER, but this can be forced to a different value. -/// \param indice The string indice of this object in its container, or empty string if none. Numeric indices are automatic. -/// \param val The numeric value of this object. Numeric AMF0 objects only support double-type values. -/// \param setType The object type to force this object to. -DTSC::DTMI::DTMI(std::string indice, double val, DTSC::DTMItype setType){//num type initializer - myIndice = indice; - myType = setType; - strval = ""; - numval = val; -}; - -/// Constructor for string objects. -/// The object type is by default AMF::AMF0_STRING, but this can be forced to a different value. -/// There is no need to manually change the type to AMF::AMF0_LONGSTRING, this will be done automatically. -/// \param indice The string indice of this object in its container, or empty string if none. Numeric indices are automatic. -/// \param val The string value of this object. -/// \param setType The object type to force this object to. -DTSC::DTMI::DTMI(std::string indice, std::string val, DTSC::DTMItype setType){//str type initializer - myIndice = indice; - myType = setType; - strval = val; - numval = 0; -}; - -/// Constructor for container objects. -/// The object type is by default AMF::AMF0_OBJECT, but this can be forced to a different value. -/// \param indice The string indice of this object in its container, or empty string if none. Numeric indices are automatic. -/// \param setType The object type to force this object to. -DTSC::DTMI::DTMI(std::string indice, DTSC::DTMItype setType){//object type initializer - myIndice = indice; - myType = setType; - strval = ""; - numval = 0; -}; - -/// Prints the contents of this object to std::cerr. -/// If this object contains other objects, it will call itself recursively -/// and print all nested content in a nice human-readable format. -void DTSC::DTMI::Print(std::string indent){ - std::cerr << indent; - // print my type - switch (myType){ - case DTMItype::DTMI_INT: std::cerr << "Integer"; break; - case DTMItype::DTMI_STRING: std::cerr << "String"; break; - case DTMItype::DTMI_OBJECT: std::cerr << "Object"; break; - case DTMItype::DTMI_OBJ_END: std::cerr << "Object end"; break; - case DTMItype::DTMI_ROOT: std::cerr << "Root Node"; break; - } - // print my string indice, if available - std::cerr << " " << myIndice << " "; - // print my numeric or string contents - switch (myType){ - case DTMItype::DTMI_INT: std::cerr << numval; break; - case DTMItype::DTMI_STRING: std::cerr << strval; break; - default: break;//we don't care about the rest, and don't want a compiler warning... - } - std::cerr << std::endl; - // if I hold other objects, print those too, recursively. - if (contents.size() > 0){ - for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){it->Print(indent+" ");} - } -};//print - -/// Packs the AMF object to a std::string for transfer over the network. -/// If the object is a container type, this function will call itself recursively and contain all contents. -std::string DTSC::DTMI::Pack(){ - std::string r = ""; - //skip output of DDV container types, they do not exist. Only output their contents. - if (myType != DTMItype::DTMI_ROOT){r += myType;} - //output the properly formatted data stream for this object's contents. - switch (myType){ - case DTMItype::DTMI_INT: - r += *(((char*)&numval)+7); r += *(((char*)&numval)+6); - r += *(((char*)&numval)+5); r += *(((char*)&numval)+4); - r += *(((char*)&numval)+3); r += *(((char*)&numval)+2); - r += *(((char*)&numval)+1); r += *(((char*)&numval)); - break; - case DTMItype::DTMI_STRING: - r += strval.size() / (256*256*256); - r += strval.size() / (256*256); - r += strval.size() / 256; - r += strval.size() % 256; - r += strval; - break; - case DTMItype::DTMI_OBJECT: - if (contents.size() > 0){ - for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ - r += it->Indice().size() / 256; - r += it->Indice().size() % 256; - r += it->Indice(); - r += it->Pack(); - } - } - r += (char)0; r += (char)0; r += (char)9; - break; - case DTMItype::DTMI_ROOT://only send contents - if (contents.size() > 0){ - for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ - r += it->Pack(); - } - } - break; - } - return r; -};//pack - -/// Parses a single AMF0 type - used recursively by the AMF::parse() functions. -/// This function updates i every call with the new position in the data. -/// \param data The raw data to parse. -/// \param len The size of the raw data. -/// \param i Current parsing position in the raw data. -/// \param name Indice name for any new object created. -/// \returns A single DTSC::DTMI, parsed from the raw data. -DTSC::DTMI DTSC::parseOneDTMI(const unsigned char *& data, unsigned int &len, unsigned int &i, std::string name){ - std::string tmpstr; - unsigned int tmpi = 0; - unsigned char tmpdbl[8]; - #if DEBUG >= 10 - fprintf(stderr, "Note: AMF type %hhx found. %i bytes left\n", data[i], len-i); - #endif - switch (data[i]){ - case DTMI::DTMI_INT: - tmpdbl[7] = data[i+1]; - tmpdbl[6] = data[i+2]; - tmpdbl[5] = data[i+3]; - tmpdbl[4] = data[i+4]; - tmpdbl[3] = data[i+5]; - tmpdbl[2] = data[i+6]; - tmpdbl[1] = data[i+7]; - tmpdbl[0] = data[i+8]; - i+=9;//skip 8(a double)+1 forwards - return DTSC::DTMI(name, *(uint64_t*)tmpdbl, AMF::AMF0_NUMBER); - break; - case DTMI::DTMI_STRING: - tmpi = data[i+1]*256*256*256+data[i+2]*256*256+data[i+3]*256+data[i+4];//set tmpi to UTF-8-long length - tmpstr.clear();//clean tmpstr, just to be sure - tmpstr.append((const char *)data+i+5, (size_t)tmpi);//add the string data - i += tmpi + 5;//skip length+size+1 forwards - return DTSC::DTMI(name, tmpstr, AMF::AMF0_LONGSTRING); - break; - case DTMI::DTMI_OBJECT:{ - ++i; - DTSC::DTMI ret(name, DTMI::DTMI_OBJECT); - while (data[i] + data[i+1] != 0){//while not encountering 0x0000 (we assume 0x000009) - tmpi = data[i]*256+data[i+1];//set tmpi to the UTF-8 length - tmpstr.clear();//clean tmpstr, just to be sure - tmpstr.append((const char*)data+i+2, (size_t)tmpi);//add the string data - i += tmpi + 2;//skip length+size forwards - ret.addContent(AMF::parseOne(data, len, i, tmpstr));//add content, recursively parsed, updating i, setting indice to tmpstr - } - i += 3;//skip 0x000009 - return ret; - } break; - } - #if DEBUG >= 2 - fprintf(stderr, "Error: Unimplemented DTMI type %hhx - returning.\n", data[i]); - #endif - return DTSC::DTMI("error", DTMI::DTMI_ROOT); -}//parseOne - -/// Parses a C-string to a valid DTSC::DTMI. -/// This function will find all AMF objects in the string and return -/// them all packed in a single AMF::AMF0_DDV_CONTAINER DTSC::DTMI. -DTSC::DTMI DTSC::parseDTMI(const unsigned char * data, unsigned int len){ - DTSC::DTMI ret("returned", DTMI::DTMI_ROOT);//container type - unsigned int i = 0, j = 0; - while (i < len){ - ret.addContent(AMF::parseOne(data, len, i, "")); - if (i > j){j = i;}else{return ret;} - } - return ret; -}//parse - -/// Parses a std::string to a valid DTSC::DTMI. -/// This function will find all AMF objects in the string and return -/// them all packed in a single AMF::AMF0_DDV_CONTAINER DTSC::DTMI. -DTSC::DTMI DTSC::parseDTMI(std::string data){ - return parse((const unsigned char*)data.c_str(), data.size()); -}//parse diff --git a/util/dtmi.h b/util/dtmi.h deleted file mode 100644 index 410df97d..00000000 --- a/util/dtmi.h +++ /dev/null @@ -1,58 +0,0 @@ -/// \file dtmi.h -/// Holds all headers for DDVTECH MediaInfo parsing/generation. - -#pragma once -#include -#include -//#include -#include - -/// Holds all DDVTECH Stream Container classes and parsers. -namespace DTSC{ - - /// Enumerates all possible DTMI types. - enum DTMItype { - DTMI_INT = 0x01, ///< Unsigned 64-bit integer. - DTMI_STRING = 0x02, ///< String, equivalent to the AMF longstring type. - DTMI_OBJECT = 0xE0, ///< Object, equivalent to the AMF object type. - DTMI_OBJ_END = 0xEE, ///< End of object marker. - DTMI_ROOT = 0xFF ///< Root node for all DTMI data. - }; - - /// Recursive class that holds DDVTECH MediaInfo. - class DTMI { - public: - std::string Indice(); - DTMItype GetType(); - uint64_t NumValue(); - std::string StrValue(); - const char * Str(); - int hasContent(); - void addContent(DTMI c); - DTMI* getContentP(int i); - DTMI getContent(int i); - DTMI* getContentP(std::string s); - DTMI getContent(std::string s); - DTMI(); - DTMI(std::string indice, double val, DTMItype setType = DTMI_INT); - DTMI(std::string indice, std::string val, DTMItype setType = DTMI_STRING); - DTMI(std::string indice, DTMItype setType = DTMI_OBJECT); - void Print(std::string indent = ""); - std::string Pack(); - protected: - std::string myIndice; ///< Holds this objects indice, if any. - DTMItype myType; ///< Holds this objects AMF0 type. - std::string strval; ///< Holds this objects string value, if any. - uint64_t numval; ///< Holds this objects numeric value, if any. - std::vector contents; ///< Holds this objects contents, if any (for container types). - };//AMFType - - /// Parses a C-string to a valid DTSC::DTMI. - DTMI parseDTMI(const unsigned char * data, unsigned int len); - /// Parses a std::string to a valid DTSC::DTMI. - DTMI parseDTMI(std::string data); - /// Parses a single DTMI type - used recursively by the DTSC::parseDTMI() functions. - DTMI parseOneDTMI(const unsigned char *& data, unsigned int &len, unsigned int &i, std::string name); - -};//DTSC namespace - diff --git a/util/dtsc.cpp b/util/dtsc.cpp index bc722ecf..9d046287 100644 --- a/util/dtsc.cpp +++ b/util/dtsc.cpp @@ -2,33 +2,50 @@ /// Holds all code for DDVTECH Stream Container parsing/generation. #include "dtsc.h" -#include "string.h" //for memcmp -#include "arpa/inet.h" //for htonl/ntohl +#include //for memcmp +#include //for htonl/ntohl +#include //for fprint, stderr -char * DTSC::Magic_Header = "DTSC"; -char * DTSC::Magic_Packet = "DTPD"; +char DTSC::Magic_Header[] = "DTSC"; +char DTSC::Magic_Packet[] = "DTPD"; +/// Initializes a DTSC::Stream with only one packet buffer. DTSC::Stream::Stream(){ datapointer = 0; + buffercount = 1; } +/// Initializes a DTSC::Stream with a minimum of rbuffers packet buffers. +/// The actual buffer count may not at all times be the requested amount. +DTSC::Stream::Stream(unsigned int rbuffers){ + datapointer = 0; + if (rbuffers < 1){rbuffers = 1;} + buffercount = rbuffers; +} + +/// Attempts to parse a packet from the given std::string buffer. +/// Returns true if successful, removing the parsed part from the buffer string. +/// Returns false if invalid or not enough data is in the buffer. +/// \arg buffer The std::string buffer to attempt to parse. bool DTSC::Stream::parsePacket(std::string & buffer){ uint32_t len; if (buffer.length() > 8){ if (memcmp(buffer.c_str(), DTSC::Magic_Header, 4) == 0){ len = ntohl(((uint32_t *)buffer.c_str())[1]); if (buffer.length() < len+8){return false;} - metadata = DTSC::parseDTMI(buffer.c_str() + 8, len); + metadata = DTSC::parseDTMI((unsigned char*)buffer.c_str() + 8, len); + buffer.erase(0, len+8); } if (memcmp(buffer.c_str(), DTSC::Magic_Packet, 4) == 0){ len = ntohl(((uint32_t *)buffer.c_str())[1]); if (buffer.length() < len+8){return false;} - lastPacket = DTSC::parseDTMI(buffer.c_str() + 8, len); + buffers.push_front(DTSC::DTMI("empty", DTMI_ROOT)); + buffers.front() = DTSC::parseDTMI((unsigned char*)buffer.c_str() + 8, len); datapointertype = INVALID; - if (lastPacket.getContentP("data")){ - datapointer = lastPacket.getContentP("data")->StrValue.c_str(); - if (lastPacket.getContentP("datatype")){ - std::string tmp = lastPacket.getContentP("datatype")->StrValue(); + if (buffers.front().getContentP("data")){ + datapointer = buffers.front().getContentP("data")->StrValue().c_str(); + if (buffers.front().getContentP("datatype")){ + std::string tmp = buffers.front().getContentP("datatype")->StrValue(); if (tmp == "video"){datapointertype = VIDEO;} if (tmp == "audio"){datapointertype = AUDIO;} if (tmp == "meta"){datapointertype = META;} @@ -36,23 +53,372 @@ bool DTSC::Stream::parsePacket(std::string & buffer){ }else{ datapointer = 0; } + buffer.erase(0, len+8); + while (buffers.size() > buffercount){buffers.pop_back();} + advanceRings(); } + #if DEBUG >= 2 + std::cerr << "Error: Invalid DTMI data! I *will* get stuck!" << std::endl; + #endif } return false; } -char * DTSC::Stream::lastData(){ +/// Returns a direct pointer to the data attribute of the last received packet, if available. +/// Returns NULL if no valid pointer or packet is available. +const char * DTSC::Stream::lastData(){ return datapointer; } +/// Returns the packed in this buffer number. +/// \arg num Buffer number. +DTSC::DTMI & DTSC::Stream::getPacket(unsigned int num){ + return buffers[num]; +} + +/// Returns the type of the last received packet. DTSC::datatype DTSC::Stream::lastType(){ return datapointertype; } +/// Returns true if the current stream contains at least one video track. bool DTSC::Stream::hasVideo(){ return (metadata.getContentP("video") != 0); } +/// Returns true if the current stream contains at least one audio track. bool DTSC::Stream::hasAudio(){ return (metadata.getContentP("audio") != 0); } + +/// Returns a packed DTSC packet, ready to sent over the network. +std::string DTSC::Stream::outPacket(unsigned int num){ + std::string tmp; + unsigned int size; + tmp = Magic_Packet; + size = htonl(buffers[num].Pack().length()); + tmp.append((char*)&size, 4); + tmp.append(buffers[num].Pack()); + return tmp; +} + +/// Returns a packed DTSC header, ready to sent over the network. +std::string DTSC::Stream::outHeader(){ + std::string tmp; + unsigned int size; + tmp = Magic_Header; + size = htonl(metadata.Pack().length()); + tmp.append((char*)&size, 4); + tmp.append(metadata.Pack()); + return tmp; +} + +/// advances all given out and internal Ring classes to point to the new buffer, after one has been added. +/// Also updates the internal keyframes ring, as well as marking rings as starved if they are. +/// Unsets waiting rings, updating them with their new buffer number. +void DTSC::Stream::advanceRings(){ + std::deque::iterator dit; + std::set::iterator sit; + for (sit = rings.begin(); sit != rings.end(); sit++){ + (*sit)->b++; + if ((*sit)->waiting){(*sit)->waiting = false; (*sit)->b = 0;} + if ((*sit)->b >= buffers.size()){(*sit)->starved = true;} + } + for (dit = keyframes.begin(); dit != keyframes.end(); dit++){ + dit->b++; + if (dit->b >= buffers.size()){keyframes.erase(dit); break;} + } + if ((lastType() == VIDEO) && (buffers.front().getContentP("keyframe"))){ + keyframes.push_front(DTSC::Ring(0)); + } + //increase buffer size if no keyframes available + if ((buffercount > 1) && (keyframes.size() < 1)){buffercount++;} +} + +/// Constructs a new Ring, at the given buffer position. +/// \arg v Position for buffer. +DTSC::Ring::Ring(unsigned int v){ + b = v; + waiting = false; + starved = false; +} + +/// Requests a new Ring, which will be created and added to the internal Ring list. +/// This Ring will be kept updated so it always points to valid data or has the starved boolean set. +/// Don't forget to call dropRing() for all requested Ring classes that are no longer neccessary! +DTSC::Ring * DTSC::Stream::getRing(){ + DTSC::Ring * tmp; + if (keyframes.size() == 0){ + tmp = new DTSC::Ring(0); + }else{ + tmp = new DTSC::Ring(keyframes[0].b); + } + rings.insert(tmp); + return tmp; +} + +/// Deletes a given out Ring class from memory and internal Ring list. +/// Checks for NULL pointers and invalid pointers, silently discarding them. +void DTSC::Stream::dropRing(DTSC::Ring * ptr){ + if (rings.find(ptr) != rings.end()){ + rings.erase(ptr); + delete ptr; + } +} + +/// Properly cleans up the object for erasing. +/// Drops all Ring classes that have been given out. +DTSC::Stream::~Stream(){ + std::set::iterator sit; + for (sit = rings.begin(); sit != rings.end(); sit++){delete (*sit);} +} + +/// Returns the std::string Indice for the current object, if available. +/// Returns an empty string if no indice exists. +std::string DTSC::DTMI::Indice(){return myIndice;}; + +/// Returns the DTSC::DTMItype AMF0 object type for this object. +DTSC::DTMItype DTSC::DTMI::GetType(){return myType;}; + +/// Returns the numeric value of this object, if available. +/// If this object holds no numeric value, 0 is returned. +uint64_t DTSC::DTMI::NumValue(){return numval;}; + +/// Returns the std::string value of this object, if available. +/// If this object holds no string value, an empty string is returned. +std::string DTSC::DTMI::StrValue(){return strval;}; + +/// Returns the C-string value of this object, if available. +/// If this object holds no string value, an empty C-string is returned. +const char * DTSC::DTMI::Str(){return strval.c_str();}; + +/// Returns a count of the amount of objects this object currently holds. +/// If this object is not a container type, this function will always return 0. +int DTSC::DTMI::hasContent(){return contents.size();}; + +/// Adds an DTSC::DTMI to this object. Works for all types, but only makes sense for container types. +/// This function resets DTMI::packed to an empty string, forcing a repack on the next call to DTMI::Pack. +void DTSC::DTMI::addContent(DTSC::DTMI c){contents.push_back(c); packed = "";}; + +/// Returns a pointer to the object held at indice i. +/// Returns AMF::AMF0_DDV_CONTAINER of indice "error" if no object is held at this indice. +/// \param i The indice of the object in this container. +DTSC::DTMI* DTSC::DTMI::getContentP(int i){return &contents.at(i);}; + +/// Returns a copy of the object held at indice i. +/// Returns a AMF::AMF0_DDV_CONTAINER of indice "error" if no object is held at this indice. +/// \param i The indice of the object in this container. +DTSC::DTMI DTSC::DTMI::getContent(int i){return contents.at(i);}; + +/// Returns a pointer to the object held at indice s. +/// Returns NULL if no object is held at this indice. +/// \param s The indice of the object in this container. +DTSC::DTMI* DTSC::DTMI::getContentP(std::string s){ + for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ + if (it->Indice() == s){return &(*it);} + } + return 0; +}; + +/// Returns a copy of the object held at indice s. +/// Returns a AMF::AMF0_DDV_CONTAINER of indice "error" if no object is held at this indice. +/// \param s The indice of the object in this container. +DTSC::DTMI DTSC::DTMI::getContent(std::string s){ + for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ + if (it->Indice() == s){return *it;} + } + return DTSC::DTMI("error", DTMI_ROOT); +}; + +/// Default constructor. +/// Simply fills the data with DTSC::DTMI("error", AMF0_DDV_CONTAINER) +DTSC::DTMI::DTMI(){ + *this = DTSC::DTMI("error", DTMI_ROOT); +};//default constructor + +/// Constructor for numeric objects. +/// The object type is by default AMF::AMF0_NUMBER, but this can be forced to a different value. +/// \param indice The string indice of this object in its container, or empty string if none. Numeric indices are automatic. +/// \param val The numeric value of this object. Numeric AMF0 objects only support double-type values. +/// \param setType The object type to force this object to. +DTSC::DTMI::DTMI(std::string indice, double val, DTSC::DTMItype setType){//num type initializer + myIndice = indice; + myType = setType; + strval = ""; + numval = val; +}; + +/// Constructor for string objects. +/// The object type is by default AMF::AMF0_STRING, but this can be forced to a different value. +/// There is no need to manually change the type to AMF::AMF0_LONGSTRING, this will be done automatically. +/// \param indice The string indice of this object in its container, or empty string if none. Numeric indices are automatic. +/// \param val The string value of this object. +/// \param setType The object type to force this object to. +DTSC::DTMI::DTMI(std::string indice, std::string val, DTSC::DTMItype setType){//str type initializer + myIndice = indice; + myType = setType; + strval = val; + numval = 0; +}; + +/// Constructor for container objects. +/// The object type is by default AMF::AMF0_OBJECT, but this can be forced to a different value. +/// \param indice The string indice of this object in its container, or empty string if none. Numeric indices are automatic. +/// \param setType The object type to force this object to. +DTSC::DTMI::DTMI(std::string indice, DTSC::DTMItype setType){//object type initializer + myIndice = indice; + myType = setType; + strval = ""; + numval = 0; +}; + +/// Prints the contents of this object to std::cerr. +/// If this object contains other objects, it will call itself recursively +/// and print all nested content in a nice human-readable format. +void DTSC::DTMI::Print(std::string indent){ + std::cerr << indent; + // print my type + switch (myType){ + case DTMI_INT: std::cerr << "Integer"; break; + case DTMI_STRING: std::cerr << "String"; break; + case DTMI_OBJECT: std::cerr << "Object"; break; + case DTMI_OBJ_END: std::cerr << "Object end"; break; + case DTMI_ROOT: std::cerr << "Root Node"; break; + } + // print my string indice, if available + std::cerr << " " << myIndice << " "; + // print my numeric or string contents + switch (myType){ + case DTMI_INT: std::cerr << numval; break; + case DTMI_STRING: std::cerr << strval; break; + default: break;//we don't care about the rest, and don't want a compiler warning... + } + std::cerr << std::endl; + // if I hold other objects, print those too, recursively. + if (contents.size() > 0){ + for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){it->Print(indent+" ");} + } +};//print + +/// Packs the DTMI to a std::string for transfer over the network. +/// If a packed version already exists, does not regenerate it. +/// If the object is a container type, this function will call itself recursively and contain all contents. +std::string DTSC::DTMI::Pack(){ + if (packed != ""){return packed;} + std::string r = ""; + //skip output of DDV container types, they do not exist. Only output their contents. + if (myType != DTMI_ROOT){r += myType;} + //output the properly formatted data stream for this object's contents. + switch (myType){ + case DTMI_INT: + r += *(((char*)&numval)+7); r += *(((char*)&numval)+6); + r += *(((char*)&numval)+5); r += *(((char*)&numval)+4); + r += *(((char*)&numval)+3); r += *(((char*)&numval)+2); + r += *(((char*)&numval)+1); r += *(((char*)&numval)); + break; + case DTMI_STRING: + r += strval.size() / (256*256*256); + r += strval.size() / (256*256); + r += strval.size() / 256; + r += strval.size() % 256; + r += strval; + break; + case DTMI_OBJECT: + if (contents.size() > 0){ + for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ + r += it->Indice().size() / 256; + r += it->Indice().size() % 256; + r += it->Indice(); + r += it->Pack(); + } + } + r += (char)0; r += (char)0; r += (char)9; + break; + case DTMI_ROOT://only send contents + if (contents.size() > 0){ + for (std::vector::iterator it = contents.begin(); it != contents.end(); it++){ + r += it->Pack(); + } + } + break; + case DTMI_OBJ_END: + break; + } + packed = r; + return r; +};//pack + +/// Parses a single AMF0 type - used recursively by the AMF::parse() functions. +/// This function updates i every call with the new position in the data. +/// \param data The raw data to parse. +/// \param len The size of the raw data. +/// \param i Current parsing position in the raw data. +/// \param name Indice name for any new object created. +/// \returns A single DTSC::DTMI, parsed from the raw data. +DTSC::DTMI DTSC::parseOneDTMI(const unsigned char *& data, unsigned int &len, unsigned int &i, std::string name){ + std::string tmpstr; + unsigned int tmpi = 0; + unsigned char tmpdbl[8]; + #if DEBUG >= 10 + fprintf(stderr, "Note: AMF type %hhx found. %i bytes left\n", data[i], len-i); + #endif + switch (data[i]){ + case DTMI_INT: + tmpdbl[7] = data[i+1]; + tmpdbl[6] = data[i+2]; + tmpdbl[5] = data[i+3]; + tmpdbl[4] = data[i+4]; + tmpdbl[3] = data[i+5]; + tmpdbl[2] = data[i+6]; + tmpdbl[1] = data[i+7]; + tmpdbl[0] = data[i+8]; + i+=9;//skip 8(a double)+1 forwards + return DTSC::DTMI(name, *(uint64_t*)tmpdbl, DTMI_INT); + break; + case DTMI_STRING: + tmpi = data[i+1]*256*256*256+data[i+2]*256*256+data[i+3]*256+data[i+4];//set tmpi to UTF-8-long length + tmpstr.clear();//clean tmpstr, just to be sure + tmpstr.append((const char *)data+i+5, (size_t)tmpi);//add the string data + i += tmpi + 5;//skip length+size+1 forwards + return DTSC::DTMI(name, tmpstr, DTMI_STRING); + break; + case DTMI_OBJECT:{ + ++i; + DTSC::DTMI ret(name, DTMI_OBJECT); + while (data[i] + data[i+1] != 0){//while not encountering 0x0000 (we assume 0x000009) + tmpi = data[i]*256+data[i+1];//set tmpi to the UTF-8 length + tmpstr.clear();//clean tmpstr, just to be sure + tmpstr.append((const char*)data+i+2, (size_t)tmpi);//add the string data + i += tmpi + 2;//skip length+size forwards + ret.addContent(parseOneDTMI(data, len, i, tmpstr));//add content, recursively parsed, updating i, setting indice to tmpstr + } + i += 3;//skip 0x000009 + return ret; + } break; + } + #if DEBUG >= 2 + fprintf(stderr, "Error: Unimplemented DTMI type %hhx - returning.\n", data[i]); + #endif + return DTSC::DTMI("error", DTMI_ROOT); +}//parseOne + +/// Parses a C-string to a valid DTSC::DTMI. +/// This function will find all AMF objects in the string and return +/// them all packed in a single AMF::AMF0_DDV_CONTAINER DTSC::DTMI. +DTSC::DTMI DTSC::parseDTMI(const unsigned char * data, unsigned int len){ + DTSC::DTMI ret("returned", DTMI_ROOT);//container type + unsigned int i = 0, j = 0; + while (i < len){ + ret.addContent(parseOneDTMI(data, len, i, "")); + if (i > j){j = i;}else{return ret;} + } + ret.packed = std::string((char*)data, (size_t)len); + return ret; +}//parse + +/// Parses a std::string to a valid DTSC::DTMI. +/// This function will find all AMF objects in the string and return +/// them all packed in a single AMF::AMF0_DDV_CONTAINER DTSC::DTMI. +DTSC::DTMI DTSC::parseDTMI(std::string data){ + return parseDTMI((const unsigned char*)data.c_str(), data.size()); +}//parse diff --git a/util/dtsc.h b/util/dtsc.h index 6b918f30..3a025753 100644 --- a/util/dtsc.h +++ b/util/dtsc.h @@ -2,46 +2,117 @@ /// Holds all headers for DDVTECH Stream Container parsing/generation. #pragma once -#include "dtmi.h" +#include +#include +#include //for uint64_t +#include +#include +#include -// Video: -// Codec (string) +// video +// codec (string) -// Audio: -// Codec (string) -// Samping rate (int, Hz) -// Sample Size (int, bytesize) -// Channels (int, channelcount) +// audio +// codec (string) +// sampingrate (int, Hz) +// samplesize (int, bytesize) +// channels (int, channelcount) +/// Holds all DDVTECH Stream Container classes and parsers. namespace DTSC{ + /// Enumerates all possible DTMI types. + enum DTMItype { + DTMI_INT = 0x01, ///< Unsigned 64-bit integer. + DTMI_STRING = 0x02, ///< String, equivalent to the AMF longstring type. + DTMI_OBJECT = 0xE0, ///< Object, equivalent to the AMF object type. + DTMI_OBJ_END = 0xEE, ///< End of object marker. + DTMI_ROOT = 0xFF ///< Root node for all DTMI data. + }; + + /// Recursive class that holds DDVTECH MediaInfo. + class DTMI { + public: + std::string Indice(); + DTMItype GetType(); + uint64_t NumValue(); + std::string StrValue(); + const char * Str(); + int hasContent(); + void addContent(DTMI c); + DTMI* getContentP(int i); + DTMI getContent(int i); + DTMI* getContentP(std::string s); + DTMI getContent(std::string s); + DTMI(); + DTMI(std::string indice, double val, DTMItype setType = DTMI_INT); + DTMI(std::string indice, std::string val, DTMItype setType = DTMI_STRING); + DTMI(std::string indice, DTMItype setType = DTMI_OBJECT); + void Print(std::string indent = ""); + std::string Pack(); + std::string packed; + protected: + std::string myIndice; ///< Holds this objects indice, if any. + DTMItype myType; ///< Holds this objects AMF0 type. + std::string strval; ///< Holds this objects string value, if any. + uint64_t numval; ///< Holds this objects numeric value, if any. + std::vector contents; ///< Holds this objects contents, if any (for container types). + };//AMFType + + /// Parses a C-string to a valid DTSC::DTMI. + DTMI parseDTMI(const unsigned char * data, unsigned int len); + /// Parses a std::string to a valid DTSC::DTMI. + DTMI parseDTMI(std::string data); + /// Parses a single DTMI type - used recursively by the DTSC::parseDTMI() functions. + DTMI parseOneDTMI(const unsigned char *& data, unsigned int &len, unsigned int &i, std::string name); + /// This enum holds all possible datatypes for DTSC packets. enum datatype { AUDIO, ///< Stream Audio data VIDEO, ///< Stream Video data META, ///< Stream Metadata INVALID ///< Anything else or no data available. - } + }; - char * Magic_Header; ///< The magic bytes for a DTSC header - char * Magic_Packet; ///< The magic bytes for a DTSC packet + extern char Magic_Header[]; ///< The magic bytes for a DTSC header + extern char Magic_Packet[]; ///< The magic bytes for a DTSC packet - /// Holds temporary data for a DTSC stream and provides functions to access/store it. + /// A part from the DTSC::Stream ringbuffer. + /// Holds information about a buffer that will stay consistent + class Ring { + public: + Ring(unsigned int v); + unsigned int b; ///< Holds current number of buffer. May and is intended to change unexpectedly! + bool waiting; ///< If true, this Ring is currently waiting for a buffer fill. + bool starved; ///< If true, this Ring can no longer receive valid data. + }; + + /// Holds temporary data for a DTSC stream and provides functions to utilize it. + /// Optionally also acts as a ring buffer of a certain requested size. + /// If ring buffering mode is enabled, it will automatically grow in size to always contain at least one keyframe. class Stream { public: Stream(); + ~Stream(); + Stream(unsigned int buffers); DTSC::DTMI metadata; - DRSC::DTMI lastPacket; + DTSC::DTMI & getPacket(unsigned int num = 0); datatype lastType(); - char * lastData(); + const char * lastData(); bool hasVideo(); bool hasAudio(); bool parsePacket(std::string & buffer); - private: - char * datapointer; + std::string outPacket(unsigned int num); + std::string outHeader(); + Ring * getRing(); + void dropRing(Ring * ptr); + private: + std::deque buffers; + std::set rings; + std::deque keyframes; + void advanceRings(); + const char * datapointer; datatype datapointertype; - } - - - + unsigned int buffercount; + }; }; diff --git a/util/socket.cpp b/util/socket.cpp index 4fdaceec..ed669e75 100644 --- a/util/socket.cpp +++ b/util/socket.cpp @@ -270,7 +270,7 @@ bool Socket::Connection::write(const void * buffer, int len){ /// \param buffer Location of the buffer to read to. /// \param len Amount of bytes to read. /// \returns True if the whole read was succesfull, false otherwise. -bool Socket::Connection::read(void * buffer, int len){ +bool Socket::Connection::read(const void * buffer, int len){ int sofar = 0; if (sock < 0){return false;} while (sofar != len){ @@ -309,9 +309,9 @@ bool Socket::Connection::read(void * buffer, int len){ }//Socket::Connection::read /// Read call that is compatible with file access syntax. This function simply calls the other read function. -bool Socket::Connection::read(void * buffer, int width, int count){return read(buffer, width*count);} +bool Socket::Connection::read(const void * buffer, int width, int count){return read(buffer, width*count);} /// Write call that is compatible with file access syntax. This function simply calls the other write function. -bool Socket::Connection::write(void * buffer, int width, int count){return write(buffer, width*count);} +bool Socket::Connection::write(const void * buffer, int width, int count){return write(buffer, width*count);} /// Write call that is compatible with std::string. This function simply calls the other write function. bool Socket::Connection::write(const std::string data){return write(data.c_str(), data.size());} @@ -320,7 +320,7 @@ bool Socket::Connection::write(const std::string data){return write(data.c_str() /// \param buffer Location of the buffer to write from. /// \param len Amount of bytes to write. /// \returns The amount of bytes actually written. -int Socket::Connection::iwrite(void * buffer, int len){ +int Socket::Connection::iwrite(const void * buffer, int len){ if (sock < 0){return 0;} int r = send(sock, buffer, len, 0); if (r < 0){ diff --git a/util/socket.h b/util/socket.h index bfe824e5..747c861b 100644 --- a/util/socket.h +++ b/util/socket.h @@ -37,12 +37,12 @@ namespace Socket{ bool canWrite(); ///< Calls poll() on the socket, checking if data can be written. signed int ready(); ///< Returns the ready-state for this socket. bool connected(); ///< Returns the connected-state for this socket. - bool read(void * buffer, int len); ///< Reads data from socket. - bool read(void * buffer, int width, int count); ///< Read call that is compatible with file access syntax. + bool read(const void * buffer, int len); ///< Reads data from socket. + bool read(const void * buffer, int width, int count); ///< Read call that is compatible with file access syntax. bool write(const void * buffer, int len); ///< Writes data to socket. - bool write(void * buffer, int width, int count); ///< Write call that is compatible with file access syntax. + bool write(const void * buffer, int width, int count); ///< Write call that is compatible with file access syntax. bool write(const std::string data); ///< Write call that is compatible with std::string. - int iwrite(void * buffer, int len); ///< Incremental write call. + int iwrite(const void * buffer, int len); ///< Incremental write call. int iread(void * buffer, int len); ///< Incremental read call. bool read(std::string & buffer); ///< Read call that is compatible with std::string. bool swrite(std::string & buffer); ///< Read call that is compatible with std::string.