mplayerxp-cvslog Mailing List for MplayerXP-mplayer with extra performance (Page 3)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 608
          http://mplayerxp.svn.sourceforge.net/mplayerxp/?rev=608&view=rev
Author:   nickols_k
Date:     2012-12-27 16:37:25 +0000 (Thu, 27 Dec 2012)
Log Message:
-----------
convert struct play_tree_t into class PlayTree

Modified Paths:
--------------
    TODO
    mplayerxp/libmpconf/cfgparser.cpp
    mplayerxp/libmpconf/cfgparser.h
    mplayerxp/libplaytree/asxparser.cpp
    mplayerxp/libplaytree/asxparser.h
    mplayerxp/libplaytree/playtree.cpp
    mplayerxp/libplaytree/playtree.h
    mplayerxp/libplaytree/playtreeparser.cpp
    mplayerxp/libplaytree/playtreeparser.h
    mplayerxp/mplayerxp.cpp
    mplayerxp/postproc/libmenu/menu_pt.cpp

Modified: TODO
===================================================================

--- TODO	2012-12-27 14:05:33 UTC (rev 607)
+++ TODO	2012-12-27 16:37:25 UTC (rev 608)
@@ -1,5 +1,6 @@
 TODO for mplayerxp:
 
+- remove m_config_t from libplaytree: implement config independed container
 - Implement libmpdemux3:
     class Demuxer_Driver {
 	Demuxer_Driver(Demuxer& parent);

Modified: mplayerxp/libmpconf/cfgparser.cpp
===================================================================
--- mplayerxp/libmpconf/cfgparser.cpp	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libmpconf/cfgparser.cpp	2012-12-27 16:37:25 UTC (rev 608)
@@ -193,7 +193,7 @@
   return ret;
 }
 
-m_config_t& m_config_new(play_tree_t* pt,libinput_t&libinput) {
+m_config_t& m_config_new(PlayTree* pt,libinput_t&libinput) {
   m_config_t& config = *new(zeromem) m_config_t(libinput);
   config.config_stack = (config_save_t**)mp_calloc(1,sizeof(config_save_t*));
   SET_GLOBAL(config); // We always start with global options
@@ -228,13 +228,13 @@
 }
 
 static int config_is_entry_option(m_config_t& config,const std::string& opt,const std::string& param) {
-    play_tree_t* entry = NULL;
+    PlayTree* entry = NULL;
 
     std::string lopt=opt;
     std::transform(lopt.begin(),lopt.end(),lopt.begin(), ::tolower);
     if(lopt=="playlist") { // We handle playlist here
 	if(param.empty()) return ERR_MISSING_PARAM;
-	entry = parse_playlist_file(config.libinput,param);
+	entry = PlayTree::parse_playlist_file(config.libinput,param);
 	if(!entry) {
 	    mpxp_err<<"Playlist parsing failed: "<<param<<std::endl;
 	    return 1;
@@ -242,8 +242,8 @@
     }
 
     if(entry) {
-	if(config.last_entry)	play_tree_append_entry(config.last_entry,entry);
-	else			play_tree_set_child(config.pt,entry);
+	if(config.last_entry)	config.last_entry->append_entry(entry);
+	else			config.pt->set_child(entry);
 	config.last_entry = entry;
 	if(config.parser_mode == COMMAND_LINE) UNSET_GLOBAL(config);
 	return 1;
@@ -449,15 +449,15 @@
 	}
 out:
 	if(ret >= 0 && ! IS_RUNNING(config) && ! IS_GLOBAL(config) && ! (conf[i].flags & CONF_GLOBAL) && conf[i].type != CONF_TYPE_SUBCONFIG ) {
-	  play_tree_t* dest = config.last_entry ? config.last_entry : config.last_parent;
+	  PlayTree* dest = config.last_entry ? config.last_entry : config.last_parent;
 	  std::string o;
 	  if(config.sub_conf)	o=std::string(config.sub_conf)+":"+opt;
 	  else			o=opt;
 
 	  if(ret == 0)
-	    play_tree_set_param(dest,o,"");
+	    dest->set_param(o,"");
 	  else if(ret > 0)
-	    play_tree_set_param(dest,o,param);
+	    dest->set_param(o,param);
 	  m_config_pop(config);
 	}
 	return ret;
@@ -728,12 +728,12 @@
 	    continue;
 	}
 	if(opt[0] == '{' && opt[1] == '\0') {
-	    play_tree_t* entry = play_tree_new();
+	    PlayTree* entry = new(zeromem) PlayTree;
 	    UNSET_GLOBAL(config);
 	    if(config.last_entry == NULL) {
-		play_tree_set_child(config.last_parent,entry);
+		config.last_parent->set_child(entry);
 	    } else {
-		play_tree_append_entry(config.last_entry,entry);
+		config.last_entry->append_entry(entry);
 		config.last_entry = NULL;
 	    }
 	    config.last_parent = entry;
@@ -741,12 +741,12 @@
 	}
 
 	if(opt[0] == '}' && opt[1] == '\0') {
-	    if( ! config.last_parent || ! config.last_parent->parent) {
+	    if( ! config.last_parent || ! config.last_parent->get_parent()) {
 		mpxp_err<<"too much }-"<<std::endl;
 		goto err_out;
 	    }
 	    config.last_entry = config.last_parent;
-	    config.last_parent = config.last_entry->parent;
+	    config.last_parent = config.last_entry->get_parent();
 	    continue;
 	}
 
@@ -788,14 +788,14 @@
 		    break;
 	    }
 	} else /* filename */ {
-	    play_tree_t* entry = play_tree_new();
+	    PlayTree* entry = new(zeromem) PlayTree;
 	    mpxp_dbg2<<"Adding file "<<argv[i]<<std::endl;
-	    play_tree_add_file(entry,argv[i]);
+	    entry->add_file(argv[i]);
 	    if(argv[i]=="-") m_config_set_option(config,"use-stdin",NULL);
 	    /* opt is not an option -> treat it as a filename */
 	    UNSET_GLOBAL(config); // We start entry specific options
-	    if(config.last_entry == NULL) play_tree_set_child(config.last_parent,entry);
-	    else play_tree_append_entry(config.last_entry,entry);
+	    if(config.last_entry == NULL) config.last_parent->set_child(entry);
+	    else config.last_entry->append_entry(entry);
 	    config.last_entry = entry;
 	}
     }

Modified: mplayerxp/libmpconf/cfgparser.h
===================================================================
--- mplayerxp/libmpconf/cfgparser.h	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libmpconf/cfgparser.h	2012-12-27 16:37:25 UTC (rev 608)
@@ -10,8 +10,8 @@
 
 namespace mpxp {
     struct libinput_t;
+    struct PlayTree;
 }
-struct play_tree_t;
 /* config types */
 enum {
     CONF_TYPE_FLAG	=0,
@@ -64,9 +64,9 @@
     int parser_mode;  /* COMMAND_LINE or CONFIG_FILE */
     int flags;
     const char* sub_conf; // When we save a subconfig
-    play_tree_t* pt; // play tree we use for playlist option, etc
-    play_tree_t* last_entry; // last added entry
-    play_tree_t* last_parent; // if last_entry is NULL we must create child of this
+    PlayTree* pt; // play tree we use for playlist option, etc
+    PlayTree* last_entry; // last added entry
+    PlayTree* last_parent; // if last_entry is NULL we must create child of this
     int recursion_depth;
     libinput_t&	libinput;
 };
@@ -96,7 +96,7 @@
     MPXP_Rc mpxp_parse_command_line(m_config_t& config, const std::vector<std::string>& argv,const std::map<std::string,std::string>& envm);
 }
 
-m_config_t& m_config_new(play_tree_t* pt,libinput_t&libinput);
+m_config_t& m_config_new(PlayTree* pt,libinput_t&libinput);
 
 void m_config_free(m_config_t* config);
 

Modified: mplayerxp/libplaytree/asxparser.cpp
===================================================================
--- mplayerxp/libplaytree/asxparser.cpp	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/asxparser.cpp	2012-12-27 16:37:25 UTC (rev 608)
@@ -295,7 +295,7 @@
     return 1;
 }
 
-void ASX_Parser::param(ASX_Attrib& cattribs, play_tree_t* pt) const {
+void ASX_Parser::param(ASX_Attrib& cattribs, PlayTree* pt) const {
     std::string name,val;
 
     name = cattribs.get("NAME");
@@ -310,10 +310,10 @@
 	else		mpxp_warn<<std::endl;
 	return;
     }
-    play_tree_set_param(pt,name,val);
+    pt->set_param(name,val);
 }
 
