mplayer: turn playtree into a list, and change per-file option handling

Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
  but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
  and playlist_prev added. (See etc/input.conf changes.)
  This is a user visible incompatible change, and will break slave-mode
  applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
  anymore, and playlist entries have always exactly one entry. Whenever
  something adds more than one file (like ASX playlists or dvd:// or
  dvdnav:// on the command line), all files are added as separate
  playlist entries.

Note that some of the changes are quite deep and violent. Expect
regressions.

The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)

The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.

Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.

It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.

Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:

    mplayer file1.mkv file2.mkv --no-audio file3.mkv

This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.

This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.

Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).

One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)

There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.

Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.

Add a way to specify per-file options on command line. Example:

    mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3

will have the following options per file set:

    f1.mkv, f4.mkv: -o0 -o3
    f2.mkv, f3.mkv: -o0 -o3 -o1 -o2

The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.

1 files changed, 0 insertions, 908 deletions

diff --git a/playtree.c b/playtree.c
deleted file mode 100644
index df7f1ce7ee..0000000000
--- a/playtree.c
+++ /dev/null
@@ -1,908 +0,0 @@
-/*
- * This file is part of MPlayer.
- *
- * MPlayer 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 2 of the License, or
- * (at your option) any later version.
- *
- * MPlayer 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 MPlayer; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-/// \file
-/// \ingroup Playtree
-
-#include "config.h"
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <errno.h>
-#include <assert.h>
-
-#include "talloc.h"
-
-#include "m_config.h"
-#include "playtree.h"
-#include "mp_msg.h"
-
-static int
-play_tree_is_valid(play_tree_t* pt);
-
-play_tree_t*
-play_tree_new(void) {
-  play_tree_t* r = calloc(1,sizeof(play_tree_t));
-  r->entry_type = PLAY_TREE_ENTRY_NODE;
-  return r;
-}
-
-void
-play_tree_free(play_tree_t* pt, int children) {
-  play_tree_t* iter;
-
-  assert(pt != NULL);
-
-  if(children) {
-    for(iter = pt->child; iter != NULL; ) {
-      play_tree_t* nxt=iter->next;
-      play_tree_free(iter,1);
-      iter = nxt;
-    }
-    pt->child = NULL;
-  }
-
-  play_tree_remove(pt,0,0);
-
-  for(iter = pt->child ; iter != NULL ; iter = iter->next)
-    iter->parent = NULL;
-
-  talloc_free(pt->params);
-
-  if(pt->files) {
-    int i;
-    for(i = 0 ; pt->files[i] != NULL ; i++)
-      free(pt->files[i]);
-    free(pt->files);
-  }
-
-  free(pt);
-}
-
-void
-play_tree_free_list(play_tree_t* pt, int children) {
-  play_tree_t* iter;
-
-  assert(pt != NULL);
-
-  for(iter = pt ; iter->prev != NULL ; iter = iter->prev)
-    /* NOTHING */;
-
-  while(iter) {
-    play_tree_t* nxt = iter->next;
-    play_tree_free(iter, children);
-    iter = nxt;
-  }
-
-
-}
-
-void
-play_tree_append_entry(play_tree_t* pt, play_tree_t* entry) {
-  play_tree_t* iter;
-
-  assert(pt != NULL);
-  assert(entry != NULL);
-
-  if(pt == entry)
-    return;
-
-  for(iter = pt ; iter->next != NULL ; iter = iter->next)
-    /* NOTHING */;
-
-  entry->parent = iter->parent;
-  entry->prev = iter;
-  entry->next = NULL;
-  iter->next = entry;
-}
-
-void
-play_tree_prepend_entry(play_tree_t* pt, play_tree_t* entry) {
-  play_tree_t* iter;
-
-  assert(pt != NULL);
-  assert(entry != NULL);
-
-  for(iter = pt ; iter->prev != NULL; iter = iter->prev)
-    /* NOTHING */;
-
-  entry->prev = NULL;
-  entry->next = iter;
-  entry->parent = iter->parent;
-
-  iter->prev = entry;
-  if(entry->parent) {
-    assert(entry->parent->child == iter);
-    entry->parent->child = entry;
-  }
-}
-
-void
-play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry) {
-
-  assert(pt != NULL);
-  assert(entry != NULL);
-
-  entry->parent = pt->parent;
-  entry->prev = pt;
-  if(pt->next) {
-    assert(pt->next->prev == pt);
-    entry->next = pt->next;
-    entry->next->prev = entry;
-  } else
-    entry->next = NULL;
-  pt->next = entry;
-
-}
-
-void
-play_tree_remove(play_tree_t* pt, int free_it, int with_children) {
-
-  assert(pt != NULL);
-
-  // Middle of list
-  if(pt->prev && pt->next) {
-    assert(pt->prev->next == pt);
-    assert(pt->next->prev == pt);
-    pt->prev->next = pt->next;
-    pt->next->prev = pt->prev;
-  } // End of list
-  else if(pt->prev) {
-    assert(pt->prev->next == pt);
-    pt->prev->next = NULL;
-  } // Beginning of list
-  else if(pt->next) {
-    assert(pt->next->prev == pt);
-    pt->next->prev = NULL;
-    if(pt->parent) {
-      assert(pt->parent->child == pt);
-      pt->parent->child = pt->next;
-    }
-  } // The only one
-  else if(pt->parent) {
-    assert(pt->parent->child == pt);
-    pt->parent->child = NULL;
-  }
-
-  pt->prev = pt->next = pt->parent = NULL;
-  if(free_it)
-    play_tree_free(pt,with_children);
-
-}
-
-void
-play_tree_set_child(play_tree_t* pt, play_tree_t* child) {
-  play_tree_t* iter;
-
-  /* Roughly validate input data. Both, pt and child are going to be
-   * dereferenced, hence assure they're not NULL.
-   */
-  if (!pt || !child) {
-    mp_msg(MSGT_PLAYTREE, MSGL_ERR, "Internal error, attempt to add an empty child or use empty playlist\n");
-    return;
-  }
-
-  assert(pt->entry_type == PLAY_TREE_ENTRY_NODE);
-
-  //DEBUG_FF: Where are the children freed?
-  // Attention in using this function!
-  for(iter = pt->child ; iter != NULL ; iter = iter->next)
-    iter->parent = NULL;
-
-  // Go back to first one
-  for(iter = child ; iter->prev != NULL ; iter = iter->prev)
-    /* NOTHING */;
-
-  pt->child = iter;
-
-  for( ; iter != NULL ; iter= iter->next)
-    iter->parent = pt;
-
-}
-
-void
-play_tree_set_parent(play_tree_t* pt, play_tree_t* parent) {
-  play_tree_t* iter;
-
-  assert(pt != NULL);
-
-  if(pt->parent)
-    pt->parent->child = NULL;
-
-  for(iter = pt ; iter != NULL ; iter = iter->next)
-    iter->parent = parent;
-
-  if(pt->prev) {
-    for(iter = pt->prev ; iter->prev != NULL ; iter = iter->prev)
-      iter->parent = parent;
-    iter->parent = parent;
-    parent->child = iter;
-  } else
-    parent->child = pt;
-
-}
-
-
-void
-play_tree_add_file(play_tree_t* pt,const char* file) {
-  int n = 0;
-
-  assert(pt != NULL);
-  assert(pt->child == NULL);
-  assert(file != NULL);
-
-  if(pt->entry_type != PLAY_TREE_ENTRY_NODE &&
-     pt->entry_type != PLAY_TREE_ENTRY_FILE)
-    return;
-
-  if(pt->files) {
-    for(n = 0 ; pt->files[n] != NULL ; n++)
-      /* NOTHING */;
-  }
-  pt->files = realloc(pt->files, (n + 2) * sizeof(char*));
-  if(pt->files ==NULL) {
-    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(n+2)*(int)sizeof(char*));
-    return;
-  }
-
-  pt->files[n]   = strdup(file);
-  pt->files[n+1] = NULL;
-
-  pt->entry_type = PLAY_TREE_ENTRY_FILE;
-
-}
-
-int
-play_tree_remove_file(play_tree_t* pt,const char* file) {
-  int n,f = -1;
-
-  assert(pt != NULL);
-  assert(file != NULL);
-  assert(pt->entry_type != PLAY_TREE_ENTRY_NODE);
-
-  for(n=0 ; pt->files[n] != NULL ; n++) {
-    if(strcmp(file,pt->files[n]) == 0)
-      f = n;
-  }
-
-  if(f < 0) // Not found
-    return 0;
-
-  free(pt->files[f]);
-
-  if(n > 1) {
-    memmove(&pt->files[f],&pt->files[f+1],(n-f)*sizeof(char*));
-    pt->files = realloc(pt->files, n * sizeof(char*));
-    if(pt->files == NULL) {
-      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(n+2)*(int)sizeof(char*));
-      return -1;
-    }
-  } else {
-    free(pt->files);
-    pt->files = NULL;
-  }
-
-  return 1;
-}
-
-void
-play_tree_set_param(play_tree_t* pt, struct bstr name, struct bstr val) {
-  int n = 0;
-
-  assert(pt != NULL);
-
-  if(pt->params)
-    for ( ; pt->params[n].name != NULL ; n++ ) { }
-
-  pt->params = talloc_realloc(NULL, pt->params, struct play_tree_param, n + 2);
-  pt->params[n].name = bstrdup0(pt->params, name);
-  pt->params[n].value = bstrdup0(pt->params, val);
-  memset(&pt->params[n+1],0,sizeof(play_tree_param_t));
-
-  return;
-}
-
-int
-play_tree_unset_param(play_tree_t* pt, const char* name) {
-  int n,ni = -1;
-
-  assert(pt != NULL);
-  assert(name != NULL);
-  assert(pt->params != NULL);
-
-  for(n = 0 ; pt->params[n].name != NULL ; n++) {
-    if(strcasecmp(pt->params[n].name,name) == 0)
-      ni = n;
-  }
-
-  if(ni < 0)
-    return 0;
-
-  talloc_free(pt->params[ni].name);
-  talloc_free(pt->params[ni].value);
-
-  if(n > 1) {
-    memmove(&pt->params[ni],&pt->params[ni+1],(n-ni)*sizeof(play_tree_param_t));
-    pt->params = talloc_realloc(NULL, pt->params, struct play_tree_param, n);
-  } else {
-    talloc_free(pt->params);
-    pt->params = NULL;
-  }
-
-  return 1;
-}
-
-void
-play_tree_set_params_from(play_tree_t* dest,play_tree_t* src) {
-  int i;
-
-  assert(dest != NULL);
-  assert(src != NULL);
-
-  if(!src->params)
-    return;
-
-  for(i = 0; src->params[i].name != NULL ; i++)
-      play_tree_set_param(dest, bstr0(src->params[i].name), bstr0(src->params[i].value));
-  if(src->flags & PLAY_TREE_RND) // pass the random flag too
-    dest->flags |= PLAY_TREE_RND;
-
-}
-
-static void
-play_tree_unset_flag(play_tree_t* pt, int flags , int deep) {
-  play_tree_t*  i;
-
-  pt->flags &= ~flags;
-
-  if(deep && pt->child) {
-    if(deep > 0) deep--;
-    for(i = pt->child ; i ; i = i->next)
-      play_tree_unset_flag(i,flags,deep);
-  }
-}
-
-
-//////////////////////////////////// ITERATOR //////////////////////////////////////
-
-static void
-play_tree_iter_push_params(play_tree_iter_t* iter) {
-  int n;
-  play_tree_t* pt;
-  assert(iter->config != NULL);
-  assert(iter->tree != NULL);
-
-  pt = iter->tree;
-
-  // We always push a config because we can set some option
-  // while playing
-  m_config_push(iter->config);
-
-  if(pt->params == NULL)
-    return;
-
-
-  for(n = 0; pt->params[n].name != NULL ; n++) {
-    int e;
-    if((e = m_config_set_option0(iter->config, pt->params[n].name,
-                                 pt->params[n].value, false)) < 0) {
-      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error %d while setting option '%s' with value '%s'\n",e,
-	     pt->params[n].name,pt->params[n].value);
-    }
-  }
-
-  if(!pt->child)
-    iter->entry_pushed = 1;
-}
-
-// Shuffle the tree if the PLAY_TREE_RND flag is set, and unset it.
-// This is done recursively, but only the siblings with the same parent are
-// shuffled with each other.
-static void shuffle_tree(play_tree_t *pt) {
-    if (!pt)
-        return;
-
-    int count = 0;
-    play_tree_t *child = pt->child;
-    while (child) {
-        // possibly shuffle children
-        shuffle_tree(child);
-        child = child->next;
-        count++;
-    }
-
-    if (pt->flags & PLAY_TREE_RND) {
-        // Move a random element to the front and go to the next, until no
-        // elements are left.
-        // prev = pointer to next-link to the first yet-unshuffled entry
-        play_tree_t** prev = &pt->child;
-        while (count > 1) {
-            int n = (int)((double)(count) * rand() / (RAND_MAX + 1.0));
-            // move = element that is moved to front (inserted after prev)
-            play_tree_t **before_move = prev;
-            play_tree_t *move = *before_move;
-            while (n > 0) {
-                before_move = &move->next;
-                move = *before_move;
-                n--;
-            }
-            // unlink from old list
-            *before_move = move->next;
-            // insert between prev and the following element
-            // note that move could be the first unshuffled element
-            move->next = (*prev == move) ? move->next : *prev;
-            *prev = move;
-            prev = &move->next;
-            count--;
-        }
-        // reconstruct prev links
-        child = pt->child;
-        play_tree_t *prev_child = NULL;
-        while (child) {
-            child->prev = prev_child;
-            prev_child = child;
-            child = child->next;
-        }
-        pt->flags = pt->flags & ~PLAY_TREE_RND;
-    }
-}
-
-play_tree_iter_t*
-play_tree_iter_new(play_tree_t* pt,m_config_t* config) {
-  play_tree_iter_t* iter;
-
-  assert(pt != NULL);
-  assert(config != NULL);
-
-  if( ! play_tree_is_valid(pt))
-    return NULL;
-
-  iter = calloc(1,sizeof(play_tree_iter_t));
-  if(! iter) {
-      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate new iterator (%d bytes of memory)\n",(int)sizeof(play_tree_iter_t));
-      return NULL;
-  }
-  iter->root = pt;
-  iter->tree = NULL;
-  iter->config = config;
-
-  shuffle_tree(pt);
-
-  if(pt->parent)
-    iter->loop = pt->parent->loop;
-
-  return iter;
-}
-
-void
-play_tree_iter_free(play_tree_iter_t* iter) {
-
-  assert(iter != NULL);
-
-  if(iter->status_stack) {
-    assert(iter->stack_size > 0);
-    free(iter->status_stack);
-  }
-
-  free(iter);
-}
-
-static play_tree_t*
-play_tree_rnd_step(play_tree_t* pt) {
-  int count = 0;
-  int r;
-  play_tree_t *i,*head;
-
-  // Count how many free choice we have
-  for(i = pt ; i->prev ; i = i->prev)
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
-  head = i;
-  if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
-  for(i = pt->next ; i ; i = i->next)
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
-
-  if(!count) return NULL;
-
-  r = (int)((float)(count) * rand() / (RAND_MAX + 1.0));
-
-  for(i = head ; i  ; i=i->next) {
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) r--;
-    if(r < 0) return i;
-  }
-
-  mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Random stepping error\n");
-  return NULL;
-}
-
-
-int
-play_tree_iter_step(play_tree_iter_t* iter, int d,int with_nodes) {
-  play_tree_t* pt;
-
-  if ( !iter ) return PLAY_TREE_ITER_ENTRY;
-  if ( !iter->root ) return PLAY_TREE_ITER_ENTRY;
-
-  assert(iter != NULL);
-  assert(iter->root != NULL);
-
-  if(iter->tree == NULL) {
-    iter->tree = iter->root;
-    return play_tree_iter_step(iter,0,with_nodes);
-  }
-
-  if(iter->config && iter->entry_pushed > 0) {
-    iter->entry_pushed = 0;
-    m_config_pop(iter->config);
-  }
-
-  if(iter->tree->parent && (iter->tree->parent->flags & PLAY_TREE_RND))
-    iter->mode = PLAY_TREE_ITER_RND;
-  else
-    iter->mode = PLAY_TREE_ITER_NORMAL;
-
-  iter->file = -1;
-  if(iter->mode == PLAY_TREE_ITER_RND)
-    pt = play_tree_rnd_step(iter->tree);
-  else if( d > 0 ) {
-    int i;
-    pt = iter->tree;
-    for(i = d ; i > 0 && pt ; i--)
-      pt = pt->next;
-    d = i ? i : 1;
-  } else if(d < 0) {
-    int i;
-    pt = iter->tree;
-    for(i = d ; i < 0 && pt ; i++)
-      pt = pt->prev;
-    d = i ? i : -1;
-  } else
-    pt = iter->tree;
-
-  if(pt == NULL) { // No next
-    // Must we loop?
-    if (iter->mode == PLAY_TREE_ITER_RND) {
-      if (iter->root->loop == 0)
-        return PLAY_TREE_ITER_END;
-      play_tree_unset_flag(iter->root, PLAY_TREE_RND_PLAYED, -1);
-      if (iter->root->loop > 0) iter->root->loop--;
-      // try again
-      return play_tree_iter_step(iter, 0, with_nodes);
-    } else
-    if(iter->tree->parent && iter->tree->parent->loop != 0 && ((d > 0 && iter->loop != 0) || ( d < 0 && (iter->loop < 0 || iter->loop < iter->tree->parent->loop) ) ) ) {
-      if(d > 0) { // Go back to the first one
-	for(pt = iter->tree ; pt->prev != NULL; pt = pt->prev)
-	  /* NOTHNG */;
-	if(iter->loop > 0) iter->loop--;
-      } else if( d < 0 ) { // Or the last one
-	for(pt = iter->tree ; pt->next != NULL; pt = pt->next)
-	  /* NOTHNG */;
-	if(iter->loop >= 0 && iter->loop < iter->tree->parent->loop) iter->loop++;
-      }
-      iter->tree = pt;
-      return play_tree_iter_step(iter,0,with_nodes);
-    }
-    // Go up one level
-    return play_tree_iter_up_step(iter,d,with_nodes);
-
-  }
-
-  // Is there any valid child?
-  if(pt->child && play_tree_is_valid(pt->child)) {
-    iter->tree = pt;
-    if(with_nodes) { // Stop on the node
-      return PLAY_TREE_ITER_NODE;
-    } else      // Or follow it
-      return play_tree_iter_down_step(iter,d,with_nodes);
-  }
-
-  // Is it a valid entry?
-  if(! play_tree_is_valid(pt)) {
-    if(d == 0) { // Can this happen ? FF: Yes!
-      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"What to do now ???? Infinite loop if we continue\n");
-      return PLAY_TREE_ITER_ERROR;
-    } // Not a valid entry : go to next one
-    return play_tree_iter_step(iter,d,with_nodes);
-  }
-
-  assert(pt->files != NULL);
-
-  iter->tree = pt;
-
-  for(d = 0 ; iter->tree->files[d] != NULL ; d++)
-    /* NOTHING */;
-  iter->num_files = d;
-
-  if(iter->config) {
-    play_tree_iter_push_params(iter);
-    iter->entry_pushed = 1;
-    if(iter->mode == PLAY_TREE_ITER_RND)
-      pt->flags |= PLAY_TREE_RND_PLAYED;
-  }
-
-  return PLAY_TREE_ITER_ENTRY;
-
-}
-
-static int
-play_tree_is_valid(play_tree_t* pt) {
-  play_tree_t* iter;
-
-  if(pt->entry_type != PLAY_TREE_ENTRY_NODE) {
-    assert(pt->child == NULL);
-    return 1;
-  }
-  else if (pt->child != NULL) {
-    for(iter = pt->child ; iter != NULL ; iter = iter->next) {
-      if(play_tree_is_valid(iter))
-	return 1;
-    }
-  }
-  return 0;
-}
-
-int
-play_tree_iter_up_step(play_tree_iter_t* iter, int d,int with_nodes) {
-
-  assert(iter != NULL);
-  assert(iter->tree != NULL);
-
-  iter->file = -1;
-  if(iter->tree->parent == iter->root->parent)
-    return PLAY_TREE_ITER_END;
-
-  assert(iter->tree->parent != NULL);
-  assert(iter->stack_size > 0);
-  assert(iter->status_stack != NULL);
-
-  iter->stack_size--;
-  iter->loop = iter->status_stack[iter->stack_size];
-  if(iter->stack_size > 0)
-    iter->status_stack = realloc(iter->status_stack, iter->stack_size * sizeof(int));
-  else {
-    free(iter->status_stack);
-    iter->status_stack = NULL;
-  }
-  if(iter->stack_size > 0 && iter->status_stack == NULL) {
-    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",iter->stack_size*(int)sizeof(char*));
-    return PLAY_TREE_ITER_ERROR;
-  }
-  iter->tree = iter->tree->parent;
-
-  // Pop subtree params
-  if(iter->config) {
-    m_config_pop(iter->config);
-    if(iter->mode == PLAY_TREE_ITER_RND)
-      iter->tree->flags |= PLAY_TREE_RND_PLAYED;
-  }
-
-  return play_tree_iter_step(iter,d,with_nodes);
-}
-
-int
-play_tree_iter_down_step(play_tree_iter_t* iter, int d,int with_nodes) {
-
-  assert(iter->tree->files == NULL);
-  assert(iter->tree->child != NULL);
-  assert(iter->tree->child->parent == iter->tree);
-
-  iter->file = -1;
-
-  //  Push subtree params
-  if(iter->config)
-    play_tree_iter_push_params(iter);
-
-  iter->stack_size++;
-  iter->status_stack = realloc(iter->status_stack, iter->stack_size * sizeof(int));
-  if(iter->status_stack == NULL) {
-    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",iter->stack_size*(int)sizeof(int));
-    return PLAY_TREE_ITER_ERROR;
-  }
-  iter->status_stack[iter->stack_size-1] = iter->loop;
-  // Set new status
-  iter->loop = iter->tree->loop-1;
-  if(d >= 0)
-    iter->tree = iter->tree->child;
-  else {
-    play_tree_t* pt;
-    for(pt = iter->tree->child ; pt->next != NULL ; pt = pt->next)
-      /*NOTING*/;
-    iter->tree = pt;
-  }
-
-  return play_tree_iter_step(iter,0,with_nodes);
-}
-
-char*
-play_tree_iter_get_file(play_tree_iter_t* iter, int d) {
-  assert(iter != NULL);
-  assert(iter->tree->child == NULL);
-
-  if(iter->tree->files == NULL)
-    return NULL;
-
-  assert(iter->num_files > 0);
-
-  if(iter->file >= iter->num_files-1 || iter->file < -1)
-    return NULL;
-
-  if(d > 0) {
-    if(iter->file >= iter->num_files - 1)
-      iter->file = 0;
-    else
-      iter->file++;
-  } else if(d < 0) {
-    if(iter->file <= 0)
-      iter->file = iter->num_files - 1;
-    else
-      iter->file--;
-  }
-  return iter->tree->files[iter->file];
-}
-
-play_tree_t*
-play_tree_cleanup(play_tree_t* pt) {
-  play_tree_t* iter, *tmp, *first;
-
-  assert(pt != NULL);
-
-  if( ! play_tree_is_valid(pt)) {
-    play_tree_remove(pt,1,1);
-    return NULL;
-  }
-
-  first = pt->child;
-
-  for(iter = pt->child ; iter != NULL ; ) {
-    tmp = iter;
-    iter = iter->next;
-    if(! play_tree_is_valid(tmp)) {
-      play_tree_remove(tmp,1,1);
-      if(tmp == first) first = iter;
-    }
-  }
-
-  for(iter = first ; iter != NULL ; ) {
-    tmp = iter;
-    iter = iter->next;
-    play_tree_cleanup(tmp);
-  }
-
-  return pt;
-
-}
-
-play_tree_iter_t*
-play_tree_iter_new_copy(play_tree_iter_t* old) {
-  play_tree_iter_t* iter;
-
-  assert(old != NULL);
-
-  iter = malloc(sizeof(play_tree_iter_t));
-  if(iter == NULL) {
-    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",(int)sizeof(play_tree_iter_t));
-    return NULL;
-  }
-;
-  memcpy(iter,old,sizeof(play_tree_iter_t));
-  if(old->status_stack) {
-    iter->status_stack = malloc(old->stack_size * sizeof(int));
-    if(iter->status_stack == NULL) {
-      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",old->stack_size * (int)sizeof(int));
-      free(iter);
-      return NULL;
-    }
-    memcpy(iter->status_stack,old->status_stack,iter->stack_size*sizeof(int));
-  }
-  iter->config = NULL;
-
-  return iter;
-}
-
-// HIGH Level API, by Fabian Franz (mplayer@fabian-franz.de)
-//
-play_tree_iter_t* pt_iter_create(play_tree_t** ppt, m_config_t* config)
-{
-  play_tree_iter_t* r=NULL;
-  assert(*ppt!=NULL);
-
-  *ppt=play_tree_cleanup(*ppt);
-
-  if(*ppt) {
-    r = play_tree_iter_new(*ppt,config);
-    if (r && play_tree_iter_step(r,0,0) != PLAY_TREE_ITER_ENTRY)
-    {
-      play_tree_iter_free(r);
-      r = NULL;
-    }
-  }
-
-  return r;
-}
-
-void pt_iter_destroy(play_tree_iter_t** iter)
-{
-  if (iter && *iter)
-  {
-    free(*iter);
-    iter=NULL;
-  }
-}
-
-char* pt_iter_get_file(play_tree_iter_t* iter, int d)
-{
-  int i=0;
-  char* r;
-
-  if (iter==NULL)
-    return NULL;
-
-  r = play_tree_iter_get_file(iter,d);
-
-  while (!r && d!=0)
-  {
-    if (play_tree_iter_step(iter,d,0) != PLAY_TREE_ITER_ENTRY)
-        break;
-    r=play_tree_iter_get_file(iter,d);
-    i++;
-  }
-
-  return r;
-}
-
-void pt_iter_insert_entry(play_tree_iter_t* iter, play_tree_t* entry)
-{
-  play_tree_t *pt = iter->tree;
-  assert(pt!=NULL);
-  assert(entry!=NULL);
-  assert(entry!=pt);
-
-  play_tree_insert_entry(pt, entry);
-  play_tree_set_params_from(entry,pt);
-}
-
-void pt_iter_replace_entry(play_tree_iter_t* iter, play_tree_t* entry)
-{
-  play_tree_t *pt = iter->tree;
-
-  pt_iter_insert_entry(iter, entry);
-  play_tree_remove(pt, 1, 1);
-  iter->tree=entry;
-}
-
-//Add a new file as a new entry
-void pt_add_file(play_tree_t** ppt, const char* filename)
-{
-  play_tree_t *pt = *ppt, *entry = play_tree_new();
-
-  play_tree_add_file(entry, filename);
-  if (pt)
-    play_tree_append_entry(pt, entry);
-  else
-  {
-    pt=entry;
-    *ppt=pt;
-  }
-  play_tree_set_params_from(entry,pt);
-}
-
-void pt_iter_goto_head(play_tree_iter_t* iter)
-{
-  iter->tree=iter->root;
-  play_tree_iter_step(iter, 0, 0);
-}