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->mconfig, 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     // When we have info in playtree we add these info
 359     free(entries[num].title);
 360     free(entries[num].length);
 361   }
 362
 363   free(entries);
 364
 365   if (!list)
 366     return NULL;
 367
 368   entry = play_tree_new();
 369   play_tree_set_child(entry,list);
 370   return entry;
 371 }
 372
 373 /*
 374  Reference Ini-Format: Each entry is assumed a reference
 375  */
 376 static play_tree_t*
 377 parse_ref_ini(play_tree_parser_t* p) {
 378   char *line,*v;
 379   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 380
 381   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying reference-ini playlist...\n");
 382   if (!(line = play_tree_parser_get_line(p)))
 383     return NULL;
 384   strstrip(line);
 385   if(strcasecmp(line,"[Reference]"))
 386     return NULL;
 387   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected reference-ini playlist format\n");
 388   play_tree_parser_stop_keeping(p);
 389   line = play_tree_parser_get_line(p);
 390   if(!line)
 391     return NULL;
 392   while(line) {
 393     strstrip(line);
 394     if(strncasecmp(line,"Ref",3) == 0) {
 395       v = pls_entry_get_value(line+3);
 396       if(!v)
 397         mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line);
 398       else
 399       {
 400         mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding entry %s\n",v);
 401         entry = play_tree_new();
 402         play_tree_add_file(entry,v);
 403         if(list)
 404           play_tree_append_entry(last_entry,entry);
 405         else
 406           list = entry;
 407         last_entry = entry;
 408       }
 409     }
 410     line = play_tree_parser_get_line(p);
 411   }
 412
 413   if(!list) return NULL;
 414   entry = play_tree_new();
 415   play_tree_set_child(entry,list);
 416   return entry;
 417 }
 418
 419 static play_tree_t*
 420 parse_m3u(play_tree_parser_t* p) {
 421   char* line;
 422   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 423
 424   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying extended m3u playlist...\n");
 425   if (!(line = play_tree_parser_get_line(p)))
 426     return NULL;
 427   strstrip(line);
 428   if(strcasecmp(line,"#EXTM3U"))
 429     return NULL;
 430   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected extended m3u playlist format\n");
 431   play_tree_parser_stop_keeping(p);
 432
 433   while((line = play_tree_parser_get_line(p)) != NULL) {
 434     strstrip(line);
 435     if(line[0] == '\0')
 436       continue;
 437     /* EXTM3U files contain such lines:
 438      * #EXTINF:<seconds>, <title>
 439      * followed by a line with the filename
 440      * for now we have no place to put that
 441      * so we just skip that extra-info ::atmos
 442      */
 443     if(line[0] == '#') {
 444 #if 0 /* code functional */
 445       if(strncasecmp(line,"#EXTINF:",8) == 0) {
 446         mp_msg(MSGT_PLAYTREE,MSGL_INFO,"[M3U] Duration: %dsec  Title: %s\n",
 447           strtol(line+8,&line,10), line+2);
 448       }
 449 #endif
 450       continue;
 451     }
 452     entry = play_tree_new();
 453     play_tree_add_file(entry,line);
 454     if(!list)
 455       list = entry;
 456     else
 457       play_tree_append_entry(last_entry,entry);
 458     last_entry = entry;
 459   }
 460
 461   if(!list) return NULL;
 462   entry = play_tree_new();
 463   play_tree_set_child(entry,list);
 464   return entry;
 465 }
 466
 467 static play_tree_t*
 468 parse_smil(play_tree_parser_t* p) {
 469   int entrymode=0;
 470   char* line,source[512],*pos,*s_start,*s_end,*src_line;
 471   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 472   int is_rmsmil = 0;
 473   unsigned int npkt, ttlpkt;
 474
 475   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying smil playlist...\n");
 476
 477   // Check if smil
 478   while((line = play_tree_parser_get_line(p)) != NULL) {
 479     strstrip(line);
 480     if(line[0] == '\0') // Ignore empties
 481       continue;
 482     if (strncasecmp(line,"<?xml",5)==0) // smil in xml
 483       continue;
 484     if (strncasecmp(line,"<!DOCTYPE smil",13)==0) // smil in xml
 485       continue;
 486     if (strncasecmp(line,"<smil",5)==0 || strncasecmp(line,"<?wpl",5)==0 ||
 487       strncasecmp(line,"(smil-document",14)==0)
 488       break; // smil header found
 489     else
 490       return NULL; //line not smil exit
 491   }
 492
 493   if (!line) return NULL;
 494   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected smil playlist format\n");
 495   play_tree_parser_stop_keeping(p);
 496
 497   if (strncasecmp(line,"(smil-document",14)==0) {
 498     mp_msg(MSGT_PLAYTREE,MSGL_V,"Special smil-over-realrtsp playlist header\n");
 499     is_rmsmil = 1;
 500     if (sscanf(line, "(smil-document (ver 1.0)(npkt %u)(ttlpkt %u", &npkt, &ttlpkt) != 2) {
 501       mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: header parsing failure, assuming single packet.\n");
 502       npkt = ttlpkt = 1;
 503     }
 504     if (ttlpkt == 0 || npkt > ttlpkt) {
 505       mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: bad packet counters (npkk = %u, ttlpkt = %u), assuming single packet.\n",
 506         npkt, ttlpkt);
 507       npkt = ttlpkt = 1;
 508     }
 509   }
 510
 511   //Get entries from smil
 512   src_line = line;
 513   line = NULL;
 514   do {
 515     strstrip(src_line);
 516     free(line);
 517     line = NULL;
 518     /* If we're parsing smil over realrtsp and this is not the last packet and
 519      * this is the last line in the packet (terminating with ") ) we must get
 520      * the next line, strip the header, and concatenate it to the current line.
 521      */
 522     if (is_rmsmil && npkt != ttlpkt && strstr(src_line,"\")")) {
 523       char *payload;
 524
 525       line = strdup(src_line);
 526       if(!(src_line = play_tree_parser_get_line(p))) {
 527         mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: can't get line from packet %u/%u.\n", npkt, ttlpkt);
 528         break;
 529       }
 530       strstrip(src_line);
 531       // Skip header, packet starts after "
 532       if(!(payload = strchr(src_line,'\"'))) {
 533         mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: can't find start of packet, using complete line.\n");
 534         payload = src_line;
 535       } else
 536         payload++;
 537       // Skip ") at the end of the last line from the current packet
 538       line[strlen(line)-2] = 0;
 539       line = realloc(line, strlen(line)+strlen(payload)+1);
 540       strcat (line, payload);
 541       npkt++;
 542     } else
 543       line = strdup(src_line);
 544     /* Unescape \" to " for smil-over-rtsp */
 545     if (is_rmsmil && line[0] != '\0') {
 546       int i, j;
 547
 548       for (i = 0; i < strlen(line); i++)
 549         if (line[i] == '\\' && line[i+1] == '"')
 550           for (j = i; line[j]; j++)
 551             line[j] = line[j+1];
 552     }
 553     pos = line;
 554    while (pos) {
 555     if (!entrymode) { // all entries filled so far
 556      while ((pos=strchr(pos, '<'))) {
 557       if (strncasecmp(pos,"<video",6)==0  || strncasecmp(pos,"<audio",6)==0 || strncasecmp(pos,"<media",6)==0) {
 558           entrymode=1;
 559           break; // Got a valid tag, exit '<' search loop
 560       }
 561       pos++;
 562      }
 563     }
 564     if (entrymode) { //Entry found but not yet filled
 565       pos = strstr(pos,"src=");   // Is source present on this line
 566       if (pos != NULL) {
 567         entrymode=0;
 568         if (pos[4] != '"' && pos[4] != '\'') {
 569           mp_msg(MSGT_PLAYTREE,MSGL_V,"Unknown delimiter %c in source line %s\n", pos[4], line);
 570           break;
 571         }
 572         s_start=pos+5;
 573         s_end=strchr(s_start,pos[4]);
 574         if (s_end == NULL) {
 575           mp_msg(MSGT_PLAYTREE,MSGL_V,"Error parsing this source line %s\n",line);
 576           break;
 577         }
 578         if (s_end-s_start> 511) {
 579           mp_msg(MSGT_PLAYTREE,MSGL_V,"Cannot store such a large source %s\n",line);
 580           break;
 581         }
 582         strncpy(source,s_start,s_end-s_start);
 583         source[(s_end-s_start)]='\0'; // Null terminate
 584         entry = play_tree_new();
 585         play_tree_add_file(entry,source);
 586         if(!list)  //Insert new entry
 587           list = entry;
 588         else
 589           play_tree_append_entry(last_entry,entry);
 590         last_entry = entry;
 591         pos = s_end;
 592       }
 593     }
 594    }
 595   } while((src_line = play_tree_parser_get_line(p)) != NULL);
 596
 597   free(line);
 598
 599   if(!list) return NULL; // Nothing found
 600
 601   entry = play_tree_new();
 602   play_tree_set_child(entry,list);
 603   return entry;
 604 }
 605
 606 static play_tree_t*
 607 embedded_playlist_parse(struct m_config *mconfig, char *line) {
 608   int f=DEMUXER_TYPE_PLAYLIST;
 609   stream_t* stream;
 610   play_tree_parser_t* ptp;
 611   play_tree_t* entry;
 612
 613   // Get stream opened to link
 614   stream=open_stream(line,0,&f);
 615   if(!stream) {
 616     mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Can't open playlist %s\n",line);
 617     return NULL;
 618   }
 619
 620   //add new playtree
 621   mp_msg(MSGT_PLAYTREE,MSGL_V,"Adding playlist %s to element entryref\n",line);
 622
 623   ptp = play_tree_parser_new(stream, mconfig, 1);
 624   entry = play_tree_parser_get_play_tree(ptp, 1);
 625   play_tree_parser_free(ptp);
 626   free_stream(stream);
 627
 628   return entry;
 629 }
 630
 631 static play_tree_t*
 632 parse_textplain(play_tree_parser_t* p) {
 633   char* line;
 634   char *c;
 635   int embedded;
 636   play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL;
 637
 638   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying plaintext playlist...\n");
 639   play_tree_parser_stop_keeping(p);
 640
 641   while((line = play_tree_parser_get_line(p)) != NULL) {
 642     strstrip(line);
 643     if(line[0] == '\0' || line[0] == '#' || (line[0] == '/' && line[1] == '/'))
 644       continue;
 645
 646     //Special check for embedded smil or ram reference in file
 647     embedded = 0;
 648     if (strlen(line) > 5)
 649       for(c = line; c[0]; c++ )
 650         if ( ((c[0] == '.') && //start with . and next have smil with optional ? or &
 651            (tolower(c[1]) == 's') && (tolower(c[2])== 'm') &&
 652            (tolower(c[3]) == 'i') && (tolower(c[4]) == 'l') &&
 653            (!c[5] || c[5] == '?' || c[5] == '&')) || // or
 654           ((c[0] == '.') && // start with . and next have smi or ram with optional ? or &
 655           ( ((tolower(c[1]) == 's') && (tolower(c[2])== 'm') && (tolower(c[3]) == 'i')) ||
 656             ((tolower(c[1]) == 'r') && (tolower(c[2])== 'a') && (tolower(c[3]) == 'm')) )
 657            && (!c[4] || c[4] == '?' || c[4] == '&')) ){
 658             entry=embedded_playlist_parse(p->mconfig, line);
 659           embedded = 1;
 660           break;
 661         }
 662
 663     if (!embedded) {      //regular file link
 664       entry = play_tree_new();
 665       play_tree_add_file(entry,line);
 666     }
 667
 668     if (entry != NULL) {
 669       if(!list)
 670         list = entry;
 671       else
 672         play_tree_append_entry(last_entry,entry);
 673       last_entry = entry;
 674     }
 675   }
 676
 677   if(!list) return NULL;
 678   entry = play_tree_new();
 679   play_tree_set_child(entry,list);
 680   return entry;
 681 }
 682
 683 /**
 684  * \brief decode the base64 used in nsc files
 685  * \param in input string, 0-terminated
 686  * \param buf output buffer, must point to memory suitable for realloc,
 687  *            will be NULL on failure.
 688  * \return decoded length in bytes
 689  */
 690 static int decode_nsc_base64(char *in, char **buf) {
 691   int i, j, n;
 692   if (in[0] != '0' || in[1] != '2')
 693     goto err_out;
 694   in += 2; // skip prefix
 695   if (strlen(in) < 16) // error out if nothing to decode
 696     goto err_out;
 697   in += 12; // skip encoded string length
 698   n = strlen(in) / 4;
 699   *buf = realloc(*buf, n * 3);
 700   for (i = 0; i < n; i++) {
 701     uint8_t c[4];
 702     for (j = 0; j < 4; j++) {
 703       c[j] = in[4 * i + j];
 704       if (c[j] >= '0' && c[j] <= '9') c[j] += 0 - '0';
 705       else if (c[j] >= 'A' && c[j] <= 'Z') c[j] += 10 - 'A';
 706       else if (c[j] >= 'a' && c[j] <= 'z') c[j] += 36 - 'a';
 707       else if (c[j] == '{') c[j] = 62;
 708       else if (c[j] == '}') c[j] = 63;
 709       else {
 710         mp_msg(MSGT_PLAYTREE, MSGL_ERR, "Invalid character %c (0x%02"PRIx8")\n", c[j], c[j]);
 711         goto err_out;
 712       }
 713     }
 714     (*buf)[3 * i] = (c[0] << 2) | (c[1] >> 4);
 715     (*buf)[3 * i + 1] = (c[1] << 4) | (c[2] >> 2);
 716     (*buf)[3 * i + 2] = (c[2] << 6) | c[3];
 717   }
 718   return 3 * n;
 719 err_out:
 720   free(*buf);
 721   *buf = NULL;
 722   return 0;
 723 }
 724
 725 /**
 726  * \brief "converts" utf16 to ascii by just discarding every second byte
 727  * \param buf buffer to convert
 728  * \param len lenght of buffer, must be > 0
 729  */
 730 static void utf16_to_ascii(char *buf, int len) {
 731   int i;
 732   if (len <= 0) return;
 733   for (i = 0; i < len / 2; i++)
 734     buf[i] = buf[i * 2];
 735   buf[i] = 0; // just in case
 736 }
 737
 738 static play_tree_t *parse_nsc(play_tree_parser_t* p) {
 739   char *line, *addr = NULL, *url, *unicast_url = NULL;
 740   int port = 0;
 741   play_tree_t *entry = NULL;
 742
 743   mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying nsc playlist...\n");
 744   while((line = play_tree_parser_get_line(p)) != NULL) {
 745     strstrip(line);
 746     if(!line[0]) // Ignore empties
 747       continue;
 748     if (strncasecmp(line,"[Address]", 9) == 0)
 749       break; // nsc header found
 750     else
 751       return NULL;
 752   }
 753   mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected nsc playlist format\n");
 754   play_tree_parser_stop_keeping(p);
 755   while ((line = play_tree_parser_get_line(p)) != NULL) {
 756     strstrip(line);
 757     if (!line[0])
 758       continue;
 759     if (strncasecmp(line, "Unicast URL=", 12) == 0) {
 760       int len = decode_nsc_base64(&line[12], &unicast_url);
 761       if (len <= 0)
 762         mp_msg(MSGT_PLAYTREE, MSGL_WARN, "[nsc] Unsupported Unicast URL encoding\n");
 763       else
 764         utf16_to_ascii(unicast_url, len);
 765     } else if (strncasecmp(line, "IP Address=", 11) == 0) {
 766       int len = decode_nsc_base64(&line[11], &addr);
 767       if (len <= 0)
 768         mp_msg(MSGT_PLAYTREE, MSGL_WARN, "[nsc] Unsupported IP Address encoding\n");
 769       else
 770         utf16_to_ascii(addr, len);
 771     } else if (strncasecmp(line, "IP Port=", 8) == 0) {
 772       port = strtol(&line[8], NULL, 0);
 773     }
 774   }
 775
 776   if (unicast_url)
 777     url = strdup(unicast_url);
 778   else if (addr && port) {
 779     url = malloc(strlen(addr) + 7 + 20 + 1);
 780     sprintf(url, "http://%s:%i", addr, port);
 781   } else
 782    goto out;
 783
 784   entry = play_tree_new();
 785   play_tree_add_file(entry, url);
 786   free(url);
 787 out:
 788   free(addr);
 789   free(unicast_url);
 790   return entry;
 791 }
 792
 793 play_tree_t*
 794 parse_playtree(stream_t *stream, struct m_config *mconfig, int forced) {
 795   play_tree_parser_t* p;
 796   play_tree_t* ret;
 797
 798 #ifdef MP_DEBUG
 799   assert(stream != NULL);
 800 #endif
 801
 802   p = play_tree_parser_new(stream, mconfig, 0);
 803   if(!p)
 804     return NULL;
 805
 806   ret = play_tree_parser_get_play_tree(p, forced);
 807   play_tree_parser_free(p);
 808
 809   return ret;
 810 }
 811
 812 static void
 813 play_tree_add_basepath(play_tree_t* pt, char* bp) {
 814   int i,bl = strlen(bp),fl;
 815
 816   if(pt->child) {
 817     play_tree_t* i;
 818     for(i = pt->child ; i != NULL ; i = i->next)
 819       play_tree_add_basepath(i,bp);
 820     return;
 821   }
 822
 823   if(!pt->files)
 824     return;
 825
 826   for(i = 0 ; pt->files[i] != NULL ; i++) {
 827     fl = strlen(pt->files[i]);
 828     // if we find a full unix path, url:// or X:\ at the beginning,
 829     // don't mangle it.
 830     if(fl <= 0 || strstr(pt->files[i],"://") || (strstr(pt->files[i],":\\") == pt->files[i] + 1) || (pt->files[i][0] == '/') )
 831       continue;
 832     // if the path begins with \ then prepend drive letter to it.
 833     if (pt->files[i][0] == '\\') {
 834       if (pt->files[i][1] == '\\')
 835         continue;
 836       pt->files[i] = realloc(pt->files[i], 2 + fl + 1);
 837       memmove(pt->files[i] + 2,pt->files[i],fl+1);
 838       memcpy(pt->files[i],bp,2);
 839       continue;
 840     }
 841     pt->files[i] = realloc(pt->files[i], bl + fl + 1);
 842     memmove(pt->files[i] + bl,pt->files[i],fl+1);
 843     memcpy(pt->files[i],bp,bl);
 844   }
 845 }
 846
 847 // Wrapper for play_tree_add_basepath (add base path from file)
 848 void play_tree_add_bpf(play_tree_t* pt, char* filename)
 849 {
 850   char *ls, *file;
 851
 852   if (pt && filename)
 853   {
 854     file = strdup(filename);
 855     if (file)
 856     {
 857       ls = strrchr(file,'/');
 858       if(!ls) ls = strrchr(file,'\\');
 859       if(ls) {
 860         ls[1] = '\0';
 861         play_tree_add_basepath(pt,file);
 862       }
 863       free(file);
 864     }
 865   }
 866 }
 867
 868 play_tree_t*
 869 parse_playlist_file(struct m_config *mconfig, char* file) {
 870   stream_t *stream;
 871   play_tree_t* ret;
 872   int f=DEMUXER_TYPE_PLAYLIST;
 873
 874   stream = open_stream(file,0,&f);
 875
 876   if(!stream) {
 877     mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error while opening playlist file %s: %s\n",file,strerror(errno));
 878     return NULL;
 879   }
 880
 881   mp_msg(MSGT_PLAYTREE,MSGL_V,"Parsing playlist file %s...\n",file);
 882
 883   ret = parse_playtree(stream, mconfig, 1);
 884   free_stream(stream);
 885
 886   play_tree_add_bpf(ret, file);
 887
 888   return ret;
 889
 890 }
 891
 892
 893 play_tree_parser_t*
 894 play_tree_parser_new(stream_t* stream, struct m_config *mconfig, int deep) {
 895   play_tree_parser_t* p;
 896
 897   p = calloc(1,sizeof(play_tree_parser_t));
 898   if(!p)
 899     return NULL;
 900   p->stream = stream;
 901   p->mconfig = mconfig;
 902   p->deep = deep;
 903   p->keep = 1;
 904
 905   return p;
 906
 907 }
 908
 909 void
 910 play_tree_parser_free(play_tree_parser_t* p) {
 911
 912 #ifdef MP_DEBUG
 913   assert(p != NULL);
 914 #endif
 915
 916   free(p->buffer);
 917   free(p->line);
 918   free(p);
 919 }
 920
 921 play_tree_t*
 922 play_tree_parser_get_play_tree(play_tree_parser_t* p, int forced) {
 923   play_tree_t* tree = NULL;
 924
 925 #ifdef MP_DEBUG
 926   assert(p != NULL);
 927 #endif
 928
 929
 930   while(play_tree_parser_get_line(p) != NULL) {
 931     play_tree_parser_reset(p);
 932
 933     tree = parse_asx(p);
 934     if(tree) break;
 935     play_tree_parser_reset(p);
 936
 937     tree = parse_pls(p);
 938     if(tree) break;
 939     play_tree_parser_reset(p);
 940
 941     tree = parse_m3u(p);
 942     if(tree) break;
 943     play_tree_parser_reset(p);
 944
 945     tree = parse_ref_ini(p);
 946     if(tree) break;
 947     play_tree_parser_reset(p);
 948
 949     tree = parse_smil(p);
 950     if(tree) break;
 951     play_tree_parser_reset(p);
 952
 953     tree = parse_nsc(p);
 954     if(tree) break;
 955     play_tree_parser_reset(p);
 956
 957     // Here come the others formats ( textplain must stay the last one )
 958     if (forced)
 959     {
 960       tree = parse_textplain(p);
 961       if(tree) break;
 962     }
 963     break;
 964   }
 965
 966   if(tree)
 967     mp_msg(MSGT_PLAYTREE,MSGL_V,"Playlist successfully parsed\n");
 968   else
 969     mp_msg(MSGT_PLAYTREE,((forced==1)?MSGL_ERR:MSGL_V),"Error while parsing playlist\n");
 970
 971   if(tree)
 972     tree = play_tree_cleanup(tree);
 973
 974   if(!tree) mp_msg(MSGT_PLAYTREE,((forced==1)?MSGL_WARN:MSGL_V),"Warning: empty playlist\n");
 975
 976   return tree;
 977 }