-void ASX_Parser::ref(ASX_Attrib& cattribs, play_tree_t* pt) const {
+void ASX_Parser::ref(ASX_Attrib& cattribs, PlayTree* pt) const {
     std::string href;
 
     href = cattribs.get("HREF");
@@ -325,12 +325,12 @@
     if (href.substr(0,7)=="http://") {
 	href = "mms"+href;
     }
-    play_tree_add_file(pt,href);
+    pt->add_file(href);
     mpxp_v<<"Adding file "<<href<<" to element entry"<<std::endl;
 }
 
-play_tree_t* ASX_Parser::entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const {
-    play_tree_t* pt;
+PlayTree* ASX_Parser::entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const {
+    PlayTree* pt;
     std::string href;
     Stream* stream;
     play_tree_parser_t* ptp;
@@ -363,13 +363,13 @@
     return pt;
 }
 
-play_tree_t* ASX_Parser::entry(const char* buffer,ASX_Attrib& _attribs) {
+PlayTree* ASX_Parser::entry(const char* buffer,ASX_Attrib& _attribs) {
     ASX_Element element;
     int r,nref=0;
-    play_tree_t *pt_ref;
+    PlayTree *pt_ref;
     UNUSED(_attribs);
 
-    pt_ref = play_tree_new();
+    pt_ref = new(zeromem) PlayTree;
 
     while(buffer && buffer[0] != '\0') {
 	r = get_element(&buffer,element);
@@ -386,28 +386,29 @@
 	} else mpxp_dbg2<<"Ignoring element "<<element.name()<<std::endl;
     }
     if(nref <= 0) {
-	play_tree_free(pt_ref,1);
+	pt_ref->free(1);
+	delete pt_ref;
 	return NULL;
     }
     return pt_ref;
 }
 
-play_tree_t* ASX_Parser::repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs) {
+PlayTree* ASX_Parser::repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs) {
     ASX_Element element;
-    play_tree_t *pt_repeat, *list=NULL, *pt_entry;
+    PlayTree *pt_repeat, *list=NULL, *pt_entry;
     std::string count;
     int r;
 
-    pt_repeat = play_tree_new();
+    pt_repeat = new(zeromem) PlayTree;
 
     count = _attribs.get("COUNT");
     if(count.empty()) {
 	mpxp_dbg2<<"Setting element repeat loop to infinit"<<std::endl;
-	pt_repeat->loop = -1; // Infinit
+	pt_repeat->set_loop(-1); // Infinit
     } else {
-	pt_repeat->loop = ::atoi(count.c_str());
-	if(pt_repeat->loop == 0) pt_repeat->loop = 1;
-	mpxp_dbg2<<"Setting element repeat loop to "<<pt_repeat->loop<<std::endl;
+	pt_repeat->set_loop(::atoi(count.c_str()));
+	if(pt_repeat->get_loop() == 0) pt_repeat->set_loop(1);
+	mpxp_dbg2<<"Setting element repeat loop to "<<pt_repeat->get_loop()<<std::endl;
     }
 
     while(buffer && buffer[0] != '\0') {
@@ -422,21 +423,21 @@
 	    pt_entry = entry(element.body().c_str(),element.attribs());
 	    if(pt_entry) {
 		if(!list) list = pt_entry;
-		else play_tree_append_entry(list,pt_entry);
+		else list->append_entry(pt_entry);
 		mpxp_dbg2<<"Adding element "<<element.name()<<" to repeat"<<std::endl;
 	    }
 	} else if(uname=="ENTRYREF") {
 	    pt_entry = entryref(libinput,element.body().c_str(),element.attribs());
 	    if(pt_entry) {
 		if(!list) list = pt_entry;
-		else play_tree_append_entry(list,pt_entry);
+		else list->append_entry(pt_entry);
 		mpxp_dbg2<<"Adding element "<<element.name()<<" to repeat"<<std::endl;
 	    }
 	} else if(uname=="REPEAT") {
 	    pt_entry = repeat(libinput,element.body().c_str(),element.attribs());
 	    if(pt_entry) {
 		if(!list) list = pt_entry;
-		else play_tree_append_entry(list,pt_entry);
+		else list->append_entry(pt_entry);
 		mpxp_dbg2<<"Adding element "<<element.name()<<" to repeat"<<std::endl;
 	    }
 	} else if(uname=="PARAM") {
@@ -445,17 +446,18 @@
     }
 
     if(!list) {
-	play_tree_free(pt_repeat,1);
+	pt_repeat->free(1);
+	delete pt_repeat;
 	return NULL;
     }
-    play_tree_set_child(pt_repeat,list);
+    pt_repeat->set_child(list);
     return pt_repeat;
 }
 
-play_tree_t* ASX_Parser::build_tree(libinput_t&libinput,const char* buffer,int deep) {
+PlayTree* ASX_Parser::build_tree(libinput_t&libinput,const char* buffer,int deep) {
     ASX_Element asx_element,element;
     int r;
-    play_tree_t *asx,*pt_entry,*list = NULL;
+    PlayTree *asx,*pt_entry,*list = NULL;
     ASX_Parser& parser = *new(zeromem) ASX_Parser;
 
     parser.line = 1;
@@ -486,7 +488,7 @@
 	return NULL;
     }
 
-    asx = play_tree_new();
+    asx = new(zeromem) PlayTree;
     buffer = asx_element.body().c_str();
     while(buffer && buffer[0] != '\0') {
 	r = parser.get_element(&buffer,element);
@@ -501,21 +503,21 @@
 	    pt_entry = parser.entry(element.body().c_str(),element.attribs());
 	    if(pt_entry) {
 		if(!list) list = pt_entry;
-		else play_tree_append_entry(list,pt_entry);
+		else list->append_entry(pt_entry);
 		mpxp_dbg2<<"Adding element "<<element.name()<<" to asx"<<std::endl;
 	    }
 	} else if(uname=="ENTRYREF") {
 	    pt_entry = parser.entryref(libinput,element.body().c_str(),element.attribs());
 	    if(pt_entry) {
 		if(!list) list = pt_entry;
-		else play_tree_append_entry(list,pt_entry);
+		else list->append_entry(pt_entry);
 		mpxp_dbg2<<"Adding element "<<element.name()<<" to asx"<<std::endl;
 	    }
 	} else if(uname=="REPEAT") {
 	    pt_entry = parser.repeat(libinput,element.body().c_str(),element.attribs());
 	    if(pt_entry) {
 		if(!list) list = pt_entry;
-		else play_tree_append_entry(list,pt_entry);
+		else list->append_entry(pt_entry);
 		mpxp_dbg2<<"Adding element "<<element.name()<<" to asx"<<std::endl;
 	    }
 	} else mpxp_dbg2<<"Ignoring element "<<element.name()<<std::endl;
@@ -524,10 +526,11 @@
     delete &parser;
 
     if(!list) {
-	play_tree_free(asx,1);
+	asx->free(1);
+	delete asx;
 	return NULL;
     }
-    play_tree_set_child(asx,list);
+    asx->set_child(list);
     return asx;
 }
 } // namespace mpxp

Modified: mplayerxp/libplaytree/asxparser.h
===================================================================
--- mplayerxp/libplaytree/asxparser.h	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/asxparser.h	2012-12-27 16:37:25 UTC (rev 608)
@@ -51,7 +51,7 @@
 	    ASX_Parser();
 	    virtual ~ASX_Parser();
 
