DASHEncoder.cpp

#include "AnyOption.h"
#include "multiplexer/MP4BoxMultiplexer.h"
#include "encoder/IEncoder.h"
#include "encoder/AbstractAudioEncoder.h"
#include "encoder/AbstractVideoEncoder.h"
#include "encoder/EncoderFactory.h"
#include "mpdgenerator/MPDGenerator.h"

#include <vector>
#include <iostream>
#include <fstream>
#include <map>
//#include "mysql/mysql.h"

void parse(int argc, char* argv[]);
void setHelp(AnyOption*);
void setOptions(AnyOption*);
IEncoder::EncoderType getEncoder(std::string);
int convertMPD(std::string input, std::string output, std::string duration, std::string baseurl, std::string minbuffer, std::string segduration);

AnyOption *opt;

int main(int argc, char* argv[])
{
 parse(argc, argv);
 return 0;
}

void parse(int argc, char* argv[])
{
 std::cout << "==========DASH ENCODER===============\n";
 AnyOption *opt = new AnyOption();

 /* COMMAND LINE PREFERENCES */
 opt->setVerbose(); /* print warnings about unknown options */
 opt->autoUsagePrint(true); /* print usage for bad options */

 /* SET THE USAGE/HELP */
 setHelp(opt);

 /* SET THE OPTION STRINGS/CHARACTERS */

 setOptions(opt);

 /* PROCESS THE RESOURCE FILE */
 opt->processFile("./DASHEncoder.config");
 /* PROCESS THE COMMANDLINE */
 opt->processCommandArgs(argc, argv);

 /* Run DASH Encoding */

 EncoderFactory* encoder_factory= new EncoderFactory();
 std::cout << "current encoder " << opt->getValue("video-encoder") << "\n";
 if(getEncoder(opt->getValue("video-encoder")) == IEncoder::x264)
 std::cout << "YES\n";

 AbstractVideoEncoder* e = (AbstractVideoEncoder*)encoder_factory->getEncoder(opt, getEncoder(opt->getValue("video-encoder")));
 AbstractAudioEncoder* a = (AbstractAudioEncoder*)encoder_factory->getEncoder(opt, getEncoder(opt->getValue("audio-encoder")));

 MPDGenerator* mpdgen = new MPDGenerator();
 MPDGenerator* mpdgenNonSeg = new MPDGenerator();
 MP4BoxMultiplexer* m = new MP4BoxMultiplexer();

 std::map<int, std::string> audio_files;
 std::map<int, int> av_mux_mapping;

 /* MySQL Support Disabled

 MYSQL_RES *result;

 MYSQL_ROW row;

 MYSQL *connection, mysql;

 */

 int state;

 m->setFragSize(atoi(opt->getValue("fragment-size")));
 m->setRAPAligned(opt->getFlag("rap-aligned"));
 m->setOutputDir(opt->getValue("dest-directory"));
 m->setSegSize(atoi(opt->getValue("segment-size")));

 std::string h264file;
 vector<std::string> mpds;
 std::string folder;
 std::string foldername;
 std::string h264new;
 ifstream infile;
 std::string finalMPDhead = "";
 std::string finalMPDbody = "";
 std::string finalMPDfoot = "";
 std::string video_length = "";

 std::string baseURL = "";

 std::string exp_name = opt->getValue("dest-directory");
 exp_name.append(opt->getValue("mpd-name"));

 std::string exp_nameNonSeg = opt->getValue("dest-directory");
 exp_nameNonSeg.append("NonSeg");
 exp_nameNonSeg.append(opt->getValue("mpd-name"));

 ofstream mpdexportfile;
 mpdexportfile.open(exp_name.c_str());

 ofstream mpdexportfileNonSeg;
 mpdexportfileNonSeg.open(exp_nameNonSeg.c_str());


 std::string act = "";
 std::string mpd_temp;
 std::string act_line;
 std::string act_rep;

 if(opt->getFlag("set-base-url")){
 baseURL = "<BaseURL>";
 baseURL.append(opt->getValue("url-root"));
 baseURL.append("</BaseURL>");
 }

 /************* AUDIO/VIDEO MULTIPLEXING INFORMATION ******************************/

 if(opt->getValue("mux-combi")!=NULL){
 std::string muxconfig = opt->getValue("mux-combi");
 std::string currentaudio;
 std::string bitrates;
 do{
 bitrates = muxconfig.substr(0,muxconfig.find('@'));
 if(muxconfig.find('|') == std::string::npos){
 currentaudio = muxconfig.substr(muxconfig.find('@')+1);
 muxconfig = "";
 }
 else{
 currentaudio = muxconfig.substr(muxconfig.find('@')+1, muxconfig.find('|') );
 muxconfig = muxconfig.substr(muxconfig.find('|')+1);
 }
 do{
 if(bitrates.find(',') == std::string::npos){
 av_mux_mapping[atoi(bitrates.c_str())] = atoi(currentaudio.c_str());
 bitrates = "";
 }
 else{
 av_mux_mapping[atoi(bitrates.substr(0,',').c_str())] = atoi(currentaudio.c_str());
 bitrates = bitrates.substr(bitrates.find(',')+1);
 }
 }while(bitrates.size()>0);
 }while(muxconfig.size()>0);
 }

 /************************ AUDIO PROCESSING ******************************/
 std::string audio_quality = opt->getValue("audio-quality");
 char*c2 = (char*) malloc(audio_quality.length() * sizeof(char));
 strcpy(c2, audio_quality.c_str());
 char* act_audio = strtok(c2, "|");

 std::string act_quality = "";
 std::string act_audio_encoding;
 std::string act_audio_seg;

 while (act_audio != NULL)
 {

 act_quality = act_audio;
 a->setChannels(atoi(act_quality.substr(0, act_quality.find(',')).c_str()));

 act_quality = act_quality.substr(act_quality.find(',') + 1);
 a->setSamplingRate(atoi(act_quality.substr(0, act_quality.find(',')).c_str()));

 a->setBitrate(atoi(act_quality.substr(act_quality.find(',') + 1).c_str()));

 act_audio_encoding = a->encode();

 audio_files[a->getBitrate()] = act_audio_encoding;

 if (opt->getValue("mux-combi") == NULL)
 {
 /************ FOLDER CREATION **********************/

 foldername = opt->getValue("folder-prefix");
 foldername.append("_");
 foldername.append(DASHHelper::itos(a->getChannels()));
 foldername.append("ch_audio_");
 foldername.append(DASHHelper::itos(a->getBitrate()));
 foldername.append("kbit");

 folder = "mkdir ";
 folder.append(opt->getValue("dest-directory"));
 folder.append(foldername);
 system(folder.c_str());

 folder = "mv ";
 folder.append(opt->getValue("dest-directory"));
 folder.append(act_audio_encoding);
 folder.append(" ");
 folder.append(opt->getValue("dest-directory"));
 folder.append(foldername);
 system(folder.c_str());

 /************ MULTIPLEXING & SEGMENTATION **************/

 act_audio_seg = opt->getValue("dest-directory");
 act_audio_seg.append(foldername);
 act_audio_seg.append("/");
 act_audio_seg.append(opt->getValue("segment-name"));

 m->setSegName(act_audio_seg);

 act_audio_seg = opt->getValue("dest-directory");
 act_audio_seg.append(foldername);
 act_audio_seg.append("/");
 act_audio_seg.append(act_audio_encoding);

 std::string mpd = m->multiplex(act_audio_seg);

 mpds.push_back(mpd);

 /************ MPD READ **********************/

 mpd_temp = opt->getValue("dest-directory");
 mpd_temp.append(foldername);
 mpd_temp.append("/");
 mpd_temp.append(h264file.substr(0, h264file.find_last_of('.')));
 mpd_temp.append("_dash.mpd");

 infile.open(mpd_temp.c_str(), ifstream::in);

 act_rep = "";

 if (infile.is_open())
 {
 while (infile.good())
 {
 getline(infile, act_line);
 act_rep.append(act_line);
 act_rep.append("\n");
 }
 infile.close();
 }
 else
 cout << "Error: Unable to open MPD file!";

 act_rep = act_rep.substr(act_rep.find("<Representation"), act_rep.find("</Representation>") - act_rep.find("<Representation") + 17);
 while (act_rep.find(m->getOutputDir()) != std::string::npos)
 {
 act_rep.replace(act_rep.find(m->getOutputDir()), m->getOutputDir().size(), opt->getValue("url-root"));
 }
 std::cout << "\nDone...\n";

 mpdgen->appendMPDbody(act_rep);
 mpdgen->appendMPDbody("\n");
 }

 act_audio = strtok(NULL, "|");
 }

 /************************ VIDEO PROCESSING ******************************/

 string bitrates = opt->getValue('b');
 char*c1 = (char*) malloc(bitrates.length() * sizeof(char));
 strcpy(c1, bitrates.c_str());
 char* pch = strtok(c1, "|");



 while (pch != NULL)
 {
 /************ ENCODING *****************************/
 act = pch;

 if (act.find('@') != std::string::npos)
 {
 std::cout << act << "\n";
 e->setWidth(atoi(act.substr(act.find('@') + 1, act.find('x') - act.find('@') - 1).c_str()));
 e->setHeight(atoi(act.substr(act.find('x') + 1).c_str()));
 e->setBitrate(atoi(act.substr(0, act.find('@')).c_str()));
 }
 else
 {
 e->setBitrate(atoi(pch));
 }

 h264file = e->encode();


 /************ FOLDER CREATION **********************/

 foldername = opt->getValue("folder-prefix");
 foldername.append("_");
 foldername.append(DASHHelper::itos(e->getBitrate()));
 foldername.append("kbit");

 folder = "mkdir ";
 folder.append(opt->getValue("dest-directory"));
 folder.append(foldername);
 system(folder.c_str());

 folder = "mv ";
 folder.append(opt->getValue("dest-directory"));
 folder.append(h264file);
 folder.append(" ");
 folder.append(opt->getValue("dest-directory"));
 folder.append(foldername);
 system(folder.c_str());

 if(opt->getValue("mux-combi")!=NULL){

 folder = "cp ";
 folder.append(opt->getValue("dest-directory"));
 folder.append(audio_files[av_mux_mapping[e->getBitrate()]]);
 folder.append(" ");
 folder.append(opt->getValue("dest-directory"));
 folder.append(foldername);
 folder.append("/");
 folder.append(audio_files[av_mux_mapping[e->getBitrate()]]);
 std::cout << "copy audio: " << folder;
 system(folder.c_str());
 }

 /************ STORE STATISTICS *********************/
/* MySQL Support Disabled
 if(opt->getFlag("store-psnr")){

 mysql_init(&mysql);

 mysql_options(&mysql, MYSQL_READ_DEFAULT_FILE, "/opt/lampp/etc/my.cnf");
 //mysql_options(&mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, "/etc/ssl/certs/ComodoIntermediate.pem");
 //mysql_ssl_set(&mysql, NULL, NULL, "/etc/ssl/certs/ComodoIntermediate.pem",NULL, NULL);

 connection = mysql_real_connect(&mysql,opt->getValue("sql-host"),opt->getValue("sql-user"),opt->getValue("sql-pw"),opt->getValue("sql-database"),0,0,0);

 if (connection == NULL)
 {
 std::cout << "MySQL Error: " << mysql_error(&mysql) << "\n";
 return ;
 }
 infile.open("out.txt", ifstream::in);

 act_rep = "";
 std::string query;
 int posStart;
 int posEnd;

 if (infile.is_open())
 {
 while (infile.good())
 {
 getline(infile, act_line);
 if(act_line.find("x264 [debug]: frame=") != std::string::npos){
 //std::cout << act_line << "\n";
 query = "INSERT INTO frames (framenr, type, ypsnr,upsnr, vpsnr, representation) Values (";

 posStart = act_line.find("frame=")+6;
 query.append(act_line.substr(posStart, act_line.find("QP")-posStart));
 query.append(", \"");

 query.append(act_line.substr(act_line.find("Slice:")+6, 1));
 query.append("\", ");

 posStart = act_line.find("Y:")+2;
 query.append(act_line.substr(posStart, act_line.find("U:")-posStart));
 query.append(", ");

 posStart = act_line.find("U:")+2;
 query.append(act_line.substr(posStart, act_line.find("V:")-posStart));
 query.append(", ");

 query.append(act_line.substr(act_line.find("V:")+2));
 query.append(", \"");

 query.append(foldername);
 query.append("\")");
 //std::cout << "\n" << query;
 mysql_query(connection, query.c_str());
 }
 }
 std::cout << "PSNR data stored in MySQL database!";
 infile.close();
 }
 else
 cout << "Error: Unable to open Log file!";
 }

*/
 /************ MULTIPLEXING & SEGMENTATION **************/

 h264new = opt->getValue("dest-directory");
 h264new.append(foldername);
 h264new.append("/");
 h264new.append(opt->getValue("segment-name"));

 m->setSegName(h264new);

 h264new = opt->getValue("dest-directory");
 h264new.append(foldername);
 h264new.append("/");
 h264new.append(h264file);

 if(opt->getValue("mux-combi")!=NULL){

 std::string af =opt->getValue("dest-directory");
 af.append(foldername);
 af.append("/");
 af.append(audio_files[av_mux_mapping[e->getBitrate()]]);

 m->setAudioFile(af);
 }

 std::string mpd = m->multiplex(h264new);
 mpds.push_back(mpd);



 /************ MPD READ **********************/

 mpd_temp = opt->getValue("dest-directory");
 mpd_temp.append(foldername);
 mpd_temp.append("/");
 mpd_temp.append(h264file.substr(0, h264file.find_last_of('.')));
 mpd_temp.append("_dash.mpd");

 infile.open(mpd_temp.c_str(), ifstream::in);

 act_rep = "";

 if (infile.is_open())
 {
 while (infile.good())
 {
 getline(infile, act_line);
 act_rep.append(act_line);
 act_rep.append("\n");
 }
 infile.close();
 }
 else
 cout << "Error: Unable to open MPD file!";

 act_rep = act_rep.substr(act_rep.find("<Representation"), act_rep.find("</Representation>") - act_rep.find("<Representation") + 17);



 if(opt->getFlag("add-non-segmented")){
 /************ GENERATE UNSEGMENTED FILE *****/
 std::string tmp_rep = act_rep;
 tmp_rep = m->unSegment(tmp_rep);

 while (tmp_rep.find(m->getOutputDir()) != std::string::npos)
 {
 if(opt->getFlag("set-base-url"))
 tmp_rep.replace(tmp_rep.find(m->getOutputDir()), m->getOutputDir().size(), "");
 else
 tmp_rep.replace(tmp_rep.find(m->getOutputDir()), m->getOutputDir().size(), opt->getValue("url-root"));
 }

 if(opt->getFlag("set-base-url")){
 std::string tmp_base = baseURL;
 tmp_base.append("\n<Init");
 tmp_rep.replace(tmp_rep.find("<Init"), 5, tmp_base);
 }
 mpdgenNonSeg->appendMPDbody(tmp_rep);
 mpdgenNonSeg->appendMPDbody("\n");
 }

 while (act_rep.find(m->getOutputDir()) != std::string::npos)
 {
 if(opt->getFlag("set-base-url"))
 act_rep.replace(act_rep.find(m->getOutputDir()), m->getOutputDir().size(), "");
 else
 act_rep.replace(act_rep.find(m->getOutputDir()), m->getOutputDir().size(), opt->getValue("url-root"));
 }

 if(opt->getFlag("set-base-url")){
 std::string tmp_base = baseURL;
 tmp_base.append("\n<Init");
 act_rep.replace(act_rep.find("<Init"), 5, tmp_base);
 }

 std::cout << "\nDone...\n";

 mpdgen->appendMPDbody(act_rep);
 mpdgen->appendMPDbody("\n");

 e->setWidth(0);
 e->setHeight(0);

 pch = strtok(NULL, "|");
 }

 /* MPD Gneration */
 std::cout << "\nWriting final MPD...\n";

 mpdexportfile << mpdgen->getMPD();
 mpdexportfile.close();

 if(opt->getFlag("transform-mpd")){
 std::cout << "\nConverting MPDs to actual standard ...";
 convertMPD(exp_name.c_str(), opt->getValue("mpdActStandardPostfix"), opt->getValue("duration"), opt->getValue("url-root"), opt->getValue("minBufferTime"), opt->getValue("segDuration"));
 }

 /* Non-Segmented MPD Gneration */
 if(opt->getFlag("add-non-segmented")){
 mpdexportfileNonSeg << mpdgenNonSeg->getMPD();
 mpdexportfileNonSeg.close();

 /* Run MPD Converion */
 if(opt->getFlag("transform-mpd")){
 std::cout << "\nConverting MPDs to actual standard ...";
 convertMPD(exp_nameNonSeg.c_str(), opt->getValue("mpdActStandardPostfix"), opt->getValue("duration"), opt->getValue("url-root"),opt->getValue("minBufferTime"), opt->getValue("segDuration"));
 }
 }
 std::cout << "\nFINISHED\n";
 delete opt;
}

