#include "output_dash_mp4.h"
#include <mist/defines.h>
#include <mist/mp4.h>
#include <mist/mp4_generic.h>
#include <mist/mp4_dash.h>
#include <mist/checksum.h>
#include <mist/timing.h>
#include <mist/stream.h>
#include <iomanip>

namespace Mist{
  OutDashMP4::OutDashMP4(Socket::Connection & conn) : HTTPOutput(conn){
    uaDelay = 0;
    realTime = 0;
  }
  OutDashMP4::~OutDashMP4(){}
  
  std::string OutDashMP4::makeTime(uint64_t time){
    std::stringstream r;
    r << "PT";
    if (time >= 3600000){r << (time / 3600000) << "H";}
    if (time >= 60000){r << (time / 60000) % 60 << "M";}
    r << (time / 1000) % 60 << "." << std::setfill('0') << std::setw(3) << (time % 1000) << "S";
    return r.str();
  }
 
  /// Sends an empty moov box for the given track to the connected client, for following up with moof box(es).
  void OutDashMP4::sendMoov(uint32_t tid){
    DTSC::Track & Trk = myMeta.tracks[tid];

    MP4::MOOV moovBox;
    MP4::MVHD mvhdBox(0);
    mvhdBox.setTrackID(1);
    mvhdBox.setDuration(0xFFFFFFFF);
    moovBox.setContent(mvhdBox, 0);

    MP4::IODS iodsBox;
    if (Trk.type == "video"){
      iodsBox.setODVideoLevel(0xFE);
    }else{
      iodsBox.setODAudioLevel(0xFE);
    }
    moovBox.setContent(iodsBox, 1);
    
    
    MP4::MVEX mvexBox;
    MP4::MEHD mehdBox;
    mehdBox.setFragmentDuration(0xFFFFFFFF);
    mvexBox.setContent(mehdBox, 0);
    MP4::TREX trexBox;
    trexBox.setTrackID(1);
    mvexBox.setContent(trexBox, 1);
    moovBox.setContent(mvexBox, 2);
    
    MP4::TRAK trakBox;
    MP4::TKHD tkhdBox(1, 0, Trk.width, Trk.height);
    tkhdBox.setFlags(3);
    if (Trk.type == "audio"){
      tkhdBox.setVolume(256);
      tkhdBox.setWidth(0);
      tkhdBox.setHeight(0);
    }
    tkhdBox.setDuration(0xFFFFFFFF);
    trakBox.setContent(tkhdBox, 0);
    
    MP4::MDIA mdiaBox;
    MP4::MDHD mdhdBox(0);
    mdhdBox.setLanguage(0x44);
    mdhdBox.setDuration(Trk.lastms);
    mdiaBox.setContent(mdhdBox, 0);
    
    if (Trk.type == "video"){
      MP4::HDLR hdlrBox(Trk.type,"VideoHandler");
      mdiaBox.setContent(hdlrBox, 1);
    }else{
      MP4::HDLR hdlrBox(Trk.type,"SoundHandler");
      mdiaBox.setContent(hdlrBox, 1);
    }

    MP4::MINF minfBox;
    MP4::DINF dinfBox;
    MP4::DREF drefBox;
    dinfBox.setContent(drefBox, 0);
    minfBox.setContent(dinfBox, 0);
    
    MP4::STBL stblBox;
    MP4::STSD stsdBox;
    stsdBox.setVersion(0);
    
    if (Trk.codec == "H264"){
      MP4::AVC1 avc1Box;
      avc1Box.setWidth(Trk.width);
      avc1Box.setHeight(Trk.height);
      
      MP4::AVCC avccBox;
      avccBox.setPayload(Trk.init);
      avc1Box.setCLAP(avccBox);
      stsdBox.setEntry(avc1Box, 0);
    }
    if (Trk.codec == "HEVC"){
      MP4::HEV1 hev1Box;
      hev1Box.setWidth(Trk.width);
      hev1Box.setHeight(Trk.height);
      
      MP4::HVCC hvccBox;
      hvccBox.setPayload(Trk.init);
      hev1Box.setCLAP(hvccBox);
      stsdBox.setEntry(hev1Box, 0);
    }
    if (Trk.codec == "AAC" || Trk.codec == "MP3"){
      MP4::AudioSampleEntry ase;
      ase.setCodec("mp4a");
      ase.setDataReferenceIndex(1);
      ase.setSampleRate(Trk.rate);
      ase.setChannelCount(Trk.channels);
      ase.setSampleSize(Trk.size);
      MP4::ESDS esdsBox(Trk.init);
      ase.setCodecBox(esdsBox);
      stsdBox.setEntry(ase,0);
    }
    if (Trk.codec == "AC3"){
      ///\todo Note: this code is copied, note for muxing seperation
      MP4::AudioSampleEntry ase;
      ase.setCodec("ac-3");
      ase.setDataReferenceIndex(1);
      ase.setSampleRate(Trk.rate);
      ase.setChannelCount(Trk.channels);
      ase.setSampleSize(Trk.size);
      MP4::DAC3 dac3Box(Trk.rate, Trk.channels);
      ase.setCodecBox(dac3Box);
      stsdBox.setEntry(ase,0);
    }
    
    stblBox.setContent(stsdBox, 0);
    
    MP4::STTS sttsBox;
    sttsBox.setVersion(0);
    stblBox.setContent(sttsBox, 1);
    
    MP4::STSC stscBox;
    stscBox.setVersion(0);
    stblBox.setContent(stscBox, 2);
    
    MP4::STCO stcoBox;
    stcoBox.setVersion(0);
    stblBox.setContent(stcoBox, 3);
    
    MP4::STSZ stszBox;
    stszBox.setVersion(0);
    stblBox.setContent(stszBox, 4);
    
    minfBox.setContent(stblBox, 1);
    
    if (Trk.type == "video"){
      MP4::VMHD vmhdBox;
      vmhdBox.setFlags(1);
      minfBox.setContent(vmhdBox, 2);
    }else{
      MP4::SMHD smhdBox;
      minfBox.setContent(smhdBox, 2);
    }

    mdiaBox.setContent(minfBox, 2);
    trakBox.setContent(mdiaBox, 1);
    moovBox.setContent(trakBox, 3);
   
    H.Chunkify(moovBox.asBox(), moovBox.boxedSize(), myConn);
  }
    