-	    static play_tree_t*	build_tree(libinput_t& libinput,const char* buffer, int ref);
+	    static PlayTree*	build_tree(libinput_t& libinput,const char* buffer, int ref);
 
 	    virtual int		parse_attribs(const char* buffer,ASX_Attrib& _attribs) const;
 	    /*
@@ -60,13 +60,13 @@
 	    virtual int		get_element(const char** _buffer,ASX_Element& _attribs);
 	    int			get_line() const { return line; }
 	private:
-	    play_tree_t*	repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs);
+	    PlayTree*		repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs);
 	    void		warning_attrib_required(const char *elem, const char *attr) const;
 	    void		warning_body_parse_error(const char *elem) const;
-	    void		param(ASX_Attrib& attribs, play_tree_t* pt) const;
-	    void		ref(ASX_Attrib& attribs, play_tree_t* pt) const;
-	    play_tree_t*	entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const;
-	    play_tree_t*	entry(const char* buffer,ASX_Attrib& _attribs);
+	    void		param(ASX_Attrib& attribs, PlayTree* pt) const;
+	    void		ref(ASX_Attrib& attribs, PlayTree* pt) const;
+	    PlayTree*		entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const;
+	    PlayTree*		entry(const char* buffer,ASX_Attrib& _attribs);
 
 	    int			line; // Curent line
 	    ASX_LineSave_t*	ret_stack;

Modified: mplayerxp/libplaytree/playtree.cpp
===================================================================
--- mplayerxp/libplaytree/playtree.cpp	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtree.cpp	2012-12-27 16:37:25 UTC (rev 608)
@@ -13,168 +13,133 @@
 #include "playtree.h"
 #include "playtree_msg.h"
 
-static int
-play_tree_is_valid(play_tree_t* pt);
+namespace mpxp {
 
-play_tree_t*
-play_tree_new(void) {
-  play_tree_t* r = (play_tree_t*)mp_calloc(1,sizeof(play_tree_t));
-  if(r == NULL)
-    mpxp_err<<"Can't allocate memory"<<std::endl;
-  r->entry_type = PLAY_TREE_ENTRY_NODE;
-  return r;
-}
+PlayTree::PlayTree()
+	:entry_type(PLAY_TREE_ENTRY_NODE) {}
+PlayTree::~PlayTree() {}
 
-void
-play_tree_free(play_tree_t* pt, int childs) {
-  play_tree_t* iter;
+void PlayTree::free(int childs) {
+    PlayTree* iter;
 
-  if(childs) {
-    for(iter = pt->child; iter != NULL; ) {
-      play_tree_t* nxt=iter->next;
-      play_tree_free(iter,1);
-      iter = nxt;
+    if(childs) {
+	for(iter = child; iter != NULL; ) {
+	    PlayTree* nxt=iter->next;
+	    iter->free(1);
+	    delete iter;
+	    iter = nxt;
+	}
+	child = NULL;
     }
-    pt->child = NULL;
-  }
+    remove(0,0);
+    for(iter = child ; iter != NULL ; iter = iter->next) iter->parent = NULL;
+}
 
-  play_tree_remove(pt,0,0);
+void PlayTree::free_list(int childs) {
+    PlayTree* iter;
 
-  for(iter = pt->child ; iter != NULL ; iter = iter->next)
-    iter->parent = NULL;
-
-  delete pt;
+    for(iter = this ; iter->prev != NULL ; iter = iter->prev) /* NOTHING */;
+    while(iter) {
+	PlayTree* nxt = iter->next;
+	iter->free(childs);
+	delete iter;
+	iter = nxt;
+    }
 }
 