void setHelp(AnyOption* opt)
{
 opt->addUsage("");
 opt->addUsage("Usage: ");
 opt->addUsage("");
 opt->addUsage(" -h --help Print help ");
 opt->addUsage(" -i --input Input file");
 opt->addUsage(" -x --pass1 Additional Options: 1st pass video encoding");
 opt->addUsage(" -X --pass2 Additional Options: 2nd pass video encoding");
 opt->addUsage(" -b --bitrate Video bitrates (exmaple: see config file)");
 opt->addUsage(" -s --statistics Statistic file for multi pass video encoding");
 opt->addUsage(" -g --gop GOP Size");
 opt->addUsage(" -c --scenecut Scenecut sensitivity");
 opt->addUsage(" -p --profile h.264 profile");
 opt->addUsage(" -P --preset x264 preset");
 opt->addUsage(" -f --fragment-size Fragment size in seconds");
 opt->addUsage(" -r --rap-aligned Muliplexing at GOP boundaries");
 opt->addUsage(" -o --store-psnr Store PSNR statistics to database");
 opt->addUsage(" -y --sql-host MySQL host");
 opt->addUsage(" -z --sql-user MySQL user");
 opt->addUsage(" -Z --sql-pw MySQL password");
 opt->addUsage(" -Y --sql-database MySQL database");
 opt->addUsage(" -N --segment-name DASH segment name");
 opt->addUsage(" -S --segment-size DASH segment size in seconds");
 opt->addUsage(" -F --folder-prefix Represenation folder prefix");
 opt->addUsage(" -d --dest-directory Destination directory");
 opt->addUsage(" -m --mpd-name MPD name");
 opt->addUsage(" -u --url-root Base url");
 opt->addUsage(" -a --audio-quality Audio qualities (see config file)");
 opt->addUsage(" -I --audio-input Audio source");
 opt->addUsage(" -C --audio-codec Audio codec");
 opt->addUsage(" -M --mux-combi A/V muxing combinations");
 opt->addUsage(" -V --video-encoder Video encoder");
 opt->addUsage(" -A --audio-encoder Audio encoder");
 opt->addUsage(" -R --multiplexer Multiplexing tool");
 opt->addUsage(" -K --const-filesize Encode using constant filesize");
 opt->addUsage(" -k --passes Encoding passes");
 opt->addUsage(" -D --add-non-segmented Generate also non-segmented version");
 opt->addUsage(" -J --set-base-url Use the base url");
 opt->addUsage(" -G --use-ffmpeg-pipe FFMPEG input conversion pipe");
 opt->addUsage(" -g --ffmpeg-opt Additional FFMPEG options");
 opt->addUsage(" -I --input-res Resolution of input video");
 opt->addUsage(" -t --transform-mpd Transform MPD to act standard");
 opt->addUsage(" -T --duration Content duration for MPD");
 opt->addUsage(" -a --mpdActStandardPostfix ");
 opt->addUsage(" -B --minBufferTime Minimum Buffer in MPD");
 opt->addUsage(" -e --segDuration Segment Duration for MPD");
 opt->addUsage("");
}
void setOptions(AnyOption* opt)
{
 opt->setFlag("help", 'h');
 opt->setOption("input", 'i');
 opt->setOption("pass1", 'x');
 opt->setOption("pass2", 'X');
 opt->setOption("bitrate", 'b');
 opt->setOption("statistics", 's');
 opt->setOption("gop", 'g');
 opt->setOption("scenecut", 'c');
 opt->setOption("profile", 'p');
 opt->setOption("preset", 'P');
 opt->setOption("fragment-size", 'f');
 opt->setFlag("rap-aligned", 'r');
 opt->setFlag("store-psnr", 'o');
 opt->setOption("segment-name", 'N');
 opt->setOption("segment-size", 'S');
 opt->setOption("folder-prefix", 'F');
 opt->setOption("dest-directory", 'd');
 opt->setOption("mpd-name", 'm');
 opt->setOption("url-root", 'u');
 opt->setOption("audio-quality", 'a');
 opt->setOption("audio-input", 'I');
 opt->setOption("audio-codec", 'C');
 opt->setOption("mux-combi", 'M');
 opt->setOption("video-encoder", 'V');
 opt->setOption("audio-encoder", 'A');
 opt->setOption("multiplexer", 'R');
 opt->setOption("const-filesize", 'K');
 opt->setOption("passes", 'k');
 opt->setOption("sql-host", 'y');
 opt->setOption("sql-user", 'z');
 opt->setOption("sql-pw", 'Z');
 opt->setOption("sql-database", 'Y');
 opt->setFlag("add-non-segmented", 'D');
 opt->setFlag("set-base-url", 'J');
 opt->setFlag("use-ffmpeg-pipe", 'G');
 opt->setOption("ffmpeg-opt", 'g');
 opt->setOption("input-res", 'I');
 opt->setFlag("transform-mpd", 't');
 opt->setOption("duration", 'T');
 opt->setOption("mpdActStandardPostfix", 'a');
 opt->setOption("minBufferTime", 'B');
 opt->setOption("segDuration", 'e');
}