  void OutDashMP4::sendMoof(uint32_t tid, uint32_t fragIndice){
    DTSC::Track & Trk = myMeta.tracks[tid];
    MP4::MOOF moofBox;
    MP4::MFHD mfhdBox;
    mfhdBox.setSequenceNumber(fragIndice + Trk.missedFrags);
    moofBox.setContent(mfhdBox, 0);
    MP4::TRAF trafBox;
    MP4::TFHD tfhdBox;
    tfhdBox.setTrackID(1);
    if (Trk.type == "audio"){
      tfhdBox.setFlags(MP4::tfhdSampleFlag);
      tfhdBox.setDefaultSampleFlags(MP4::isKeySample);
    }
    trafBox.setContent(tfhdBox, 0);
    MP4::TFDT tfdtBox;
    tfdtBox.setBaseMediaDecodeTime(Trk.getKey(Trk.fragments[fragIndice].getNumber()).getTime());
    trafBox.setContent(tfdtBox, 1);
    MP4::TRUN trunBox;

    if (Trk.type == "video"){
      uint32_t headSize = 0;
      if (Trk.codec == "H264"){
        MP4::AVCC avccBox;
        avccBox.setPayload(Trk.init);
        headSize = 14 + avccBox.getSPSLen() + avccBox.getPPSLen();
      }
      if (Trk.codec == "HEVC"){
        MP4::HVCC hvccBox;
        hvccBox.setPayload(myMeta.tracks[tid].init);
        std::deque<MP4::HVCCArrayEntry> content = hvccBox.getArrays();
        for (std::deque<MP4::HVCCArrayEntry>::iterator it = content.begin(); it != content.end(); it++){
          for (std::deque<std::string>::iterator it2 = it->nalUnits.begin(); it2 != it->nalUnits.end(); it2++){
            headSize += 4 + (*it2).size();
          }
        }
      }
      trunBox.setFlags(MP4::trundataOffset | MP4::trunsampleSize | MP4::trunsampleDuration | MP4::trunfirstSampleFlags | MP4::trunsampleOffsets);
      trunBox.setFirstSampleFlags(MP4::isKeySample);
      trunBox.setDataOffset(0);
      uint32_t j = 0;
      for (DTSC::PartIter parts(Trk, Trk.fragments[fragIndice]); parts; ++parts){
        MP4::trunSampleInformation trunEntry;
        trunEntry.sampleSize = parts->getSize();
        if (!j){
          trunEntry.sampleSize += headSize;
        }
        trunEntry.sampleDuration = parts->getDuration();
        trunEntry.sampleOffset = parts->getOffset();
        trunBox.setSampleInformation(trunEntry, j);
        ++j;
      }
      trunBox.setDataOffset(92 + (12 * j) + 8);
    }
    if (Trk.type == "audio"){
      trunBox.setFlags(MP4::trundataOffset | MP4::trunsampleSize | MP4::trunsampleDuration);
      trunBox.setDataOffset(0);
      uint32_t j = 0;
      for (DTSC::PartIter parts(Trk, Trk.fragments[fragIndice]); parts; ++parts){
        MP4::trunSampleInformation trunEntry;
        trunEntry.sampleSize = parts->getSize();
        trunEntry.sampleDuration = parts->getDuration();
        trunBox.setSampleInformation(trunEntry, j);
        ++j;
      }
      trunBox.setDataOffset(92 + (8 * j) + 8);
    }
    trafBox.setContent(trunBox, 2);
    moofBox.setContent(trafBox, 1);
    H.Chunkify(moofBox.asBox(), moofBox.boxedSize(), myConn);
  }
  
