mistserver/lib/converter.cpp

#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <sstream>

#include "timing.h"
#include "converter.h"
#include "procs.h"
#include "config.h"

namespace Converter {

  ///\brief The base constructor
  Converter::Converter() {
    fillFFMpegEncoders();
  }

  ///\brief A function that fill the internal variables with values provided by examing ffmpeg output
  ///
  ///Checks for the following encoders:
  /// - AAC
  /// - H264
  /// - MP3
  void Converter::fillFFMpegEncoders() {
    std::vector<char *> cmd;
    cmd.reserve(3);
    cmd.push_back((char *)"ffmpeg");
    cmd.push_back((char *)"-encoders");
    cmd.push_back(NULL);
    int outFD = -1;
    Util::Procs::StartPiped("FFMpegInfo", &cmd[0], 0, &outFD, 0);
    while (Util::Procs::isActive("FFMpegInfo")) {
      Util::sleep(100);
    }
    FILE * outFile = fdopen(outFD, "r");
    char * fileBuf = 0;
    size_t fileBufLen = 0;
    while (!(feof(outFile) || ferror(outFile)) && (getline(&fileBuf, &fileBufLen, outFile) != -1)) {
      if (strstr(fileBuf, "aac") || strstr(fileBuf, "AAC")) {
        strtok(fileBuf, " \t");
        allCodecs["ffmpeg"][strtok(NULL, " \t")] = "aac";
      }
      if (strstr(fileBuf, "h264") || strstr(fileBuf, "H264")) {
        strtok(fileBuf, " \t");
        allCodecs["ffmpeg"][strtok(NULL, " \t")] = "h264";
      }
      if (strstr(fileBuf, "mp3") || strstr(fileBuf, "MP3")) {
        strtok(fileBuf, " \t");
        allCodecs["ffmpeg"][strtok(NULL, " \t")] = "mp3";
      }
    }
    fclose(outFile);
  }

  ///\brief A function to obtain all available codecs that have been obtained from the encoders.
  ///\return A reference to the allCodecs member.
  converterInfo & Converter::getCodecs() {
    return allCodecs;
  }

  ///\brief A function to obtain the available encoders in JSON format.
  ///\return A JSON::Value containing all encoder:codec pairs.
  JSON::Value Converter::getEncoders() {
    JSON::Value result;
    for (converterInfo::iterator convIt = allCodecs.begin(); convIt != allCodecs.end(); convIt++) {
      for (codecInfo::iterator codIt = convIt->second.begin(); codIt != convIt->second.end(); codIt++) {
        if (codIt->second == "h264") {
          result[convIt->first]["video"][codIt->first] = codIt->second;
        } else {
          result[convIt->first]["audio"][codIt->first] = codIt->second;

        }
      }
    }
    return result;
  }

  ///\brief Looks in a given path for all files that could be converted
  ///\param myPath The location to look at, this should be a folder.
  ///\return A JSON::Value containing all media files in the location, with their corresponding metadata values.
  JSON::Value Converter::queryPath(std::string myPath) {
    char const * cmd[3] = {0, 0, 0};
    std::string mistPath = Util::getMyPath() + "MistInfo";
    cmd[0] = mistPath.c_str();
    JSON::Value result;
    DIR * Dirp = opendir(myPath.c_str());
    struct stat StatBuf;
    if (Dirp) {
      dirent * entry;
      while ((entry = readdir(Dirp))) {
        if (stat(std::string(myPath + "/" + entry->d_name).c_str(), &StatBuf) == -1) {
          continue;
        }
        if ((StatBuf.st_mode & S_IFREG) == 0) {
          continue;
        }
        std::string fileName = entry->d_name;
        std::string mijnPad = std::string(myPath + (myPath[myPath.size() - 1] == '/' ? "" : "/") +  entry->d_name);
        cmd[1] = mijnPad.c_str();
        result[fileName] = JSON::fromString(Util::Procs::getOutputOf((char * const *)cmd));
      }
    }
    return result;
  }

