interface

util/MP4/box.cpp

@@ -46,7 +46,6 @@ class Box {
     uint8_t * Payload;
     BoxHeader header;
     uint32_t PayloadSize;
-  private:
 };//Box Class
 
 Box::Box() {
@@ -176,3 +175,225 @@ void Box::ResetPayload( ) {
     Payload = NULL;
   }
 }
+
+void Box::Parse( std::string PrintOffset ) {
+  if( header.BoxType == 0x61627374 ) {
+    uint8_t Version = Payload[0];
+    uint32_t Flags = (Payload[1] << 16) + (Payload[2] << 8) + (Payload[3]); //uint24_t
+    uint32_t BootstrapInfoVersion = (Payload[4] << 24) + (Payload[5] << 16) +(Payload[6] << 8) + (Payload[7]);
+    uint8_t Profile = (Payload[8] >> 6); //uint2_t
+    uint8_t Live = (( Payload[8] >> 5 ) & 0x1); //uint1_t
+    uint8_t Update = (( Payload[8] >> 4 ) & 0x1); //uint1_t
+    uint8_t Reserved = ( Payload[8] & 0x4); //uint4_t
+    uint32_t Timescale = (Payload[9] << 24) + (Payload[10] << 16) +(Payload[11] << 8) + (Payload[12]);
+    uint32_t CurrentMediaTime_Upperhalf = (Payload[13] << 24) + (Payload[14] << 16) +(Payload[15] << 8) + (Payload[16]);
+    uint32_t CurrentMediaTime_Lowerhalf = (Payload[17] << 24) + (Payload[18] << 16) +(Payload[19] << 8) + (Payload[20]);
+    uint32_t SmpteTimeCodeOffset_Upperhalf = (Payload[21] << 24) + (Payload[22] << 16) +(Payload[23] << 8) + (Payload[24]);
+    uint32_t SmpteTimeCodeOffset_Lowerhalf = (Payload[25] << 24) + (Payload[26] << 16) +(Payload[27] << 8) + (Payload[28]);
+
+    std::string MovieIdentifier;
+    uint8_t ServerEntryCount = -1;
+    std::vector<std::string> ServerEntryTable;
+    uint8_t QualityEntryCount = -1;
+    std::vector<std::string> QualityEntryTable;
+    std::string DrmData;
+    std::string MetaData;
+    uint8_t SegmentRunTableCount = -1;
+    std::vector<Box*> SegmentRunTableEntries;
+    uint8_t FragmentRunTableCount = -1;
+    std::vector<Box*> FragmentRunTableEntries;
+
+    uint32_t CurrentOffset = 29;
+    uint32_t TempSize;
+    Box* TempBox;
+    std::string temp;
+    while( Payload[CurrentOffset] != '\0' ) { MovieIdentifier += Payload[CurrentOffset]; CurrentOffset ++; }
+    CurrentOffset ++;
+    ServerEntryCount = Payload[CurrentOffset];
+    CurrentOffset ++;
+    for( uint8_t i = 0; i < ServerEntryCount; i++ ) {
+      temp = "";
+      while( Payload[CurrentOffset] != '\0' ) { temp += Payload[CurrentOffset]; CurrentOffset ++; }
+      ServerEntryTable.push_back(temp);
+      CurrentOffset++;
+    }
+    QualityEntryCount = Payload[CurrentOffset];
+    CurrentOffset ++;
+    for( uint8_t i = 0; i < QualityEntryCount; i++ ) {
+      temp = "";
+      while( Payload[CurrentOffset] != '\0' ) { temp += Payload[CurrentOffset]; CurrentOffset ++; }
+      QualityEntryTable.push_back(temp);
+      CurrentOffset++;
+    }
+    while( Payload[CurrentOffset] != '\0' ) { DrmData += Payload[CurrentOffset]; CurrentOffset ++; }
+    CurrentOffset ++;
+    while( Payload[CurrentOffset] != '\0' ) { MetaData += Payload[CurrentOffset]; CurrentOffset ++; }
+    CurrentOffset ++;
+    SegmentRunTableCount = Payload[CurrentOffset];
+    CurrentOffset ++;
+    for( uint8_t i = 0; i < SegmentRunTableCount; i++ ) {
+      TempSize = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1]<< 16) + (Payload[CurrentOffset+2]<< 8) + (Payload[CurrentOffset+3]);
+      TempBox = new Box( &Payload[CurrentOffset], TempSize );
+      SegmentRunTableEntries.push_back(TempBox);
+      CurrentOffset += TempSize;
+    }
+    FragmentRunTableCount = Payload[CurrentOffset];
+    CurrentOffset ++;
+    for( uint8_t i = 0; i < FragmentRunTableCount; i++ ) {
+      TempSize = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1]<< 16) + (Payload[CurrentOffset+2]<< 8) + (Payload[CurrentOffset+3]);
+      TempBox = new Box( &Payload[CurrentOffset], TempSize );
+      FragmentRunTableEntries.push_back(TempBox);
+      CurrentOffset += TempSize;
+    }
+
+    std::cerr << "Box_ABST:\n";
+    std::cerr << PrintOffset << "  Version: " << (int)Version << "\n";
+    std::cerr << PrintOffset << "  Flags: " << (int)Flags << "\n";
+    std::cerr << PrintOffset << "  BootstrapInfoVersion: " << (int)BootstrapInfoVersion << "\n";
+    std::cerr << PrintOffset << "  Profile: " << (int)Profile << "\n";
+    std::cerr << PrintOffset << "  Live: " << (int)Live << "\n";
+    std::cerr << PrintOffset << "  Update: " << (int)Update << "\n";
+    std::cerr << PrintOffset << "  Reserved: " << (int)Reserved << "\n";
+    std::cerr << PrintOffset << "  Timescale: " << (int)Timescale << "\n";
+    std::cerr << PrintOffset << "  CurrentMediaTime: " << (int)CurrentMediaTime_Upperhalf << " " << CurrentMediaTime_Lowerhalf << "\n";
+    std::cerr << PrintOffset << "  SmpteTimeCodeOffset: " << (int)SmpteTimeCodeOffset_Upperhalf << " " << SmpteTimeCodeOffset_Lowerhalf << "\n";
+    std::cerr << PrintOffset << "  MovieIdentifier: " << MovieIdentifier << "\n";
+    std::cerr << PrintOffset << "  ServerEntryCount: " << (int)ServerEntryCount << "\n";
+    std::cerr << PrintOffset << "  ServerEntryTable:\n";
+    for( uint32_t i = 0; i < ServerEntryTable.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ": " << ServerEntryTable[i] << "\n";
+    }
+    std::cerr << PrintOffset << "  QualityEntryCount: " << (int)QualityEntryCount << "\n";
+    std::cerr << PrintOffset << "  QualityEntryTable:\n";
+    for( uint32_t i = 0; i < QualityEntryTable.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ": " << QualityEntryTable[i] << "\n";
+    }
+    std::cerr << PrintOffset << "  DrmData: " << DrmData << "\n";
+    std::cerr << PrintOffset << "  MetaData: " << MetaData << "\n";
+    std::cerr << PrintOffset << "  SegmentRunTableCount: " << (int)SegmentRunTableCount << "\n";
+    std::cerr << PrintOffset << "  SegmentRunTableEntries:\n";
+    for( uint32_t i = 0; i < SegmentRunTableEntries.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ": ";
+      SegmentRunTableEntries[i]->Parse( PrintOffset+"      ");
+    }
+    std::cerr << PrintOffset << "  FragmentRunTableCount: " << (int)FragmentRunTableCount << "\n";
+    std::cerr << PrintOffset << "  FragmentRunTableEntries:\n";
+    for( uint32_t i = 0; i < FragmentRunTableEntries.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ": ";
+      FragmentRunTableEntries[i]->Parse( PrintOffset+"      ");
+    }
+
+  } else if ( header.BoxType == 0x61737274 ) {
+    uint8_t Version = Payload[0];
+    uint32_t Flags = (Payload[1] << 16) + (Payload[2] << 8) + (Payload[3]); //uint24_t
+    uint8_t QualityEntryCount;
+    std::vector<std::string> QualitySegmentUrlModifiers;
+    uint32_t SegmentRunEntryCount;
+    std::vector< std::pair<uint32_t,uint32_t> > SegmentRunEntryTable;
+
+    uint32_t CurrentOffset = 4;
+    std::string temp;
+    std::pair<uint32_t,uint32_t> TempPair;
+    QualityEntryCount = Payload[CurrentOffset];
+    CurrentOffset ++;
+    for( uint8_t i = 0; i < QualityEntryCount; i++ ) {
+      temp = "";
+      while( Payload[CurrentOffset] != '\0' ) { temp += Payload[CurrentOffset]; CurrentOffset ++; }
+      QualitySegmentUrlModifiers.push_back(temp);
+      CurrentOffset++;
+    }
+    SegmentRunEntryCount = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2]) + (Payload[CurrentOffset+3]);
+    CurrentOffset +=4;
+    for( uint8_t i = 0; i < SegmentRunEntryCount; i++ ) {
+      TempPair.first = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2] << 8) + (Payload[CurrentOffset+3]);
+      CurrentOffset+=4;
+      TempPair.second = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2] << 8) + (Payload[CurrentOffset+3]);
+      CurrentOffset+=4;
+      SegmentRunEntryTable.push_back(TempPair);
+    }
+
+    std::cerr << "Box_ASRT:\n";
+    std::cerr << PrintOffset << "  Version: " << (int)Version << "\n";
+    std::cerr << PrintOffset << "  Flags: " << (int)Flags << "\n";
+    std::cerr << PrintOffset << "  QualityEntryCount: " << (int)QualityEntryCount << "\n";
+    std::cerr << PrintOffset << "  QualitySegmentUrlModifiers:\n";
+    for( uint32_t i = 0; i < QualitySegmentUrlModifiers.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ": " << QualitySegmentUrlModifiers[i] << "\n";
+    }
+    std::cerr << PrintOffset << "  SegmentRunEntryCount: " << (int)SegmentRunEntryCount << "\n";
+    std::cerr << PrintOffset << "  SegmentRunEntryTable:\n";
+    for( uint32_t i = 0; i < SegmentRunEntryTable.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ":\n";
+      std::cerr << PrintOffset << "      FirstSegment: " << SegmentRunEntryTable[i].first << "\n";
+      std::cerr << PrintOffset << "      FragmentsPerSegment: " << SegmentRunEntryTable[i].second << "\n";
+    }
+  } else if ( header.BoxType == 0x61667274 ) {
+    uint8_t Version = Payload[0];
+    uint32_t Flags = (Payload[1] << 16) + (Payload[2] << 8) + (Payload[3]); //uint24_t
+    uint32_t TimeScale = (Payload[4] << 24) + (Payload[5] << 16) + (Payload[6] << 8) + (Payload[7]);
+    uint8_t QualityEntryCount;
+    std::vector<std::string> QualitySegmentUrlModifiers;
+    uint32_t FragmentRunEntryCount;
+    std::vector<afrt_fragmentrunentry> FragmentRunEntryTable;
+
+    uint32_t CurrentOffset = 8;
+    std::string temp;
+    afrt_fragmentrunentry TempEntry;
+    QualityEntryCount = Payload[CurrentOffset];
+    CurrentOffset ++;
+    for( uint8_t i = 0; i < QualityEntryCount; i++ ) {
+      temp = "";
+      while( Payload[CurrentOffset] != '\0' ) { temp += Payload[CurrentOffset]; CurrentOffset ++; }
+      QualitySegmentUrlModifiers.push_back(temp);
+      CurrentOffset++;
+    }
+    FragmentRunEntryCount = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2]) + (Payload[CurrentOffset+3]);
+    CurrentOffset +=4;
+    for( uint8_t i = 0; i < FragmentRunEntryCount; i ++ ) {
+      TempEntry.FirstFragment = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2]) + (Payload[CurrentOffset+3]);
+      CurrentOffset +=4;
+      TempEntry.FirstFragmentTimestamp_Upperhalf = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2]) + (Payload[CurrentOffset+3]);
+      CurrentOffset +=4;
+      TempEntry.FirstFragmentTimestamp = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2]) + (Payload[CurrentOffset+3]);
+      CurrentOffset +=4;
+      TempEntry.FragmentDuration = (Payload[CurrentOffset] << 24) + (Payload[CurrentOffset+1] << 16) + (Payload[CurrentOffset+2]) + (Payload[CurrentOffset+3]);
+      CurrentOffset +=4;
+      if( TempEntry.FragmentDuration == 0 ) {
+        TempEntry.DiscontinuityIndicator = Payload[CurrentOffset];
+        CurrentOffset++;
+      }
+      FragmentRunEntryTable.push_back(TempEntry);
+    }
+
+    std::cerr << "Box_AFRT:\n";
+    std::cerr << PrintOffset << "  Version: " << (int)Version << "\n";
+    std::cerr << PrintOffset << "  Flags: " << (int)Flags << "\n";
+    std::cerr << PrintOffset << "  Timescale: " << (int)TimeScale << "\n";
+    std::cerr << PrintOffset << "  QualityEntryCount: " << (int)QualityEntryCount << "\n";
+    std::cerr << PrintOffset << "  QualitySegmentUrlModifiers:\n";
+    for( uint32_t i = 0; i < QualitySegmentUrlModifiers.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ": " << QualitySegmentUrlModifiers[i] << "\n";
+    }
+    std::cerr << PrintOffset << "  FragmentRunEntryCount: " << (int)FragmentRunEntryCount << "\n";
+    std::cerr << PrintOffset << "  FragmentRunEntryTable:\n";
+    for( uint32_t i = 0; i < FragmentRunEntryTable.size( ); i++ ) {
+      std::cerr << PrintOffset << "    " << i+1 << ":\n";
+      std::cerr << PrintOffset << "      FirstFragment: " << FragmentRunEntryTable[i].FirstFragment << "\n";
+      std::cerr << PrintOffset << "      FirstFragmentTimestamp: " << FragmentRunEntryTable[i].FirstFragmentTimestamp_Upperhalf << FragmentRunEntryTable[i].FirstFragmentTimestamp << "\n";
+      std::cerr << PrintOffset << "      FragmentDuration: " << FragmentRunEntryTable[i].FragmentDuration << "\n";
+      if( FragmentRunEntryTable[i].FragmentDuration == 0 ) {
+        std::cerr << PrintOffset << "      DiscontinuityIndicator: " << (int)FragmentRunEntryTable[i].DiscontinuityIndicator << "\n";
+      }
+    }
+  } else if ( header.BoxType == 0x6D646174 ) {
+    std::cerr << "mdat box containing " << PayloadSize << " bytes of payload" << std::endl;
+  } else {
+    std::cerr << "BoxType '"
+              << (char)(header.BoxType >> 24)
+              << (char)((header.BoxType << 8) >> 24)
+              << (char)((header.BoxType << 16) >> 24)
+              << (char)((header.BoxType << 24) >> 24)
+              << "' not yet implemented!\n";
+  }
+}
+