  std::string OutDashMP4::buildNalUnit(unsigned int len, const char * data){
    std::stringstream r;
    r << (char)((len >> 24) & 0xFF);
    r << (char)((len >> 16) & 0xFF);
    r << (char)((len >> 8) & 0xFF);
    r << (char)((len) & 0xFF);
    r << std::string(data, len);
    return r.str();
  }
  
  void OutDashMP4::sendMdat(uint32_t tid, uint32_t fragIndice){
    DTSC::Track & Trk = myMeta.tracks[tid];
    DTSC::Fragment & Frag = Trk.fragments[fragIndice];
    uint32_t size = 8 + Frag.getSize();
    if (Trk.codec == "H264"){
      MP4::AVCC avccBox;
      avccBox.setPayload(Trk.init);
      size += 14 + avccBox.getSPSLen() + avccBox.getPPSLen();
    }
    if (Trk.codec == "HEVC"){
      MP4::HVCC hvccBox;
      hvccBox.setPayload(Trk.init);
      std::deque<MP4::HVCCArrayEntry> content = hvccBox.getArrays();
      for (std::deque<MP4::HVCCArrayEntry>::iterator it = content.begin(); it != content.end(); it++){
        for (std::deque<std::string>::iterator it2 = it->nalUnits.begin(); it2 != it->nalUnits.end(); it2++){
          size += 4 + (*it2).size();
        }
      }
    }
    char mdatstr[8] ={0, 0, 0, 0, 'm', 'd', 'a', 't'};
    mdatstr[0] = (char)((size >> 24) & 0xFF);
    mdatstr[1] = (char)((size >> 16) & 0xFF);
    mdatstr[2] = (char)((size >> 8) & 0xFF);
    mdatstr[3] = (char)((size) & 0xFF);
    H.Chunkify(mdatstr, 8, myConn);
    std::string init;
    if (Trk.codec == "H264"){
      MP4::AVCC avccBox;
      avccBox.setPayload(Trk.init);
      init = buildNalUnit(2, "\011\340");
      H.Chunkify(init, myConn);//09E0
      init = buildNalUnit(avccBox.getSPSLen(), avccBox.getSPS());
      H.Chunkify(init, myConn);
      init = buildNalUnit(avccBox.getPPSLen(), avccBox.getPPS());
      H.Chunkify(init, myConn);
    }
    if (Trk.codec == "HEVC"){
      MP4::HVCC hvccBox;
      hvccBox.setPayload(Trk.init);
      std::deque<MP4::HVCCArrayEntry> content = hvccBox.getArrays();
      for (std::deque<MP4::HVCCArrayEntry>::iterator it = content.begin(); it != content.end(); it++){
        for (std::deque<std::string>::iterator it2 = it->nalUnits.begin(); it2 != it->nalUnits.end(); it2++){
          init = buildNalUnit((*it2).size(), (*it2).c_str());
          H.Chunkify(init, myConn);
        }
      }
    }
    //we pull these values first, because seek() destroys our Trk reference
    uint64_t startTime = Trk.getKey(Frag.getNumber()).getTime();
    targetTime = startTime + Frag.getDuration();
    HIGH_MSG("Starting playback from %llu to %llu", startTime, targetTime);
    wantRequest = false;
    parseData = true;
    //select only the tid track, and seek to the start time
    selectedTracks.clear();
    selectedTracks.insert(tid);
    seek(startTime);
  }

