Mercurial > mplayer.hg
annotate playtreeparser.c @ 33556:520fb0f7544c
Rename GUI directory 'mplayer' and some files in it.
The directory 'mplayer' contains the files for the user interface and
has thus been renamed 'ui'.
Inside this directory the following files have been renamed to better
reflect their contents:
mw.c -> main.c
sw.c -> sub.c
pb.c -> playbar.c
gui_common.* -> render.*
play.* -> actions.*
author | ib |
---|---|
date | Sat, 18 Jun 2011 16:03:31 +0000 |
parents | 5a3aa408c9ad |
children | 3a0badbaab9c |
rev | line source |
---|---|
30429
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
1 /* |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
2 * This file is part of MPlayer. |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
3 * |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
4 * MPlayer is free software; you can redistribute it and/or modify |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
6 * the Free Software Foundation; either version 2 of the License, or |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
7 * (at your option) any later version. |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
8 * |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
9 * MPlayer is distributed in the hope that it will be useful, |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
12 * GNU General Public License for more details. |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
13 * |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
14 * You should have received a copy of the GNU General Public License along |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
15 * with MPlayer; if not, write to the Free Software Foundation, Inc., |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
c1a3f1bbba26
Add license header to all top-level files missing them.
diego
parents:
29263
diff
changeset
|
17 */ |
18265 | 18 |
19 /// \file | |
20 /// \ingroup PlaytreeParser | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
21 |
4156
22fadd4022b5
playtree-based config patch by Alban Bedel <albeu@free.fr>
arpi
parents:
4043
diff
changeset
|
22 #include "config.h" |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
23 #include <stdlib.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
24 #include <stdio.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
25 #include <string.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
26 #include <assert.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
27 #include <errno.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
28 #include <sys/types.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
29 #include <sys/stat.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
30 #include <fcntl.h> |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
31 #include <unistd.h> |
12300
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
32 #include <ctype.h> |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
33 #include <limits.h> |
30632
dad8e0eb182a
Add asx_parser_build_tree() to asxparser.h instead of forward declaring it.
diego
parents:
30429
diff
changeset
|
34 #include "asxparser.h" |
9749 | 35 #include "m_config.h" |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
36 #include "playtree.h" |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
37 #include "playtreeparser.h" |
19271
64d82a45a05d
introduce new 'stream' directory for all stream layer related components and split them from libmpdemux
ben
parents:
18928
diff
changeset
|
38 #include "stream/stream.h" |
12223 | 39 #include "libmpdemux/demuxer.h" |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
40 #include "mp_msg.h" |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
41 |
6662
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
42 |
4782 | 43 #define BUF_STEP 1024 |
44 | |
45 #define WHITES " \n\r\t" | |
46 | |
47 static void | |
48 strstrip(char* str) { | |
49 char* i; | |
50 | |
8907 | 51 if (str==NULL) |
52 return; | |
4782 | 53 for(i = str ; i[0] != '\0' && strchr(WHITES,i[0]) != NULL; i++) |
54 /* NOTHING */; | |
55 if(i[0] != '\0') { | |
8907 | 56 memmove(str,i,strlen(i) + 1); |
57 for(i = str + strlen(str) - 1 ; strchr(WHITES,i[0]) != NULL; i--) | |
4782 | 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) { | |
18869 | 70 p->buffer = malloc(BUF_STEP); |
4782 | 71 p->buffer_size = BUF_STEP; |
28183 | 72 p->buffer[0] = 0; |
4782 | 73 p->iter = p->buffer; |
74 } | |
75 | |
5802 | 76 if(p->stream->eof && (p->buffer_end == 0 || p->iter[0] == '\0')) |
4782 | 77 return NULL; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
78 |
28182
26ab2d01157f
Add asserts to detect when assumptions for play_tree_parser_get_line
reimar
parents:
25141
diff
changeset
|
79 assert(p->buffer_end < p->buffer_size); |
26ab2d01157f
Add asserts to detect when assumptions for play_tree_parser_get_line
reimar
parents:
25141
diff
changeset
|
80 assert(!p->buffer[p->buffer_end]); |
4782 | 81 while(1) { |
82 | |
83 if(resize) { | |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
84 char *tmp; |
4782 | 85 r = p->iter - p->buffer; |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
86 end = p->buffer + p->buffer_end; |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
87 if (p->buffer_size > INT_MAX - BUF_STEP) |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
88 break; |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
89 tmp = realloc(p->buffer, p->buffer_size + BUF_STEP); |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
90 if (!tmp) |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
91 break; |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
92 p->buffer = tmp; |
4782 | 93 p->iter = p->buffer + r; |
94 p->buffer_size += BUF_STEP; | |
95 resize = 0; | |
96 } | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
97 |
4782 | 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; | |
28182
26ab2d01157f
Add asserts to detect when assumptions for play_tree_parser_get_line
reimar
parents:
25141
diff
changeset
|
102 assert(p->buffer_end < p->buffer_size); |
4782 | 103 p->buffer[p->buffer_end] = '\0'; |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
104 while(strlen(p->buffer + p->buffer_end - r) != r) |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
105 p->buffer[p->buffer_end - r + strlen(p->buffer + p->buffer_end - r)] = '\n'; |
4782 | 106 } |
28182
26ab2d01157f
Add asserts to detect when assumptions for play_tree_parser_get_line
reimar
parents:
25141
diff
changeset
|
107 assert(!p->buffer[p->buffer_end]); |
4782 | 108 } |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
109 |
4782 | 110 end = strchr(p->iter,'\n'); |
111 if(!end) { | |
112 if(p->stream->eof) { | |
4857 | 113 end = p->buffer + p->buffer_end; |
4782 | 114 break; |
115 } | |
116 resize = 1; | |
117 continue; | |
118 } | |
119 break; | |
120 } | |
121 | |
25141
fba022abe464
100l in play_tree_parser_get_line, check that there actually is
reimar
parents:
24962
diff
changeset
|
122 line_end = (end > p->iter && *(end-1) == '\r') ? end-1 : end; |
5802 | 123 if(line_end - p->iter >= 0) |
30702 | 124 p->line = realloc(p->line, line_end - p->iter + 1); |
5802 | 125 else |
4782 | 126 return NULL; |
5802 | 127 if(line_end - p->iter > 0) |
128 strncpy(p->line,p->iter,line_end - p->iter); | |
4782 | 129 p->line[line_end - p->iter] = '\0'; |
5802 | 130 if(end[0] != '\0') |
4857 | 131 end++; |
4782 | 132 |
133 if(!p->keep) { | |
4857 | 134 if(end[0] != '\0') { |
5788
8bd1c1e319fb
Fix a bug produced when line are terminated with \r\n and not a single
albeu
parents:
4857
diff
changeset
|
135 p->buffer_end -= end-p->iter; |
4782 | 136 memmove(p->buffer,end,p->buffer_end); |
137 } else | |
138 p->buffer_end = 0; | |
28183 | 139 p->buffer[p->buffer_end] = '\0'; |
4782 | 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); | |
28184
0fb5551413f7
1000l, play_tree_parser_stop_keeping broke 0-termination of buffer
reimar
parents:
28183
diff
changeset
|
159 p->buffer[p->buffer_end] = 0; |
4782 | 160 p->iter = p->buffer; |
161 } | |
162 } | |
163 | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
164 |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
165 static play_tree_t* |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
166 parse_asx(play_tree_parser_t* p) { |
4782 | 167 int comments = 0,get_line = 1; |
168 char* line = NULL; | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
169 |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
170 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying asx...\n"); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
171 |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
172 while(1) { |
4782 | 173 if(get_line) { |
174 line = play_tree_parser_get_line(p); | |
175 if(!line) | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
176 return NULL; |
4782 | 177 strstrip(line); |
178 if(line[0] == '\0') | |
179 continue; | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
180 } |
4782 | 181 if(!comments) { |
182 if(line[0] != '<') { | |
183 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"First char isn't '<' but '%c'\n",line[0]); | |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
184 mp_msg(MSGT_PLAYTREE,MSGL_DBG3,"Buffer = [%s]\n",p->buffer); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
185 return NULL; |
4782 | 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; | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
204 |
4782 | 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; | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
214 } |
4782 | 215 } |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
216 |
4782 | 217 mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected asx format\n"); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
218 |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
219 // We have an asx : load it in memory and parse |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
220 |
4782 | 221 while((line = play_tree_parser_get_line(p)) != NULL) |
222 /* NOTHING */; | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
223 |
10487 | 224 mp_msg(MSGT_PLAYTREE,MSGL_DBG3,"Parsing asx file: [%s]\n",p->buffer); |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
225 return asx_parser_build_tree(p->buffer,p->deep); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
226 } |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
227 |
4782 | 228 static char* |
229 pls_entry_get_value(char* line) { | |
230 char* i; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
231 |
4782 | 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); | |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
249 int limit = INT_MAX / sizeof(*e); |
4782 | 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); | |
30751
a375d947381b
Use negative return values for errors in pls_read_entry to make it match
reimar
parents:
30750
diff
changeset
|
255 return -1; |
4782 | 256 } |
257 | |
258 num = atoi(line); | |
30750
b9ec8956164f
A playlist entry number of 0 is invalid for pls playlists.
reimar
parents:
30749
diff
changeset
|
259 if(num <= 0 || num > limit) { |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
260 if (max_entry >= limit) { |
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
261 mp_msg(MSGT_PLAYTREE, MSGL_WARN, "Too many index entries\n"); |
30751
a375d947381b
Use negative return values for errors in pls_read_entry to make it match
reimar
parents:
30750
diff
changeset
|
262 return -1; |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
263 } |
4782 | 264 num = max_entry+1; |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
265 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"No or invalid entry index in entry %s\nAssuming %d\n",line,num); |
4782 | 266 } |
267 if(num > max_entry) { | |
30702 | 268 e = realloc(e, num * sizeof(pls_entry_t)); |
30749
88cd611f49dd
Improve integer overflow and realloc error handling in playlist parser.
reimar
parents:
30702
diff
changeset
|
269 if (!e) |
30751
a375d947381b
Use negative return values for errors in pls_read_entry to make it match
reimar
parents:
30750
diff
changeset
|
270 return -1; |
4782 | 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 | |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
282 static play_tree_t* |
4782 | 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; | |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
287 play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL; |
4782 | 288 |
10487 | 289 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying Winamp playlist...\n"); |
20834 | 290 while((line = play_tree_parser_get_line(p))) { |
291 strstrip(line); | |
292 if(strlen(line)) | |
293 break; | |
294 } | |
295 if (!line) | |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
296 return NULL; |
4782 | 297 if(strcasecmp(line,"[playlist]")) |
298 return NULL; | |
10487 | 299 mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected Winamp playlist format\n"); |
4782 | 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) | |
10487 | 309 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Invalid number of entries: very funny!!!\n"); |
4782 | 310 else |
10487 | 311 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Playlist claims to have %d entries. Let's see.\n",n_entries); |
4782 | 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); | |
33532 | 337 else { |
338 char *end; | |
339 long val = strtol(v, &end, 10); | |
340 if (*end || (val <= 0 && val != -1)) | |
341 mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Invalid length value in entry %s\n",line); | |
342 else if (val > 0) | |
343 entries[num-1].length = strdup(v); | |
344 } | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
345 } else |
10397 | 346 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Unknown entry type %s\n",line); |
4782 | 347 line = play_tree_parser_get_line(p); |
348 } | |
349 | |
350 for(num = 0; num < max_entry ; num++) { | |
351 if(entries[num].file == NULL) | |
352 mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Entry %d don't have a file !!!!\n",num+1); | |
353 else { | |
5866 | 354 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding entry %s\n",entries[num].file); |
4782 | 355 entry = play_tree_new(); |
356 play_tree_add_file(entry,entries[num].file); | |
33532 | 357 if (entries[num].length) |
358 play_tree_set_param(entry, "endpos", entries[num].length); | |
4782 | 359 free(entries[num].file); |
360 if(list) | |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
361 play_tree_append_entry(last_entry,entry); |
4782 | 362 else |
363 list = entry; | |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
364 last_entry = entry; |
4782 | 365 } |
32511
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
366 // When we have info in playtree we add these info |
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
367 free(entries[num].title); |
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
368 free(entries[num].length); |
4782 | 369 } |
370 | |
371 free(entries); | |
5866 | 372 |
31880
4f837c9acc58
Avoid trying to parse playlists without any recognized entries.
siretart
parents:
30751
diff
changeset
|
373 if (!list) |
4f837c9acc58
Avoid trying to parse playlists without any recognized entries.
siretart
parents:
30751
diff
changeset
|
374 return NULL; |
4f837c9acc58
Avoid trying to parse playlists without any recognized entries.
siretart
parents:
30751
diff
changeset
|
375 |
5866 | 376 entry = play_tree_new(); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
377 play_tree_set_child(entry,list); |
5866 | 378 return entry; |
4782 | 379 } |
380 | |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
381 /* |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
382 Reference Ini-Format: Each entry is assumed a reference |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
383 */ |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
384 static play_tree_t* |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
385 parse_ref_ini(play_tree_parser_t* p) { |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
386 char *line,*v; |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
387 play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL; |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
388 |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
389 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying reference-ini playlist...\n"); |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
390 if (!(line = play_tree_parser_get_line(p))) |
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
391 return NULL; |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
392 strstrip(line); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
393 if(strcasecmp(line,"[Reference]")) |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
394 return NULL; |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
395 mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected reference-ini playlist format\n"); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
396 play_tree_parser_stop_keeping(p); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
397 line = play_tree_parser_get_line(p); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
398 if(!line) |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
399 return NULL; |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
400 while(line) { |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
401 strstrip(line); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
402 if(strncasecmp(line,"Ref",3) == 0) { |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
403 v = pls_entry_get_value(line+3); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
404 if(!v) |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
405 mp_msg(MSGT_PLAYTREE,MSGL_ERR,"No value in entry %s\n",line); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
406 else |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
407 { |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
408 mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding entry %s\n",v); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
409 entry = play_tree_new(); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
410 play_tree_add_file(entry,v); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
411 if(list) |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
412 play_tree_append_entry(last_entry,entry); |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
413 else |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
414 list = entry; |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
415 last_entry = entry; |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
416 } |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
417 } |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
418 line = play_tree_parser_get_line(p); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
419 } |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
420 |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
421 if(!list) return NULL; |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
422 entry = play_tree_new(); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
423 play_tree_set_child(entry,list); |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
424 return entry; |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
425 } |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
426 |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
427 static play_tree_t* |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
428 parse_m3u(play_tree_parser_t* p) { |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
429 char* line; |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
430 play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL; |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
431 |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
432 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying extended m3u playlist...\n"); |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
433 if (!(line = play_tree_parser_get_line(p))) |
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
434 return NULL; |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
435 strstrip(line); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
436 if(strcasecmp(line,"#EXTM3U")) |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
437 return NULL; |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
438 mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected extended m3u playlist format\n"); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
439 play_tree_parser_stop_keeping(p); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
440 |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
441 while((line = play_tree_parser_get_line(p)) != NULL) { |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
442 strstrip(line); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
443 if(line[0] == '\0') |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
444 continue; |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
445 /* EXTM3U files contain such lines: |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
446 * #EXTINF:<seconds>, <title> |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
447 * followed by a line with the filename |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
448 * for now we have no place to put that |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
449 * so we just skip that extra-info ::atmos |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
450 */ |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
451 if(line[0] == '#') { |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
452 #if 0 /* code functional */ |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
453 if(strncasecmp(line,"#EXTINF:",8) == 0) { |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
454 mp_msg(MSGT_PLAYTREE,MSGL_INFO,"[M3U] Duration: %dsec Title: %s\n", |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
455 strtol(line+8,&line,10), line+2); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
456 } |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
457 #endif |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
458 continue; |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
459 } |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
460 entry = play_tree_new(); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
461 play_tree_add_file(entry,line); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
462 if(!list) |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
463 list = entry; |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
464 else |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
465 play_tree_append_entry(last_entry,entry); |
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
466 last_entry = entry; |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
467 } |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
468 |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
469 if(!list) return NULL; |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
470 entry = play_tree_new(); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
471 play_tree_set_child(entry,list); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
472 return entry; |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
473 } |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
474 |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
475 static play_tree_t* |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
476 parse_smil(play_tree_parser_t* p) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
477 int entrymode=0; |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
478 char* line,source[512],*pos,*s_start,*s_end,*src_line; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
479 play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL; |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
480 int is_rmsmil = 0; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
481 unsigned int npkt, ttlpkt; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
482 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
483 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying smil playlist...\n"); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
484 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
485 // Check if smil |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
486 while((line = play_tree_parser_get_line(p)) != NULL) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
487 strstrip(line); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
488 if(line[0] == '\0') // Ignore empties |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
489 continue; |
22518
29a3bb75db47
Support smil embedded into xml, fixes bugzilla #768
rtogni
parents:
22477
diff
changeset
|
490 if (strncasecmp(line,"<?xml",5)==0) // smil in xml |
29a3bb75db47
Support smil embedded into xml, fixes bugzilla #768
rtogni
parents:
22477
diff
changeset
|
491 continue; |
28314 | 492 if (strncasecmp(line,"<!DOCTYPE smil",13)==0) // smil in xml |
493 continue; | |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
494 if (strncasecmp(line,"<smil",5)==0 || strncasecmp(line,"<?wpl",5)==0 || |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
495 strncasecmp(line,"(smil-document",14)==0) |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
496 break; // smil header found |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
497 else |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
498 return NULL; //line not smil exit |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
499 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
500 |
24962
fb50e37df836
Fix possible null-pointer-dereference in parse_smil().
cehoyos
parents:
24424
diff
changeset
|
501 if (!line) return NULL; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
502 mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected smil playlist format\n"); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
503 play_tree_parser_stop_keeping(p); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
504 |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
505 if (strncasecmp(line,"(smil-document",14)==0) { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
506 mp_msg(MSGT_PLAYTREE,MSGL_V,"Special smil-over-realrtsp playlist header\n"); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
507 is_rmsmil = 1; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
508 if (sscanf(line, "(smil-document (ver 1.0)(npkt %u)(ttlpkt %u", &npkt, &ttlpkt) != 2) { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
509 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: header parsing failure, assuming single packet.\n"); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
510 npkt = ttlpkt = 1; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
511 } |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
512 if (ttlpkt == 0 || npkt > ttlpkt) { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
513 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: bad packet counters (npkk = %u, ttlpkt = %u), assuming single packet.\n", |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
514 npkt, ttlpkt); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
515 npkt = ttlpkt = 1; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
516 } |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
517 } |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
518 |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
519 //Get entries from smil |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
520 src_line = line; |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
521 line = NULL; |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
522 do { |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
523 strstrip(src_line); |
32511
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
524 free(line); |
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
525 line = NULL; |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
526 /* If we're parsing smil over realrtsp and this is not the last packet and |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
527 * this is the last line in the packet (terminating with ") ) we must get |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
528 * the next line, strip the header, and concatenate it to the current line. |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
529 */ |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
530 if (is_rmsmil && npkt != ttlpkt && strstr(src_line,"\")")) { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
531 char *payload; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
532 |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
533 line = strdup(src_line); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
534 if(!(src_line = play_tree_parser_get_line(p))) { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
535 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: can't get line from packet %u/%u.\n", npkt, ttlpkt); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
536 break; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
537 } |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
538 strstrip(src_line); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
539 // Skip header, packet starts after " |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
540 if(!(payload = strchr(src_line,'\"'))) { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
541 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"smil-over-realrtsp: can't find start of packet, using complete line.\n"); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
542 payload = src_line; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
543 } else |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
544 payload++; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
545 // Skip ") at the end of the last line from the current packet |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
546 line[strlen(line)-2] = 0; |
22477 | 547 line = realloc(line, strlen(line)+strlen(payload)+1); |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
548 strcat (line, payload); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
549 npkt++; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
550 } else |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
551 line = strdup(src_line); |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
552 /* Unescape \" to " for smil-over-rtsp */ |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
553 if (is_rmsmil && line[0] != '\0') { |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
554 int i, j; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
555 |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
556 for (i = 0; i < strlen(line); i++) |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
557 if (line[i] == '\\' && line[i+1] == '"') |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
558 for (j = i; line[j]; j++) |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
559 line[j] = line[j+1]; |
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
560 } |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
561 pos = line; |
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
562 while (pos) { |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
563 if (!entrymode) { // all entries filled so far |
24424 | 564 while ((pos=strchr(pos, '<'))) { |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
565 if (strncasecmp(pos,"<video",6)==0 || strncasecmp(pos,"<audio",6)==0 || strncasecmp(pos,"<media",6)==0) { |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
566 entrymode=1; |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
567 break; // Got a valid tag, exit '<' search loop |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
568 } |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
569 pos++; |
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
570 } |
22520 | 571 } |
572 if (entrymode) { //Entry found but not yet filled | |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
573 pos = strstr(pos,"src="); // Is source present on this line |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
574 if (pos != NULL) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
575 entrymode=0; |
23774
16a67232e916
realrtsp smil files can also use ' as field delimiter instead of "
rtogni
parents:
22712
diff
changeset
|
576 if (pos[4] != '"' && pos[4] != '\'') { |
16a67232e916
realrtsp smil files can also use ' as field delimiter instead of "
rtogni
parents:
22712
diff
changeset
|
577 mp_msg(MSGT_PLAYTREE,MSGL_V,"Unknown delimiter %c in source line %s\n", pos[4], line); |
16a67232e916
realrtsp smil files can also use ' as field delimiter instead of "
rtogni
parents:
22712
diff
changeset
|
578 break; |
16a67232e916
realrtsp smil files can also use ' as field delimiter instead of "
rtogni
parents:
22712
diff
changeset
|
579 } |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
580 s_start=pos+5; |
23774
16a67232e916
realrtsp smil files can also use ' as field delimiter instead of "
rtogni
parents:
22712
diff
changeset
|
581 s_end=strchr(s_start,pos[4]); |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
582 if (s_end == NULL) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
583 mp_msg(MSGT_PLAYTREE,MSGL_V,"Error parsing this source line %s\n",line); |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
584 break; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
585 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
586 if (s_end-s_start> 511) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
587 mp_msg(MSGT_PLAYTREE,MSGL_V,"Cannot store such a large source %s\n",line); |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
588 break; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
589 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
590 strncpy(source,s_start,s_end-s_start); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
591 source[(s_end-s_start)]='\0'; // Null terminate |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
592 entry = play_tree_new(); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
593 play_tree_add_file(entry,source); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
594 if(!list) //Insert new entry |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
595 list = entry; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
596 else |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
597 play_tree_append_entry(last_entry,entry); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
598 last_entry = entry; |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
599 pos = s_end; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
600 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
601 } |
22712
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
602 } |
c7eee1ecbe8c
Support multiple tags in a single line and tags on the same line as the
rtogni
parents:
22520
diff
changeset
|
603 } while((src_line = play_tree_parser_get_line(p)) != NULL); |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
604 |
32511
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
605 free(line); |
22242
4cabf7499fef
Add support for smil playlist served over realrtsp
rtogni
parents:
21910
diff
changeset
|
606 |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
607 if(!list) return NULL; // Nothing found |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
608 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
609 entry = play_tree_new(); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
610 play_tree_set_child(entry,list); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
611 return entry; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
612 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
613 |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
614 static play_tree_t* |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
615 embedded_playlist_parse(char *line) { |
12223 | 616 int f=DEMUXER_TYPE_PLAYLIST; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
617 stream_t* stream; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
618 play_tree_parser_t* ptp; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
619 play_tree_t* entry; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
620 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
621 // Get stream opened to link |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
622 stream=open_stream(line,0,&f); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
623 if(!stream) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
624 mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Can't open playlist %s\n",line); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
625 return NULL; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
626 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
627 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
628 //add new playtree |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
629 mp_msg(MSGT_PLAYTREE,MSGL_V,"Adding playlist %s to element entryref\n",line); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
630 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
631 ptp = play_tree_parser_new(stream,1); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
632 entry = play_tree_parser_get_play_tree(ptp, 1); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
633 play_tree_parser_free(ptp); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
634 free_stream(stream); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
635 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
636 return entry; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
637 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
638 |
18916
a95ed361d16b
several function from playtreeparser.c maked static,
reynaldo
parents:
18879
diff
changeset
|
639 static play_tree_t* |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
640 parse_textplain(play_tree_parser_t* p) { |
4782 | 641 char* line; |
12300
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
642 char *c; |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
643 int embedded; |
9789
45173e0d34cc
Fix the incredible slowness with very long list. Now a 10^6 entries
albeu
parents:
9749
diff
changeset
|
644 play_tree_t *list = NULL, *entry = NULL, *last_entry = NULL; |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
645 |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
646 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying plaintext playlist...\n"); |
4782 | 647 play_tree_parser_stop_keeping(p); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
648 |
4782 | 649 while((line = play_tree_parser_get_line(p)) != NULL) { |
650 strstrip(line); | |
12689
050c90536ddd
Support for comments in plaintext playlist by adland
alex
parents:
12538
diff
changeset
|
651 if(line[0] == '\0' || line[0] == '#' || (line[0] == '/' && line[1] == '/')) |
4782 | 652 continue; |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
653 |
12538
2beafad68f68
Enhance detection of embedded smil playlist, add embedded ram playlist
rtognimp
parents:
12300
diff
changeset
|
654 //Special check for embedded smil or ram reference in file |
12300
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
655 embedded = 0; |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
656 if (strlen(line) > 5) |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
657 for(c = line; c[0]; c++ ) |
12538
2beafad68f68
Enhance detection of embedded smil playlist, add embedded ram playlist
rtognimp
parents:
12300
diff
changeset
|
658 if ( ((c[0] == '.') && //start with . and next have smil with optional ? or & |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
659 (tolower(c[1]) == 's') && (tolower(c[2])== 'm') && |
12300
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
660 (tolower(c[3]) == 'i') && (tolower(c[4]) == 'l') && |
12538
2beafad68f68
Enhance detection of embedded smil playlist, add embedded ram playlist
rtognimp
parents:
12300
diff
changeset
|
661 (!c[5] || c[5] == '?' || c[5] == '&')) || // or |
2beafad68f68
Enhance detection of embedded smil playlist, add embedded ram playlist
rtognimp
parents:
12300
diff
changeset
|
662 ((c[0] == '.') && // start with . and next have smi or ram with optional ? or & |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
663 ( ((tolower(c[1]) == 's') && (tolower(c[2])== 'm') && (tolower(c[3]) == 'i')) || |
12538
2beafad68f68
Enhance detection of embedded smil playlist, add embedded ram playlist
rtognimp
parents:
12300
diff
changeset
|
664 ((tolower(c[1]) == 'r') && (tolower(c[2])== 'a') && (tolower(c[3]) == 'm')) ) |
2beafad68f68
Enhance detection of embedded smil playlist, add embedded ram playlist
rtognimp
parents:
12300
diff
changeset
|
665 && (!c[4] || c[4] == '?' || c[4] == '&')) ){ |
12300
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
666 entry=embedded_playlist_parse(line); |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
667 embedded = 1; |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
668 break; |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
669 } |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
670 |
95ea9f5f6f14
Fix embedded smil playlist detection if there are parameters on the url
rtognimp
parents:
12223
diff
changeset
|
671 if (!embedded) { //regular file link |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
672 entry = play_tree_new(); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
673 play_tree_add_file(entry,line); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
674 } |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
675 |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
676 if (entry != NULL) { |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
677 if(!list) |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
678 list = entry; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
679 else |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
680 play_tree_append_entry(last_entry,entry); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
681 last_entry = entry; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
682 } |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
683 } |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
684 |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
685 if(!list) return NULL; |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
686 entry = play_tree_new(); |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
687 play_tree_set_child(entry,list); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
688 return entry; |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
689 } |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
690 |
32623 | 691 /** |
692 * \brief decode the base64 used in nsc files | |
693 * \param in input string, 0-terminated | |
694 * \param buf output buffer, must point to memory suitable for realloc, | |
695 * will be NULL on failure. | |
696 * \return decoded length in bytes | |
697 */ | |
698 static int decode_nsc_base64(char *in, char **buf) { | |
699 int i, j, n; | |
700 if (in[0] != '0' || in[1] != '2') | |
701 goto err_out; | |
702 in += 2; // skip prefix | |
703 if (strlen(in) < 16) // error out if nothing to decode | |
704 goto err_out; | |
705 in += 12; // skip encoded string length | |
706 n = strlen(in) / 4; | |
707 *buf = realloc(*buf, n * 3); | |
708 for (i = 0; i < n; i++) { | |
709 uint8_t c[4]; | |
710 for (j = 0; j < 4; j++) { | |
711 c[j] = in[4 * i + j]; | |
712 if (c[j] >= '0' && c[j] <= '9') c[j] += 0 - '0'; | |
713 else if (c[j] >= 'A' && c[j] <= 'Z') c[j] += 10 - 'A'; | |
714 else if (c[j] >= 'a' && c[j] <= 'z') c[j] += 36 - 'a'; | |
715 else if (c[j] == '{') c[j] = 62; | |
716 else if (c[j] == '}') c[j] = 63; | |
717 else { | |
718 mp_msg(MSGT_PLAYTREE, MSGL_ERR, "Invalid character %c (0x%02"PRIx8")\n", c[j], c[j]); | |
719 goto err_out; | |
720 } | |
721 } | |
722 (*buf)[3 * i] = (c[0] << 2) | (c[1] >> 4); | |
723 (*buf)[3 * i + 1] = (c[1] << 4) | (c[2] >> 2); | |
724 (*buf)[3 * i + 2] = (c[2] << 6) | c[3]; | |
725 } | |
726 return 3 * n; | |
727 err_out: | |
32628 | 728 free(*buf); |
32623 | 729 *buf = NULL; |
730 return 0; | |
731 } | |
732 | |
733 /** | |
734 * \brief "converts" utf16 to ascii by just discarding every second byte | |
735 * \param buf buffer to convert | |
736 * \param len lenght of buffer, must be > 0 | |
737 */ | |
738 static void utf16_to_ascii(char *buf, int len) { | |
739 int i; | |
740 if (len <= 0) return; | |
741 for (i = 0; i < len / 2; i++) | |
742 buf[i] = buf[i * 2]; | |
743 buf[i] = 0; // just in case | |
744 } | |
745 | |
746 static play_tree_t *parse_nsc(play_tree_parser_t* p) { | |
747 char *line, *addr = NULL, *url, *unicast_url = NULL; | |
748 int port = 0; | |
749 play_tree_t *entry = NULL; | |
750 | |
751 mp_msg(MSGT_PLAYTREE,MSGL_V,"Trying nsc playlist...\n"); | |
752 while((line = play_tree_parser_get_line(p)) != NULL) { | |
753 strstrip(line); | |
754 if(!line[0]) // Ignore empties | |
755 continue; | |
756 if (strncasecmp(line,"[Address]", 9) == 0) | |
757 break; // nsc header found | |
758 else | |
759 return NULL; | |
760 } | |
761 mp_msg(MSGT_PLAYTREE,MSGL_V,"Detected nsc playlist format\n"); | |
762 play_tree_parser_stop_keeping(p); | |
763 while ((line = play_tree_parser_get_line(p)) != NULL) { | |
764 strstrip(line); | |
765 if (!line[0]) | |
766 continue; | |
767 if (strncasecmp(line, "Unicast URL=", 12) == 0) { | |
768 int len = decode_nsc_base64(&line[12], &unicast_url); | |
769 if (len <= 0) | |
770 mp_msg(MSGT_PLAYTREE, MSGL_WARN, "[nsc] Unsupported Unicast URL encoding\n"); | |
771 else | |
772 utf16_to_ascii(unicast_url, len); | |
773 } else if (strncasecmp(line, "IP Address=", 11) == 0) { | |
774 int len = decode_nsc_base64(&line[11], &addr); | |
775 if (len <= 0) | |
776 mp_msg(MSGT_PLAYTREE, MSGL_WARN, "[nsc] Unsupported IP Address encoding\n"); | |
777 else | |
778 utf16_to_ascii(addr, len); | |
779 } else if (strncasecmp(line, "IP Port=", 8) == 0) { | |
780 port = strtol(&line[8], NULL, 0); | |
781 } | |
782 } | |
783 | |
784 if (unicast_url) | |
785 url = strdup(unicast_url); | |
786 else if (addr && port) { | |
787 url = malloc(strlen(addr) + 7 + 20 + 1); | |
788 sprintf(url, "http://%s:%i", addr, port); | |
789 } else | |
790 goto out; | |
791 | |
792 entry = play_tree_new(); | |
793 play_tree_add_file(entry, url); | |
794 free(url); | |
795 out: | |
32628 | 796 free(addr); |
797 free(unicast_url); | |
32623 | 798 return entry; |
799 } | |
800 | |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
801 play_tree_t* |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
802 parse_playtree(stream_t *stream, int forced) { |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
803 play_tree_parser_t* p; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
804 play_tree_t* ret; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
805 |
4156
22fadd4022b5
playtree-based config patch by Alban Bedel <albeu@free.fr>
arpi
parents:
4043
diff
changeset
|
806 #ifdef MP_DEBUG |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
807 assert(stream != NULL); |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
808 #endif |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
809 |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
810 p = play_tree_parser_new(stream,0); |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
811 if(!p) |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
812 return NULL; |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
813 |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
814 ret = play_tree_parser_get_play_tree(p, forced); |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
815 play_tree_parser_free(p); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
816 |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
817 return ret; |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
818 } |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
819 |
6662
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
820 static void |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
821 play_tree_add_basepath(play_tree_t* pt, char* bp) { |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
822 int i,bl = strlen(bp),fl; |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
823 |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
824 if(pt->child) { |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
825 play_tree_t* i; |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
826 for(i = pt->child ; i != NULL ; i = i->next) |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
827 play_tree_add_basepath(i,bp); |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
828 return; |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
829 } |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
830 |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
831 if(!pt->files) |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
832 return; |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
833 |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
834 for(i = 0 ; pt->files[i] != NULL ; i++) { |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
835 fl = strlen(pt->files[i]); |
13305
90ffe76b5b25
Don't prepend basepath to a full unix path. ( 10l to Joey. )
al
parents:
13010
diff
changeset
|
836 // if we find a full unix path, url:// or X:\ at the beginning, |
90ffe76b5b25
Don't prepend basepath to a full unix path. ( 10l to Joey. )
al
parents:
13010
diff
changeset
|
837 // don't mangle it. |
90ffe76b5b25
Don't prepend basepath to a full unix path. ( 10l to Joey. )
al
parents:
13010
diff
changeset
|
838 if(fl <= 0 || strstr(pt->files[i],"://") || (strstr(pt->files[i],":\\") == pt->files[i] + 1) || (pt->files[i][0] == '/') ) |
6662
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
839 continue; |
13010 | 840 // if the path begins with \ then prepend drive letter to it. |
841 if (pt->files[i][0] == '\\') { | |
18928
586777f09b1b
relative-to-absolute path fixes: Do not prepend drive letter to \\ paths.
reimar
parents:
18916
diff
changeset
|
842 if (pt->files[i][1] == '\\') |
586777f09b1b
relative-to-absolute path fixes: Do not prepend drive letter to \\ paths.
reimar
parents:
18916
diff
changeset
|
843 continue; |
30702 | 844 pt->files[i] = realloc(pt->files[i], 2 + fl + 1); |
13010 | 845 memmove(pt->files[i] + 2,pt->files[i],fl+1); |
846 memcpy(pt->files[i],bp,2); | |
18928
586777f09b1b
relative-to-absolute path fixes: Do not prepend drive letter to \\ paths.
reimar
parents:
18916
diff
changeset
|
847 continue; |
13010 | 848 } |
30702 | 849 pt->files[i] = realloc(pt->files[i], bl + fl + 1); |
6662
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
850 memmove(pt->files[i] + bl,pt->files[i],fl+1); |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
851 memcpy(pt->files[i],bp,bl); |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
852 } |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
853 } |
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
854 |
9301
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
855 // Wrapper for play_tree_add_basepath (add base path from file) |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
856 void play_tree_add_bpf(play_tree_t* pt, char* filename) |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
857 { |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
858 char *ls, *file; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
859 |
9301
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
860 if (pt && filename) |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
861 { |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
862 file = strdup(filename); |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
863 if (file) |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
864 { |
13010 | 865 ls = strrchr(file,'/'); |
866 if(!ls) ls = strrchr(file,'\\'); | |
9301
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
867 if(ls) { |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
868 ls[1] = '\0'; |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
869 play_tree_add_basepath(pt,file); |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
870 } |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
871 free(file); |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
872 } |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
873 } |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
874 } |
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
875 |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
876 play_tree_t* |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
877 parse_playlist_file(char* file) { |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
878 stream_t *stream; |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
879 play_tree_t* ret; |
12223 | 880 int f=DEMUXER_TYPE_PLAYLIST; |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
881 |
9749 | 882 stream = open_stream(file,0,&f); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
883 |
9749 | 884 if(!stream) { |
10487 | 885 mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Error while opening playlist file %s: %s\n",file,strerror(errno)); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
886 return NULL; |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
887 } |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
888 |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
889 mp_msg(MSGT_PLAYTREE,MSGL_V,"Parsing playlist file %s...\n",file); |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
890 |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
891 ret = parse_playtree(stream,1); |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
892 free_stream(stream); |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
893 |
9301
7841308ad250
this patch fixes latest bug, discovered by .so ... (relative filenames &
arpi
parents:
9089
diff
changeset
|
894 play_tree_add_bpf(ret, file); |
6662
f8e25756a5ec
Relative filename in playlist are now relative to the playlist path
albeu
parents:
6661
diff
changeset
|
895 |
4043
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
896 return ret; |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
897 |
25590564842f
tree-based playlist parser code by Alban Bedel <albeu@free.fr>
arpi
parents:
diff
changeset
|
898 } |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
899 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
900 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
901 play_tree_parser_t* |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
902 play_tree_parser_new(stream_t* stream,int deep) { |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
903 play_tree_parser_t* p; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
904 |
18879 | 905 p = calloc(1,sizeof(play_tree_parser_t)); |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
906 if(!p) |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
907 return NULL; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
908 p->stream = stream; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
909 p->deep = deep; |
4782 | 910 p->keep = 1; |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
911 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
912 return p; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
913 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
914 } |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
915 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
916 void |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
917 play_tree_parser_free(play_tree_parser_t* p) { |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
918 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
919 #ifdef MP_DEBUG |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
920 assert(p != NULL); |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
921 #endif |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
922 |
32511
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
923 free(p->buffer); |
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
31880
diff
changeset
|
924 free(p->line); |
4782 | 925 free(p); |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
926 } |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
927 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
928 play_tree_t* |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
929 play_tree_parser_get_play_tree(play_tree_parser_t* p, int forced) { |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
930 play_tree_t* tree = NULL; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
931 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
932 #ifdef MP_DEBUG |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
933 assert(p != NULL); |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
934 #endif |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
935 |
4782 | 936 |
937 while(play_tree_parser_get_line(p) != NULL) { | |
938 play_tree_parser_reset(p); | |
939 | |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
940 tree = parse_asx(p); |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
941 if(tree) break; |
4782 | 942 play_tree_parser_reset(p); |
943 | |
944 tree = parse_pls(p); | |
945 if(tree) break; | |
946 play_tree_parser_reset(p); | |
947 | |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
948 tree = parse_m3u(p); |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
949 if(tree) break; |
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
950 play_tree_parser_reset(p); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
951 |
8897
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
952 tree = parse_ref_ini(p); |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
953 if(tree) break; |
ef01554542fb
This patch adds support for some silly ini-style-playlist-file-format ...
arpi
parents:
8164
diff
changeset
|
954 play_tree_parser_reset(p); |
6661
dc61b6b159e4
Add support for m3u playlists as generated by eg recent versions of winamp.
atmos4
parents:
5866
diff
changeset
|
955 |
12097
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
956 tree = parse_smil(p); |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
957 if(tree) break; |
cb0cdaa0bddf
Support for smil playlist, both standalone and embedded into other
rtognimp
parents:
10694
diff
changeset
|
958 play_tree_parser_reset(p); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
959 |
32623 | 960 tree = parse_nsc(p); |
961 if(tree) break; | |
962 play_tree_parser_reset(p); | |
963 | |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
964 // Here come the others formats ( textplain must stay the last one ) |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
965 if (forced) |
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
966 { |
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
967 tree = parse_textplain(p); |
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
968 if(tree) break; |
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
969 } |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
970 break; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
971 } |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
972 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
973 if(tree) |
10487 | 974 mp_msg(MSGT_PLAYTREE,MSGL_V,"Playlist successfully parsed\n"); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
975 else |
8925
5c15777f1c07
this patch adds an fallback to playlist (any but the plaintext-list format)
arpi
parents:
8907
diff
changeset
|
976 mp_msg(MSGT_PLAYTREE,((forced==1)?MSGL_ERR:MSGL_V),"Error while parsing playlist\n"); |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
977 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
978 if(tree) |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
979 tree = play_tree_cleanup(tree); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28314
diff
changeset
|
980 |
10487 | 981 if(!tree) mp_msg(MSGT_PLAYTREE,((forced==1)?MSGL_WARN:MSGL_V),"Warning: empty playlist\n"); |
4308
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
982 |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
983 return tree; |
d752f99fd535
Objectization of the play_tree_parser for more flexiblity
albeu
parents:
4156
diff
changeset
|
984 } |