1
0
mirror of https://github.com/mpv-player/mpv synced 2024-12-25 00:02:13 +00:00
mpv/core/asxparser.c
wm4 4873b32c59 Rename directories, move files (step 2 of 2)
Finish renaming directories and moving files. Adjust all include
statements to make the previous commit compile.

The two commits are separate, because git is bad at tracking renames
and content changes at the same time.

Also take this as an opportunity to remove the separation between
"common" and "mplayer" sources in the Makefile. ("common" used to be
shared between mplayer and mencoder.)
2012-11-12 20:08:18 +01:00

593 lines
16 KiB
C

/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include "playlist.h"
#include "playlist_parser.h"
#include "stream/stream.h"
#include "demux/demux.h"
#include "asxparser.h"
#include "core/mp_msg.h"
typedef struct ASX_Parser_t ASX_Parser_t;
typedef struct {
char* buffer;
int line;
} ASX_LineSave_t;
struct ASX_Parser_t {
int line; // Curent line
ASX_LineSave_t *ret_stack;
int ret_stack_size;
char* last_body;
int deep;
struct playlist *pl;
};
ASX_Parser_t *asx_parser_new(struct playlist *pl);
void
asx_parser_free(ASX_Parser_t* parser);
/*
* Return -1 on error, 0 when nothing is found, 1 on sucess
*/
int
asx_get_element(ASX_Parser_t* parser,char** _buffer,
char** _element,char** _body,char*** _attribs);
int
asx_parse_attribs(ASX_Parser_t* parser,char* buffer,char*** _attribs);
/////// Attribs utils
char*
asx_get_attrib(const char* attrib,char** attribs);
#define asx_free_attribs(a) asx_list_free(&a,free)
////// List utils
typedef void (*ASX_FreeFunc)(void* arg);
void
asx_list_free(void* list_ptr,ASX_FreeFunc free_func);
////// List utils
void
asx_list_free(void* list_ptr,ASX_FreeFunc free_func) {
void** ptr = *(void***)list_ptr;
if(ptr == NULL) return;
if(free_func != NULL) {
for( ; *ptr != NULL ; ptr++)
free_func(*ptr);
}
free(*(void**)list_ptr);
*(void**)list_ptr = NULL;
}
/////// Attribs utils
char*
asx_get_attrib(const char* attrib,char** attribs) {
char** ptr;
if(attrib == NULL || attribs == NULL) return NULL;
for(ptr = attribs; ptr[0] != NULL; ptr += 2){
if(strcasecmp(ptr[0],attrib) == 0)
return strdup(ptr[1]);
}
return NULL;
}
#define asx_warning_attrib_required(p,e,a) mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : element %s don't have the required attribute %s",p->line,e,a)
#define asx_warning_body_parse_error(p,e) mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : error while parsing %s body",p->line,e)
ASX_Parser_t *asx_parser_new(struct playlist *pl)
{
ASX_Parser_t* parser = calloc(1,sizeof(ASX_Parser_t));
parser->pl = pl;
return parser;
}
void
asx_parser_free(ASX_Parser_t* parser) {
if(!parser) return;
free(parser->ret_stack);
free(parser);
}
#define LETTER "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define SPACE " \n\t\r"
int
asx_parse_attribs(ASX_Parser_t* parser,char* buffer,char*** _attribs) {
char *ptr1, *ptr2, *ptr3;
int n_attrib = 0;
char **attribs = NULL;
char *attrib, *val;
ptr1 = buffer;
while(1) {
for( ; strchr(SPACE,*ptr1) != NULL; ptr1++) { // Skip space
if(*ptr1 == '\0') break;
}
ptr3 = strchr(ptr1,'=');
if(ptr3 == NULL) break;
for(ptr2 = ptr3-1; strchr(SPACE,*ptr2) != NULL; ptr2--) {
if (ptr2 == ptr1) {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : this should never append, back to attribute begin while skipping end space",parser->line);
break;
}
}
attrib = malloc(ptr2-ptr1+2);
strncpy(attrib,ptr1,ptr2-ptr1+1);
attrib[ptr2-ptr1+1] = '\0';
ptr1 = strchr(ptr3,'"');
if(ptr1 == NULL || ptr1[1] == '\0') ptr1 = strchr(ptr3,'\'');
if(ptr1 == NULL || ptr1[1] == '\0') {
mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : can't find attribute %s value",parser->line,attrib);
free(attrib);
break;
}
ptr2 = strchr(ptr1+1,ptr1[0]);
if (ptr2 == NULL) {
mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : value of attribute %s isn't finished",parser->line,attrib);
free(attrib);
break;
}
ptr1++;
val = malloc(ptr2-ptr1+1);
strncpy(val,ptr1,ptr2-ptr1);
val[ptr2-ptr1] = '\0';
n_attrib++;
attribs = realloc(attribs, (2 * n_attrib + 1) * sizeof(char*));
attribs[n_attrib*2-2] = attrib;
attribs[n_attrib*2-1] = val;
ptr1 = ptr2+1;
}
if(n_attrib > 0)
attribs[n_attrib*2] = NULL;
*_attribs = attribs;
return n_attrib;
}
/*
* Return -1 on error, 0 when nothing is found, 1 on sucess
*/
int
asx_get_element(ASX_Parser_t* parser,char** _buffer,
char** _element,char** _body,char*** _attribs) {
char *ptr1,*ptr2, *ptr3, *ptr4;
char *attribs = NULL;
char *element = NULL, *body = NULL, *ret = NULL, *buffer;
int n_attrib = 0;
int body_line = 0,attrib_line,ret_line,in = 0;
int quotes = 0;
if(_buffer == NULL || _element == NULL || _body == NULL || _attribs == NULL) {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : asx_get_element called with invalid value",parser->line);
return -1;
}
*_body = *_element = NULL;
*_attribs = NULL;
buffer = *_buffer;
if(buffer == NULL) return 0;
if(parser->ret_stack && /*parser->last_body && */buffer != parser->last_body) {
ASX_LineSave_t* ls = parser->ret_stack;
int i;
for(i = 0 ; i < parser->ret_stack_size ; i++) {
if(buffer == ls[i].buffer) {
parser->line = ls[i].line;
break;
}
}
if( i < parser->ret_stack_size) {
i++;
if( i < parser->ret_stack_size)
memmove(parser->ret_stack,parser->ret_stack+i, (parser->ret_stack_size - i)*sizeof(ASX_LineSave_t));
parser->ret_stack_size -= i;
if(parser->ret_stack_size > 0)
parser->ret_stack = realloc(parser->ret_stack,parser->ret_stack_size*sizeof(ASX_LineSave_t));
else {
free(parser->ret_stack);
parser->ret_stack = NULL;
}
}
}
ptr1 = buffer;
while(1) {
for( ; ptr1[0] != '<' ; ptr1++) {
if(ptr1[0] == '\0') {
ptr1 = NULL;
break;
}
if(ptr1[0] == '\n') parser->line++;
}
//ptr1 = strchr(ptr1,'<');
if(!ptr1 || ptr1[1] == '\0') return 0; // Nothing found
if(strncmp(ptr1,"<!--",4) == 0) { // Comments
for( ; strncmp(ptr1,"-->",3) != 0 ; ptr1++) {
if(ptr1[0] == '\0') {
ptr1 = NULL;
break;
}
if(ptr1[0] == '\n') parser->line++;
}
//ptr1 = strstr(ptr1,"-->");
if(!ptr1) {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : unfinished comment",parser->line);
return -1;
}
} else {
break;
}
}
// Is this space skip very useful ??
for(ptr1++; strchr(SPACE,ptr1[0]) != NULL; ptr1++) { // Skip space
if(ptr1[0] == '\0') {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
return -1;
}
if(ptr1[0] == '\n') parser->line++;
}
for(ptr2 = ptr1; strchr(LETTER,*ptr2) != NULL;ptr2++) { // Go to end of name
if(*ptr2 == '\0'){
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
return -1;
}
if(ptr2[0] == '\n') parser->line++;
}
element = malloc(ptr2-ptr1+1);
strncpy(element,ptr1,ptr2-ptr1);
element[ptr2-ptr1] = '\0';
for( ; strchr(SPACE,*ptr2) != NULL; ptr2++) { // Skip space
if(ptr2[0] == '\0') {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
free(element);
return -1;
}
if(ptr2[0] == '\n') parser->line++;
}
attrib_line = parser->line;
for(ptr3 = ptr2; ptr3[0] != '\0'; ptr3++) { // Go to element end
if(ptr3[0] == '"') quotes ^= 1;
if(!quotes && (ptr3[0] == '>' || strncmp(ptr3,"/>",2) == 0))
break;
if(ptr3[0] == '\n') parser->line++;
}
if(ptr3[0] == '\0' || ptr3[1] == '\0') { // End of file
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing element start",parser->line);
free(element);
return -1;
}
// Save attribs string
if(ptr3-ptr2 > 0) {
attribs = malloc(ptr3-ptr2+1);
strncpy(attribs,ptr2,ptr3-ptr2);
attribs[ptr3-ptr2] = '\0';
}
//bs_line = parser->line;
if(ptr3[0] != '/') { // Not Self closed element
ptr3++;
for( ; strchr(SPACE,*ptr3) != NULL; ptr3++) { // Skip space on body begin
if(*ptr3 == '\0') {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing %s element body",parser->line,element);
free(element);
free(attribs);
return -1;
}
if(ptr3[0] == '\n') parser->line++;
}
ptr4 = ptr3;
body_line = parser->line;
while(1) { // Find closing element
for( ; ptr4[0] != '<' ; ptr4++) {
if(ptr4[0] == '\0') {
ptr4 = NULL;
break;
}
if(ptr4[0] == '\n') parser->line++;
}
if(ptr4 && strncmp(ptr4,"<!--",4) == 0) { // Comments
for( ; strncmp(ptr4,"-->",3) != 0 ; ptr4++) {
if(ptr4[0] == '\0') {
ptr4 = NULL;
break;
}
if(ptr1[0] == '\n') parser->line++;
}
continue;
}
if(ptr4 == NULL || ptr4[1] == '\0') {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : EOB reached while parsing %s element body",parser->line,element);
free(element);
free(attribs);
return -1;
}
if(ptr4[1] != '/' && strncasecmp(element,ptr4+1,strlen(element)) == 0) {
in++;
ptr4+=2;
continue;
} else if(strncasecmp(element,ptr4+2,strlen(element)) == 0) { // Extract body
if(in > 0) {
in--;
ptr4 += 2+strlen(element);
continue;
}
ret = ptr4+strlen(element)+3;
if(ptr4 != ptr3) {
ptr4--;
for( ; ptr4 != ptr3 && strchr(SPACE,*ptr4) != NULL; ptr4--) ;// Skip space on body end
// if(ptr4[0] == '\0') parser->line--;
//}
ptr4++;
body = malloc(ptr4-ptr3+1);
strncpy(body,ptr3,ptr4-ptr3);
body[ptr4-ptr3] = '\0';
}
break;
} else {
ptr4 += 2;
}
}
} else {
ret = ptr3 + 2; // 2 is for />
}
for( ; ret[0] != '\0' && strchr(SPACE,ret[0]) != NULL; ret++) { // Skip space
if(ret[0] == '\n') parser->line++;
}
ret_line = parser->line;
if(attribs) {
parser->line = attrib_line;
n_attrib = asx_parse_attribs(parser,attribs,_attribs);
free(attribs);
if(n_attrib < 0) {
mp_msg(MSGT_PLAYTREE,MSGL_WARN,"At line %d : error while parsing element %s attributes",parser->line,element);
free(element);
free(body);
return -1;
}
} else
*_attribs = NULL;
*_element = element;
*_body = body;
parser->last_body = body;
parser->ret_stack_size++;
parser->ret_stack = realloc(parser->ret_stack,parser->ret_stack_size*sizeof(ASX_LineSave_t));
if(parser->ret_stack_size > 1)
memmove(parser->ret_stack+1,parser->ret_stack,(parser->ret_stack_size-1)*sizeof(ASX_LineSave_t));
parser->ret_stack[0].buffer = ret;
parser->ret_stack[0].line = ret_line;
parser->line = body ? body_line : ret_line;
*_buffer = ret;
return 1;
}
static void
asx_parse_ref(ASX_Parser_t* parser, char** attribs) {
char *href;
href = asx_get_attrib("HREF",attribs);
if(href == NULL) {
asx_warning_attrib_required(parser,"REF" ,"HREF" );
return;
}
#if 0
// replace http my mmshttp to avoid infinite loops
// disabled since some playlists for e.g. WinAMP use asx as well
// "-user-agent NSPlayer/4.1.0.3856" is a possible workaround
if (strncmp(href, "http://", 7) == 0) {
char *newref = malloc(3 + strlen(href) + 1);
strcpy(newref, "mms");
strcpy(newref + 3, href);
free(href);
href = newref;
}
#endif
playlist_add_file(parser->pl, href);
mp_msg(MSGT_PLAYTREE,MSGL_V,"Adding file %s to element entry\n",href);
free(href);
}
static void asx_parse_entryref(ASX_Parser_t* parser,char* buffer,char** _attribs) {
char *href;
stream_t* stream;
int f=DEMUXER_TYPE_UNKNOWN;
if(parser->deep > 0)
return;
href = asx_get_attrib("HREF",_attribs);
if(href == NULL) {
asx_warning_attrib_required(parser,"ENTRYREF" ,"HREF" );
return;
}
stream=open_stream(href,0,&f);
if(!stream) {
mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Can't open playlist %s\n",href);
free(href);
return;
}
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Not recursively loading playlist %s\n",href);
free_stream(stream);
free(href);
//mp_msg(MSGT_PLAYTREE,MSGL_INFO,"Need to implement entryref\n");
}
static void asx_parse_entry(ASX_Parser_t* parser,char* buffer,char** _attribs) {
char *element,*body,**attribs;
int r;
while(buffer && buffer[0] != '\0') {
r = asx_get_element(parser,&buffer,&element,&body,&attribs);
if(r < 0) {
asx_warning_body_parse_error(parser,"ENTRY");
return;
} else if (r == 0) { // No more element
break;
}
if(strcasecmp(element,"REF") == 0) {
asx_parse_ref(parser,attribs);
mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Adding element %s to entry\n",element);
} else
mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Ignoring element %s\n",element);
free(body);
asx_free_attribs(attribs);
}
}
static void asx_parse_repeat(ASX_Parser_t* parser,char* buffer,char** _attribs) {
char *element,*body,**attribs;
int r;
asx_get_attrib("COUNT",_attribs);
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Ignoring repeated playlist entries\n");
while(buffer && buffer[0] != '\0') {
r = asx_get_element(parser,&buffer,&element,&body,&attribs);
if(r < 0) {
asx_warning_body_parse_error(parser,"REPEAT");
return;
} else if (r == 0) { // No more element
break;
}
if(strcasecmp(element,"ENTRY") == 0) {
asx_parse_entry(parser,body,attribs);
} else if(strcasecmp(element,"ENTRYREF") == 0) {
asx_parse_entryref(parser,body,attribs);
} else if(strcasecmp(element,"REPEAT") == 0) {
asx_parse_repeat(parser,body,attribs);
} else
mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Ignoring element %s\n",element);
free(body);
asx_free_attribs(attribs);
}
}
bool asx_parse(char* buffer, struct playlist *pl)
{
char *element,*asx_body,**asx_attribs,*body = NULL, **attribs;
int r;
ASX_Parser_t* parser = asx_parser_new(pl);
parser->line = 1;
parser->deep = 0;
r = asx_get_element(parser,&buffer,&element,&asx_body,&asx_attribs);
if(r < 0) {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"At line %d : Syntax error ???",parser->line);
asx_parser_free(parser);
return false;
} else if(r == 0) { // No contents
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"empty asx element");
asx_parser_free(parser);
return false;
}
if(strcasecmp(element,"ASX") != 0) {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"first element isn't ASX, it's %s\n",element);
asx_free_attribs(asx_attribs);
asx_parser_free(parser);
return false;
}
if(!asx_body) {
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"ASX element is empty");
asx_free_attribs(asx_attribs);
asx_parser_free(parser);
return false;
}
buffer = asx_body;
while(buffer && buffer[0] != '\0') {
r = asx_get_element(parser,&buffer,&element,&body,&attribs);
if(r < 0) {
asx_warning_body_parse_error(parser,"ASX");
asx_parser_free(parser);
return false;
} else if (r == 0) { // No more element
break;
}
if(strcasecmp(element,"ENTRY") == 0) {
asx_parse_entry(parser,body,attribs);
} else if(strcasecmp(element,"ENTRYREF") == 0) {
asx_parse_entryref(parser,body,attribs);
} else if(strcasecmp(element,"REPEAT") == 0) {
asx_parse_repeat(parser,body,attribs);
} else
mp_msg(MSGT_PLAYTREE,MSGL_DBG2,"Ignoring element %s\n",element);
free(body);
asx_free_attribs(attribs);
}
free(asx_body);
asx_free_attribs(asx_attribs);
asx_parser_free(parser);
return true;
}