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