-void
-play_tree_free_list(play_tree_t* pt, int childs) {
-  play_tree_t* iter;
+MPXP_Rc PlayTree::is_valid() const {
+    PlayTree* iter;
 
-  for(iter = pt ; iter->prev != NULL ; iter = iter->prev)
-    /* NOTHING */;
-
-  while(iter) {
-    play_tree_t* nxt = iter->next;
-    play_tree_free(iter, childs);
-    iter = nxt;
-  }
-
+    if(entry_type != PLAY_TREE_ENTRY_NODE) return MPXP_Ok;
+    else if (child != NULL) {
+	for(iter = child ; iter != NULL ; iter = iter->next) {
+	    if(iter->is_valid()) return MPXP_Ok;
+	}
+    }
+    return MPXP_False;
 }
 
-void
-play_tree_append_entry(play_tree_t* pt, play_tree_t* entry) {
-  play_tree_t* iter;
+void PlayTree::append_entry(PlayTree* entry) {
+    PlayTree* iter;
 
-  if(pt == entry)
-    return;
+    if(this == entry) return;
 
-  for(iter = pt ; iter->next != NULL ; iter = iter->next)
-    /* NOTHING */;
+    for(iter = this; iter->next != NULL ; iter = iter->next) /* NOTHING */;
 
-  entry->parent = iter->parent;
-  entry->prev = iter;
-  entry->next = NULL;
-  iter->next = entry;
+    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;
+void PlayTree::prepend_entry(PlayTree* entry) {
+    PlayTree* iter;
 
-  for(iter = pt ; iter->prev != NULL; iter = iter->prev)
-    /* NOTHING */;
+    for(iter = this ; iter->prev != NULL; iter = iter->prev) /* NOTHING */;
 
-  entry->prev = NULL;
-  entry->next = iter;
-  entry->parent = iter->parent;
+    entry->prev = NULL;
+    entry->next = iter;
+    entry->parent = iter->parent;
 
-  iter->prev = entry;
-  if(entry->parent) {
-    entry->parent->child = entry;
-  }
+    iter->prev = entry;
+    if(entry->parent) entry->parent->child = entry;
 }
 
-void
-play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry) {
-
-  entry->parent = pt->parent;
-  entry->prev = pt;
-  if(pt->next) {
-    entry->next = pt->next;
-    entry->next->prev = entry;
-  } else
-    entry->next = NULL;
-  pt->next = entry;
-
+void PlayTree::insert_entry(PlayTree* entry) {
+    entry->parent = parent;
+    entry->prev = this;
+    if(next) {
+	entry->next = next;
+	entry->next->prev = entry;
+    } else  entry->next = NULL;
+    next = entry;
 }
 
-void
-play_tree_remove(play_tree_t* pt, int free_it,int with_childs) {
-
-  // Middle of list
-  if(pt->prev && pt->next) {
-    pt->prev->next = pt->next;
-    pt->next->prev = pt->prev;
-  } // End of list
-  else if(pt->prev) {
-    pt->prev->next = NULL;
-  } // Begining of list
-  else if(pt->next) {
-    pt->next->prev = NULL;
-    if(pt->parent) {
-      pt->parent->child = pt->next;
+void PlayTree::remove(int free_it,int with_childs) {
+    // Middle of list
+    if(prev && next) {
+	prev->next = next;
+	next->prev = prev;
+    } // End of list
+    else if(prev) {
+	prev->next = NULL;
+    } // Begining of list
+    else if(next) {
+	next->prev = NULL;
+	if(parent) parent->child = next;
+    } // The only one
+    else if(parent) {
+	parent->child = NULL;
     }
-  } // The only one
-  else if(pt->parent) {
-    pt->parent->child = NULL;
-  }
-
-  pt->prev = pt->next = pt->parent = NULL;
-  if(free_it)
-    play_tree_free(pt,with_childs);
-
+    prev = next = parent = NULL;
+    if(free_it) free(with_childs);
 }
 
-void
-play_tree_set_child(play_tree_t* pt, play_tree_t* child) {
-  play_tree_t* iter;
+void PlayTree::set_child(PlayTree* _child) {
+    PlayTree* iter;
 
-  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;
-
+    for(iter = _child ; iter != NULL ; iter = iter->next) iter->parent = NULL;
+    // Go back to first one
+    for(iter = _child ; iter->prev != NULL ; iter = iter->prev) /* NOTHING */;
+    child = iter;
+    for( ; iter != NULL ; iter= iter->next)  iter->parent = this;
 }
 
-void
-play_tree_set_parent(play_tree_t* pt, play_tree_t* parent) {
-  play_tree_t* iter;
+void PlayTree::set_parent(PlayTree* _parent) {
+    PlayTree* iter;
 
-  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;
+    if(_parent) _parent->child = NULL;
+    for(iter = this ; iter != NULL ; iter = iter->next) iter->parent = _parent;
+    if(prev) {
+	for(iter = prev ; iter->prev != NULL ; iter = iter->prev) iter->parent = _parent;
+	iter->parent=_parent;
+	_parent->child=iter;
+    } else _parent->child = this;
 }
 
-void play_tree_add_file(play_tree_t* pt,const std::string& file) {
-    if(pt->entry_type != PLAY_TREE_ENTRY_NODE &&
-	pt->entry_type != PLAY_TREE_ENTRY_FILE)
+void PlayTree::add_file(const std::string& file) {
+    if(entry_type != PLAY_TREE_ENTRY_NODE &&
+	entry_type != PLAY_TREE_ENTRY_FILE)
 	return;
 
     size_t pos;
@@ -182,131 +147,156 @@
     std::transform(lf.begin(),lf.end(),lf.begin(), ::tolower);
 
     if(lf.substr(0,6)=="vcd://") {
-	pt->entry_type = PLAY_TREE_ENTRY_VCD;
+	entry_type = PLAY_TREE_ENTRY_VCD;
 	pos=6;
     } else if(lf.substr(0,6)=="dvd://") {
-	pt->entry_type = PLAY_TREE_ENTRY_DVD;
+	entry_type = PLAY_TREE_ENTRY_DVD;
 	pos=6;
     } else if(lf.substr(0,5)=="tv://") {
-	pt->entry_type = PLAY_TREE_ENTRY_TV;
+	entry_type = PLAY_TREE_ENTRY_TV;
 	pos=5;
     } else {
-	pt->entry_type = PLAY_TREE_ENTRY_FILE;
+	entry_type = PLAY_TREE_ENTRY_FILE;
 	pos=0;
     }
     tail=file.substr(pos);
-    pt->files.push_back(tail);
+    files.push_back(tail);
 }
 
-MPXP_Rc play_tree_remove_file(play_tree_t* pt,const std::string& file) {
+MPXP_Rc PlayTree::remove_file(const std::string& file) {
     int f = -1;
-    size_t n,sz=pt->files.size();
+    size_t n,sz=files.size();
 
-    for(n=0; n<sz; n++) if(file==pt->files[n]) f = n;
+    for(n=0; n<sz; n++) if(file==files[n]) f = n;
 
     if(f < 0) return MPXP_False; // Not found
 
-    pt->files.erase(pt->files.begin()+f);
+    files.erase(files.begin()+f);
 
     return MPXP_Ok;
 }
 
-void play_tree_set_param(play_tree_t* pt,const std::string& name,const std::string& val) {
+void PlayTree::set_param(const std::string& name,const std::string& val) {
     int ni = -1;
-    size_t n,sz=pt->params.size();
+    size_t n,sz=params.size();
 
     std::string lname=name;
     std::transform(lname.begin(),lname.end(),lname.begin(), ::tolower);
-    if(!pt->params.empty()) {
+    if(!params.empty()) {
 	for(n=0; n<sz; n++) {
-	    std::string lparm=pt->params[n].name;
+	    std::string lparm=params[n].name;
 	    std::transform(lparm.begin(),lparm.end(),lparm.begin(), ::tolower);
 	    if(lname==lparm) ni = n;
 	}
     }
 
     if(ni > 0) {
-	pt->params[ni].value = val;
+	params[ni].value = val;
 	return;
     }
 
     play_tree_param_t param;
     param.name=name;
     param.value=val;
-    pt->params.push_back(param);
+    params.push_back(param);
 }
 
-MPXP_Rc play_tree_unset_param(play_tree_t* pt,const std::string& name) {
+MPXP_Rc PlayTree::unset_param(const std::string& name) {
     int ni = -1;
-    size_t n,sz=pt->params.size();
+    size_t n,sz=params.size();
 
     std::string lname=name;
     std::transform(lname.begin(),lname.end(),lname.begin(), ::tolower);
     for(n=0;n<sz;n++) {
-	std::string lparm=pt->params[n].name;
+	std::string lparm=params[n].name;
 	std::transform(lparm.begin(),lparm.end(),lparm.begin(), ::tolower);
 	if(lname==lparm) ni = n;
     }
 
     if(ni < 0) return MPXP_False;
 
-    if(n > 1)	pt->params.erase(pt->params.begin()+ni);
-    else	pt->params.clear();
+    if(n > 1)	params.erase(params.begin()+ni);
+    else	params.clear();
 
     return MPXP_Ok;
 }
 
-void play_tree_set_params_from(play_tree_t* dest,const play_tree_t* src) {
-    size_t i,sz=src->params.size();
+void PlayTree::set_params_from(const PlayTree& src) {
+    size_t i,sz=src.params.size();
 
-    if(src->params.empty()) return;
+    if(src.params.empty()) return;
 
     for(i=0;i<sz; i++)
-	play_tree_set_param(dest,src->params[i].name,src->params[i].value);
-    if(src->flags & PLAY_TREE_RND) // pass the random flag too
-	dest->flags |= PLAY_TREE_RND;
+	set_param(src.params[i].name,src.params[i].value);
+    if(src.flags & PLAY_TREE_RND) // pass the random flag too
+	flags |= PLAY_TREE_RND;
 }
 
 // all children if deep < 0
-void play_tree_set_flag(play_tree_t* pt, int flags , int deep) {
-  play_tree_t*  i;
+void PlayTree::set_flag(int _flags, int deep) {
+    PlayTree* i;
 
-  pt->flags |= flags;
+    flags |= _flags;
 
-  if(deep && pt->child) {
-    if(deep > 0) deep--;
-    for(i = pt->child ; i ; i = i->next)
-      play_tree_set_flag(i,flags,deep);
-  }
+    if(deep && child) {
+	if(deep > 0) deep--;
+	for(i = child ; i ; i = i->get_next()) i->set_flag(_flags,deep);
+    }
 }
 
-void play_tree_unset_flag(play_tree_t* pt, int flags , int deep) {
-  play_tree_t*  i;
+void PlayTree::unset_flag(int _flags, int deep) {
+    PlayTree* i;
 
-  pt->flags &= ~flags;
+    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);
-  }
+    if(deep && child) {
+	if(deep > 0) deep--;
+	for(i = child ; i ; i = i->get_next()) i->unset_flag(_flags,deep);
+    }
 }
 
-static play_tree_t*
-play_tree_rnd_step(play_tree_t* pt) {
+MPXP_Rc PlayTree::cleanup() {
+    PlayTree* iter, *tmp, *first;
+
+    if( ! is_valid()) {
+	remove(1,1);
+	return MPXP_False;
+    }
+
+    first = child;
+
+    for(iter = child ; iter != NULL ; ) {
+	tmp = iter;
+	iter = iter->next;
+	if(! tmp->is_valid()) {
+	    tmp->remove(1,1);
+	    if(tmp == first) first = iter;
+	}
+    }
+
+    for(iter = first ; iter != NULL ; ) {
+	tmp = iter;
+	iter = iter->next;
+	tmp->cleanup();
+    }
+    return MPXP_Ok;
+}
+
+static PlayTree*
+play_tree_rnd_step(PlayTree* pt) {
   int count = 0;
   int r,rnd;
   time_t tim;
-  play_tree_t *i,*head;
+  PlayTree *i,*head;
 
   // Count how many mp_free choice we have
-  for(i = pt ; i->prev ; i = i->prev)
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
+  for(i = pt ; i->get_prev() ; i = i->get_prev())
+    if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) count++;
   head = i;
-  if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
-  if(pt->next)
-  for(i = pt->next ; i ; i = i->next)
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
+  if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) count++;
+  if(pt->get_next())
+  for(i = pt->get_next() ; i ; i = i->get_next())
+    if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) count++;
 
   if(!count) return NULL;
   /* make it time depended */
@@ -316,24 +306,23 @@
   r = (int)(((float)(count) * rnd) / (RAND_MAX + 1.0));
   if(r) rnd = r = count - (tim%r);
 
-  for(i = head ; i  ; i=i->next) {
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) r--;
+  for(i = head ; i  ; i=i->get_next()) {
+    if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) r--;
     if(r < 0) return i;
   }
-  for(i = head ; i  ; i=i->next) {
-    if(!(i->flags & PLAY_TREE_RND_PLAYED)) return i;
+  for(i = head ; i ; i=i->get_next()) {
+    if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) return i;
   }
 
   mpxp_err<<"Random stepping error r="<<rnd<<std::endl;
   return NULL;
 }
 
-namespace mpxp {
-_PlayTree_Iter::_PlayTree_Iter(play_tree_t* pt,m_config_t& _config)
+_PlayTree_Iter::_PlayTree_Iter(PlayTree* pt,m_config_t& _config)
 		:root(pt),
 		tree(NULL),
 		config(_config) {
-    if(pt->parent) loop = pt->parent->loop;
+    if(pt->get_parent()) loop = pt->get_parent()->get_loop();
 }
 
 _PlayTree_Iter::_PlayTree_Iter(const _PlayTree_Iter& old)
@@ -348,7 +337,7 @@
 _PlayTree_Iter::~_PlayTree_Iter() {}
 
 void _PlayTree_Iter::push_params() {
-    play_tree_t* pt;
+    PlayTree* pt;
 
     pt = tree;
 
@@ -356,21 +345,21 @@
     // while playing
     m_config_push(config);
 
-    if(pt->params.empty()) return;
-    size_t n,sz=pt->params.size();
+    if(pt->get_params().empty()) return;
+    size_t n,sz=pt->get_params().size();
 
     for(n=0; n<sz; n++) {
 	int e;
-	if((e = m_config_set_option(config,pt->params[n].name,pt->params[n].value)) < 0)
-	    mpxp_err<<"Error "<<e<<" while setting option '"<<pt->params[n].name<<"' with value '"<<pt->params[n].value<<"'"<<std::endl;
+	if((e = m_config_set_option(config,pt->get_param(n).name,pt->get_param(n).value)) < 0)
+	    mpxp_err<<"Error "<<e<<" while setting option '"<<pt->get_param(n).name<<"' with value '"<<pt->get_param(n).value<<"'"<<std::endl;
     }
 
-    if(!pt->child) entry_pushed = 1;
+    if(!pt->get_child()) entry_pushed = 1;
     return;
 }
 
 int _PlayTree_Iter::step(int d,int with_nodes) {
-    play_tree_t* pt;
+    PlayTree* pt;
     int rnd;
 
     if(tree == NULL) {
@@ -383,7 +372,7 @@
 	m_config_pop(config);
     }
 
-    if(tree->parent && (tree->parent->flags & PLAY_TREE_RND))
+    if(tree->get_parent() && (tree->get_parent()->get_flags() & PLAY_TREE_RND))
 	rnd=mode = PLAY_TREE_ITER_RND;
     else
 	rnd=mode = PLAY_TREE_ITER_NORMAL;
@@ -393,30 +382,30 @@
     else if( d > 0 ) {
 	int i;
 	pt = tree;
-	for(i = d ; i > 0 && pt ; i--) pt = pt->next;
+	for(i = d ; i > 0 && pt ; i--) pt = pt->get_next();
 	d = i ? i : 1;
     } else if(d < 0) {
 	int i;
 	pt = tree;
-	for(i = d ; i < 0 && pt ; i++)  pt = pt->prev;
+	for(i = d ; i < 0 && pt ; i++)  pt = pt->get_prev();
 	d = i ? i : -1;
     } else pt = tree;
 
     if(pt == NULL) { // No next
 	// Must we loop?
 	if (mode == PLAY_TREE_ITER_RND) {
-	    if (root->loop == 0) return PLAY_TREE_ITER_END;
-	    play_tree_unset_flag(root, PLAY_TREE_RND_PLAYED, -1);
-	    if (root->loop > 0) root->loop--;
+	    if (root->get_loop() == 0) return PLAY_TREE_ITER_END;
+	    root->unset_flag(PLAY_TREE_RND_PLAYED, -1);
+	    if (root->get_loop() > 0) root->set_loop(root->get_loop()-1);
 	    // try again
 	    return step(0, with_nodes);
-	} else if(tree->parent && tree->parent->loop != 0 && ((d > 0 && loop != 0) || ( d < 0 && (loop < 0 || loop < tree->parent->loop)))) {
+	} else if(tree->get_parent() && tree->get_parent()->get_loop() != 0 && ((d > 0 && loop != 0) || ( d < 0 && (loop < 0 || loop < tree->get_parent()->get_loop())))) {
 	    if(d > 0) { // Go back to the first one
-		for(pt = tree ; pt->prev != NULL; pt = pt->prev) /* NOTHNG */;
+		for(pt = tree ; pt->get_prev() != NULL; pt = pt->get_prev()) /* NOTHNG */;
 		if(loop > 0) loop--;
 	    } else if( d < 0 ) { // Or the last one
-		for(pt = tree ; pt->next != NULL; pt = pt->next) /* NOTHNG */;
-		if(loop >= 0 && loop < tree->parent->loop) loop++;
+		for(pt = tree ; pt->get_next() != NULL; pt = pt->get_next()) /* NOTHNG */;
+		if(loop >= 0 && loop < tree->get_parent()->get_loop()) loop++;
 	    }
 	    tree = pt;
 	    return step(0,with_nodes);
@@ -425,7 +414,7 @@
 	return up_step(d,with_nodes);
     }
     // Is there any valid child?
-    if(pt->child && play_tree_is_valid(pt->child)) {
+    if(pt->get_child() && pt->get_child()->is_valid()) {
 	tree = pt;
 	if(with_nodes) { // Stop on the node
 	    return PLAY_TREE_ITER_NODE;
@@ -433,7 +422,7 @@
 	    return down_step(d,with_nodes);
     }
     // Is it a valid entry?
-    if(! play_tree_is_valid(pt)) {
+    if(! pt->is_valid()) {
 	if(d == 0 && rnd==PLAY_TREE_ITER_NORMAL) { // Can this happen ? FF: Yes!
 	    mpxp_err<<"What to do now ???? Infinite loop if we continue"<<std::endl;
 	    return PLAY_TREE_ITER_ERROR;
@@ -443,25 +432,25 @@
 
     tree = pt;
 
-    num_files = tree->files.size();
+    num_files = tree->get_files().size();
 
     push_params();
     entry_pushed = 1;
-    if(mode == PLAY_TREE_ITER_RND) pt->flags |= PLAY_TREE_RND_PLAYED;
+    if(mode == PLAY_TREE_ITER_RND) pt->set_flags(pt->get_flags()|PLAY_TREE_RND_PLAYED);
 
     return PLAY_TREE_ITER_ENTRY;
 }
 
 int _PlayTree_Iter::up_step(int d,int with_nodes) {
     file = -1;
-    if(tree->parent == root->parent) return PLAY_TREE_ITER_END;
+    if(tree->get_parent() == root->get_parent()) return PLAY_TREE_ITER_END;
 
     loop = status_stack.top(); status_stack.pop();
-    tree = tree->parent;
+    tree = tree->get_parent();
 
     // Pop subtree params
     m_config_pop(config);
-    if(mode == PLAY_TREE_ITER_RND) tree->flags |= PLAY_TREE_RND_PLAYED;
+    if(mode == PLAY_TREE_ITER_RND) tree->set_flags(tree->get_flags()|PLAY_TREE_RND_PLAYED);
     return step(d,with_nodes);
 }
 
@@ -473,11 +462,11 @@
 
     status_stack.push(loop);
     // Set new status
-    loop = tree->loop-1;
-    if(d >= 0) tree = tree->child;
+    loop = tree->get_loop()-1;
+    if(d >= 0) tree = tree->get_child();
     else {
-	play_tree_t* pt;
-	for(pt = tree->child ; pt->next != NULL ; pt = pt->next) /*NOTING*/;
+	PlayTree* pt;
+	for(pt = tree->get_child() ; pt->get_next() != NULL ; pt = pt->get_next()) /*NOTING*/;
 	tree = pt;
     }
     return step(0,with_nodes);
@@ -486,7 +475,7 @@
 std::string _PlayTree_Iter::get_file(int d) {
     std::string entry;
 
-    if(tree->files.empty()) return "";
+    if(tree->get_files().empty()) return "";
     if(file >= num_files-1 || file < -1) return "";
     if(d > 0) {
 	if(file >= num_files - 1) file = 0;
@@ -495,9 +484,9 @@
 	if(file <= 0) file = num_files - 1;
 	else file--;
     }
-    entry = tree->files[file];
+    entry = tree->get_file(file);
 
-    switch(tree->entry_type) {
+    switch(tree->get_entry_type()) {
 	case PLAY_TREE_ENTRY_DVD :
 	    if(entry.length() == 0) entry = "1";
 	    m_config_set_option(config,"dvd",entry);
@@ -531,73 +520,6 @@
 
 } // namespace mpxp
 
-
-static int
-play_tree_is_valid(play_tree_t* pt) {
-  play_tree_t* iter;
-
-  if(pt->entry_type != PLAY_TREE_ENTRY_NODE) {
-    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;
-}
-
-play_tree_t*
-play_tree_cleanup(play_tree_t* pt) {
-  play_tree_t* iter, *tmp, *first;
-
-  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;
-
-}
-
-// HIGH Level API, by Fabian Franz (mp...@fa...)
-//
-_PlayTree_Iter* pt_iter_create(play_tree_t** ppt, m_config_t& config)
-{
-  _PlayTree_Iter* r=NULL;
-
-  *ppt=play_tree_cleanup(*ppt);
-
-  if(*ppt) {
-    r = new _PlayTree_Iter(*ppt,config);
-    if (r && r->step(0,0) != PLAY_TREE_ITER_ENTRY)
-    {
-      delete r;
-      r = NULL;
-    }
-  }
-
-  return r;
-}
-
 void pt_iter_destroy(_PlayTree_Iter** iter)
 {
   if (iter && *iter)
@@ -627,40 +549,40 @@
   return r;
 }
 
-void pt_iter_insert_entry(_PlayTree_Iter* iter, play_tree_t* entry)
+void pt_iter_insert_entry(_PlayTree_Iter* iter, PlayTree* entry)
 {
-  play_tree_t *pt = iter->get_tree();
+  PlayTree *pt = iter->get_tree();
 
-  play_tree_insert_entry(pt, entry);
-  play_tree_set_params_from(entry,pt);
+  pt->insert_entry(entry);
+  entry->set_params_from(*pt);
 }
 
-void pt_iter_replace_entry(_PlayTree_Iter* iter, play_tree_t* entry)
+void pt_iter_replace_entry(_PlayTree_Iter* iter, PlayTree* entry)
 {
-  play_tree_t *pt = iter->get_tree();
+  PlayTree *pt = iter->get_tree();
 
   pt_iter_insert_entry(iter, entry);
-  play_tree_remove(pt, 1, 1);
+  pt->remove(1, 1);
   iter->set_tree(entry);
 }
 
 //Add a new file as a new entry
-void pt_add_file(play_tree_t** ppt,const std::string& filename)
+void pt_add_file(PlayTree** ppt,const std::string& filename)
 {
-  play_tree_t *pt = *ppt, *entry = play_tree_new();
+  PlayTree *pt = *ppt, *entry = new(zeromem) PlayTree;
 
-  play_tree_add_file(entry, filename);
+  entry->add_file(filename);
   if (pt)
-    play_tree_append_entry(pt, entry);
+    pt->append_entry(entry);
   else
   {
     pt=entry;
     *ppt=pt;
   }
-  play_tree_set_params_from(entry,pt);
+  entry->set_params_from(*pt);
 }
 
-void pt_add_gui_file(play_tree_t** ppt,const std::string& path,const std::string& file)
+void pt_add_gui_file(PlayTree** ppt,const std::string& path,const std::string& file)
 {
     std::string wholename;
 

Modified: mplayerxp/libplaytree/playtree.h
===================================================================
--- mplayerxp/libplaytree/playtree.h	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtree.h	2012-12-27 16:37:25 UTC (rev 608)
@@ -44,29 +44,75 @@
 /// \defgroup Playtree
 ///@{
 
-struct play_tree_param_t {
-    std::string name;
-    std::string value;
-};
+namespace mpxp {
+    struct play_tree_param_t {
+	std::string name;
+	std::string value;
+    };
 
-struct play_tree_t {
-    play_tree_t* parent;
-    play_tree_t* child;
-    play_tree_t* next;
-    play_tree_t* prev;
+    class PlayTree : public Opaque {
+	public:
+	    PlayTree();
+	    virtual ~PlayTree();
 
-  //play_tree_info_t info;
-    std::vector<play_tree_param_t> params;
-    int loop;
-    std::vector<std::string> files;
-    int entry_type;
-    int flags;
-};
+	    static PlayTree*	parse_playtree(libinput_t& libinput,Stream* stream);
+	    static PlayTree*	parse_playlist_file(libinput_t&libinput,const std::string& file);
+	    virtual MPXP_Rc	cleanup();
+	    // If childs is true mp_free also the childs
+	    virtual void	free(int childs);
+	    virtual void	free_list(int childs);
 
-namespace mpxp {
+	    virtual void	set_child(PlayTree* child);
+	    virtual void	set_parent(PlayTree* parent);
+	    // Add at end
+	    virtual void	append_entry(PlayTree* entry);
+	    // And on begining
+	    virtual void	prepend_entry(PlayTree* entry);
+	    // Insert after
+	    virtual void	insert_entry(PlayTree* entry);
+	    // Detach from the tree
+	    virtual void	remove(int free_it,int with_childs);
+	    virtual void	add_file(const std::string& file);
+	    virtual MPXP_Rc	remove_file(const std::string& file);
+	    virtual void	set_param(const std::string& name,const std::string& val);
+	    virtual MPXP_Rc	unset_param(const std::string& name);
+	    /// Copy the config parameters from one item to another.
+	    virtual void	set_params_from(const PlayTree& src);
+	    virtual void	set_flag(int flags, int deep);
+	    virtual void	unset_flag(int flags, int deep);
+	    virtual MPXP_Rc	is_valid() const;
+
+	    PlayTree*		get_parent() const { return parent; }
+	    PlayTree*		get_child() const { return child; }
+	    PlayTree*		get_prev() const { return prev; }
+	    PlayTree*		get_next() const { return next; }
+	    void		set_prev(PlayTree* p) { prev=p; }
+	    void		set_next(PlayTree* p) { next=p; }
+	    const std::string&	get_file(size_t idx) const { return files[idx]; }
+	    const std::vector<std::string>&	get_files() const { return files; }
+	    const play_tree_param_t&		get_param(size_t idx) const { return params[idx]; }
+	    const std::vector<play_tree_param_t>&get_params() const { return params; }
+	    int			get_entry_type() const { return entry_type; }
+	    int			get_loop() const { return loop; }
+	    void		set_loop(int l) { loop=l; }
+	    int			get_flags() const { return flags; }
+	    void		set_flags(int f) { flags=f; }
+	private:
+	    PlayTree* parent;
+	    PlayTree* child;
+	    PlayTree* next;
+	    PlayTree* prev;
+
+	    std::vector<play_tree_param_t> params;
+	    int loop;
+	    std::vector<std::string> files;
+	    int entry_type;
+	    int flags;
+    };
+
     struct _PlayTree_Iter : public Opaque {
 	public:
-	    _PlayTree_Iter(play_tree_t* parent,m_config_t& config);
+	    _PlayTree_Iter(PlayTree* parent,m_config_t& config);
 	    _PlayTree_Iter(const _PlayTree_Iter& old);
 	    virtual ~_PlayTree_Iter();
 
@@ -79,16 +125,16 @@
 	    virtual int		down_step(int d,int with_nodes);
 	    virtual std::string	get_file(int d);
 
-	    play_tree_t*	get_root() const { return root; }
-	    play_tree_t*	get_tree() const { return tree; }
-	    void		set_tree(play_tree_t* _tree) { tree=_tree; }
+	    PlayTree*		get_root() const { return root; }
+	    PlayTree*		get_tree() const { return tree; }
+	    void		set_tree(PlayTree* _tree) { tree=_tree; }
 	    void		reset_tree() { tree=root; }
 	    int			get_file() const { return file; }
 	    int			get_num_files() const { return num_files; }
 	private:
 	    void		push_params();
-	    play_tree_t*	root; // Iter root tree
-	    play_tree_t*	tree; // Current tree
+	    PlayTree*		root; // Iter root tree
+	    PlayTree*		tree; // Current tree
 	    m_config_t&		config;
 	    int			loop;  // Looping status
 	    int			file;
@@ -99,72 +145,13 @@
 	    std::stack<int> status_stack;
     };
 } // namespace mpxp
-play_tree_t* parse_playtree(libinput_t& libinput,Stream* stream);
 
-play_tree_t* play_tree_cleanup(play_tree_t* pt);
-
-play_tree_t* parse_playlist_file(libinput_t&libinput,const std::string& file);
-
-play_tree_t* play_tree_new(void);
-
-// If childs is true mp_free also the childs
-void
-play_tree_free(play_tree_t* pt, int childs);
-
-
-void
-play_tree_free_list(play_tree_t* pt, int childs);
-
-
-// Childs
-void
-play_tree_set_child(play_tree_t* pt, play_tree_t* child);
-// Or parent
-void
-play_tree_set_parent(play_tree_t* pt, play_tree_t* parent);
-
-
-// Add at end
-void
-play_tree_append_entry(play_tree_t* pt, play_tree_t* entry);
-
-// And on begining
-void
-play_tree_prepend_entry(play_tree_t* pt, play_tree_t* entry);
-
-// Insert after
-void
-play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry);
-
-// Detach from the tree
-void
-play_tree_remove(play_tree_t* pt, int free_it,int with_childs);
-
-
-void
-play_tree_add_file(play_tree_t* pt,const std::string& file);
-
-MPXP_Rc play_tree_remove_file(play_tree_t* pt,const std::string& file);
-
-// Val can be NULL
-void
-play_tree_set_param(play_tree_t* pt,const std::string& name,const std::string& val);
-
-MPXP_Rc play_tree_unset_param(play_tree_t* pt,const std::string& name);
-/// Copy the config parameters from one item to another.
-void
-play_tree_set_params_from(play_tree_t* dest,const play_tree_t* src);
-
-
 /// \defgroup PtAPI Playtree highlevel API
 /// \ingroup Playtree
 /// Highlevel API with pt-suffix to different from low-level API
 /// by Fabian Franz (mp...@fa...).
 ///@{
 
-// Cleans up pt and creates a new iter.
-_PlayTree_Iter* pt_iter_create(play_tree_t** pt, struct m_config* config);
-
 /// Frees the iter.
 void pt_iter_destroy(_PlayTree_Iter** iter);
 
@@ -176,21 +163,21 @@
 static inline std::string pt_iter_get_prev_file(_PlayTree_Iter* iter) { return pt_iter_get_file(iter, -1); }
 
 /// Inserts entry into the playtree.
-void pt_iter_insert_entry(_PlayTree_Iter* iter, play_tree_t* entry);
+void pt_iter_insert_entry(_PlayTree_Iter* iter, PlayTree* entry);
 
 /// Replaces current entry in playtree with entry by doing insert and remove.
-void pt_iter_replace_entry(_PlayTree_Iter* iter, play_tree_t* entry);
+void pt_iter_replace_entry(_PlayTree_Iter* iter, PlayTree* entry);
 
 /// Adds a new file to the playtree, if it is not valid it is created.
-void pt_add_file(play_tree_t** ppt,const std::string& filename);
+void pt_add_file(PlayTree** ppt,const std::string& filename);
 
 /// \brief Performs a convert to playtree-syntax, by concat path/file
 /// and performs pt_add_file
-void pt_add_gui_file(play_tree_t** ppt,const std::string& path,const std::string& file);
+void pt_add_gui_file(PlayTree** ppt,const std::string& path,const std::string& file);
 
 // Two macros to use only the iter and not the other things.
-static inline void pt_iter_add_file(_PlayTree_Iter* iter, const std::string& filename) { play_tree_t* tree=iter->get_tree();  pt_add_file(&tree, filename); }
-static inline void pt_iter_add_gui_file(_PlayTree_Iter* iter,const std::string& path,const std::string& name) { play_tree_t* tree=iter->get_tree(); pt_add_gui_file(&tree, path, name); }
+static inline void pt_iter_add_file(_PlayTree_Iter* iter, const std::string& filename) { PlayTree* tree=iter->get_tree();  pt_add_file(&tree, filename); }
+static inline void pt_iter_add_gui_file(_PlayTree_Iter* iter,const std::string& path,const std::string& name) { PlayTree* tree=iter->get_tree(); pt_add_gui_file(&tree, path, name); }
 
 /// Resets the iter and goes back to head.
 void pt_iter_goto_head(_PlayTree_Iter* iter);

Modified: mplayerxp/libplaytree/playtreeparser.cpp
===================================================================
--- mplayerxp/libplaytree/playtreeparser.cpp	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtreeparser.cpp	2012-12-27 16:37:25 UTC (rev 608)
@@ -116,7 +116,7 @@
 }
 
 
-static play_tree_t* parse_asx(libinput_t& libinput,play_tree_parser_t* p) {
+static PlayTree* parse_asx(libinput_t& libinput,play_tree_parser_t* p) {
   int comments = 0,get_line = 1;
   char* line = NULL;
 
@@ -224,12 +224,12 @@
 }
 
 
-play_tree_t*
+PlayTree*
 parse_pls(play_tree_parser_t* p) {
   char *line,*v;
   pls_entry_t* entries = NULL;
   int n_entries = 0,max_entry=0,num;
-  play_tree_t *list = NULL, *entry = NULL;
+  PlayTree *list = NULL, *entry = NULL;
 
   mpxp_v<<"Trying winamp playlist..."<<std::endl;
   line = play_tree_parser_get_line(p);
@@ -286,11 +286,11 @@
       mpxp_err<<"Entry "<<(num+1)<<" don't have a file !!!!"<<std::endl;
     else {
       mpxp_dbg2<<"Adding entry "<<entries[num].file<<std::endl;
-      entry = play_tree_new();
-      play_tree_add_file(entry,entries[num].file);
+      entry = new(zeromem) PlayTree;
+      entry->add_file(entries[num].file);
       delete entries[num].file;
       if(list)
-	play_tree_append_entry(list,entry);
+	list->append_entry(entry);
       else
 	list = entry;
     }
@@ -306,15 +306,15 @@
 
   delete entries;
 
-  entry = play_tree_new();
-  play_tree_set_child(entry,list);
+  entry = new(zeromem) PlayTree;
+  entry->set_child(list);
   return entry;
 }
 
-play_tree_t*
+PlayTree*
 parse_textplain(play_tree_parser_t* p) {
   char* line;
-  play_tree_t *list = NULL, *entry = NULL;
+  PlayTree *list = NULL, *entry = NULL;
 
   mpxp_v<<"Trying plaintext..."<<std::endl;
   play_tree_parser_stop_keeping(p);
@@ -323,23 +323,24 @@
     strstrip(line);
     if(line[0] == '\0')
       continue;
-    entry = play_tree_new();
-    play_tree_add_file(entry,line);
+    entry = new(zeromem) PlayTree;
+    entry->add_file(line);
     if(!list)
       list = entry;
     else
-      play_tree_append_entry(list,entry);
+      list->append_entry(entry);
   }
 
   if(!list) return NULL;
-  entry = play_tree_new();
-  play_tree_set_child(entry,list);
+  entry = new(zeromem) PlayTree;
+  entry->set_child(list);
   return entry;
 }
 
-play_tree_t* parse_playtree(libinput_t&libinput,Stream* stream) {
+namespace mpxp {
+PlayTree* PlayTree::parse_playtree(libinput_t&libinput,Stream* stream) {
   play_tree_parser_t* p;
-  play_tree_t* ret;
+  PlayTree* ret;
 
   p = play_tree_parser_new(stream,0);
   if(!p)
@@ -351,9 +352,9 @@
   return ret;
 }
 
-play_tree_t* parse_playlist_file(libinput_t&libinput,const std::string& file) {
+PlayTree* PlayTree::parse_playlist_file(libinput_t&libinput,const std::string& file) {
   Stream *stream;
-  play_tree_t* ret;
+  PlayTree* ret;
   int ff;
 
   mpxp_v<<"Parsing playlist file "<<file<<"..."<<std::endl;
@@ -361,12 +362,12 @@
   stream = new(zeromem) Stream;
   stream->open(libinput,file,&ff);
   stream->type(Stream::Type_Text);
-  ret = parse_playtree(libinput,stream);
+  ret = PlayTree::parse_playtree(libinput,stream);
   delete stream;
 
   return ret;
-
 }
+} // namespace mpxp
 
 play_tree_parser_t* play_tree_parser_new(Stream* stream,int deep) {
   play_tree_parser_t* p;
@@ -390,9 +391,9 @@
   delete p;
 }
 
-play_tree_t*
+PlayTree*
 play_tree_parser_get_play_tree(libinput_t& libinput,play_tree_parser_t* p) {
-  play_tree_t* tree = NULL;
+  PlayTree* tree = NULL;
 
   while(play_tree_parser_get_line(p) != NULL) {
     play_tree_parser_reset(p);
@@ -415,10 +416,7 @@
     mpxp_v<<"Playlist succefully parsed"<<std::endl;
   else mpxp_err<<"Error while parsing playlist"<<std::endl;
 
-  if(tree)
-    tree = play_tree_cleanup(tree);
+  if(tree->cleanup()!=MPXP_Ok) mpxp_warn<<"Warning empty playlist"<<std::endl;
 
-  if(!tree) mpxp_warn<<"Warning empty playlist"<<std::endl;
-
   return tree;
 }

Modified: mplayerxp/libplaytree/playtreeparser.h
===================================================================
--- mplayerxp/libplaytree/playtreeparser.h	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtreeparser.h	2012-12-27 16:37:25 UTC (rev 608)
@@ -14,6 +14,6 @@
 
 void play_tree_parser_free(play_tree_parser_t* p);
 
-play_tree_t* play_tree_parser_get_play_tree(libinput_t&libinput,play_tree_parser_t* p);
+PlayTree* play_tree_parser_get_play_tree(libinput_t&libinput,play_tree_parser_t* p);
 
 #endif

Modified: mplayerxp/mplayerxp.cpp
===================================================================
--- mplayerxp/mplayerxp.cpp	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/mplayerxp.cpp	2012-12-27 16:37:25 UTC (rev 608)
@@ -154,7 +154,7 @@
 	MPXP_Rc		ao_inited;
 	int		osd_show_framedrop;
 	int		osd_function;
-	play_tree_t*	playtree;
+	PlayTree*	playtree;
 	// for multifile support:
 	_PlayTree_Iter* playtree_iter;
     private:
@@ -935,11 +935,11 @@
 int MPXPSystem::handle_playlist(const std::string& filename) const {
     Stream* stream=static_cast<Stream*>(_demuxer->stream);
     int eof=0;
-    play_tree_t* entry;
+    PlayTree* entry;
     // Handle playlist
     MP_UNIT("handle_playlist");
     mpxp_v<<"Parsing playlist "<<filename<<"..."<<std::endl;
-    entry = parse_playtree(_libinput,stream);
+    entry = PlayTree::parse_playtree(_libinput,stream);
     if(!entry) {
       entry = playtree_iter->get_tree();
       if(playtree_iter->step(1,0) != PLAY_TREE_ITER_ENTRY) {
@@ -952,17 +952,17 @@
 	  return eof;
 	}
       }
-      play_tree_remove(entry,1,1);
+      entry->remove(1,1);
       eof = PT_NEXT_SRC;
       return eof;
     }
-    play_tree_insert_entry(playtree_iter->get_tree(),entry);
+    playtree_iter->get_tree()->insert_entry(entry);
     entry = playtree_iter->get_tree();
     if(playtree_iter->step(1,0) != PLAY_TREE_ITER_ENTRY) {
       eof = PT_NEXT_ENTRY;
       return eof;
     }
-    play_tree_remove(entry,1,1);
+    entry->remove(1,1);
     eof = PT_NEXT_SRC;
     return eof;
 }
@@ -1681,7 +1681,7 @@
     MPXPSystem& MPXPSys=*mpxp_context().engine().MPXPSys;
     MPXPSys.init_keyboard_fifo();
 
-    MPXPSys.playtree = play_tree_new();
+    MPXPSys.playtree = new(zeromem) PlayTree;
 
     m_config_t& m_config=m_config_new(MPXPSys.playtree,MPXPSys.libinput());
     mpxp_context().mconfig = &m_config;
@@ -1708,10 +1708,10 @@
 #if defined( ARCH_X86 ) || defined(ARCH_X86_64)
     get_mmx_optimizations();
 #endif
-    if(mp_conf.shuffle_playback) MPXPSys.playtree->flags|=PLAY_TREE_RND;
-    else			 MPXPSys.playtree->flags&=~PLAY_TREE_RND;
+    if(mp_conf.shuffle_playback) MPXPSys.playtree->set_flags(MPXPSys.playtree->get_flags()|PLAY_TREE_RND);
+    else			 MPXPSys.playtree->set_flags(MPXPSys.playtree->get_flags()&~PLAY_TREE_RND);
 
-    MPXPSys.playtree = play_tree_cleanup(MPXPSys.playtree);
+//    MPXPSys.playtree = play_tree_cleanup(MPXPSys.playtree);
     if(MPXPSys.playtree) {
       MPXPSys.playtree_iter = new _PlayTree_Iter(MPXPSys.playtree,m_config);
       if(MPXPSys.playtree_iter) {

Modified: mplayerxp/postproc/libmenu/menu_pt.cpp
===================================================================
--- mplayerxp/postproc/libmenu/menu_pt.cpp	2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/postproc/libmenu/menu_pt.cpp	2012-12-27 16:37:25 UTC (rev 608)
@@ -27,7 +27,7 @@
 
 struct list_entry_s {
   struct list_entry p;
-  play_tree_t* pt;
+  PlayTree* pt;
 };
 
 
@@ -57,24 +57,24 @@
   case MENU_CMD_OK: {
     int d = 1;
     char str[15];
-    play_tree_t* i;
+    PlayTree* i;
     mp_cmd_t* c;
     _PlayTree_Iter* _playtree_iter =mpxp_get_playtree_iter();
 
     if(_playtree_iter->get_tree() == mpriv->p.current->pt)
       break;
 
-    if(_playtree_iter->get_tree()->parent && mpriv->p.current->pt == _playtree_iter->get_tree()->parent)
+    if(_playtree_iter->get_tree()->get_parent() && mpriv->p.current->pt == _playtree_iter->get_tree()->get_parent())
       snprintf(str,15,"pt_up_step 1");
     else {
-      for(i = _playtree_iter->get_tree()->next; i != NULL ; i = i->next) {
+      for(i = _playtree_iter->get_tree()->get_next(); i != NULL ; i = i->get_next()) {
 	if(i == mpriv->p.current->pt)
 	  break;
 	d++;
       }
       if(i == NULL) {
 	d = -1;
-	for(i = _playtree_iter->get_tree()->prev; i != NULL ; i = i->prev) {
+	for(i = _playtree_iter->get_tree()->get_prev(); i != NULL ; i = i->get_prev()) {
 	  if(i == mpriv->p.current->pt)
 	    break;
 	  d--;
@@ -106,7 +106,7 @@
 }
 
 static int op(menu_t* menu,const char* args) {
-  play_tree_t* i;
+  PlayTree* i;
   list_entry_t* e;
   _PlayTree_Iter* _playtree_iter = mpxp_get_playtree_iter();
 
@@ -121,19 +121,19 @@
 
   mpriv->p.title = mpriv->title;
 
-  if(_playtree_iter->get_tree()->parent != _playtree_iter->get_root()) {
+  if(_playtree_iter->get_tree()->get_parent() != _playtree_iter->get_root()) {
     e = new(zeromem) list_entry_t;
     e->p.txt = "..";
-    e->pt = _playtree_iter->get_tree()->parent;
+    e->pt = _playtree_iter->get_tree()->get_parent();
     menu_list_add_entry(menu,e);
   }
 
-  for(i = _playtree_iter->get_tree() ; i->prev != NULL ; i = i->prev)
+  for(i = _playtree_iter->get_tree() ; i->get_prev() != NULL ; i = i->get_prev())
     /* NOP */;
-  for( ; i != NULL ; i = i->next ) {
+  for( ; i != NULL ; i = i->get_next() ) {
     e = new(zeromem) list_entry_t;
-    if(!i->files.empty())
-      e->p.txt = mp_basename(i->files[0]);
+    if(!i->get_files().empty())
+      e->p.txt = mp_basename(i->get_file(0));
     else
       e->p.txt = "Group ...";
     e->pt = i;

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.





2002	Jan	Feb	Mar (53)	Apr (142)	May (129)	Jun (160)	Jul (102)	Aug (14)	Sep (50)	Oct (27)	Nov (52)	Dec (41)
2003	Jan (136)	Feb (170)	Mar (103)	Apr (102)	May (44)	Jun (25)	Jul (2)	Aug	Sep (6)	Oct (1)	Nov	Dec (4)
2004	Jan	Feb (21)	Mar (1)	Apr	May	Jun	Jul	Aug	Sep (12)	Oct (160)	Nov (63)	Dec (5)
2005	Jan (10)	Feb (14)	Mar (18)	Apr (74)	May (72)	Jun (22)	Jul (28)	Aug (1)	Sep	Oct	Nov	Dec
2006	Jan (91)	Feb (71)	Mar (1)	Apr	May	Jun (4)	Jul (3)	Aug (4)	Sep (21)	Oct (42)	Nov (9)	Dec (26)
2007	Jan (1)	Feb	Mar	Apr (17)	May (1)	Jun	Jul	Aug	Sep	Oct	Nov (134)	Dec (72)
2008	Jan (6)	Feb (1)	Mar	Apr	May (2)	Jun	Jul (5)	Aug	Sep (1)	Oct (21)	Nov (41)	Dec (12)
2009	Jan (57)	Feb	Mar (1)	Apr	May	Jun (1)	Jul	Aug	Sep (25)	Oct (1)	Nov (46)	Dec (59)
2010	Jan (84)	Feb (5)	Mar	Apr (2)	May	Jun (2)	Jul (1)	Aug (1)	Sep	Oct	Nov	Dec
2012	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct (122)	Nov (223)	Dec (132)
2013	Jan	Feb	Mar	Apr (8)	May (13)	Jun (10)	Jul	Aug (1)	Sep	Oct	Nov	Dec

mplayerxp-cvslog Mailing List for MplayerXP-mplayer with extra performance (Page 3)

mplayerxp-cvslog — CVS commits of mplayerxp