  ///\brief Start a conversion with the given parameters
  ///\param name The name to use for logging the conversion.
  ///\param parameters The parameters, accepted are the following:
  /// - input The input url
  /// - output The output url
  /// - encoder The encoder to use
  /// - video An object containing video parameters, if not existant no video will be output. Values are:
  ///   - width The width of the resulting video
  ///   - height The height of the resulting video
  ///   - codec The codec to encode video in, or copy to use the current codec
  ///   - fpks The framerate in fps * 1000
  /// - audio An object containing audio parameters, if not existant no audio will be output. Values are:
  ///   - codec The codec to encode audio in, or copy to use the current codec
  ///   - samplerate The target samplerate for the audio, in hz
  void Converter::startConversion(std::string name, JSON::Value parameters) {
    if (!parameters.isMember("input")) {
      statusHistory[name] = "No input file supplied";
      return;
    }
    if (!parameters.isMember("output")) {
      statusHistory[name] = "No output file supplied";
      return;
    }
    struct stat statBuf;
    std::string outPath = parameters["output"].asString();
    outPath = outPath.substr(0, outPath.rfind('/'));
    int statRes = stat(outPath.c_str(), & statBuf);
    if (statRes == -1 || !S_ISDIR(statBuf.st_mode)) {
      statusHistory[name] = "Output path is either non-existent, or not a path.";
      return;
    }
    if (!parameters.isMember("encoder")) {
      statusHistory[name] = "No encoder specified";
      return;
    }
    if (allCodecs.find(parameters["encoder"]) == allCodecs.end()) {
      statusHistory[name] = "Can not find encoder " + parameters["encoder"].asString();
      return;
    }
    if (parameters.isMember("video")) {
      if (parameters["video"].isMember("width") && !parameters["video"].isMember("height")) {
        statusHistory[name] = "No height parameter given";
        return;
      }
      if (parameters["video"].isMember("height") && !parameters["video"].isMember("width")) {
        statusHistory[name] = "No width parameter given";
        return;
      }
    }
    std::stringstream encoderCommand;
    if (parameters["encoder"] == "ffmpeg") {
      encoderCommand << "ffmpeg -i ";
      encoderCommand << parameters["input"].asString() << " ";
      if (parameters.isMember("video")) {
        if (!parameters["video"].isMember("codec") || parameters["video"]["codec"] == "copy") {
          encoderCommand << "-vcodec copy ";
        } else {
          codecInfo::iterator vidCodec = allCodecs["ffmpeg"].find(parameters["video"]["codec"]);
          if (vidCodec == allCodecs["ffmpeg"].end()) {
            statusHistory[name] = "Can not find video codec " + parameters["video"]["codec"].asString();
            return;
          }
          encoderCommand << "-vcodec " << vidCodec->first << " ";
          if (parameters["video"]["codec"].asString() == "h264") {
            //Enforce baseline
            encoderCommand << "-preset slow -profile:v baseline -level 30 ";
          }
          if (parameters["video"].isMember("fpks")) {
            encoderCommand << "-r " << parameters["video"]["fpks"].asInt() / 1000 << " ";
          }
          if (parameters["video"].isMember("width")) {
            encoderCommand << "-s " << parameters["video"]["width"].asInt() << "x" << parameters["video"]["height"].asInt() << " ";
          }
          ///\todo Keyframe interval (different in older and newer versions of ffmpeg?)
        }
      } else {
        encoderCommand << "-vn ";
      }
      if (parameters.isMember("audio")) {
        if (!parameters["audio"].isMember("codec")) {
          encoderCommand << "-acodec copy ";
        } else {
          codecInfo::iterator audCodec = allCodecs["ffmpeg"].find(parameters["audio"]["codec"]);
          if (audCodec == allCodecs["ffmpeg"].end()) {
            statusHistory[name] = "Can not find audio codec " + parameters["audio"]["codec"].asString();
            return;
          }
          if (audCodec->second == "aac") {
            encoderCommand << "-strict -2 ";
          }
          encoderCommand << "-acodec " << audCodec->first << " ";
          if (parameters["audio"].isMember("samplerate")) {
            encoderCommand << "-ar " << parameters["audio"]["samplerate"].asInt() << " ";
          }
        }
      } else {
        encoderCommand << "-an ";
      }
      encoderCommand << "-f flv -";
    }
    int statusFD = -1;
    Util::Procs::StartPiped2(name, encoderCommand.str(), Util::getMyPath() + "MistFLV2DTSC -o " + parameters["output"].asString(), 0, 0, &statusFD, 0);
    parameters["statusFD"] = statusFD;
    allConversions[name] = parameters;
    allConversions[name]["status"]["duration"] = "?";
    allConversions[name]["status"]["progress"] = 0;
    allConversions[name]["status"]["frame"] = 0;
    allConversions[name]["status"]["time"] = 0;
  }