  void OutDashMP4::sendNext(){
    if (thisPacket.getTime() >= targetTime){
      HIGH_MSG("Finished playback to %llu", targetTime);
      wantRequest = true;
      parseData = false;
      H.Chunkify("", 0, myConn);
      H.Clean();
      return;
    }
    char *  data;
    size_t dataLen;
    thisPacket.getString("data", data, dataLen);
    H.Chunkify(data, dataLen, myConn);
  }

  /// Examines Trk and adds playable fragments from it to r.
  void OutDashMP4::addSegmentTimeline(std::stringstream & r, DTSC::Track & Trk, bool live){
    std::deque<DTSC::Fragment>::iterator it = Trk.fragments.begin();
    bool first = true;
    //skip the first two fragments if live
    if (live && Trk.fragments.size() > 6){++(++it);}
    for (; it != Trk.fragments.end(); it++){
      uint64_t starttime = Trk.getKey(it->getNumber()).getTime();
      uint32_t duration = it->getDuration();
      if (!duration){
        if (live){continue;}//skip last fragment when live
        duration = Trk.lastms - starttime;
      }
      if (first){
        r << "          <S t=\"" << starttime << "\" d=\"" << duration << "\" />" << std::endl;
        first = false;
      }else{
        r << "          <S d=\"" << duration << "\" />" << std::endl;
      }
    }
  }