util/MP4/interface.cpp

@@ -547,13 +547,13 @@ std::string Interface::GenerateLiveBootstrap( uint32_t CurMediaTime ) {
   afrt->SetUpdate(false);
   afrt->SetTimeScale( 1000 );
   afrt->AddQualityEntry( "" );
-  afrt->AddFragmentRunEntry( 1, 1 , 4000 );
+  afrt->AddFragmentRunEntry( 1, 1 , 4000 ); //FirstFragment, FirstFragmentTimestamp,Fragment Duration in milliseconds
   afrt->WriteContent( );
 
   //SetUpASRT
   asrt->SetUpdate(false);
   asrt->AddQualityEntry( "" );
-  asrt->AddSegmentRunEntry( 1, 199 );
+  asrt->AddSegmentRunEntry( 1, 199 );//1 Segment, 199 Fragments
   asrt->WriteContent( );
 
   //SetUpABST
@@ -562,9 +562,9 @@ std::string Interface::GenerateLiveBootstrap( uint32_t CurMediaTime ) {
   abst->SetLive( true );
   abst->SetUpdate( false );
   abst->SetTimeScale( 1000 );
-  abst->SetMediaTime( 596458 );
+  abst->SetMediaTime( CurMediaTime );
   abst->SetSMPTE( 0 );
-  abst->SetMovieIdentifier( "" );
+  abst->SetMovieIdentifier( "fifa" );
   abst->SetDRM( "" );
   abst->SetMetaData( "" );
   abst->AddServerEntry( "" );

util/ddv_socket.cpp

@@ -1,3 +1,4 @@
+#pragma once
 #include <string>
 #include <sys/types.h>
 #include <sys/socket.h>

util/flv_data.cpp

@@ -0,0 +1,90 @@
+#include <unistd.h> //for read()
+#include <fcntl.h>
+
+struct FLV_Pack {
+  int len;
+  int buf;
+  bool isKeyframe;
+  char * data;
+};//FLV_Pack
+
+char FLVHeader[13];
+bool All_Hell_Broke_Loose = false;
+
+//checks FLV Header for correctness
+//returns true if everything is alright, false otherwise
+bool FLV_Checkheader(char * header){
+  if (header[0] != 'F') return false;
+  if (header[1] != 'L') return false;
+  if (header[2] != 'V') return false;
+  if (header[8] != 0x09) return false;
+  if (header[9] != 0) return false;
+  if (header[10] != 0) return false;
+  if (header[11] != 0) return false;
+  if (header[12] != 0) return false;
+  return true;
+}//FLV_Checkheader
+
+//returns true if header is an FLV header
+bool FLV_Isheader(char * header){
+  if (header[0] != 'F') return false;
+  if (header[1] != 'L') return false;
+  if (header[2] != 'V') return false;
+  return true;
+}//FLV_Isheader
+
+bool ReadUntil(char * buffer, unsigned int count, unsigned int & sofar, char * D, unsigned int S, unsigned int & P){
+  if (sofar >= count){return true;}
+  int r = 0;
+  if (P+(count-sofar) > S){r = S-P;}else{r = count-sofar;}
+  memcpy(buffer+sofar, D+P, r);
+  P += r;
+  sofar += r;
+  if (sofar >= count){return true;}
+  return false;
+}
+
+//gets a packet, storing in given FLV_Pack pointer.
+//will assign pointer if null
+//resizes FLV_Pack data field bigger if data doesn't fit
+// (does not auto-shrink for speed!)
+bool FLV_GetPacket(FLV_Pack *& p, char * D, unsigned int S, unsigned int & P){
+  static bool done = true;
+  static unsigned int sofar = 0;
+  if (!p){p = (FLV_Pack*)calloc(1, sizeof(FLV_Pack));}
+  if (p->buf < 15){p->data = (char*)realloc(p->data, 15000000); p->buf = 15000000;}
+
+  if (done){
+    //read a header
+    if (ReadUntil(p->data, 11, sofar, D, S, P)){
+      //if its a correct FLV header, throw away and read tag header
+      if (FLV_Isheader(p->data)){
+        if (ReadUntil(p->data, 13, sofar, D, S, P)){
+          if (FLV_Checkheader(p->data)){
+            sofar = 0;
+            memcpy(FLVHeader, p->data, 13);
+          }else{All_Hell_Broke_Loose = true;}
+        }
+      }else{
+        //if a tag header, calculate length and read tag body
+        p->len = p->data[3] + 15;
+        p->len += (p->data[2] << 8);
+        p->len += (p->data[1] << 16);
+        //if (p->buf < p->len){p->data = (char*)realloc(p->data, p->len);p->buf = p->len;}
+        done = false;
+      }
+    }
+  }else{
+    //read tag body
+    if (ReadUntil(p->data, p->len, sofar, D, S, P)){
+      //calculate keyframeness, next time read header again, return true
+      p->isKeyframe = false;
+      if ((p->data[0] == 0x09) && (((p->data[11] & 0xf0) >> 4) == 1)){p->isKeyframe = true;}
+      done = true;
+      sofar = 0;
+      return true;
+    }
+  }
+  return false;
+}//FLV_GetPacket
+

util/http_parser.cpp

@@ -1,10 +1,14 @@
+#pragma once
+#include "ddv_socket.cpp"
 #include <map>
 #include <stdlib.h>
+#include <stdio.h>
 
 class HTTPReader{
   public:
     HTTPReader();
     bool ReadSocket(int CONN_fd);
+    bool ReadSocket(FILE * F);
     std::string GetHeader(std::string i);
     std::string GetVar(std::string i);
     void SetHeader(std::string i, std::string v);
@@ -18,6 +22,8 @@ class HTTPReader{
     void SendBodyPart(int conn, char * buffer, int len);
     void SendBodyPart(int conn, std::string bodypart);
     void Clean();
+    bool CleanForNext();
+    std::string body;
     std::string method;
     std::string url;
     std::string protocol;
@@ -39,12 +45,26 @@ void HTTPReader::Clean(){
   method = "GET";
   url = "/";
   protocol = "HTTP/1.1";
+  body = "";
   length = 0;
   HTTPbuffer = "";
   headers.erase(headers.begin(), headers.end());
   vars.erase(vars.begin(), vars.end());
 }
 
+bool HTTPReader::CleanForNext(){
+  seenHeaders = false;
+  seenReq = false;
+  method = "GET";
+  url = "/";
+  protocol = "HTTP/1.1";
+  body = "";
+  length = 0;
+  headers.erase(headers.begin(), headers.end());
+  vars.erase(vars.begin(), vars.end());
+  return parse();
+}
+
 std::string HTTPReader::BuildRequest(){
   std::map<std::string, std::string>::iterator it;
   std::string tmp = method+" "+url+" "+protocol+"\n";
@@ -129,6 +149,16 @@ bool HTTPReader::ReadSocket(int CONN_fd){
   return false;
 }//HTTPReader::ReadSocket
 
+bool HTTPReader::ReadSocket(FILE * F){
+  //returned true als hele http packet gelezen is
+  int b = 1;
+  char buffer[500];
+  while (b > 0){
+    b = fread(buffer, 1, 500, F);
+    HTTPbuffer.append(buffer, b);
+  }
+  return false;
+}//HTTPReader::ReadSocket
 
 bool HTTPReader::parse(){
   size_t f;
@@ -148,7 +178,7 @@ bool HTTPReader::parse(){
         if (f != std::string::npos){url = tmpA.substr(0, f); tmpA.erase(0, f+1);}
         f = tmpA.find(' ');
         if (f != std::string::npos){protocol = tmpA.substr(0, f); tmpA.erase(0, f+1);}
-        //TODO: GET variable parsing
+        //TODO: GET variable parsing?
       }else{
         if (tmpA.size() == 0){
           seenHeaders = true;
@@ -164,8 +194,14 @@ bool HTTPReader::parse(){
     }
     if (seenHeaders){
       if (length > 0){
-        //TODO: POST variable parsing
+        //TODO: POST variable parsing?
-        return (HTTPbuffer.length() >= length);
+        if (HTTPbuffer.length() >= length){
+          body = HTTPbuffer.substr(0, length);
+          HTTPbuffer.erase(0, length);
+          return true;
+        }else{
+          return false;
+        }
       }else{
         return true;
       }