annotate src/sc_converter.cpp @ 0:add35537fdbb tip

Initial import

//  Copyright 2011, Ian Hobson.
//
//  This file is part of gpsynth.
//
//  gpsynth is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  gpsynth is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with gpsynth in the file COPYING. 
//  If not, see http://www.gnu.org/licenses/.

#include "sc_converter.hpp"

#include "boost_ex.hpp"
#include "logger.hpp"

#include "boost/graph/graphviz.hpp"
#include "boost/graph/topological_sort.hpp"

#include <iomanip>
#include <fstream>


namespace {

const std::string g_VariablePrefix("v");
const std::string g_ArgumentPrefix("arg_");
const int g_label_decimal_places = 2;
  
} // namespace


namespace sc {

// picks the lowest available variable for a command, or creates a new one 
int Converter::AssignVariable(sg::Vertex vertex) {
  int variable;
  if (available_variables_.size() > 0) {
    std::set<int>::iterator lowest_variable = available_variables_.begin();
    variable = *(lowest_variable);
    available_variables_.erase(lowest_variable);
  } else {
    variable = variables_created_++;
  }
  // store the command's variable
  variable_map_[vertex] = variable;
  return variable;
}

// retrieves the assigned variable for a specific command vertex
int Converter::GetVariable(sg::Vertex vertex) {
  int variable = variable_map_[vertex];
  variable_map_.erase(vertex);
  available_variables_.insert(variable);
  return variable;
}

void Converter::SynthDefSpecial(sg::Vertex vertex,
                                const sg::Node& node,
                                const sg::Graph& graph) {
  if ((node.id_ == sc::Command::kMixer)
      || (node.id_ == sc::Command::kMultiplier)) {
    // e.g. v0 + v1 + v2
    command_script_ << '\t';
    // is this the root mixer?
    bool root_command = (boost::out_degree(vertex, graph) == 0);
    if (root_command) {
      command_script_ << "Out.ar([0, 1], ";
    } else {
      command_script_ << g_VariablePrefix << AssignVariable(vertex) << " = ";
    }
    // clip output
    command_script_ << "Clip.";
    if (node.rate_ == sg::kAudioRate) {
      command_script_ << "ar(";
    } else {
      command_script_ << "kr(";
    }
    // process command parameter, based on vertex inputs
    sg::Graph::in_edge_iterator in_edge;
    sg::Graph::in_edge_iterator in_edge_end;
    bool first_argument = true;
    bool parentheses = (boost::in_degree(vertex, graph) > 1);
    // get separator for this command
    std::string separator;
    if (node.id_ == sc::Command::kMixer) {
      separator = " + ";
    } else {
      separator = " * ";
    }
    for (boost::tie(in_edge, in_edge_end) = boost::in_edges(vertex, graph);
         in_edge != in_edge_end;
         ++in_edge) {
      const sg::Connection& connection = graph[*in_edge];
      if (!first_argument) {
        command_script_ << separator;
      } else {
        first_argument = false;
      }
      const sg::Vertex& source_vertex = boost::source(*in_edge, graph);
      const sg::Node& source = graph[source_vertex];
      sg::NodeType source_type = source.type_;
      if (source_type == sg::kConstant) {
        // calculate weighted constant value 
        double value = source.constant_value_;
        command_script_ << (value * connection.weight_ + connection.offset_);
      } else {
        if (parentheses) {
          command_script_ << '(';
        }
        if (source_type == sg::kParameter) {
          command_script_ << g_ArgumentPrefix << source.id_;
        } else if (source_type == sg::kCommand) {
          command_script_ << g_VariablePrefix << GetVariable(source_vertex);
        } else if (source_type == sg::kSpecial) {
          command_script_ << g_VariablePrefix << GetVariable(source_vertex);
        }
        if (connection.weight_ != 1) {
          command_script_ << " * " << connection.weight_;
        }
        if (connection.offset_ != 0) {
          command_script_ << " + " << connection.offset_;
        }
        if (parentheses) {
          command_script_ << ')';
        }
      }
    }
    // end of Clip command
    if (node.rate_ == sg::kAudioRate) {
      command_script_ << ", -1, 1)";
    } else {
      command_script_ << ", 0, 1)";
    }
    // end of Out.ar command for root mixer
    if (root_command) {
      command_script_ << ')';
    }
    command_script_ << ";\n";
  }
}

void Converter::SynthDefCommand(sg::Vertex vertex,
                                const sg::Node& node,
                                const sg::Graph& graph) {
  const sc::Command& command = commands_[node.id_];
  command_script_ << '\t';
  command_script_ << g_VariablePrefix << AssignVariable(vertex) << " = ";
  command_script_ << command.Name() << '.';
  // command type
  if (node.rate_ == sg::kAudioRate) {
    command_script_ << "ar(";
  } else {
    command_script_ << "kr(";
  }
  // command inputs
  sg::Graph::in_edge_iterator in_edge;
  sg::Graph::in_edge_iterator in_edge_end;
  bool first_argument = true;
  for (boost::tie(in_edge, in_edge_end) = boost::in_edges(vertex, graph);
       in_edge != in_edge_end;
       ++in_edge) {
    const sg::Connection& connection = graph[*in_edge];
    const sc::Argument& argument = command.GetArgument(connection.input_);
    if (!first_argument) {
      command_script_ << ", ";
    } else {
      first_argument = false; 
    }
    // argument value
    command_script_ << argument.name_ << ": ";
    const sg::Vertex& source_vertex = boost::source(*in_edge, graph);
    const sg::Node& source = graph[source_vertex];
    sg::NodeType source_type = source.type_;
    if (source_type == sg::kConstant) {
      // calculate weighted constant value 
      double value = source.constant_value_;
      command_script_ << (value * connection.weight_ + connection.offset_);
    } else {
      if (source_type == sg::kParameter) {
        command_script_ << g_ArgumentPrefix << source.id_;
      } else if (source_type == sg::kCommand) {
        command_script_ << g_VariablePrefix << GetVariable(source_vertex);
      } else if (source_type == sg::kSpecial) {
        command_script_ << g_VariablePrefix << GetVariable(source_vertex);
      }
      if (connection.weight_ != 1) {
        command_script_ << " * " << connection.weight_;
      }
      if (connection.offset_ != 0) {
        command_script_ << " + " << connection.offset_;
      }
    }
  }
  // write preset constant arguments
  foreach (const sc::Argument& argument, command.Arguments()) {
    if (argument.scaling_mode_ == sc::Argument::kConstant) {
      if (!first_argument) {
        command_script_ << ", ";
      }
      first_argument = false;
      command_script_ << argument.name_ << ": " << argument.constant_value_;
    }
  }
  //command end
  command_script_ << ");\n";
}
  
// convert a given vertex
void Converter::SynthDefVertex(sg::Vertex vertex, const sg::Graph& graph) {
  const sg::Node& node = graph[vertex];
  sg::NodeType type = node.type_;
  if (type == sg::kSpecial) {
    SynthDefSpecial(vertex, node, graph);
  }
  if (type == sg::kCommand) {
    SynthDefCommand(vertex, node, graph);
  }
}

// prepares a synthdef from a synth graph
std::string Converter::ToSynthDef(const sg::Graph& graph,
                                  const std::string& synth_name,
                                  bool convert_for_realtime,
                                  const std::string& synthdef_path) {
  command_script_.str("");
  variable_map_.clear();
  variables_created_ = 0;
  available_variables_.clear();
  
  // preamble
  std::stringstream synth_def;
  synth_def << "SynthDef(\"" << synth_name << "\", {\n";
  // arguments
  std::size_t parameters = graph[boost::graph_bundle].parameters_.size();
  if (parameters > 0) {
    synth_def << "\targ ";
    for (std::size_t i = 1; i <= parameters; i++) {
      synth_def << g_ArgumentPrefix << i;
      if (i < parameters) {
        synth_def << ", ";
      }
    }
    synth_def << ";\n";
  }
  // commands
  std::vector<sg::Vertex> vertices;
  vertices.reserve(boost::num_vertices(graph));
  // perform topological sort on graph to find dependency order
  boost::topological_sort(graph, std::back_inserter(vertices));
  // traverse commands in reversed topological order
  std::map<sg::Vertex, int> variable_map;
  foreach_reverse (sg::Vertex& vertex, vertices) {
    SynthDefVertex(vertex, graph);
  }
  // declare variables required by the commands
  if (variables_created_ > 0) {
    synth_def << "\tvar ";
    for (int i = 0; i < variables_created_; i++) {
      synth_def << g_VariablePrefix << i;  
      if (i < variables_created_ - 1) {
        synth_def << ", ";
      }
    }
    synth_def << ";\n";
  }
  // store the commands in the synthdef
  synth_def << command_script_.str();
  // ending
  if (convert_for_realtime) {
    synth_def << "}).add;\n";
  } else {
    synth_def << "}).writeDefFile(\"" << synthdef_path << "\");\n";
  }
  return synth_def.str();
}

std::string Converter::ToScore(const sg::Graph& graph,
                               const std::string& synth_name,
                               const std::string& score_variable,
                               bool convert_for_realtime,
                               const std::string& synthdef_path,
                               double render_length) {
  std::stringstream score;
  score << score_variable << " = [\n";
  if (!convert_for_realtime) {
    // load the synthdef
    score << "[0.0, [\\d_load, \"" 
          << synthdef_path << '/' << synth_name << ".scsyndef\"]],\n";
  }
  // start the synth
  score << "[0.0, [\\s_new, \\" + synth_name + ", 1000, 0, 0";
  // initial parameter values
  const sg::GraphProperties& graph_properties = graph[boost::graph_bundle];
  const std::vector<double>& parameters = graph_properties.parameters_;
  for (int i = 0; i < parameters.size(); i++) {
    score << ", \\" << g_ArgumentPrefix << (i + 1) << ", " << parameters[i];
  }
  // end of \s_new command
  score << "]],\n";
  if (!convert_for_realtime) {
    // end of score, stop sound
    score << "[" << render_length << ", [\\c_set, 0, 0]]\n";
  }
  // score end
  score << "];\n";
  return score.str();
}
  
void Converter::Export(const sg::Graph& graph,
                       const std::string& export_folder,
                       const std::string& export_name) {
  std::stringstream export_path;
  export_path << export_folder << '/' << export_name << ".sc";
  std::ofstream export_file(export_path.str().c_str());
  export_file << ToSynthDef(graph, export_name)
              << ToScore(graph, export_name, "x");
  export_file << "Score.play(x);";
}

  
#pragma mark - dot converter
  
// formats a command node for dot
class CommandWriter {
  const sg::Graph& graph_;
  const std::vector<sc::Command>& commands_;
  
public:
  CommandWriter(const sg::Graph& graph,
                const std::vector<sc::Command>& commands) 
  : graph_(graph),
    commands_(commands)
  {}
  
