# Copyright (C) 2002-2004 gregoire HUBERT.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Author : gregoire HUBERT
#
# XML_node.objet
#
# This object is an XML node representation
#
# /- name (string)
# xml_node --- attributes (array)
# \- children (array) or value (string)
class xml_node {
var $name;
var $attributes = array();
var $children = array();
var $value = "";
function xml_node($name,$attributes,$children=array(),$value="") {
$this->name = $name;
if (is_array($attributes)) {
$this->attributes = $attributes;
}
$this->children = $children;
$this->value = $value;
}
}
# Copyright (C) 2003-2004 gregoire HUBERT.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Author : gregoire HUBERT
#
# xml_tree class
#
# This object parses an XML stream and offers a tree composed by xml_nodes
#
class xml_tree {
var $xml_stream;
var $current_node;
var $root_node;
var $index;
var $value;
function xml_tree() {
$this->root_node = new xml_node("__ROOT_NODE",array());
$this->current_node = $this->root_node;
}
function add_tree($xml_stream) {
# Managing the parser
$this->xml_stream = $xml_stream;
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser,XML_OPTION_CASE_FOLDING,0);
xml_parser_set_option($xml_parser,XML_OPTION_SKIP_WHITE,1);
if (!xml_parse_into_struct($xml_parser,$this->xml_stream,$this->value,$this->index)) {
xml_parser_free($xml_parser);
die("XML Parse error");
}
xml_parser_free($xml_parser);
# Now, $this->value and $this->index are informed, we can use the get_node methode.
$tab_result = $this->get_node(0,count($this->value) - 1);
$this->root_node->children[] = $tab_result[0];
$this->current_node = $this->root_node;
}
function get_node($index_start,$index_stop) {
#echo " \n";
#echo "GET-NODE($index_start,$index_stop) \n";
# What we are going to return is an array of xml_nodes
$return_tab = array();
# depth is only here to check if everything is all right
$tab_node = $this->value[$index_start];
$depth = $tab_node["level"]-1;
# Now we have to be sure we do not forget a single node
for ($index = $index_start;$index <= $index_stop;$index++) {
#echo "\$index = $index ";
# get the current node
$tab_node = $this->value[$index];
# what type of node is it ?
switch($tab_node["type"]) {
case "complete" :
# Depth integrity check
if ($tab_node["level"] != $depth+1) {
die("ERREUR # contrainte d'intégrité au noeud complet $index, niveau $depth + 1 au lieu de ".$tab_node["level"]);
}
#echo "Noeud complet trouvé position $index TAG ".$tab_node["tag"]." \n";
# Easy one, no children to manage, only a value...
$return_tab[] = new xml_node($tab_node["tag"],$tab_node["attributes"],"",$tab_node["value"]);
break;
case "open" :
# Depth integrity check
if ($tab_node["level"] != $depth +1 ) {
die("ERREUR # contrainte d'intégrité au noeud ouvert $index, niveau $depth au lieu de ".$tab_node["level"]);
}
# Open tag, we re-use this methode to return its children
# Where is the correspondong close tag ?
$node_index = $this->index[$tab_node["tag"]];
$flipped_node_index = array_flip($node_index);
#echo "This ".$tab_node["tag"]." is at coords ".$flipped_node_index[$index]." ";
$i=1;
do {
$next_index = $node_index[$flipped_node_index[$index] + $i++];
$next_tag=$this->value[$next_index];
}
while ($next_tag["level"]!=$tab_node["level"]);
#echo "Ouverture de noeud détectée pos $index TAG ".$tab_node["tag"]." \n Parcours jusqu au $next_index \n";
# good, we can now instanciate our node
$return_tab[] = new xml_node($tab_node["tag"],$tab_node["attributes"],$this->get_node($index+1,$next_index),"");
# As we called the get_node methode, we are sure that nodes have been parsed to the corresponding close tag
$index = $next_index;
break;
case "close" :
# Depth integrity check
if ($tab_node["level"] != $depth ){
die("ERREUR # contrainte d'intégrité au noeud fermé $index, niveau $depth au lieu de ".$tab_node["level"]);
}
#echo "Fermeture de noeud detectée pos $index TAG ".$tab_node["tag"]."
\n";
# This ugly thing is useless because reaching a close tag means that $index==$index_stop but who knows ? =)
# it will be skipped soon
$index = $index_stop;
break;
default:
die("Erreur de type de TAG non déterminé :'".$tab_node["type"]."'");
}
}
# We are out ... returns the array with collected children...
return ($return_tab);
}
# this function browse the xml tree and set the current node to the selected node
function give_node($path) {
if ($path[0]=="/") {
$current_node=$this->root_node;
$path=substr($path,1);
#echo "ABSOLUTE PATH GIVEN=$path ";
}
else {
$current_node = $this->current_node;
}
#echo "PATH GIVEN=$path ";
$tab_path = split("/",$path);
foreach ($tab_path as $node_expr) {
#echo "STUDYING EXPR='$node_expr' ";
$node = $current_node;
$expr_tab = split("\?",$node_expr);
$node_name = $expr_tab[0];
$attr_tab = 0;
if (count($expr_tab)>1) {
##echo "TROUVE AU MOINS UNE CONDITION SUR LES ATTRIBUTS... ";
$attr_expr_tab=split(",",$expr_tab[1]);
$attr_tab=array();
foreach($attr_expr_tab as $attr_expr) {
$attr_split_expr=split("=",$attr_expr);
$attr_tab[$attr_split_expr[0]]=$attr_split_expr[1];
}
}
$last=0;
foreach ($node->children as $children) {
#echo "COMPARING WITH '$children->name' ";
if ($children->name == $node_name) {
##echo "TROUVE NOEUD CORRESPONDANT $node_name ";
if (is_array($attr_tab)) {
$node_attributes = $children->attributes;
foreach ($attr_tab as $key=>$value) {
if ($node_attributes[$key] == $value) {
#echo "ATTRIBUTE & CHANGE CURRENT NODE TO ".$children->name." ";
$current_node = $children;
$last = 1;
}
}
}
else {
##echo "CHILD=".$children->name." ";
#echo "CHANGE CURRENT NODE TO ".$children->name." ";
$current_node = $children;
$last=1;
}
}
if ($last) {
break;
}
}
if (!$last) {
#echo "PATH ERROR $node_name ";
#die("MMmmmh It seems that this file is not a DIA XML format...sorry...");
return 0;
}
}
return $current_node;
}
function browse_tree($path) {
$node = $this->give_node($path);
if (is_object($node)) {
$this->current_node = $node;
return 1;
}
return 0;
}
# this method dumps an html representation of the xml tree
function xml_show($node = "",$level=0,$last=0) {
if ($node=="") {
$node=$this->root_node;
}
if (!is_object($node)) {
die("ERROR : node is not an object");
}
$line="";
for($i=1;$i<=$level;$i++) {
if ((i==$level-1) and ($last)) {
$line.=" ";
}
else {
$line.=" |";
}
if ($i==$level) {
$line.="`-";
}
}
$line.=$node->name;
#echo $line;
$line.="".count($node->children)."";
if (count($node->children)==1) {
$line.=" (".$node->value.") \n";
echo "$line";
}
else {
$line.=" \n";
echo "$line";
$i=1;
foreach($node->children as $children) {
if ($i==count($node->children)) {
$this->xml_show($children,$level+1,1);
}
else {
$this->xml_show($children,$level+1);
}
$i++;
}
}
}
#END_CLASS
}
FIEND (ru) - The Blooming Tremble (2009)

