playtreeparser.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 /// \file
  20 /// \ingroup PlaytreeParser
  21
  22 #include "config.h"
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <assert.h>
  27 #include <errno.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <ctype.h>
  33 #include <limits.h>
  34 #include "asxparser.h"
  35 #include "m_config.h"
  36 #include "playtree.h"
  37 #include "playtreeparser.h"
  38 #include "stream/stream.h"
  39 #include "libmpdemux/demuxer.h"
  40 #include "mp_msg.h"
  41
  42
  43 #define BUF_STEP 1024
  44
  45 #define WHITES " \n\r\t"
  46
  47 static void
  48 strstrip(char* str) {
  49   char* i;
  50
  51   if (str==NULL)
  52     return;
  53   for(i = str ; i[0] != '\0' && strchr(WHITES,i[0]) != NULL; i++)
  54     /* NOTHING */;
  55   if(i[0] != '\0') {
  56     memmove(str,i,strlen(i) + 1);
  57     for(i = str + strlen(str) - 1 ; strchr(WHITES,i[0]) != NULL; i--)
  58       /* NOTHING */;
  59     i[1] = '\0';
  60   } else
  61     str[0] = '\0';
  62 }
  63
  64 static char*
  65 play_tree_parser_get_line(play_tree_parser_t* p) {
  66   char *end,*line_end;
  67   int r,resize = 0;
  68
  69   if(p->buffer == NULL) {
  70     p->buffer = malloc(BUF_STEP);
  71     p->buffer_size = BUF_STEP;
  72     p->buffer[0] = 0;
  73     p->iter = p->buffer;
  74   }
  75
  76   if(p->stream->eof && (p->buffer_end == 0 || p->iter[0] == '\0'))
  77     return NULL;
  78
  79   assert(p->buffer_end < p->buffer_size);
  80   assert(!p->buffer[p->buffer_end]);
  81   while(1) {
  82
  83     if(resize) {
  84       char *tmp;
  85       r = p->iter - p->buffer;
  86       end = p->buffer + p->buffer_end;
  87       if (p->buffer_size > INT_MAX - BUF_STEP)
  88         break;
  89       tmp = realloc(p->buffer, p->buffer_size + BUF_STEP);
  90       if (!tmp)
  91         break;
  92       p->buffer = tmp;
  93       p->iter = p->buffer + r;
  94       p->buffer_size += BUF_STEP;
  95       resize = 0;
  96     }
  97
  98     if(p->buffer_size - p->buffer_end > 1 && ! p->stream->eof) {
  99       r = stream_read(p->stream,p->buffer + p->buffer_end,p->buffer_size - p->buffer_end - 1);
 100       if(r > 0) {
 101         p->buffer_end += r;
 102         assert(p->buffer_end < p->buffer_size);
 103         p->buffer[p->buffer_end] = '\0';
 104         while(strlen(p->buffer + p->buffer_end - r) != r)
 105           p->buffer[p->buffer_end - r + strlen(p->buffer + p->buffer_end - r)] = '\n';
 106       }
 107       assert(!p->buffer[p->buffer_end]);
 108     }
 109
 110     end = strchr(p->iter,'\n');
 111     if(!end) {
 112       if(p->stream->eof) {
 113         end = p->buffer + p->buffer_end;
 114         break;
 115       }
 116       resize = 1;
 117       continue;
 118     }
 119     break;
 120   }
 121
 122   line_end = (end > p->iter && *(end-1) == '\r') ? end-1 : end;
 123   if(line_end - p->iter >= 0)
 124     p->line = realloc(p->line, line_end - p->iter + 1);
 125   else
 126     return NULL;
 127   if(line_end - p->iter > 0)
 128     strncpy(p->line,p->iter,line_end - p->iter);
 129   p->line[line_end - p->iter] = '\0';
 130   if(end[0] != '\0')
 131     end++;
 132
 133   if(!p->keep) {
 134     if(end[0] != '\0') {
 135       p->buffer_end -= end-p->iter;
 136       memmove(p->buffer,end,p->buffer_end);
 137     } else
 138       p->buffer_end = 0;
 139     p->buffer[p->buffer_end] = '\0';
 140     p->iter = p->buffer;
 141   } else
 142     p->iter = end;
 143
 144   return p->line;
 145 }
 146
 147 static void
 148 play_tree_parser_reset(play_tree_parser_t* p) {
 149   p->iter = p->buffer;
 150 }
 151
 152 static void
 153 play_tree_parser_stop_keeping(play_tree_parser_t* p) {
 154   p->keep = 0;
 155   if(p->iter && p->iter != p->buffer) {
 156     p->buffer_end -= p->iter -p->buffer;
 157     if(p->buffer_end)
 158       memmove(p->buffer,p->iter,p->buffer_end);
 159     p->buffer[p->buffer_end] = 0;
 160     p->iter = p->buffer;
 161   }
 162 }
 163
 164
 165 static play_tree_t*
 166 parse_asx(play_tree_parser_t* p) {
 167   int comments = 0,get_line = 1;
 168   char* line = NULL;
 169
 170   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying asx...\n");
 171
 172   while(1) {
 173     if(get_line) {
 174       line = play_tree_parser_get_line(p);
 175       if(!line)
 176         return NULL;
 177       strstrip(line);
 178       if(line[0] == '\0')
 179         continue;
 180     }
 181     if(!comments) {
 182       if(line[0] != '<') {
 183         mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"First char isn't '<' but '%c'\n",line[0]);
 184         mp_msg(MSGT_PLAYTREE,MSGL_DBG3,"Buffer = [%s]\n",p->buffer);
 185         return NULL;
 186       } else if(strncmp(line,"<!--",4) == 0) { // Comments
 187         comments = 1;
 188         line += 4;
 189         if(line[0] != '\0' && strlen(line) > 0)
 190           get_line = 0;
 191       } else if(strncasecmp(line,"<ASX",4) == 0) // We got an asx element
 192         break;
 193       else // We don't get an asx
 194         return NULL;
 195     } else { // Comments
 196       char* c;
 197       c = strchr(line,'-');
 198       if(c) {
 199         if (strncmp(c,"--!>",4) == 0) { // End of comments
 200           comments = 0;
 201           line = c+4;
 202           if(line[0] != '\0') // There is some more data on this line : keep it
 203             get_line = 0;
 204
 205         } else {
 206           line = c+1; // Jump the -
 207           if(line[0] != '\0') // Some more data
 208             get_line = 0;
 209           else  // End of line
 210             get_line = 1;
 211         }
 212       } else // No - on this line (or rest of line) : get next one
 213         get_line = 1;
 214     }
 215   }
 216
 217   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected asx format\n");
 218
 219   // We have an asx : load it in memory and parse
 220
 221   while((line = play_tree_parser_get_line(p)) != NULL)
 222     /* NOTHING */;
 223
 224  mp_msg(MSGT_PLAYTREE,MSGL_DBG3,"Parsing asx file: [%s]\n",p->buffer);
 225  return asx_parser_build_tree(p->buffer,p->deep);
 226 }
 227
 228 static char*
 229 pls_entry_get_value(char* line) {
 230   char* i;
 231
 232   i = strchr(line,'=');
 233   if(!i || i[1] == '\0')
 234     return NULL;
 235   else
 236     return i+1;
 237 }
 238
 239 typedef struct pls_entry {
 240   char* file;
 241   char* title;
 242   char* length;
 243 } pls_entry_t;
 244
 245 static int
 246 pls_read_entry(char* line,pls_entry_t** _e,int* _max_entry,char** val) {
 247   int num,max_entry = (*_max_entry);
 248   pls_entry_t* e = (*_e);
 249   int limit = INT_MAX / sizeof(*e);
 250   char* v;
 251
 252   v = pls_entry_get_value(line);
 253   if(!v) {
 254     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line);
 255     return -1;
 256   }
 257
 258   num = atoi(line);
 259   if(num <= 0 || num > limit) {
 260     if (max_entry >= limit) {
 261         mp_msg(MSGT_PLAYTREE, MSGL_WARN, "Too many index entries\n");
 262         return -1;
 263     }
 264     num = max_entry+1;
 265     mp_msg(MSGT_PLAYTREE,MSGL_WARN,"No or invalid entry index in entry %s\nAssuming %d\n",line,num);
 266   }
 267   if(num > max_entry) {
 268     e = realloc(e, num * sizeof(pls_entry_t));
 269     if (!e)
 270       return -1;
 271     memset(&e[max_entry],0,(num-max_entry)*sizeof(pls_entry_t));
 272     max_entry = num;
 273   }
 274   (*_e) = e;
 275   (*_max_entry) = max_entry;
 276   (*val) = v;
 277
 278   return num;
 279 }
 280
 281
 282 static play_tree_t*
 283 parse_pls(play_tree_parser_t* p) {
 284   char *line,*v;
 285   pls_entry_t* entries = NULL;
 286   int n_entries = 0,max_entry=0,num;
 287   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 288
 289   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying Winamp playlist...\n");
 290   while((line = play_tree_parser_get_line(p))) {
 291     strstrip(line);
 292     if(strlen(line))
 293       break;
 294   }
 295   if (!line)
 296     return NULL;
 297   if(strcasecmp(line,"[playlist]"))
 298     return NULL;
 299   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected Winamp playlist format\n");
 300   play_tree_parser_stop_keeping(p);
 301   line = play_tree_parser_get_line(p);
 302   if(!line)
 303     return NULL;
 304   strstrip(line);
 305   if(strncasecmp(line,"NumberOfEntries",15) == 0) {
 306     v = pls_entry_get_value(line);
 307     n_entries = atoi(v);
 308     if(n_entries < 0)
 309       mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Invalid number of entries: very funny!!!\n");
 310     else
 311       mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Playlist claims to have %d entries. Let's see.\n",n_entries);
 312     line = play_tree_parser_get_line(p);
 313   }
 314
 315   while(line) {
 316     strstrip(line);
 317     if(line[0] == '\0') {
 318       line = play_tree_parser_get_line(p);
 319       continue;
 320     }
 321     if(strncasecmp(line,"File",4) == 0) {
 322       num = pls_read_entry(line+4,&entries,&max_entry,&v);
 323       if(num < 0)
 324         mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line);
 325       else
 326         entries[num-1].file = strdup(v);
 327     } else if(strncasecmp(line,"Title",5) == 0) {
 328       num = pls_read_entry(line+5,&entries,&max_entry,&v);
 329       if(num < 0)
 330         mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line);
 331       else
 332         entries[num-1].title = strdup(v);
 333     } else if(strncasecmp(line,"Length",6) == 0) {
 334       num = pls_read_entry(line+6,&entries,&max_entry,&v);
 335       if(num < 0)
 336         mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line);
 337       else
 338         entries[num-1].length = strdup(v);
 339     } else
 340       mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Unknown entry type %s\n",line);
 341     line = play_tree_parser_get_line(p);
 342   }
 343
 344   for(num = 0; num < max_entry ; num++) {
 345     if(entries[num].file == NULL)
 346       mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Entry %d don't have a file !!!!\n",num+1);
 347     else {
 348       mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding entry %s\n",entries[num].file);
 349       entry = play_tree_new();
 350       play_tree_add_file(entry,entries[num].file);
 351       free(entries[num].file);
 352       if(list)
 353         play_tree_append_entry(last_entry,entry);
 354       else
 355         list = entry;
 356       last_entry = entry;
 357     }
 358     if(entries[num].title) {
 359       // When we have info in playtree we add this info
 360       free(entries[num].title);
 361     }
 362     if(entries[num].length) {
 363       // When we have info in playtree we add this info
 364       free(entries[num].length);
 365     }
 366   }
 367
 368   free(entries);
 369
 370   entry = play_tree_new();
 371   play_tree_set_child(entry,list);
 372   return entry;
 373 }
 374
 375 /*
 376  Reference Ini-Format: Each entry is assumed a reference
 377  */
 378 static play_tree_t*
 379 parse_ref_ini(play_tree_parser_t* p) {
 380   char *line,*v;
 381   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 382
 383   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying reference-ini playlist...\n");
 384   if (!(line = play_tree_parser_get_line(p)))
 385     return NULL;
 386   strstrip(line);
 387   if(strcasecmp(line,"[Reference]"))
 388     return NULL;
 389   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected reference-ini playlist format\n");
 390   play_tree_parser_stop_keeping(p);
 391   line = play_tree_parser_get_line(p);
 392   if(!line)
 393     return NULL;
 394   while(line) {
 395     strstrip(line);
 396     if(strncasecmp(line,"Ref",3) == 0) {
 397       v = pls_entry_get_value(line+3);
 398       if(!v)
 399         mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line);
 400       else
 401       {
 402         mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding entry %s\n",v);
 403         entry = play_tree_new();
 404         play_tree_add_file(entry,v);
 405         if(list)
 406           play_tree_append_entry(last_entry,entry);
 407         else
 408           list = entry;
 409         last_entry = entry;
 410       }
 411     }
 412     line = play_tree_parser_get_line(p);
 413   }
 414
 415   if(!list) return NULL;
 416   entry = play_tree_new();
 417   play_tree_set_child(entry,list);
 418   return entry;
 419 }
 420
 421 static play_tree_t*
 422 parse_m3u(play_tree_parser_t* p) {
 423   char* line;
 424   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 425
 426   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying extended m3u playlist...\n");
 427   if (!(line = play_tree_parser_get_line(p)))
 428     return NULL;
 429   strstrip(line);
 430   if(strcasecmp(line,"#EXTM3U"))
 431     return NULL;
 432   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected extended m3u playlist format\n");
 433   play_tree_parser_stop_keeping(p);
 434
 435   while((line = play_tree_parser_get_line(p)) != NULL) {
 436     strstrip(line);
 437     if(line[0] == '\0')
 438       continue;
 439     /* EXTM3U files contain such lines:
 440      * #EXTINF:<seconds>, <title>
 441      * followed by a line with the filename
 442      * for now we have no place to put that
 443      * so we just skip that extra-info ::atmos
 444      */
 445     if(line[0] == '#') {
 446 #if 0 /* code functional */
 447       if(strncasecmp(line,"#EXTINF:",8) == 0) {
 448         mp_msg(MSGT_PLAYTREE,MSGL_INFO,"[M3U] Duration: %dsec  Title: %s\n",
 449           strtol(line+8,&line,10), line+2);
 450       }
 451 #endif
 452       continue;
 453     }
 454     entry = play_tree_new();
 455     play_tree_add_file(entry,line);
 456     if(!list)
 457       list = entry;
 458     else
 459       play_tree_append_entry(last_entry,entry);
 460     last_entry = entry;
 461   }
 462
 463   if(!list) return NULL;
 464   entry = play_tree_new();
 465   play_tree_set_child(entry,list);
 466   return entry;
 467 }
 468
 469 static play_tree_t*
 470 parse_smil(play_tree_parser_t* p) {
 471   int entrymode=0;
 472   char* line,source[512],*pos,*s_start,*s_end,*src_line;
 473   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 474   int is_rmsmil = 0;
 475   unsigned int npkt, ttlpkt;
 476
 477   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying smil playlist...\n");
 478
 479   // Check if smil
 480   while((line = play_tree_parser_get_line(p)) != NULL) {
 481     strstrip(line);
 482     if(line[0] == '\0') // Ignore empties
 483       continue;
 484     if (strncasecmp(line,"<?xml",5)==0) // smil in xml
 485       continue;
 486     if (strncasecmp(line,"<!DOCTYPE smil",13)==0) // smil in xml
 487       continue;
 488     if (strncasecmp(line,"<smil",5)==0 || strncasecmp(line,"<?wpl",5)==0 ||
 489       strncasecmp(line,"(smil-document",14)==0)
 490       break; // smil header found
 491     else
 492       return NULL; //line not smil exit
 493   }
 494
 495   if (!line) return NULL;
 496   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected smil playlist format\n");
 497   play_tree_parser_stop_keeping(p);
 498
 499   if (strncasecmp(line,"(smil-document",14)==0) {
 500     mp_msg(MSGT_PLAYTREE,MSGL_V,"Special smil-over-realrtsp playlist header\n");
 501     is_rmsmil = 1;
 502     if (sscanf(line, "(smil-document (ver 1.0)(npkt %u)(ttlpkt %u", &npkt, &ttlpkt) != 2) {
 503       mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: header parsing failure, assuming single packet.\n");
 504       npkt = ttlpkt = 1;
 505     }
 506     if (ttlpkt == 0 || npkt > ttlpkt) {
 507       mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: bad packet counters (npkk = %u, ttlpkt = %u), assuming single packet.\n",
 508         npkt, ttlpkt);
 509       npkt = ttlpkt = 1;
 510     }
 511   }
 512
 513   //Get entries from smil
 514   src_line = line;
 515   line = NULL;
 516   do {
 517     strstrip(src_line);
 518     if (line) {
 519       free(line);
 520       line = NULL;
 521     }
 522     /* If we're parsing smil over realrtsp and this is not the last packet and
 523      * this is the last line in the packet (terminating with ") ) we must get
 524      * the next line, strip the header, and concatenate it to the current line.
 525      */
 526     if (is_rmsmil && npkt != ttlpkt && strstr(src_line,"\")")) {
 527       char *payload;
 528
 529       line = strdup(src_line);
 530       if(!(src_line = play_tree_parser_get_line(p))) {
 531         mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: can't get line from packet %u/%u.\n", npkt, ttlpkt);
 532         break;
 533       }
 534       strstrip(src_line);
 535       // Skip header, packet starts after "
 536       if(!(payload = strchr(src_line,'\"'))) {
 537         mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: can't find start of packet, using complete line.\n");
 538         payload = src_line;
 539       } else
 540         payload++;
 541       // Skip ") at the end of the last line from the current packet
 542       line[strlen(line)-2] = 0;
 543       line = realloc(line, strlen(line)+strlen(payload)+1);
 544       strcat (line, payload);
 545       npkt++;
 546     } else
 547       line = strdup(src_line);
 548     /* Unescape \" to " for smil-over-rtsp */
 549     if (is_rmsmil && line[0] != '\0') {
 550       int i, j;
 551
 552       for (i = 0; i < strlen(line); i++)
 553         if (line[i] == '\\' && line[i+1] == '"')
 554           for (j = i; line[j]; j++)
 555             line[j] = line[j+1];
 556     }
 557     pos = line;
 558    while (pos) {
 559     if (!entrymode) { // all entries filled so far
 560      while ((pos=strchr(pos, '<'))) {
 561       if (strncasecmp(pos,"<video",6)==0  || strncasecmp(pos,"<audio",6)==0 || strncasecmp(pos,"<media",6)==0) {
 562           entrymode=1;
 563           break; // Got a valid tag, exit '<' search loop
 564       }
 565       pos++;
 566      }
 567     }
 568     if (entrymode) { //Entry found but not yet filled
 569       pos = strstr(pos,"src=");   // Is source present on this line
 570       if (pos != NULL) {
 571         entrymode=0;
 572         if (pos[4] != '"' && pos[4] != '\'') {
 573           mp_msg(MSGT_PLAYTREE,MSGL_V,"Unknown delimiter %c in source line %s\n", pos[4], line);
 574           break;
 575         }
 576         s_start=pos+5;
 577         s_end=strchr(s_start,pos[4]);
 578         if (s_end == NULL) {
 579           mp_msg(MSGT_PLAYTREE,MSGL_V,"Error parsing this source line %s\n",line);
 580           break;
 581         }
 582         if (s_end-s_start> 511) {
 583           mp_msg(MSGT_PLAYTREE,MSGL_V,"Cannot store such a large source %s\n",line);
 584           break;
 585         }
 586         strncpy(source,s_start,s_end-s_start);
 587         source[(s_end-s_start)]='\0'; // Null terminate
 588         entry = play_tree_new();
 589         play_tree_add_file(entry,source);
 590         if(!list)  //Insert new entry
 591           list = entry;
 592         else
 593           play_tree_append_entry(last_entry,entry);
 594         last_entry = entry;
 595         pos = s_end;
 596       }
 597     }
 598    }
 599   } while((src_line = play_tree_parser_get_line(p)) != NULL);
 600
 601   if (line)
 602     free(line);
 603
 604   if(!list) return NULL; // Nothing found
 605
 606   entry = play_tree_new();
 607   play_tree_set_child(entry,list);
 608   return entry;
 609 }
 610
 611 static play_tree_t*
 612 embedded_playlist_parse(char *line) {
 613   int f=DEMUXER_TYPE_PLAYLIST;
 614   stream_t* stream;
 615   play_tree_parser_t* ptp;
 616   play_tree_t* entry;
 617
 618   // Get stream opened to link
 619   stream=open_stream(line,0,&f);
 620   if(!stream) {
 621     mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Can't open playlist %s\n",line);
 622     return NULL;
 623   }
 624
 625   //add new playtree
 626   mp_msg(MSGT_PLAYTREE,MSGL_V,"Adding playlist %s to element entryref\n",line);
 627
 628   ptp = play_tree_parser_new(stream,1);
 629   entry = play_tree_parser_get_play_tree(ptp, 1);
 630   play_tree_parser_free(ptp);
 631   free_stream(stream);
 632
 633   return entry;
 634 }
 635
 636 static play_tree_t*
 637 parse_textplain(play_tree_parser_t* p) {
 638   char* line;
 639   char *c;
 640   int embedded;
 641   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 642
 643   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying plaintext playlist...\n");
 644   play_tree_parser_stop_keeping(p);
 645
 646   while((line = play_tree_parser_get_line(p)) != NULL) {
 647     strstrip(line);
 648     if(line[0] == '\0' || line[0] == '#' || (line[0] == '/' && line[1] == '/'))
 649       continue;
 650
 651     //Special check for embedded smil or ram reference in file
 652     embedded = 0;
 653     if (strlen(line) > 5)
 654       for(c = line; c[0]; c++ )
 655         if ( ((c[0] == '.') && //start with . and next have smil with optional ? or &
 656            (tolower(c[1]) == 's') && (tolower(c[2])== 'm') &&
 657            (tolower(c[3]) == 'i') && (tolower(c[4]) == 'l') &&
 658            (!c[5] || c[5] == '?' || c[5] == '&')) || // or
 659           ((c[0] == '.') && // start with . and next have smi or ram with optional ? or &
 660           ( ((tolower(c[1]) == 's') && (tolower(c[2])== 'm') && (tolower(c[3]) == 'i')) ||
 661             ((tolower(c[1]) == 'r') && (tolower(c[2])== 'a') && (tolower(c[3]) == 'm')) )
 662            && (!c[4] || c[4] == '?' || c[4] == '&')) ){
 663           entry=embedded_playlist_parse(line);
 664           embedded = 1;
 665           break;
 666         }
 667
 668     if (!embedded) {      //regular file link
 669       entry = play_tree_new();
 670       play_tree_add_file(entry,line);
 671     }
 672
 673     if (entry != NULL) {
 674       if(!list)
 675         list = entry;
 676       else
 677         play_tree_append_entry(last_entry,entry);
 678       last_entry = entry;
 679     }
 680   }
 681
 682   if(!list) return NULL;
 683   entry = play_tree_new();
 684   play_tree_set_child(entry,list);
 685   return entry;
 686 }
 687
 688 play_tree_t*
 689 parse_playtree(stream_t *stream, int forced) {
 690   play_tree_parser_t* p;
 691   play_tree_t* ret;
 692
 693 #ifdef MP_DEBUG
 694   assert(stream != NULL);
 695 #endif
 696
 697   p = play_tree_parser_new(stream,0);
 698   if(!p)
 699     return NULL;
 700
 701   ret = play_tree_parser_get_play_tree(p, forced);
 702   play_tree_parser_free(p);
 703
 704   return ret;
 705 }
 706
 707 static void
 708 play_tree_add_basepath(play_tree_t* pt, char* bp) {
 709   int i,bl = strlen(bp),fl;
 710
 711   if(pt->child) {
 712     play_tree_t* i;
 713     for(i = pt->child ; i != NULL ; i = i->next)
 714       play_tree_add_basepath(i,bp);
 715     return;
 716   }
 717
 718   if(!pt->files)
 719     return;
 720
 721   for(i = 0 ; pt->files[i] != NULL ; i++) {
 722     fl = strlen(pt->files[i]);
 723     // if we find a full unix path, url:// or X:\ at the beginning,
 724     // don't mangle it.
 725     if(fl <= 0 || strstr(pt->files[i],"://") || (strstr(pt->files[i],":\\") == pt->files[i] + 1) || (pt->files[i][0] == '/') )
 726       continue;
 727     // if the path begins with \ then prepend drive letter to it.
 728     if (pt->files[i][0] == '\\') {
 729       if (pt->files[i][1] == '\\')
 730         continue;
 731       pt->files[i] = realloc(pt->files[i], 2 + fl + 1);
 732       memmove(pt->files[i] + 2,pt->files[i],fl+1);
 733       memcpy(pt->files[i],bp,2);
 734       continue;
 735     }
 736     pt->files[i] = realloc(pt->files[i], bl + fl + 1);
 737     memmove(pt->files[i] + bl,pt->files[i],fl+1);
 738     memcpy(pt->files[i],bp,bl);
 739   }
 740 }
 741
 742 // Wrapper for play_tree_add_basepath (add base path from file)
 743 void play_tree_add_bpf(play_tree_t* pt, char* filename)
 744 {
 745   char *ls, *file;
 746
 747   if (pt && filename)
 748   {
 749     file = strdup(filename);
 750     if (file)
 751     {
 752       ls = strrchr(file,'/');
 753       if(!ls) ls = strrchr(file,'\\');
 754       if(ls) {
 755         ls[1] = '\0';
 756         play_tree_add_basepath(pt,file);
 757       }
 758       free(file);
 759     }
 760   }
 761 }
 762
 763 play_tree_t*
 764 parse_playlist_file(char* file) {
 765   stream_t *stream;
 766   play_tree_t* ret;
 767   int f=DEMUXER_TYPE_PLAYLIST;
 768
 769   stream = open_stream(file,0,&f);
 770
 771   if(!stream) {
 772     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error while opening playlist file %s: %s\n",file,strerror(errno));
 773     return NULL;
 774   }
 775
 776   mp_msg(MSGT_PLAYTREE,MSGL_V,"Parsing playlist file %s...\n",file);
 777
 778   ret = parse_playtree(stream,1);
 779   free_stream(stream);
 780
 781   play_tree_add_bpf(ret, file);
 782
 783   return ret;
 784
 785 }
 786
 787
 788 play_tree_parser_t*
 789 play_tree_parser_new(stream_t* stream,int deep) {
 790   play_tree_parser_t* p;
 791
 792   p = calloc(1,sizeof(play_tree_parser_t));
 793   if(!p)
 794     return NULL;
 795   p->stream = stream;
 796   p->deep = deep;
 797   p->keep = 1;
 798
 799   return p;
 800
 801 }
 802
 803 void
 804 play_tree_parser_free(play_tree_parser_t* p) {
 805
 806 #ifdef MP_DEBUG
 807   assert(p != NULL);
 808 #endif
 809
 810   if(p->buffer) free(p->buffer);
 811   if(p->line) free(p->line);
 812   free(p);
 813 }
 814
 815 play_tree_t*
 816 play_tree_parser_get_play_tree(play_tree_parser_t* p, int forced) {
 817   play_tree_t* tree = NULL;
 818
 819 #ifdef MP_DEBUG
 820   assert(p != NULL);
 821 #endif
 822
 823
 824   while(play_tree_parser_get_line(p) != NULL) {
 825     play_tree_parser_reset(p);
 826
 827     tree = parse_asx(p);
 828     if(tree) break;
 829     play_tree_parser_reset(p);
 830
 831     tree = parse_pls(p);
 832     if(tree) break;
 833     play_tree_parser_reset(p);
 834
 835     tree = parse_m3u(p);
 836     if(tree) break;
 837     play_tree_parser_reset(p);
 838
 839     tree = parse_ref_ini(p);
 840     if(tree) break;
 841     play_tree_parser_reset(p);
 842
 843     tree = parse_smil(p);
 844     if(tree) break;
 845     play_tree_parser_reset(p);
 846
 847     // Here come the others formats ( textplain must stay the last one )
 848     if (forced)
 849     {
 850       tree = parse_textplain(p);
 851       if(tree) break;
 852     }
 853     break;
 854   }
 855
 856   if(tree)
 857     mp_msg(MSGT_PLAYTREE,MSGL_V,"Playlist successfully parsed\n");
 858   else
 859     mp_msg(MSGT_PLAYTREE,((forced==1)?MSGL_ERR:MSGL_V),"Error while parsing playlist\n");
 860
 861   if(tree)
 862     tree = play_tree_cleanup(tree);
 863
 864   if(!tree) mp_msg(MSGT_PLAYTREE,((forced==1)?MSGL_WARN:MSGL_V),"Warning: empty playlist\n");
 865
 866   return tree;
 867 }