  void operator()(std::ostream& out, const sg::Vertex& vertex) const {
    const sg::Node& command_info = graph_[vertex];
    sg::NodeType type = command_info.type_;
    out << " [label=\"";
    if (type == sg::kConstant) {
      // calculate weighted constant value
      const sg::Edge& out_edge = *(boost::out_edges(vertex, graph_).first);
      const sg::Connection& connection = graph_[out_edge];
      double value = command_info.constant_value_;
      value = value * connection.weight_ + connection.offset_;
      out << std::setprecision(2) << std::fixed << value 
          << "\", shape=diamond";
    } else if (type == sg::kSpecial) {
      if (command_info.id_ == sc::Command::kMixer) {
        // check if this is the root mixer
        if (boost::out_degree(vertex, graph_) > 0) {
          out << "+\"";
          if (command_info.rate_ == sg::kControlRate) {
            out << ", shape=box";
          }
        } else {
          out << "Output\"";
        }
      } else if (command_info.id_ == sc::Command::kMultiplier) {
        out << "*\"";
        if (command_info.rate_ == sg::kControlRate) {
          out << ", shape=box";
        }        
      }
    } else if (type == sg::kCommand) {
      out << commands_[command_info.id_].Name() << "\"";
      if (command_info.rate_ == sg::kControlRate) {
        out << ", shape=box";
      }
    } else if (type == sg::kParameter) {
      out << g_ArgumentPrefix << command_info.id_ 
          << "\", shape=invhouse";
    }
    // end
    out << "]";
  }
};
  
// formats a connection for dot
class ConnectionWriter {
  const sg::Graph& graph_;
  const std::vector<sc::Command>& commands_;
  
public:
  ConnectionWriter(const sg::Graph& graph,
                   const std::vector<sc::Command>& commands) 
  : graph_(graph),
    commands_(commands)
  {}
  
