---

PlayListConverter.cpp

Go to the documentation of this file.

#include "PlayListConverter.h"
#include "EmpParser.h"
#include "xmlutils.h"
#include "StringUtils.h"
#include <errno.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <sys/wait.h>
#include <unistd.h> 
#include <fstream>
#include <sstream> 
#include <algorithm>

using namespace std;
using namespace xmlpp;

PlayListConverter::PlayListConverter(){}

void PlayListConverter::OutputFormat::clear()
{
  filename = "";
  begin = "";
  track = "";
  end = "";
  exec = "";
}

bool PlayListConverter::load_config()
{
  bool success(false);
  string filename;  

  if (get_config_file(filename)) 
  {
     m_config.parse_file(filename);

     Node* root = m_config.get_root_node();

     if (root != NULL) {
        Node* opts =  getFirstChild(root, "options");
        if (opts != NULL) {
          m_options.workingdir = getPropValue(opts, "working-dir");
          const Node::NodeList& formats = opts->get_children("default-format");
          Node::NodeList::const_iterator format = formats.begin();
          for(; format != formats.end(); ++format) {
             string def_format = getPropValue(*format, "name");
             if (! def_format.empty()) {
                m_options.formats.push_back(def_format);
             }
          }
        }

        expand_tilde(m_options.workingdir);
     
        success = true;
     } 
  }
  else 
  {
     cerr << "cant find a config file" << endl;
  }
  
  return success;
}


bool PlayListConverter::parse_rmp(const char* filename)
{
  m_session.emp_file = filename;
  EmpParser parser;
  return parser.parse_file(filename, m_session, m_tracks);
}

bool PlayListConverter::write_output(OutputFormat& format)
{
  bool success(false);
  if (m_tracks.empty()) return success; // need to have at least one track

  // run any chained formats first  
  StringList::const_iterator cformat = format.chained_formats.begin();
    for(; cformat != format.chained_formats.end(); ++cformat) {
      process_format(*cformat);
    } 

    // build the filename
    RmpTrack& firstTrack = *m_tracks.begin();
    m_session.output_file = make_subs(format.filename, m_session, firstTrack);

    // open file
    ostream* os = &cout;
    ofstream ofs;
    if (! m_session.output_file.empty()) {
      open_output(ofs);
      os = &ofs;
    }

    if (os && *os) {
      // write  the beginning
      if (! format.begin.empty()) {
         *os << make_subs(format.begin, m_session, firstTrack) << endl;
      }

      // write out all the track entries
      if (! format.track.empty()) {
         TrackList::const_iterator iter = m_tracks.begin();
         for(; iter != m_tracks.end(); ++iter) {
            *os << make_subs(format.track, m_session, *iter) << endl;
         }
      }

      // write end 
      if (! format.end.empty()) {
         *os << make_subs(format.end, m_session, firstTrack) << endl;
      }

     // unescape the command to execute
     format.exec = make_subs(format.exec, m_session, firstTrack);

     success = true;
  } else {
     cerr << "failed opening output file: " << m_session.output_file << endl;
  }

  return success;
}


bool PlayListConverter::exec_output(const OutputFormat& format, bool wait_for_child)
{  
  bool success(false);

  if (format.exec.length() > 0) 
  {
     char* args[] = {"sh", "-c", const_cast<char*>(format.exec.c_str()), 0};
     
     int fork_result = fork();
     
     switch (fork_result) {
     case -1:
        break;
        
     case 0:
        // were the child process
        cout << "executing: "  << format.exec << endl;
        execvp("sh",args);
        break;
        
     default:
        // were the parent prpcess
        if (wait_for_child) {
          int status;
          waitpid(fork_result, &status, 0);
        }
        success = true;
     }
  } else {
     // no command just return
     success = true;
  }
  return success;
}


bool PlayListConverter::get_config_file(std::string& filename)
{
  bool success(true);
  string home_config("~/.empxformrc");
  expand_tilde(home_config);
  const char* configs[] = {home_config.c_str(), 
                                    "/usr/share/empxform/empxformrc",
                                    "/usr/local/share/empxform/empxformrc",
                                    "/etc/empxformrc", 0};

  struct stat st; 
  unsigned int i;
  for(i=0; (configs[i] != 0) && (stat(configs[i], &st) != 0); ++i){}

  if (i < (sizeof(configs) / sizeof(char*) - 1)) {
     filename = configs[i];
  } else {
     success = false;
  }

  return success;
}


