changeset 4043:25590564842f

tree-based playlist parser code by Alban Bedel <[e-mail]>

--- a/Makefile	Tue Jan 08 01:19:54 2002 +0000
+++ b/Makefile	Tue Jan 08 01:24:25 2002 +0000
@@ -27,7 +27,7 @@
 
 SRCS_COMMON = cyuv.c adpcm.c xacodec.c cpudetect.c mp_msg.c ac3-iec958.c dec_audio.c dec_video.c msvidc.c cinepak.c fli.c qtrle.c codec-cfg.c cfgparser.c my_profile.c RTjpegN.c minilzo.c nuppelvideo.c
 SRCS_MENCODER = mencoder.c $(SRCS_COMMON) libao2/afmt.c divx4_vbr.c libvo/aclib.c libvo/img_format.c
-SRCS_MPLAYER = mplayer.c $(SRCS_COMMON) find_sub.c subreader.c lirc_mp.c mixer.c spudec.c
+SRCS_MPLAYER = mplayer.c $(SRCS_COMMON) find_sub.c subreader.c lirc_mp.c mixer.c spudec.c playtree.c playtreeparser.c asxparser.c
 
 OBJS_MENCODER = $(SRCS_MENCODER:.c=.o)
 OBJS_MPLAYER = $(SRCS_MPLAYER:.c=.o)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/asxparser.c	Tue Jan 08 01:24:25 2002 +0000