  void operator()(std::ostream& out, const sg::Edge& edge) const {
    const sg::Connection& connection = graph_[edge];
    out << "[label=\"";
    const sg::Node& target = graph_[boost::target(edge, graph_)];
    if (target.type_ == sg::kCommand) {
      const sc::Command& command = commands_[target.id_];
      const sc::Argument& argument = command.GetArgument(connection.input_);
      out << " [" << argument.name_ << ']';
    }
    if (connection.IsActive()) {
      // connection weighting
      // skip constants as they have weighting applied to label
      const sg::Node& source = graph_[boost::source(edge, graph_)];
      if (source.type_ != sg::kConstant) {
        out << " (";
        out << std::fixed << std::setprecision(g_label_decimal_places);
        if (connection.offset_ != 0) {
          out << connection.offset_ 
          << " - " 
          << (connection.offset_ + connection.weight_);
        } else {
          out << "* " << connection.weight_;
        }
        out << ")";        
      }
    }
    out << "\"]";
  }
};

class GraphPropertiesWriter {
  const sg::Graph& graph_;
public:
  GraphPropertiesWriter(const sg::Graph& graph) : graph_(graph) {}
  void operator()(std::ostream& out) const {
    out << "edge[fontsize=10]\n";
  }
};

std::string Converter::ToDOT(const sg::Graph& graph) {
  std::stringstream buffer;
  // prepare the writer classes
  CommandWriter command_writer(graph, commands_);
  ConnectionWriter connection_writer(graph, commands_);
  GraphPropertiesWriter graph_writer(graph);
  // write the graph to the buffer
  boost::write_graphviz(buffer, graph,
                        command_writer, connection_writer, graph_writer);
  return buffer.str();
}

} // sc namespace