  /// Returns a string with the full XML DASH manifest MPD file.
  std::string OutDashMP4::buildManifest(){
    initialize();
    selectDefaultTracks();
    uint64_t lastVidTime = 0;
    uint64_t vidInitTrack = 0;
    uint64_t lastAudTime = 0;
    uint64_t audInitTrack = 0;
    uint64_t subInitTrack = 0;

    /// \TODO DASH pretends there is only one audio/video track, and then prints them all using the same timing information. This is obviously wrong if the tracks are not in sync.
    for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); ++it){
      if (myMeta.tracks[*it].type == "video" && myMeta.tracks[*it].lastms > lastVidTime){
        lastVidTime = myMeta.tracks[*it].lastms;
        vidInitTrack = *it;
      }
      if (myMeta.tracks[*it].type == "audio" && myMeta.tracks[*it].lastms > lastAudTime){
        lastAudTime = myMeta.tracks[*it].lastms;
        audInitTrack = *it;
      }
      if(myMeta.tracks[*it].codec == "subtitle"){
        subInitTrack = *it;
      }
    }
    std::stringstream r;

    r << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
    r << "<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"urn:mpeg:dash:schema:mpd:2011\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\" profiles=\"urn:mpeg:dash:profile:isoff-live:2011\" ";
    if (myMeta.vod){
      r << "type=\"static\" mediaPresentationDuration=\"" << makeTime(myMeta.tracks[getMainSelectedTrack()].lastms - myMeta.tracks[getMainSelectedTrack()].firstms) << "\" minBufferTime=\"PT1.5S\" >" << std::endl;
    }else{
      r << "type=\"dynamic\" minimumUpdatePeriod=\"PT2.0S\" availabilityStartTime=\"" << Util::getUTCString(Util::epoch() - myMeta.tracks[getMainSelectedTrack()].lastms/1000) << "\" " << "timeShiftBufferDepth=\"" << makeTime(myMeta.tracks[getMainSelectedTrack()].lastms - myMeta.tracks[getMainSelectedTrack()].firstms) << "\" suggestedPresentationDelay=\"PT5.0S\" minBufferTime=\"PT2.0S\" publishTime=\"" << Util::getUTCString(Util::epoch()) << "\" >" << std::endl;
    }
    r << "  <ProgramInformation><Title>" << streamName << "</Title></ProgramInformation>" << std::endl;
    r << "  <Period ";
    if (myMeta.live){
      r << "start=\"0\" ";
    }
    r << ">" << std::endl;
    if (vidInitTrack){
      DTSC::Track & trackRef = myMeta.tracks[vidInitTrack];
      r << "    <AdaptationSet group=\"1\" id=\"9998\" mimeType=\"video/mp4\" width=\"" << trackRef.width << "\" height=\"" << trackRef.height << "\" frameRate=\"" << trackRef.fpks / 1000 << "\" segmentAlignment=\"true\" startWithSAP=\"1\" subsegmentAlignment=\"true\" subsegmentStartsWithSAP=\"1\">" << std::endl;
      r << "      <SegmentTemplate timescale=\"1000\" media=\"chunk_$RepresentationID$_$Time$.m4s\" initialization=\"chunk_$RepresentationID$_init.m4s\">" << std::endl;
      r << "        <SegmentTimeline>" << std::endl;
      addSegmentTimeline(r, trackRef, myMeta.live);
      r << "        </SegmentTimeline>" << std::endl;
      r << "      </SegmentTemplate>" << std::endl;
      for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); ++it){
        if (myMeta.tracks[*it].codec == "H264"){
          r << "      <Representation id=\"" << *it << "\" ";
          r << "codecs=\"" << Util::codecString(myMeta.tracks[*it].codec, myMeta.tracks[*it].init) << "\" ";
          //bandwidth is in bits per seconds, we have bytes, so times 8
          r << "bandwidth=\"" << (myMeta.tracks[*it].bps*8) << "\" ";
          r << "/>" << std::endl;
        }
        if (myMeta.tracks[*it].codec == "HEVC"){
          r << "      <Representation ";
          r << "id=\"" << *it << "\" ";
          r << "codecs=\"" << Util::codecString(myMeta.tracks[*it].codec, myMeta.tracks[*it].init) << "\" ";
          //bandwidth is in bits per seconds, we have bytes, so times 8
          r << "bandwidth=\"" << (myMeta.tracks[*it].bps*8) << "\" ";
          r << "/>" << std::endl;
        }
      }
      r << "    </AdaptationSet>" << std::endl;
    }
    if (audInitTrack){
      DTSC::Track & trackRef = myMeta.tracks[audInitTrack];
      r << "    <AdaptationSet group=\"2\" id=\"9999\" mimeType=\"audio/mp4\" segmentAlignment=\"true\" startWithSAP=\"1\" subsegmentAlignment=\"true\" subsegmentStartsWithSAP=\"1\" >" << std::endl;
      r << "      <Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"main\"/>" << std::endl;
      r << "      <SegmentTemplate timescale=\"1000\" media=\"chunk_$RepresentationID$_$Time$.m4s\" initialization=\"chunk_$RepresentationID$_init.m4s\">" << std::endl;

      r << "        <SegmentTimeline>" << std::endl;
      addSegmentTimeline(r, trackRef, myMeta.live);
      r << "        </SegmentTimeline>" << std::endl;
      r << "      </SegmentTemplate>" << std::endl;
 
      for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); ++it){
        if (myMeta.tracks[*it].codec == "AAC" || myMeta.tracks[*it].codec == "MP3" || myMeta.tracks[*it].codec == "AC3"){
          r << "      <Representation id=\"" << *it << "\" ";
          // (see RFC6381): sample description entry , ObjectTypeIndication [MP4RA, RFC], ObjectTypeIndication [MP4A ISO/IEC 14496-3:2009]
          r << "codecs=\"" << Util::codecString(myMeta.tracks[*it].codec, myMeta.tracks[*it].init) << "\" ";
          r << "audioSamplingRate=\"" << myMeta.tracks[*it].rate << "\" ";
          //bandwidth is in bits per seconds, we have bytes, so times 8
          r << "bandwidth=\"" << (myMeta.tracks[*it].bps*8) << "\">" << std::endl;
          r << "        <AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"" << myMeta.tracks[*it].channels << "\" />" << std::endl;
          r << "      </Representation>" << std::endl;
        }
      }
      r << "    </AdaptationSet>" << std::endl;
    }

    if(subInitTrack){
      for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); ++it){
        if(myMeta.tracks[*it].codec == "subtitle"){
          subInitTrack = *it;
          std::string lang = (myMeta.tracks[*it].lang == "" ? "unknown" : myMeta.tracks[*it].lang);
          r << "<AdaptationSet id=\"" << *it << "\" group=\"3\" mimeType=\"text/vtt\" lang=\"" << lang <<  "\">";
          r << " <Representation id=\"" << *it << "\" bandwidth=\"256\">";
          r <<   " <BaseURL>../../" << streamName << ".vtt?track=" << *it << "</BaseURL>";
          r << " </Representation></AdaptationSet>" << std::endl;
        }
      }
    }

    r << "  </Period>" << std::endl;
    r << "</MPD>" << std::endl;

    return r.str();
  }
  
  void OutDashMP4::init(Util::Config * cfg){
    HTTPOutput::init(cfg);
    capa["name"] = "DASHMP4";
    capa["friendly"] = "DASH (fMP4) over HTTP";
    capa["desc"] = "Segmented streaming in DASH (fMP4) format over HTTP";
    capa["url_rel"] = "/dash/$/index.mpd";
    capa["url_prefix"] = "/dash/$/";
    capa["socket"] = "http_dash_mp4";
    capa["codecs"][0u][0u].append("+H264");
    capa["codecs"][0u][1u].append("+HEVC");
    capa["codecs"][0u][2u].append("+AAC");
    capa["codecs"][0u][3u].append("+AC3");
    capa["codecs"][0u][4u].append("+MP3");
    capa["codecs"][0u][5u].append("+subtitle");

    capa["methods"][0u]["handler"] = "http";
    capa["methods"][0u]["type"] = "dash/video/mp4";

    //MP3 does not work in browsers
    capa["exceptions"]["codec:MP3"] = JSON::fromString("[[\"blacklist\",[\"Mozilla/\"]]]");
    //HEVC does not work in browsers
    capa["exceptions"]["codec:HEVC"] = JSON::fromString("[[\"blacklist\",[\"Mozilla/\"]]]");
    capa["methods"][0u]["priority"] = 8;

    cfg->addOption("nonchunked", JSON::fromString("{\"short\":\"C\",\"long\":\"nonchunked\",\"help\":\"Do not send chunked, but buffer whole segments.\"}"));
    capa["optional"]["nonchunked"]["name"] = "Send whole segments";
    capa["optional"]["nonchunked"]["help"] = "Disables chunked transfer encoding, forcing per-segment buffering. Reduces performance significantly, but increases compatibility somewhat.";
    capa["optional"]["nonchunked"]["option"] = "--nonchunked";
  }
  
  void OutDashMP4::onHTTP(){
    std::string method = H.method;
    
    initialize();
    if (myMeta.live){
      updateMeta();
    }
    std::string url = H.url;
    // Send a manifest for any URL with .mpd in the path
    if (url.find(".mpd") != std::string::npos){
      H.Clean();
      H.SetHeader("Content-Type", "application/dash+xml");
      H.SetHeader("Cache-Control", "no-cache");
      H.setCORSHeaders();
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      H.SetBody(buildManifest());
      H.SendResponse("200", "OK", myConn);
      DEVEL_MSG("Manifest sent");
      H.Clean();
      return;
    }

    //Not a manifest - either an init segment or data segment
    size_t pos = url.find("chunk_") + 6;//find the track ID position
    uint32_t tid = atoi(url.substr(pos).c_str());
    if (!myMeta.tracks.count(tid)){
      H.Clean();
      H.SendResponse("404", "Track not found", myConn);
      H.Clean();
      return;
    }
    DTSC::Track & Trk = myMeta.tracks[tid];
    H.Clean();
    H.SetHeader("Content-Type", "video/mp4");
    H.SetHeader("Cache-Control", "no-cache");
    H.setCORSHeaders();
    if(method == "OPTIONS" || method == "HEAD"){
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    H.StartResponse(H, myConn, config->getBool("nonchunked"));

    if (url.find("init.m4s") != std::string::npos){
      //init segment
      if (Trk.type == "video"){
        H.Chunkify("\000\000\000\040ftypisom\000\000\000\000isomavc1mp42dash", 32, myConn);
      }else{
        H.Chunkify("\000\000\000\040ftypisom\000\000\000\000isomM4A mp42dash", 32, myConn);
      }
      sendMoov(tid);
      H.Chunkify("", 0, myConn);
      H.Clean();
      return;
    }

    //data segment
    pos = url.find("_", pos + 1) + 1;
    uint64_t timeStamp = atoll(url.substr(pos).c_str());
    uint32_t fragIndice = Trk.timeToFragnum(timeStamp);
    uint32_t fragNum = Trk.fragments[fragIndice].getNumber();
    HIGH_MSG("Getting T%llu for track %lu, indice %lu, number %lu", timeStamp, tid, fragIndice, fragNum);
    H.Chunkify("\000\000\000\030stypmsdh\000\000\000\000msdhmsix", 24, myConn);
    MP4::SIDX sidxBox;
    sidxBox.setReferenceID(1);
    sidxBox.setTimescale(1000);
    sidxBox.setEarliestPresentationTime(Trk.getKey(fragNum).getTime());
    sidxBox.setFirstOffset(0);
    MP4::sidxReference refItem;
    refItem.referenceType = false;
    if (Trk.fragments[fragIndice].getDuration()){
      refItem.subSegmentDuration = Trk.fragments[fragIndice].getDuration();
    }else{
      refItem.subSegmentDuration = Trk.lastms - Trk.getKey(fragNum).getTime();
    }
    refItem.sapStart = false;
    refItem.sapType = 0;
    refItem.sapDeltaTime = 0;
    sidxBox.setReference(refItem, 0);
    H.Chunkify(sidxBox.asBox(), sidxBox.boxedSize(), myConn);
    sendMoof(tid, fragIndice);
    sendMdat(tid, fragIndice);
  }
    
}