Label : Auto-Production
Sortie du Scud : janvier 2009
Pays : Russie
Genre : Death Metal Mélodique
Type : Album
Playtime : 8 Titres - 35 Mins
En décembre 2007, Leos Hellscream décide de fonder FIEND. Il recrute trois amis et débute très vite l’enregistrement d’un premier album, seulement trois mois plus tard. Dans l’attente de réponses des labels, le combo enchaîne les petits concerts et fini par gagner un peu de reconnaissance en ouvrant pour PAIN. Malgré quelques changements de line-up, la formation se résigne à sortir indépendamment The Blooming Tremble, un an après sa conception.
L’autoproduction dont a bénéficié le disque fait ressentir ses limites sur la qualité sonore. Pourtant, cela n’empêche pas le groupe de dévoiler une musique envoûtante, jonchée d’ornements synthétiques réussis. De « Time Before The End », ouverture de l’album sur bruits urbains, chœurs éthérés tragiques et boucle Electro accrocheuse, à « The Seconds Behind » qui conclut l’opus sur une atmosphère désolée complétée de voix angéliques, et finalement le retour de l’agitation citadine validant le concept du frontman (la vie n’est peut-être qu’un rêve), les apports synthétiques se chargent d’offrir une ambiance bien particulière aux compositions. Entre boucles entraînantes, beats rythmés ou bien de simples nappes de support, les claviers donnent leur tonalité aux morceaux tout en rendant la cadence davantage aguicheuse. Ce qui profite aux lignes vocales de Leos puisque les samples combinés à la mélodie de son chant clair permettent d’obtenir d’agréables refrains (« Dream »). Les arrangements sur les vocaux sont donc réussis et parviennent à conserver une aura spéciale dans les titres, grâce à la prestation claire du frontman, qui est plus parlée que chantée, et se garnit de diverses effets, conférant ainsi un aspect singulier à la musique des Russes. Une facette également présente lors des lignes extrêmes étant donné que de nombreux overdubs les accompagnent et les rendent ainsi plus prenantes. Pour éviter la redondance, Leos n’hésite pas à faire varier ses intonations sur différents passages, partant parfois dans des agencements surprenants. L’on retrouve même quelques mimiques propres à Anders Fridén (période Whoracle) avec des passages introvertis parlés, ou bien un effet chaotique en fin de refrain. Toutefois, si le chant râpeux et criard du vocaliste russe concorde avec l’ambiance des titres, il n’en reste pas moins amateur et un peu fouillis.
Outre le micro, la tête pensante du groupe manie également la guitare, en compagnie de Glum. À eux deux ils délivrent des riffs grondants, typiques du genre, mais aussi d’excellents solos s’harmonisant pleinement avec les compositions, à l’instar de celui de « My Last Words ». Cependant, malgré leur sonorité brute qui les place un peu au-dessus dans le mix, les guitares accusent un fort manque de relief. Quelques sections acoustiques, accompagnées d’un tempo mélancolique et de vocaux parlés intimistes, renforcent également l’ambiance personnelle se dégageant de l’ensemble. Si l’atmosphère est si bien installée, c’est parce que la formation montre qu’elle sait travailler sur différents niveaux en alternant morceaux conséquents aux structures travaillées avec des titres plus directs. Une place notable est laissée à l’instrumentation, montrant ainsi qu’elle n’est pas seulement présente pour accompagner des pistes basées sur le chant, mais s’exécute, au contraire, avec force et entrain sur des partitions soignées. Différents schémas se succèdent avec cohérence, comme sur « Forgive Me », où un ingénieux break inattendu détourne la composition sur un superbe pont d’arpèges élégiaques, puis en un lead poignant.
La section rythmique est, pareillement, suffisamment étudiée pour captiver l’intérêt de l’auditeur. Jouant avec les lignes des claviers, elle s’épanche sur les passages dépourvus de chant, et se montre nerveuse et acharnée, de par des riffs acérés et une batterie impétueuse (« The Fiend »). La basse, bien qu’elle ne ressorte pas très distinctement, laisse clairement sentir ses accords robustes dans le bâtit de la rythmique. Cinétique et résonante, l’utilisation qu’en fait Podpol est prolifique aux morceaux, boostant les guitares et dynamisant le tempo. Son soutien est infaillible et il arrive que certains plans se démarquent de la structure suivie. A contrario, Insane, en charge des percussions, tente au mieux d’apporter un jeu vif mais, faute à la production, le rendu se veut mou et sans conviction. L’on note une amélioration sur les dernières pistes, avec des plans davantage soignés (« The Blooming Tremble »). Dommage, donc, que l’album soit très court, comme l’ultime morceau n’est qu’une version russe de « Forgive Me », avec un chant natal qui ne surprend pas tant que ça car Leos garde un accent prononcé en anglais, et un final acoustique supplémentaire, plus naturel et complété de quelques paroles sous-mixées pour garder l’esprit intimiste.
A l’écoute de The Blooming Tremble, la formation russe peut déjà se targuer d’avoir réussi à insuffler des éléments d’une identité sonore propre à la musique présentée. En effet, FIEND alterne avec facilité sections véhémentes et accrocheuses, tout en les agrémentant de mélodies vocales et synthétiques participant à instaurer une aura saisissante. L’amélioration de la production et de la maîtrise des parties plus extrêmes, sur une prochaine sortie, devrait sans conteste jouer en la faveur du groupe.
Ajouté : Mercredi 14 Septembre 2011 Chroniqueur : CyberIF. Score :     Lien en relation: Fiend Website Hits: 6944
|