@@ -0,0 +1,645 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "asxparser.h"
+#include "mp_msg.h"
+
+////// List utils
+
+typedef void (*ASX_FreeFunc)(void* arg);
+
+void
+asx_list_add(void* list_ptr,void* entry){
+  void** list = *(void***)list_ptr;
+  int c = 0;
+
+  if(list != NULL)
+    for( ; list[c] != NULL; c++) ;
+
+  list = (void*)realloc(list,sizeof(void*)*(c+2));
+
+  list[c] = entry;
+  list[c+1] = NULL;
+
+  *(void***)list_ptr = list;
+}
+
+
+void
+asx_list_remove(void* list_ptr,void* entry,ASX_FreeFunc free_func) {
+  void** list = *(void***)list_ptr;
+  int c,e = -1;
+
+  if(list == NULL) return;
+
+  for(c = 0 ; list[c] != NULL; c++){
+    if(list[c] == entry) e = c;
+  }
+
+  if(e == -1) return; // Not found
+
+  if(free_func != NULL) free_func(list[e]);
+  
+  if(c == 1) { // Only one entry, we drop all
+    free(list);
+    *(void**)list_ptr = NULL;
+    return;
+  }
+
+  if(c > e) // If c==e the memmove is not needed
+    memmove(list+e,list+e+1,(c-e)*sizeof(void*));
+
+  list = (void*)realloc(list,(c-1)*sizeof(void*));
+  list[c-1] = NULL;
+  
+  *(void***)list_ptr = list;
+}
+
+void
+asx_list_free(void* list_ptr,ASX_FreeFunc free_func) {
+  void** ptr = *(void***)list_ptr;
+  if(ptr == NULL) return;
+  if(free_func != NULL) {
+    for( ; *ptr != NULL ; ptr++)
+      free_func(*ptr);
+  }
+  free(*(void**)list_ptr);
+  *(void**)list_ptr = NULL;
+}
+
+/////// Attribs utils
+
+static char*
+asx_get_attrib(char* attrib,char** attribs) {
+  char** ptr;
+
+  if(attrib == NULL || attribs == NULL) return NULL;
+  for(ptr = attribs; ptr[0] != NULL; ptr += 2){
+    if(strcasecmp(ptr[0],attrib) == 0)
+      return strdup(ptr[1]);
+  }
+  return NULL;
+}
+
+static int
+asx_attrib_to_enum(char* val,char** valid_vals) {
+  char** ptr;
+  int r = 0;
+
+  if(valid_vals == NULL || val == NULL) return -2;
+  for(ptr = valid_vals ; ptr[0] != NULL ; ptr++) {
+    if(strcasecmp(val,ptr[0]) == 0) return r;
+    r++;
+  }
+
+  return -1;
+}
+
+static void
+asx_warning_attrib_invalid(ASX_Parser_t* parser, char* elem, char* attrib,
+			   char** valid_vals,char* val) {
+  char *str,*vals,**ptr;
+  int len;
+
+  if(valid_vals == NULL || valid_vals[0] == NULL) return;
+  
+  len = strlen(valid_vals[0]) + 1;
+  for(ptr = valid_vals+1 ; ptr[0] != NULL; ptr++) {
+    len += strlen(ptr[0]);
+    len += ((ptr[1] == NULL) ? 4 : 2);
+  }
+  str = vals = (char*)malloc(len);
+  vals += sprintf(vals,"%s",valid_vals[0]);
+  for(ptr = valid_vals + 1 ; ptr[0] != NULL ; ptr++) {
+    if(ptr[1] == NULL)
+      vals += sprintf(vals," or %s",ptr[0]);
+    else
+      vals += sprintf(vals,", %s",ptr[0]);
+  }
+  mp_msg(MSGT_PLAYTREE,MSGL_ERR,"at line %d : attribute %s of element %s is invalid (%s). Valid values are %s",
+	      parser->line,attrib,elem,val,str);
+  free(str);
+}
+
+static int
+asx_get_yes_no_attrib(ASX_Parser_t* parser, char* element, char* attrib,char** attribs,int def) {
+  char* val = asx_get_attrib(attrib,attribs);
+  char* valids[] = { "NO", "YES", NULL };
+  int r;
+
+  if(val == NULL) return def;
+  r = asx_attrib_to_enum(val,valids);
+
+  if(r < 0) {
+    asx_warning_attrib_invalid(parser,element,attrib,valids,val);
+    r = def;
+  }
+
+  free(val);
+  return r;
+}
+
+#define asx_free_attribs(a) asx_list_free((void***)&a,free)
+
+#define asx_warning_attrib_required(p,e,a) mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : element %s don't have the required attribute %s",p->line,e,a)
+#define asx_warning_body_parse_error(p,e) mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : error while parsing %s body",p->line,e)
+
+ASX_Parser_t*
+asx_parser_new(void) {
+  ASX_Parser_t* parser = calloc(1,sizeof(ASX_Parser_t));
+  return parser;
+}
+
+void
+asx_parser_free(ASX_Parser_t* parser) {
+  if(!parser) return;
+  if(parser->ret_stack) free(parser->ret_stack);
+  free(parser);
+
+}
+
+#define LETTER "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define SPACE " \n\t\r"
+
+static int
+asx_parse_attribs(ASX_Parser_t* parser,char* buffer,char*** _attribs) {
+  char *ptr1, *ptr2, *ptr3;
+  int n_attrib = 0;
+  char **attribs = NULL;
+  char *attrib, *val;
+
+  ptr1 = buffer;
+  while(1) {
+    for( ; strchr(SPACE,*ptr1) != NULL; ptr1++) { // Skip space
+      if(*ptr1 == '\0') break;
+    }
+    ptr3 = strchr(ptr1,'=');
+    if(ptr3 == NULL) break;
+    for(ptr2 = ptr3-1; strchr(SPACE,*ptr2) != NULL; ptr2--) {
+      if (ptr2 == ptr1) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : this should never append, back to attribute begin while skipping end space",parser->line);
+	break;
+      }
+    }
+    attrib = (char*)malloc(ptr2-ptr1+2);
+    strncpy(attrib,ptr1,ptr2-ptr1+1);
+    attrib[ptr2-ptr1+1] = '\0';
+
+    ptr1 = strchr(ptr3,'"');
+    if(ptr1 == NULL || ptr1[1] == '\0') {
+      mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : can't find attribute %s value",parser->line,attrib);
+      free(attrib);
+      break;
+    }
+    ptr1++;
+    ptr2 = strchr(ptr1,'"');
+    if (ptr2 == NULL) {
+      mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : value of attribute %s isn't finished",parser->line,attrib);
+      free(attrib);
+      break;
+    }
+    val = (char*)malloc(ptr2-ptr1+1);
+    strncpy(val,ptr1,ptr2-ptr1);
+    val[ptr2-ptr1] = '\0';
+    n_attrib++;
+    
+    attribs = (char**)realloc(attribs,2*n_attrib*sizeof(char*)+1);
+    attribs[n_attrib*2-2] = attrib;
+    attribs[n_attrib*2-1] = val;
+    
+    ptr1 = ptr2+2;
+  }
+  
+  if(n_attrib > 0)
+    attribs[n_attrib*2] = NULL;
+
+  *_attribs = attribs;
+  
+  return n_attrib;
+}
+ 
+/*
+ * Return -1 on error, 0 when nothing is found, 1 on sucess
+ */
+static int
+asx_get_element(ASX_Parser_t* parser,char** _buffer,
+		char** _element,char** _body,char*** _attribs) {
+  char *ptr1,*ptr2, *ptr3, *ptr4;
+  char *attribs = NULL;
+  char *element = NULL, *body = NULL, *ret = NULL, *buffer;
+  int n_attrib = 0;
+  int body_line = 0,attrib_line,ret_line;
+
+  if(_buffer == NULL || _element == NULL || _body == NULL || _attribs == NULL) {
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : asx_get_element called with invalid value",parser->line);
+    return -1;
+  }
+
+  *_body = *_element = NULL;
+  *_attribs =  NULL;
+  buffer = *_buffer;
+
+  if(buffer == NULL) return 0;
+
+  if(parser->ret_stack && /*parser->last_body && */buffer != parser->last_body) {
+    ASX_LineSave_t* ls = parser->ret_stack;
+    int i;
+    for(i = 0 ; i < parser->ret_stack_size ; i++) {
+      if(buffer == ls[i].buffer) {
+	parser->line = ls[i].line;
+	break;
+      }
+      
+    }
+    if( i < parser->ret_stack_size) {
+      i++;
+      if( i < parser->ret_stack_size)	
+	memmove(parser->ret_stack,parser->ret_stack+i, (parser->ret_stack_size - i)*sizeof(ASX_LineSave_t));
+      parser->ret_stack_size -= i;
+      parser->ret_stack = (ASX_LineSave_t*)realloc(parser->ret_stack,parser->ret_stack_size*sizeof(ASX_LineSave_t));      
+    }
+  }
+
+  ptr1 = buffer;
+  while(1) {
+    for( ; ptr1[0] != '<' ; ptr1++) {
+      if(ptr1[0] == '\0') {
+	ptr1 = NULL;
+	break;
+      }
+      if(ptr1[0] == '\n') parser->line++;
+    }
+    //ptr1 = strchr(ptr1,'<');
+    if(!ptr1 || ptr1[1] == '\0') return 0; // Nothing found
+    
+    if(strncmp(ptr1,"<!--",4) == 0) { // Comments
+      for( ; strncmp(ptr1,"-->",3) != 0 ; ptr1++) {
+	if(ptr1[0] == '\0') {
+	  ptr1 = NULL;
+	  break;
+	}
+	if(ptr1[0] == '\n') parser->line++;
+      }
+      //ptr1 = strstr(ptr1,"-->");
+      if(!ptr1) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : unfinished comment",parser->line);
+	return -1;
+      }
+    } else {
+      break;
+    }
+  }
+  
+  // Is this space skip very useful ??
+  for(ptr1++; strchr(SPACE,ptr1[0]) != NULL; ptr1++) { // Skip space
+    if(ptr1[0] == '\0') {
+      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
+      return -1;
+    }
+    if(ptr1[0] == '\n') parser->line++;
+  } 
+
+  for(ptr2 = ptr1; strchr(LETTER,*ptr2) != NULL;ptr2++) { // Go to end of name
+    if(*ptr2 == '\0'){
+      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
+      return -1;
+    }
+    if(ptr2[0] == '\n') parser->line++;
+  }
+
+  element = (char*)malloc(ptr2-ptr1+1);
+  strncpy(element,ptr1,ptr2-ptr1);
+  element[ptr2-ptr1] = '\0';
+
+  for( ; strchr(SPACE,*ptr2) != NULL; ptr2++) { // Skip space
+    if(ptr2[0] == '\0') {
+      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
+      free(element);
+      return -1;
+    }
+    if(ptr2[0] == '\n') parser->line++;
+  }
+  attrib_line = parser->line;
+
+  
+
+  for(ptr3 = ptr2; ptr3[0] != '\0'; ptr3++) { // Go to element end
+    if(ptr3[0] == '>' || strncmp(ptr3,"/>",2) == 0)
+      break;
+    if(ptr3[0] == '\n') parser->line++;
+  }
+  if(ptr3[0] == '\0' || ptr3[1] == '\0') { // End of file
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
+    free(element);
+    return -1;
+  }
+
+  // Save attribs string
+  if(ptr3-ptr2 > 0) {
+    attribs = (char*)malloc(ptr3-ptr2+1);
+    strncpy(attribs,ptr2,ptr3-ptr2);
+    attribs[ptr3-ptr2] = '\0';
+  }
+  //bs_line = parser->line;
+  if(ptr3[0] != '/') { // Not Self closed element
+    ptr3++;
+    for( ; strchr(SPACE,*ptr3) != NULL; ptr3++) { // Skip space on body begin
+      if(*ptr3 == '\0') {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing %s element body",parser->line,element);
+	free(element);
+	if(attribs) free(attribs);
+	return -1;
+      }
+      if(ptr3[0] == '\n') parser->line++;
+    }
+    ptr4 = ptr3;
+    body_line = parser->line;
+    while(1) { // Find closing element
+      for( ; strncmp(ptr4,"</",2) != 0; ptr4++) {
+	if(ptr4[0] == '\0') {
+	  ptr4 = NULL;
+	  break;
+	}
+	if(ptr4[0] == '\n') parser->line++;
+      }
+      //ptr4 = strstr(ptr4,"</");
+      if(ptr4 == NULL || ptr4[2] == '\0') { 
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing %s element body",parser->line,element);
+	free(element);
+	if(attribs) free(attribs);
+	return -1;
+      }
+      if(strncasecmp(element,ptr4+2,strlen(element)) == 0) { // Extract body
+	ret = ptr4+strlen(element)+3;
+	if(ptr4 != ptr3) {
+	  ptr4--;
+	  for( ; ptr4 != ptr3 && strchr(SPACE,*ptr4) != NULL; ptr4--) ;// Skip space on body end
+	  //	    if(ptr4[0] == '\0') parser->line--;
+	  //}
+	  ptr4++;
+	  body = (char*)malloc(ptr4-ptr3+1);
+	  strncpy(body,ptr3,ptr4-ptr3);
+	  body[ptr4-ptr3] = '\0';	  
+	}
+	break;
+      } else {
+	ptr4 += 2;
+      }
+    }
+  } else {
+    ret = ptr3 + 2; // 2 is for />
+  }
+
+  for( ; ret[0] != '\0' && strchr(SPACE,ret[0]) != NULL; ret++) { // Skip space
+    if(ret[0] == '\n') parser->line++;
+  }
+
+  ret_line = parser->line;
+
+  if(attribs) {
+    parser->line = attrib_line;
+    n_attrib = asx_parse_attribs(parser,attribs,_attribs);
+    free(attribs);
+    if(n_attrib < 0) {
+      mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : error while parsing element %s attributes",parser->line,element);
+      free(element);
+      free(body);
+      return -1;
+    }
+  } else
+    *_attribs = NULL;
+
+  *_element = element;
+  *_body = body;
+
+  parser->last_body = body;
+  parser->ret_stack_size++;
+  parser->ret_stack = (ASX_LineSave_t*)realloc(parser->ret_stack,parser->ret_stack_size*sizeof(ASX_LineSave_t));
+  if(parser->ret_stack_size > 1)
+    memmove(parser->ret_stack+1,parser->ret_stack,(parser->ret_stack_size-1)*sizeof(ASX_LineSave_t));
+  parser->ret_stack[0].buffer = ret;
+  parser->ret_stack[0].line = ret_line;
+  parser->line = body ? body_line : ret_line;
+
+  *_buffer = ret;
+  return 1;
+
+}
+
+static void
+asx_parse_ref(ASX_Parser_t* parser, char** attribs, play_tree_t* pt) {
+  char *href;
+
+  href = asx_get_attrib("HREF",attribs);
+  if(href == NULL) {
+    asx_warning_attrib_required(parser,"ENTRYREF" ,"HREF" );
+    return;
+  }
+
+  play_tree_add_file(pt,href);
+
+  mp_msg(MSGT_PLAYTREE,MSGL_V,"Adding file %s to element entry\n",href);
+
+  free(href);
+
+}
+
+static play_tree_t*
+asx_parse_entryref(ASX_Parser_t* parser,char* buffer,char** _attribs) {
+  mp_msg(MSGT_PLAYTREE,MSGL_INFO,"Need to implement entryref\n");
+  return NULL;
+}
+
+static play_tree_t*
+asx_parse_entry(ASX_Parser_t* parser,char* buffer,char** _attribs) {
+  char *element,*body,**attribs;
+  int r,nref=0;
+  play_tree_t *ref;
+
+  ref = play_tree_new();
+
+  while(buffer && buffer[0] != '\0') {
+    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
+    if(r < 0) {
+      asx_warning_body_parse_error(parser,"ENTRY");
+      return NULL;
+    } else if (r == 0) { // No more element
+      break;
+    }
+    if(strcasecmp(element,"REF") == 0) {
+      asx_parse_ref(parser,attribs,ref);
+      mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to entry\n",element);
+      nref++;
+    } else
+      mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Ignoring element %s\n",element);
+    if(body) free(body);
+    asx_free_attribs(attribs);
+  }
+
+  if(nref <= 0) {
+    play_tree_free(ref,1);
+    return NULL;
+  }
+  return ref;
+
+}
+  
+
+static play_tree_t*
+asx_parse_repeat(ASX_Parser_t* parser,char* buffer,char** _attribs) {
+  char *element,*body,**attribs;
+  play_tree_t *repeat, *list=NULL, *entry;
+  char* count;
+  int r;
+
+  repeat = play_tree_new();
+
+  count = asx_get_attrib("COUNT",_attribs);
+  if(count == NULL) {
+    mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Setting element repeat loop to infinit\n");
+    repeat->loop = -1; // Infinit
+  } else {
+    repeat->loop = atoi(count);
+    free(count);
+    if(repeat->loop == 0) repeat->loop = 1;
+    mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Setting element repeat loop to %d\n",repeat->loop);
+  }
+
+  while(buffer && buffer[0] != '\0') {
+    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
+    if(r < 0) {
+      asx_warning_body_parse_error(parser,"REPEAT");
+      return NULL;
+    } else if (r == 0) { // No more element
+      break;
+    }
+    if(strcasecmp(element,"ENTRY") == 0) {
+       entry = asx_parse_entry(parser,body,attribs);
+       if(entry) {
+	 if(!list) list =  entry;
+	 else play_tree_append_entry(list,entry);
+	 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to repeat\n",element);
+       }
+    } else if(strcasecmp(element,"ENTRYREF") == 0) {
+       entry = asx_parse_entryref(parser,body,attribs);
+       if(entry) {
+	 if(!list) list =  entry;
+	 else play_tree_append_entry(list,entry);
+	 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to repeat\n",element);
+       }
+     } else if(strcasecmp(element,"REPEAT") == 0) {
+       entry = asx_parse_repeat(parser,body,attribs);
+       if(entry) {
+	 if(!list) list =  entry;
+	 else play_tree_append_entry(list,entry);
+	 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to repeat\n",element);
+       }
+     } else
+       mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Ignoring element %s\n",element);
+    if(body) free(body);
+     asx_free_attribs(attribs);
+  }
+
+  if(!list) {
+    play_tree_free(repeat,1);
+    return NULL;
+  }
+  play_tree_set_child(repeat,list);
+
+  return repeat;
+
+}
+
+
+
+play_tree_t*
+asx_parser_build_tree(char* buffer) {
+  char *element,*asx_body,**asx_attribs,*body, **attribs;
+  int r;
+  play_tree_t *asx,*entry,*list = NULL;
+  ASX_Parser_t* parser = asx_parser_new();
+
+  parser->line = 1;
+
+   r = asx_get_element(parser,&buffer,&element,&asx_body,&asx_attribs);
+  if(r < 0) {
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : Syntax error ???",parser->line);
+    asx_parser_free(parser);
+    return NULL;
+  } else if(r == 0) { // No contents
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"empty asx element");
+    asx_parser_free(parser);
+    return NULL;
+  }
+
+  if(strcasecmp(element,"ASX") != 0) {
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"first element isn't ASX, it's %s\n",element);
+    asx_free_attribs(asx_attribs);
+    if(body) free(body);
+    asx_parser_free(parser);
+    return NULL;
+  }
+
+  if(!asx_body) {
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"ASX element is empty");
+    asx_free_attribs(asx_attribs);
+    asx_parser_free(parser);
+    return NULL;
+  }
+
+  asx = play_tree_new();
+  buffer = asx_body;
+  while(buffer && buffer[0] != '\0') {
+    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
+     if(r < 0) {
+       asx_warning_body_parse_error(parser,"ASX");
+       asx_parser_free(parser);
+       return NULL;
+     } else if (r == 0) { // No more element
+       break;
+     }
+     if(strcasecmp(element,"ENTRY") == 0) {
+       entry = asx_parse_entry(parser,body,attribs);
+       if(entry) {
+	 if(!list) list =  entry;
+	 else play_tree_append_entry(list,entry);
+	 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to asx\n",element);
+       }
+     } else if(strcasecmp(element,"ENTRYREF") == 0) {
+       entry = asx_parse_entryref(parser,body,attribs);
+       if(entry) {
+	 if(!list) list =  entry;
+	 else play_tree_append_entry(list,entry);
+	 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to asx\n",element);
+       }
+     } else if(strcasecmp(element,"REPEAT") == 0) {
+       entry = asx_parse_repeat(parser,body,attribs);
+       if(entry) {
+	 if(!list) list =  entry;
+	 else play_tree_append_entry(list,entry);
+	 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to asx\n",element);
+       }
+     } else
+       mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Ignoring element %s\n",element);
+     if(body) free(body);
+     asx_free_attribs(attribs);
+  }
+
+  free(asx_body);
+  asx_free_attribs(asx_attribs);
+  asx_parser_free(parser);
+
+
+  if(!list) {
+    play_tree_free(asx,1);
+    
+    return NULL;
+  }
+
+  play_tree_set_child(asx,list);
+
+  return asx;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/asxparser.h	Tue Jan 08 01:24:25 2002 +0000
@@ -0,0 +1,17 @@
+
+#include "playtree.h"
+
+typedef struct _ASX_Parser_t ASX_Parser_t;
+
+typedef struct {
+  char* buffer;
+  int line;
+} ASX_LineSave_t;
+
+struct _ASX_Parser_t {
+  int line; // Curent line
+  ASX_LineSave_t *ret_stack;
+  int ret_stack_size;
+  char* last_body;
+};
+  

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/playtree.c	Tue Jan 08 01:24:25 2002 +0000
@@ -0,0 +1,631 @@
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.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 = (play_tree_t*)calloc(1,sizeof(play_tree_t));
+  if(r == NULL)
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",sizeof(play_tree_t));
+  return r;
+}
+
+void
+play_tree_free(play_tree_t* pt, int childs) {
+  play_tree_t* iter;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+
+  if(childs) {    
+    for(iter = pt->child; iter != NULL; iter = iter->next)
+      play_tree_free(iter,1);
+    pt->child = NULL;
+  }
+
+  play_tree_remove(pt,0,0);
+
+  for(iter = pt->child ; iter != NULL ; iter = iter->next)
+    iter->parent = NULL;
+
+  //if(pt->params) 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 childs) {
+  play_tree_t* iter;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+
+  for(iter = pt ; iter->prev != NULL ; iter = iter->prev)
+    /* NOTHING */;
+
+  for( ; iter != NULL ; iter = iter->next)
+    play_tree_free(iter,childs);
+    
+
+}
+
+void
+play_tree_append_entry(play_tree_t* pt, play_tree_t* entry) {
+  play_tree_t* iter;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(entry != NULL);
+#endif
+
+  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;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(entry != NULL);
+#endif
+
+  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) {
+#ifdef DEBUG
+    assert(entry->parent->child == iter);
+#endif
+    entry->parent->child = entry;
+  }
+}
+
+void
+play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry) {
+  
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(entry != NULL);
+#endif
+
+  entry->parent = pt->parent;
+  entry->prev = pt;
+  if(pt->next) {
+#ifdef DEBUG
+    assert(pt->next->prev == pt);
+#endif
+    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_childs) {
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+
+  // Middle of list
+  if(pt->prev && pt->next) {
+#ifdef DEBUG
+    assert(pt->prev->next == pt);
+    assert(pt->next->prev == pt);
+#endif
+    pt->prev->next = pt->next;
+    pt->next->prev = pt->prev;
+  } // End of list
+  else if(pt->prev) { 
+#ifdef DEBUG
+    assert(pt->prev->next == pt);
+#endif
+    pt->prev->next = NULL;
+  } // Begining of list
+  else if(pt->next) {
+#ifdef DEBUG
+    assert(pt->next->prev == pt);
+#endif
+    pt->next->prev = NULL;
+    if(pt->parent) {
+#ifdef DEBUG
+      assert(pt->parent->child == pt);
+#endif
+      pt->parent->child = pt->next;
+    } 
+  } // The only one
+  else if(pt->parent) {
+#ifdef DEBUG
+    assert(pt->parent->child == pt);
+#endif
+    pt->parent->child = NULL;
+  }
+
+  pt->prev = pt->next = pt->parent = NULL;
+  if(free_it)
+    play_tree_free(pt,with_childs);
+
+}
+
+void
+play_tree_set_child(play_tree_t* pt, play_tree_t* child) {
+  play_tree_t* iter;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(pt->files == NULL);
+#endif
+
+  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;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+
+  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,char* file) {
+  int n = 0;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(pt->child == NULL);
+  assert(file != NULL);
+#endif
+
+  if(pt->files) {
+    for(n = 0 ; pt->files[n] != NULL ; n++)
+      /* NOTHING */;
+  }
+  pt->files = (char**)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)*sizeof(char*));
+    return;
+  }
+
+  pt->files[n] = strdup(file);
+  pt->files[n+1] = NULL;
+
+}
+
+int
+play_tree_remove_file(play_tree_t* pt,char* file) {
+  int n,f = -1;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(file != NULL);
+  assert(pt->files != NULL);
+#endif
+
+  for(n=0 ; pt->files[n] != NULL ; n++) {
+    if(strcmp(file,pt->files[n]) == 0)
+      f = n;
+  }
+
+  if(f < 0) // Not found
+    return 0;
+
+#ifdef DEBUG
+  assert(n > f);
+#endif
+
+  free(pt->files[f]);
+
+  if(n > 1) {
+    memmove(&pt->files[f],&pt->files[f+1],(n-f)*sizeof(char*));
+    pt->files = (char**)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)*sizeof(char*));
+      return -1;
+    }
+  } else {
+    free(pt->files);
+    pt->files = NULL;
+  }
+
+  return 1;
+}
+
+#if 0
+void
+play_tree_set_param(play_tree_t* pt, char* name, char* val) {
+  int n = 0,ni = -1;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(name != NULL);
+#endif
+
+  if(pt->params) {
+    for( ; pt->params[n].name != NULL ; n++) {
+      if(strcasecmp(pt->params[n].name,name) == 0)
+	ni = n;
+    }
+  }
+
+  if(ni > 0) {
+    if(pt->params[n].value != NULL) free(pt->params[n].value);
+    pt->params[n].value = val;
+    return;
+  }
+
+  pt->params = (play_tree_param_t*)realloc(pt->params,(n+2)*sizeof(play_tree_param_t));
+  pt->params[n].name = strdup(name);
+  pt->params[n].value = val != NULL ? strdup(val) : NULL;
+  memset(&pt->params[n+1],0,sizeof(play_tree_param_t));
+
+  return;
+}
+
+int
+play_tree_unset_param(play_tree_t* pt, char* name) {
+  int n,ni = 0;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+  assert(name != NULL);
+  assert(pt->params != NULL);
+#endif
+
+  for(n = 0 ; pt->params[n].name != NULL ; n++) {
+    if(strcasecmp(pt->params[n].name,name) == 0)
+      ni = n;
+  }
+
+  if(ni < 0)
+    return 0;
+
+  if(n > 1) {
+    memmove(&pt->params[ni],&pt->params[ni+1],(n-ni)*sizeof(play_tree_param_t));
+    pt->params = (play_tree_param_t*)realloc(pt->params,n*sizeof(play_tree_param_t));
+    assert(pt->params != NULL);
+  } else {
+    free(pt->params);
+    pt->params = NULL;
+  }
+
+  return 1;
+}
+
+#endif
+
+play_tree_iter_t*
+play_tree_iter_new(play_tree_t* pt) {
+  play_tree_iter_t* iter;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+  
+  if( ! play_tree_is_valid(pt))
+    return NULL;
+
+  iter = (play_tree_iter_t*)calloc(1,sizeof(play_tree_iter_t));
+  if(! iter) return NULL;
+  iter->root = pt;
+  iter->tree = NULL;
+ 
+  if(pt->parent)
+    iter->loop = pt->parent->loop;
+
+  return iter;
+}
+
+void
+play_tree_iter_free(play_tree_iter_t* iter) {
+  
+#ifdef DEBUG
+  assert(iter != NULL);
+#endif
+
+  if(iter->status_stack) {
+#ifdef DEBUG
+    assert(iter->stack_size > 0);
+#endif
+    free(iter->status_stack);
+  }
+
+  free(iter);
+}
+
+int
+play_tree_iter_step(play_tree_iter_t* iter, int d,int with_nodes) {
+  play_tree_t* pt;
+
+#ifdef DEBUG
+  assert(iter != NULL);
+  assert(iter->root != NULL);
+#endif
+
+  if(iter->tree == NULL) {
+    iter->tree = iter->root;
+    return play_tree_iter_step(iter,0,with_nodes);
+  }
+
+  iter->file = 0;
+  if( d > 0 )
+    pt = iter->tree->next;
+  else if(d < 0)
+    pt = iter->tree->prev;
+  else
+    pt = iter->tree;
+
+  if(pt == NULL) { // No next
+    // Must we loop?
+    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 childs ?
+  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 enty ?
+  if(! play_tree_is_valid(pt)) {
+    if(d == 0) { // Can this happen ?
+      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);
+  }
+
+#ifdef DEBUG
+  assert(iter->tree->files != NULL);
+#endif
+  
+  iter->tree = pt;
+  for(d = 0 ; iter->tree->files[d] != NULL ; d++)
+    /* NOTHING */;
+  iter->num_files = d;
+
+  return PLAY_TREE_ITER_ENTRY;
+
+}
+
+static int
+play_tree_is_valid(play_tree_t* pt) {
+  play_tree_t* iter;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+
+  if(pt->files != 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) {
+
+#ifdef DEBUG
+  assert(iter != NULL);
+  assert(iter->tree != NULL);
+#endif
+  
+  iter->file = 0;
+  if(iter->tree->parent == iter->root->parent)
+    return PLAY_TREE_ITER_END;
+
+#ifdef DEBUG
+  assert(iter->tree->parent != NULL);
+  assert(iter->stack_size > 0);
+  assert(iter->status_stack != NULL);
+#endif
+  
+  // Pop status
+  iter->stack_size--;
+  iter->loop = iter->status_stack[iter->stack_size];
+  iter->status_stack = (int*)realloc(iter->status_stack,iter->stack_size*sizeof(int));
+  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*sizeof(char*));
+    return PLAY_TREE_ITER_ERROR;
+  }
+  iter->tree = iter->tree->parent;
+  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) {
+
+#ifdef DEBUG
+  assert(iter->tree->files == NULL);
+  assert(iter->tree->child != NULL);
+  assert(iter->tree->child->parent == iter->tree);
+#endif
+
+  iter->file = 0;
+  //  Push status
+  iter->stack_size++;
+  iter->status_stack = (int*)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*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) {
+  
+#ifdef DEBUG
+  assert(iter != NULL);
+  assert(iter->tree->child == NULL);
+#endif
+
+  if(iter->tree->files == NULL)
+    return NULL;
+
+  if(d > 0) {
+    if(iter->tree->files[iter->file] == NULL)
+      return NULL;
+    iter->file++;
+  } else if(d < 0) {
+    if(iter->file == 0)
+      return NULL;
+    iter->file--;
+  } 
+  return iter->tree->files[iter->file-1];
+}
+
+play_tree_t*
+play_tree_cleanup(play_tree_t* pt) {
+  play_tree_t* iter, *tmp, *first;
+
+#ifdef DEBUG
+  assert(pt != NULL);
+#endif
+
+  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;
+
+#ifdef DEBUG
+  assert(old != NULL);
+#endif
+
+  iter = (play_tree_iter_t*)malloc(sizeof(play_tree_iter_t));
+  if(iter == NULL) {
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",sizeof(play_tree_iter_t));
+    return NULL;
+  }
+;
+  memcpy(iter,old,sizeof(play_tree_iter_t));
+  if(old->status_stack) {
+    iter->status_stack = (int*)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 * sizeof(int));
+      free(iter);
+      return NULL;
+    }
+    memcpy(iter->status_stack,old->status_stack,iter->stack_size*sizeof(int));
+  }
+  return iter;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/playtree.h	Tue Jan 08 01:24:25 2002 +0000
@@ -0,0 +1,144 @@
+
+#include "libmpdemux/stream.h"
+
+#define PLAY_TREE_ITER_ERROR 0
+#define PLAY_TREE_ITER_ENTRY 1
+#define PLAY_TREE_ITER_NODE  2
+#define PLAY_TREE_ITER_END 3
+
+typedef struct play_tree play_tree_t;
+typedef struct play_tree_iter play_tree_iter_t;
+
+#if 0
+typedef struct play_tree_info play_tree_info_t;
+typedef struct play_tree_param play_tree_param_t;
+
+// TODO : a attrib,val pair system and not something hardcoded
+struct play_tree_info {
+  char* title;
+  char* author;
+  char* copyright;
+  char* abstract;
+  // Some more ??
+}
+
+struct play_tree_param {
+  char* name;
+  char* value;
+}
+#endif
+
+struct play_tree {
+  play_tree_t* parent;
+  play_tree_t* child;
+  play_tree_t* next;
+  play_tree_t* prev;
+
+  //play_tree_info_t info;
+  //int n_param;
+  //play_tree_param_t* params;
+  int loop;
+  char** files;
+};
+  
+struct play_tree_iter {
+  play_tree_t* root; // Iter root tree
+  play_tree_t* tree; // Current tree
+  // struct m_config* config; 
+  int loop;  // Looping status
+  int file;
+  int num_files;
+ 
+  int* status_stack; //  loop/valid stack to save/revert status when we go up/down
+  int stack_size;  // status stack size
+};
+
+play_tree_t* 
+play_tree_new(void);
+
+// If childs is true 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,char* file);
+
+int
+play_tree_remove_file(play_tree_t* pt,char* file);
+
+
+#if 0
+// Val can be NULL
+void
+play_tree_set_param(play_tree_t* pt, char* name, char* val);
+
+int
+play_tree_unset_param(play_tree_t* pt, char* name);
+
+#endif
+
+
+/// Iterator
+
+play_tree_iter_t*
+play_tree_iter_new(play_tree_t* pt);
+
+play_tree_iter_t*
+play_tree_iter_new_copy(play_tree_iter_t* old);
+
+void
+play_tree_iter_free(play_tree_iter_t* iter);
+
+// d is the direction : d > 0 == next , d < 0 == prev
+// with_node : TRUE == stop on nodes with childs, FALSE == go directly to the next child
+
+int 
+play_tree_iter_step(play_tree_iter_t* iter, int d,int with_nodes);
+
+int // Break a loop, etc
+play_tree_iter_up_step(play_tree_iter_t* iter, int d,int with_nodes);
+
+int // Enter a node child list
+play_tree_iter_down_step(play_tree_iter_t* iter, int d,int with_nodes);
+
+char*
+play_tree_iter_get_file(play_tree_iter_t* iter, int d);
+
+play_tree_t*
+parse_playtree(stream_t *stream);
+
+play_tree_t*
+play_tree_cleanup(play_tree_t* pt);
+
+play_tree_t*
+parse_playlist_file(char* file);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/playtreeparser.c	Tue Jan 08 01:24:25 2002 +0000
@@ -0,0 +1,298 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "playtree.h"
+#include "libmpdemux/stream.h"
+#include "mp_msg.h"
+
+extern play_tree_t*
+asx_parser_build_tree(char* buffer);
+
+
+static char* buffer = NULL;
+static int buffer_size = 0, buffer_end = 0;
+
+
+
+play_tree_t*
+parse_asx(stream_t* stream) {
+  int r;
+  int comments = 0,read = 1,eof = 0;
+
+  mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying asx...\n");
+  
+  while(1) {
+    if(read && eof) // Eof reached before anything useful
+      return NULL;
+    if(read) {
+      if(buffer_size - buffer_end < 50) buffer_size += 255;
+      buffer = (char*)realloc(buffer,buffer_size*sizeof(char));
+      if(buffer == NULL) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",buffer_size*sizeof(char));
+	buffer_size = buffer_end = 0;
+	return NULL;
+      }
+  
+      r = stream_read(stream,buffer+buffer_end,buffer_size-buffer_end-1);
+      if(r < 0) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't read from stream r=%d\n",r);
+	return NULL;
+      } else if(r == 0)
+	eof = 1;
+      buffer_end += r;
+      buffer[buffer_end] = '\0';
+    }
+
+    if(comments)  { // Jump comments
+      int e;
+      char* end = strstr(buffer,"-->");
+      if(!end) {
+	if(buffer[buffer_end-1] != '-')
+	  buffer_end = 0; // Drop buffer content if last char isn't '-'
+	continue;
+      }
+      comments = 0;
+      e = end - buffer + 3;
+      if(e >= buffer_end) { // > seems impossible
+	buffer_end = 0; // Drop buffer content
+	read = 1;
+	continue;
+      }
+      buffer_end -= e;
+      memmove(buffer,end+3,buffer_end); // Drop comments
+      continue;
+    } 
+    
+    for(r= 0 ; r < buffer_end ; r++) {
+      if(strchr(" \n\r\t",buffer[r]) != NULL) // Jump space
+	continue;
+      if(buffer[r] != '<') {
+	mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"First char isn't '<' but '%c'\n",buffer[r]);
+	mp_msg(MSGT_PLAYTREE,MSGL_DBG3,"Buffer = [%s]\n",buffer);
+	return NULL;
+      }
+      break; // Stop on first '<'
+    }
+    if(r  > buffer_end-4) { // We need more
+      if(r > 0) { // Drop unuseful beggining
+	buffer_end -= r;
+	memmove(buffer,&buffer[r],buffer_end);
+      }
+      read = 1;
+      continue;
+    }
+
+    if(strncmp(&buffer[r],"<!--",4) == 0) { // Comments
+      read = 0;
+      comments = 1;
+      continue;
+    }
+
+    if(strncasecmp(&buffer[r],"<ASX",4) != 0) // First element is not a comment nor an asx : end
+      return NULL;
+	
+	
+    mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected asx format\n");
+    break;
+  }
+  // We have an asx : load it in memory and parse
+
+  while(!eof) {
+    if(buffer_size - buffer_end < 50) buffer_size += 255;
+    buffer = (char*)realloc(buffer,buffer_size*sizeof(char));
+    if(buffer == NULL) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",buffer_size*sizeof(char));
+	buffer_size = buffer_end = 0;
+	return NULL;
+      }
+    r = stream_read(stream,buffer+buffer_end,buffer_size-buffer_end-1);
+    if(r > 0)
+      buffer_end += r;
+    if(r <= 0)
+      break;
+    buffer[buffer_end] = '\0';
+  }
+
+ mp_msg(MSGT_PLAYTREE,MSGL_DBG3,"Parsing asx file : [%s]\n",buffer);
+  return asx_parser_build_tree(buffer);
+  
+
+}
+
+play_tree_t*
+parse_textplain(stream_t *stream) {
+  char* end;
+  char* file;
+  int eof = 0,r,p_end=-1,resize = 0;
+  play_tree_t *list = NULL, *entry = NULL;
+
+  mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying plaintext...\n");
+
+  if(buffer_size < 255 && ! stream->eof) {
+    buffer_size = 255;
+    buffer = (char*)realloc(buffer,buffer_size*sizeof(char));
+    if(buffer == NULL) {
+      mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",buffer_size*sizeof(char));
+      buffer_size = buffer_end = 0;
+      return NULL;
+      }
+  }
+
+
+  while(!eof) {
+    if(resize) {
+      buffer_size += 255;
+      buffer = (char*)realloc(buffer,buffer_size*sizeof(char));
+      resize = 0;
+      if(buffer == NULL) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",buffer_size*sizeof(char));
+	buffer_size = buffer_end = 0;
+	if(list) play_tree_free_list(list,1);
+	return NULL;
+      }
+    }
+    if(!stream->eof) {
+      r = stream_read(stream,buffer+buffer_end,buffer_size-buffer_end-1);
+      if(r < 0) {
+	mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't read from stream r=%d\n",r);
+	return NULL;
+      } else if(r == 0)
+	eof = 1;
+    buffer_end += r;
+    buffer[buffer_end] = '\0';
+    } else eof = 1;
+    r = 0;
+    while(1) {
+      p_end = r;
+      for( ; buffer[r] != '\0' ; r++) {
+	if(strchr(" \n\r\t",buffer[r]) != NULL)
+	  continue;
+	break;
+      }
+      if(buffer[r] == '\0') {
+	p_end = r;
+	if(!eof)
+	  resize = 1;
+	break;
+      }
+      end = strchr(&buffer[r],'\n');      
+      if(!end) {
+	if(!eof) {
+	  p_end = r;
+	  if(p_end == 0) {
+	    resize = 1;
+	  }
+	  break;
+	}
+	entry = play_tree_new();
+	play_tree_add_file(entry,&buffer[r]);
+	r = buffer_end;
+	
+      }
+      else {
+	if(r > 0 && buffer[r-1] == '\r') r--;
+	file = (char*)malloc((end-(&buffer[r])+1)*sizeof(char));
+	if(file == NULL) {
+	  mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Can't allocate %d bytes of memory\n",buffer_size*sizeof(char));
+	  buffer_size = buffer_end = 0;
+	  if(list) play_tree_free_list(list,1);
+	  return NULL;
+	}
+	// TODO : Check if the given file exist and is readable (or it'a an url)	  
+	strncpy(file,&buffer[r],end-(&buffer[r]));
+	file[end-(&buffer[r])] = '\0';
+	entry = play_tree_new();
+	play_tree_add_file(entry,file);	
+	free(file);
+	r += end-(&buffer[r]);
+	p_end = r;
+      }
+      if(entry) {
+	mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding file %s to playlist\n",entry->files[0]);
+	if(list) play_tree_append_entry(list,entry);
+	else list = entry;
+	entry = NULL;
+      }
+    }
+    if(!eof && p_end > 0 && p_end < buffer_end) {
+      memmove(buffer,&buffer[p_end],buffer_end-p_end);
+      buffer_end -= p_end;
+    } else if(!eof && !resize && p_end == buffer_end) {
+      buffer_end = 0;
+      buffer[0] = '\0';
+    }
+  }
+   
+  if(!list) return NULL;
+  entry = play_tree_new();
+  play_tree_set_child(entry,list);
+  return entry;    
+}
+
+play_tree_t*
+parse_playtree(stream_t *stream) {
+  play_tree_t* tree = NULL;
+  
+#ifdef DEBUG
+  assert(stream != NULL);
+  assert(stream->type == STREAMTYPE_PLAYLIST);
+#endif
+
+  while(1) {
+    tree = parse_asx(stream);
+    if(tree) break;
+    // Here come the others formats ( textplain must stay the last one )
+    tree = parse_textplain(stream);
+    if(tree) break;
+    break;
+  }
+
+  if(tree)
+    mp_msg(MSGT_PLAYTREE,MSGL_V,"Playlist succefully parsed\n");
+  else mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error while parsing playlist\n");
+
+  if(tree)
+    tree = play_tree_cleanup(tree);
+
+  if(!tree) mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Warning empty playlist\n");
+
+  if(buffer) free(buffer);
+  buffer = NULL;
+  buffer_end = buffer_size = 0;
+  return tree;
+}
+
+play_tree_t*
+parse_playlist_file(char* file) {
+  stream_t *stream;
+  play_tree_t* ret;
+  int fd;
+
+  if(!strcmp(file,"-"))
+    fd = 0;
+  else
+    fd = open(file,O_RDONLY);
+
+  if(fd < 0) {
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error while opening playlist file %s : %s\n",file,strerror(errno));
+    return NULL;
+  }
+
+  mp_msg(MSGT_PLAYTREE,MSGL_V,"Parsing playlist file %s...\n",file);
+
+  stream = new_stream(fd,STREAMTYPE_PLAYLIST);
+  ret = parse_playtree(stream);
+  if(close(fd) < 0)
+    mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Warning error while closing playlist file %s : %s\n",file,strerror(errno));
+  free_stream(stream);
+
+  return ret;
+
+}