void PlayListConverter::add_format_line(string &entry, const string newline) {
  if (entry.size()) {
     entry += "\n";
  }
  entry += newline;
}


string PlayListConverter::make_subs(const string& templ, const RmpSession& session, const RmpTrack& trk)
{
  string result(templ);

  size_t pos(0);

  while ((pos= result.find('%', pos)) != string::npos) {
     if (pos <  result.length() -1) {
        // check for modifiers
        int offset = is_command_modifier(result[pos +1]) ? 2 : 1;
        
        switch (result[pos +offset]) {
        case 'O': //  - generated output file (created by emp2m3u rules)
          insert_subst(result, pos, m_session.output_file);
          break;
        case 'E': //  - name of the emp file
          insert_subst(result, pos, m_session.emp_file);
          break;
        case 'P': //  - Provider name
          insert_subst(result, pos, m_session.provider);
          break;
        case 'T': //  - package title (Album name on emusic)
          insert_subst(result, pos, m_session.package_title);
          break;
        case 'A': // package artist
          insert_subst(result, pos, m_session.package_artist);
          break;
        case 'W': // Program working directory
          insert_subst(result, pos, m_options.workingdir);
          break;
        case 't': //  - title
          insert_subst(result, pos, trk.title);
          break;
        case 'a': //  - artist
          insert_subst(result, pos, trk.artist);
          break;
        case 'n': //  - track number
          insert_subst(result, pos, trk.track_num);
          break;
        case 'f': //  - file name
          insert_subst(result, pos, trk.file_name);
          break;
        case 'd': //  - id of the current track
          insert_subst(result, pos, trk.track_id);
          break;
        case 'g': //  - genre
          insert_subst(result, pos, trk.genre);
          break;
        case 'F': //  - format
          insert_subst(result, pos, trk.format);
          break;
        case 'q': //  - quality
          insert_subst(result, pos, trk.quality);
          break;
        case 'c': //  - album art (cover picture)
          insert_subst(result, pos, trk.cover);
          break;
        case 'U': //  - complete url of the current track
          insert_subst(result, pos, trk.url);
          break;          
        case 'D': //  - duation in seconds
          insert_subst(result, pos, trk.duration);
          break;          
        case 'C': //  - the number of channels
          insert_subst(result, pos, trk.channels);
          break;
        case '%': //  -  a literal % 
          insert_subst(result, pos, "%");
          break;                  
        default:
          ++pos; // unrecognsed flag just ignore it
        }
     }
  }
  return result;
}



void PlayListConverter::insert_subst(string& to_change, size_t& pos, const string& toinsert) {


  if (! is_command_modifier(to_change[pos+1])) {
     to_change.replace(pos, 2, toinsert);
     pos += toinsert.length();
     
  } else {
     // Handle escape sequence modifiers
     string new_val(toinsert);

     switch (to_change[pos+1]) {
     case '\\': // escape shell characters
        escape_shell_chars(new_val);
        break;

     case '_': // remove shell charachers, spaces to underscores
        replace_str(new_val, " ", "_");
        remove_shell_chars(new_val);
        break;
        
     case '-': // remove shell characters
        remove_shell_chars(new_val);
        break;      

     case '!': // convert \ to -
        replace_str(new_val, "/", "-");
        break;      

     case '\'': // remove quotes 
        replace_str(new_val, "\"", "");
        replace_str(new_val, "'", "");
        break;      
     }
     
     to_change.replace(pos, 3, new_val);
     pos += new_val.length();
  }

}

void PlayListConverter::change_working_dir()
{
  if (m_options.workingdir.empty()) {
     m_options.workingdir = "~";
     expand_tilde(m_options.workingdir);
  }

  if (! make_dir(m_options.workingdir)) {
     cerr << "error creating working directory: " << m_options.workingdir << endl;
  }
  
  if (chdir(m_options.workingdir.c_str()) != 0) {
     cerr << "error changing to working directory: "<< m_options.workingdir << endl;
  }  
  
}


bool PlayListConverter::is_command_modifier(char c)
{
  switch (c) {
  case '!':
  case '\\':
  case '-':
  case '_':
  case '\'':
     return true;
  default:
     return false;
  }
}


void PlayListConverter::set_options(const Options& new_opt)
{
  m_options.wait_for_child = new_opt.wait_for_child;

  if (! new_opt.workingdir.empty()) {
     m_options.workingdir = new_opt.workingdir;
     void change_working_dir();
  } 

  if (! new_opt.formats.empty()) {
     m_options.formats.clear();
     transform(new_opt.formats.begin(), new_opt.formats.end(), 
                  back_inserter(m_options.formats),
                  bind1st(mem_fun(&PlayListConverter::copy_format_name), this));
  }
}