  ///\brief Updates the internal status of the converter class.
  ///
  ///Will check for each running conversion whether it is still running, and update its status accordingly
  void Converter::updateStatus() {
    if (allConversions.size()) {
      std::map<std::string, JSON::Value>::iterator cIt;
      bool hasChanged = true;
      while (hasChanged && allConversions.size()) {
        hasChanged = false;
        for (cIt = allConversions.begin(); cIt != allConversions.end(); cIt++) {
          if (Util::Procs::isActive(cIt->first)) {
            int statusFD = dup(cIt->second["statusFD"].asInt());
            fsync(statusFD);
            FILE * statusFile = fdopen(statusFD, "r");
            char * fileBuf = 0;
            size_t fileBufLen = 0;
            fseek(statusFile, 0, SEEK_END);
            std::string line;
            int totalTime = 0;
            do {
              getdelim(&fileBuf, &fileBufLen, '\r', statusFile);
              line = fileBuf;
              if (line.find("Duration") != std::string::npos) {
                int curOffset = line.find("Duration: ") + 10;
                totalTime += atoi(line.substr(curOffset, 2).c_str()) * 60 * 60 * 1000;
                totalTime += atoi(line.substr(curOffset + 3, 2).c_str()) * 60 * 1000;
                totalTime += atoi(line.substr(curOffset + 6, 2).c_str()) * 1000;
                totalTime += atoi(line.substr(curOffset + 9, 2).c_str()) * 10;
                cIt->second["duration"] = totalTime;
              }
            } while (!feof(statusFile) && line.find("frame") != 0); //"frame" is the fist word on an actual status line of ffmpeg
            if (!feof(statusFile)) {
              cIt->second["status"] = parseFFMpegStatus(line);
              cIt->second["status"]["duration"] = cIt->second["duration"];
              cIt->second["status"]["progress"] = (cIt->second["status"]["time"].asInt() * 100) / cIt->second["duration"].asInt();
            } else {
              line.erase(line.end() - 1);
              line = line.substr(line.rfind("\n") + 1);
              cIt->second["status"] = line;
            }
            free(fileBuf);
            fclose(statusFile);
          } else {
            if (statusHistory.find(cIt->first) == statusHistory.end()) {
              statusHistory[cIt->first] = "Conversion successful, running DTSCFix";
              Util::Procs::Start(cIt->first + "DTSCFix", Util::getMyPath() + "MistDTSCFix " + cIt->second["output"].asString());
            }
            allConversions.erase(cIt);
            hasChanged = true;
            break;
          }
        }
      }
    }
    if (statusHistory.size()) {
      std::map<std::string, std::string>::iterator sIt;
      for (sIt = statusHistory.begin(); sIt != statusHistory.end(); sIt++) {
        if (statusHistory[sIt->first].find("DTSCFix") != std::string::npos) {
          if (Util::Procs::isActive(sIt->first + "DTSCFIX")) {
            continue;
          }
          statusHistory[sIt->first] = "Conversion successful";
        }
      }
    }
  }

  ///\brief Parses a single ffmpeg status line into a JSON format
  ///\param statusLine The current status of ffmpeg
  ///\return A JSON::Value with the following values set:
  /// - frame The current last encoded frame
  /// - time The current last encoded timestamp
  JSON::Value Converter::parseFFMpegStatus(std::string statusLine) {
    JSON::Value result;
    int curOffset = statusLine.find("frame=") + 6;
    result["frame"] = atoi(statusLine.substr(curOffset, statusLine.find("fps=") - curOffset).c_str());
    curOffset = statusLine.find("time=") + 5;
    int myTime = 0;
    myTime += atoi(statusLine.substr(curOffset, 2).c_str()) * 60 * 60 * 1000;
    myTime += atoi(statusLine.substr(curOffset + 3, 2).c_str()) * 60 * 1000;
    myTime += atoi(statusLine.substr(curOffset + 6, 2).c_str()) * 1000;
    myTime += atoi(statusLine.substr(curOffset + 9, 2).c_str()) * 10;
    result["time"] = myTime;
    return result;
  }

  ///\brief Obtain the current internal status of the conversion class
  ///\return A JSON::Value with the status of each conversion
  JSON::Value Converter::getStatus() {
    updateStatus();
    JSON::Value result;
    if (allConversions.size()) {
      for (std::map<std::string, JSON::Value>::iterator cIt = allConversions.begin(); cIt != allConversions.end(); cIt++) {
        result[cIt->first] = cIt->second["status"];
        result[cIt->first]["details"] = cIt->second;
      }
    }
    if (statusHistory.size()) {
      std::map<std::string, std::string>::iterator sIt;
      for (sIt = statusHistory.begin(); sIt != statusHistory.end(); sIt++) {
        result[sIt->first] = sIt->second;
      }
    }
    return result;
  }

  ///\brief Clears the status history of all conversions
  void Converter::clearStatus() {
    statusHistory.clear();
  }
}