IEncoder::EncoderType getEncoder(std::string e){
 if(e.compare("vp8")==0)
 return IEncoder::vp8;
 else if(e.compare("ffmpegAAC")==0)
 return IEncoder::ffmpegAAC;
 else if(e.compare("x264")==0)
 return IEncoder::x264;

 return IEncoder::x264;
}
int convertMPD(std::string input, std::string output, std::string duration, std::string baseurl, std::string minbuffer, std::string segduration){
 std::cout << "\nConvert the to act DASH standard: " << input << "\nto: " << output << "\n";

 string mpd_temp = "", act_line = "", temp;
 string filename = input;

 temp = ".mpd";
 filename.replace(filename.find(temp), temp.length(),output);

 ofstream mpdexportfile;
 mpdexportfile.open(filename.c_str());


 ifstream infile;

 infile.open(input.c_str(), ifstream::in);



 if (infile.is_open())
 {
 while (infile.good())
 {
 getline(infile, act_line);
 mpd_temp.append(act_line);
 mpd_temp.append("\n");
 }
 infile.close();
 }
 else
 cout << "Error: Unable to open MPD file!";

 string finalMPDhead, finalMPDfoot, finalMPDbody;
 int pos;

 finalMPDhead.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 finalMPDhead.append("<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
 finalMPDhead.append(" xmlns=\"urn:mpeg:DASH:schema:MPD:2011\"\n");
 finalMPDhead.append(" xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011\"\n");
 finalMPDhead.append(" profiles= \"urn:mpeg:dash:profile:isoff-main:2011\"\n");
 finalMPDhead.append(" type=\"static\"\n");

 //adding Duration
 finalMPDhead.append(" mediaPresentationDuration=\"PT");
 finalMPDhead.append(duration);
 finalMPDhead.append("\"\n");

 //adding Buffer Time
 finalMPDhead.append(" minBufferTime=\"PT");
 finalMPDhead.append(minbuffer);
 finalMPDhead.append("\"> \n");
/* pos = mpd_temp.find("minBufferTime");
 if(pos != std::string::npos){
 pos = pos + 15;
 temp = mpd_temp.substr(pos,mpd_temp.find("\"", pos)- pos );
 pos = temp.length(); //1000
 string millisec, sec;
 millisec = temp.substr(pos-3,1);
 sec = temp.substr(0,pos-3);
 finalMPDhead.append(sec);
 finalMPDhead.append(".");
 finalMPDhead.append(millisec);
 finalMPDhead.append("\"> \n");
 }
 else{
 std::cout << "ERROR: Could not find buffer time!\n";
 std::cout << mpd_temp;
 return 1;
 }*/

 //adding base URL
 finalMPDhead.append(" <BaseURL>");
 finalMPDhead.append(baseurl);
 finalMPDhead.append("</BaseURL>\n");
 finalMPDhead.append(" <Period start=\"PT0S\">\n");
 finalMPDhead.append(" <AdaptationSet bitstreamSwitching=\"true\" >\n");
 mpdexportfile << finalMPDhead;


 finalMPDfoot.append(" </AdaptationSet>\n");
 finalMPDfoot.append(" </Period>\n");
 finalMPDfoot.append("</MPD>\n");


 finalMPDbody = "";

 int lastRep = 0, id = 0;
 string act_rep, finalRep, temp2;


 while(mpd_temp.find("<Representation", lastRep)!= std::string::npos){
 act_rep = mpd_temp.substr(mpd_temp.find("<Representation", lastRep), mpd_temp.find("</Representation>", lastRep)+ 17 - mpd_temp.find("<Representation", lastRep) );
 lastRep = mpd_temp.find("</Representation>", lastRep)+ 17;

 finalRep = "";

 string addID = "<Representation id=\"";
 addID.append(DASHHelper::itos(id));
 addID.append("\"");

 temp2 = "<Representation";
 act_rep.replace(act_rep.find(temp2), temp2.length(),addID);
 temp2 = "startWithRAP=\"true\"";
 act_rep.replace(act_rep.find(temp2), temp2.length(),"startWithSAP=\"1\"");

 temp2 = "mimeType=\"video/mp4\"";
 act_rep.replace(act_rep.find(temp2), temp2.length(),"codecs=\"avc1\" mimeType=\"video/mp4\"");

 temp = act_rep.substr(0, act_rep.find(">"));
 temp.append(">\n");
 finalRep.append(temp);


 //add init segment
 pos = act_rep.find("<InitialisationSegmentURL");
 temp = act_rep.substr(pos,act_rep.find("/>", pos)+2 - pos);
 temp2 = "InitialisationSegmentURL";
 temp.replace(temp.find(temp2), temp2.length(), "Initialisation");
 pos = act_rep.find("/>", pos)+2;

 finalRep.append("<SegmentBase>\n ");
 finalRep.append(temp);
 finalRep.append("\n</SegmentBase>\n");

 //add segments
 finalRep.append("<SegmentList duration=\"");
 finalRep.append(segduration);
 finalRep.append("\">");
 temp = act_rep.substr(pos, act_rep.find("</SegmentInfo>",pos) -pos);
 temp2 = "<Url";
 while(temp.find(temp2)!= std::string::npos){
 temp.replace(temp.find(temp2), temp2.length(),"<SegmentURL");
 string temp3 = "sourceURL";
 temp.replace(temp.find(temp3), temp3.length(),"media");
 string temp4 = "range";
 if(temp.find(temp4)!= std::string::npos)
 temp.replace(temp.find(temp4), temp4.length(),"mediaRange");
 }
 finalRep.append(temp);
 finalRep.append("</SegmentList>\n");
 finalRep.append("</Representation>\n");

 mpdexportfile << finalRep;
 id++;
 }


 mpdexportfile << finalMPDfoot;
 mpdexportfile.close();

 return 0;
}