string PlayListConverter::copy_format_name(string format) 
{
  if (format.length() && (format[0] != '<')) {
     return format;
  } else {
     // its a format specified inline
     static int format_num = 0; // counter for naming anonymous formats
     stringstream tmp_name;
     tmp_name << "anonymous-" << format_num++ << '\0';
     string format_name(tmp_name.str());

     format = "<format name=\"" + format_name + "\">" + format + "</format>";

     // now  parse the xml & add the new format to the ones read from the config file
     DomParser tree;
     tree.parse_memory(format);
     if (! tree) {
        cerr << "Error: cant parse anonymous format: " << format << endl;
     } else {
        Node* new_format = tree.get_root_node();
        Node* conf_root = m_config.get_root_node();
        if (conf_root && new_format) {
//        conf_root->add_child(new Node(*new_format));
          addChild(conf_root, new Node(*new_format));
        }
     }
     
     return format_name;
  }
}

bool PlayListConverter::process_rmp(const char* rmp_file)
{
  bool success = parse_rmp(rmp_file);
  change_working_dir();

  if (success) {
     StringList::const_iterator iter = m_options.formats.begin();

     for(; iter != m_options.formats.end(); ++iter) {
        success &= process_format(*iter);
     } 
  }
  return success;
}


bool PlayListConverter::process_format(const std::string& format_name) 
{
  bool success;
  OutputFormat format;
  success = load_format(format_name.c_str(), format);
  success &= write_output(format);
  success &= exec_output(format, m_options.wait_for_child);
}


bool PlayListConverter::load_format(const char* format_name, OutputFormat& oformat)
{
  bool success(false);
  string filename;  
  oformat.clear();

  if (m_config) 
  {
     Node* root = m_config.get_root_node();

     const Node::NodeList& formats = root->get_children("format");
     Node::NodeList::const_iterator format = formats.begin();
     while ((format != formats.end()) && 
              static_cast<Element*>((*format))->get_attribute("name")->get_value() != format_name){++format; }
     if (format != formats.end()) {
        // found the format we want
        const Node::NodeList& children = (*format)->get_children();
        Node::NodeList::const_iterator curr_child = children.begin();
        for(; curr_child != children.end(); ++curr_child) {
          if ((*curr_child)->get_name() == "filename") 
          {
              oformat.filename = getChildContent(*curr_child);
              expand_tilde(oformat.filename);
          } 
          else if ((*curr_child)->get_name() == "run-format") 
          {
             oformat.chained_formats.push_back(getPropValue(*curr_child, "name"));
          } 
          else if ((*curr_child)->get_name() == "begin") 
          {
             add_format_line(oformat.begin, getChildContent(*curr_child));
          } 
          else if ((*curr_child)->get_name() == "track") 
          {
             add_format_line(oformat.track, getChildContent(*curr_child));
          } 
          else if ((*curr_child)->get_name() == "end") 
          {
             add_format_line(oformat.end, getChildContent(*curr_child));
          } 
          else if ((*curr_child)->get_name() == "exec") 
          {
             oformat.exec = getChildContent(*curr_child);
          }
        }
        success = true;
     } else {
        cerr << "cant find the requested format \"" << format_name << "\"" << endl;
     }
     
  } 
  else 
  {
     cerr << "Cant find a config file" << endl;
  }
  
  return success;

}


int PlayListConverter::get_formats(FormatDescList& format_desc)
{
  bool success(false);
  string filename;  
  format_desc.clear();

  if (get_config_file(filename)) 
  {
     DomParser config(filename);

     Node* root = config.get_root_node();

     Node::NodeList formats = root->get_children("format");
     Node::NodeList::const_iterator iter = formats.begin();
     for(; iter != formats.end(); ++iter) {
        FormatDesc a_format;
        a_format.name = getPropValue(*iter, "name");
        getChildContent(*iter, "desc", a_format.desc);
        format_desc.push_back(a_format);
     }

     format_desc.sort();
  }
  return format_desc.size();
}


void PlayListConverter::open_output(ofstream& os) 
{
  if (! m_session.output_file.empty()) {
     string& filename = m_session.output_file;
     size_t slashpos = filename.rfind('/');

     if (slashpos != string::npos) {
        // theres a directory component, create as necessary        
        make_dir(filename.substr(0, slashpos));
     }

     os.open(filename.c_str());
  }
}

---