diff options
Diffstat (limited to 'stream/realrtsp')
| -rw-r--r-- | stream/realrtsp/asmrp.c | 677 | ||||
| -rw-r--r-- | stream/realrtsp/asmrp.h | 45 | ||||
| -rw-r--r-- | stream/realrtsp/real.c | 612 | ||||
| -rw-r--r-- | stream/realrtsp/real.h | 56 | ||||
| -rw-r--r-- | stream/realrtsp/rmff.c | 907 | ||||
| -rw-r--r-- | stream/realrtsp/rmff.h | 270 | ||||
| -rw-r--r-- | stream/realrtsp/sdpplin.c | 366 | ||||
| -rw-r--r-- | stream/realrtsp/sdpplin.h | 109 | ||||
| -rw-r--r-- | stream/realrtsp/xbuffer.c | 102 | ||||
| -rw-r--r-- | stream/realrtsp/xbuffer.h | 26 |
10 files changed, 3170 insertions, 0 deletions
diff --git a/stream/realrtsp/asmrp.c b/stream/realrtsp/asmrp.c new file mode 100644 index 0000000000..05953daeb8 --- /dev/null +++ b/stream/realrtsp/asmrp.c @@ -0,0 +1,677 @@ +/* + * This file was ported to MPlayer from xine CVS asmrp.c,v 1.2 2002/12/17 16:49:48 + */ + +/* + * Copyright (C) 2002 the xine project + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * + * a parser for real's asm rules + * + * grammar for these rules: + * + + rule_book = { rule } + rule = ( '#' condition { ',' assignment } | [ assignment {',' assignment} ]) ';' + assignment = id '=' const + const = ( number | string ) + condition = comp_expr { ( '&&' | '||' ) comp_expr } + comp_expr = operand { ( '<' | '<=' | '==' | '>=' | '>' ) operand } + operand = ( '$' id | num | '(' condition ')' ) + + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +/* +#define LOG +*/ + +#define ASMRP_SYM_NONE 0 +#define ASMRP_SYM_EOF 1 + +#define ASMRP_SYM_NUM 2 +#define ASMRP_SYM_ID 3 +#define ASMRP_SYM_STRING 4 + +#define ASMRP_SYM_HASH 10 +#define ASMRP_SYM_SEMICOLON 11 +#define ASMRP_SYM_COMMA 12 +#define ASMRP_SYM_EQUALS 13 +#define ASMRP_SYM_AND 14 +#define ASMRP_SYM_OR 15 +#define ASMRP_SYM_LESS 16 +#define ASMRP_SYM_LEQ 17 +#define ASMRP_SYM_GEQ 18 +#define ASMRP_SYM_GREATER 19 +#define ASMRP_SYM_DOLLAR 20 +#define ASMRP_SYM_LPAREN 21 +#define ASMRP_SYM_RPAREN 22 + +#define ASMRP_MAX_ID 1024 + +#define ASMRP_MAX_SYMTAB 10 + +typedef struct { + char *id; + int v; +} asmrp_sym_t; + +typedef struct { + + /* public part */ + + int sym; + int num; + + char str[ASMRP_MAX_ID]; + + /* private part */ + + char *buf; + int pos; + char ch; + + asmrp_sym_t sym_tab[ASMRP_MAX_SYMTAB]; + int sym_tab_num; + +} asmrp_t; + +static asmrp_t *asmrp_new (void) { + + asmrp_t *p; + + p = malloc (sizeof (asmrp_t)); + + p->sym_tab_num = 0; + p->sym = ASMRP_SYM_NONE; + + return p; +} + +static void asmrp_dispose (asmrp_t *p) { + + int i; + + for (i=0; i<p->sym_tab_num; i++) + free (p->sym_tab[i].id); + + free (p); +} + +static void asmrp_getch (asmrp_t *p) { + p->ch = p->buf[p->pos]; + p->pos++; + +#ifdef LOG + printf ("%c\n", p->ch); +#endif + +} + +static void asmrp_init (asmrp_t *p, const char *str) { + + p->buf = strdup (str); + p->pos = 0; + + asmrp_getch (p); +} + +static void asmrp_number (asmrp_t *p) { + + int num; + + num = 0; + while ( (p->ch>='0') && (p->ch<='9') ) { + + num = num*10 + (p->ch - '0'); + + asmrp_getch (p); + } + + p->sym = ASMRP_SYM_NUM; + p->num = num; +} + +static void asmrp_string (asmrp_t *p) { + + int l; + + l = 0; + + while ( (p->ch!='"') && (p->ch>=32) ) { + + p->str[l] = p->ch; + + l++; + asmrp_getch (p); + } + p->str[l]=0; + + if (p->ch=='"') + asmrp_getch (p); + + p->sym = ASMRP_SYM_STRING; +} + +static void asmrp_identifier (asmrp_t *p) { + + int l; + + l = 0; + + while ( ((p->ch>='A') && (p->ch<='z')) + || ((p->ch>='0') && (p->ch<='9'))) { + + p->str[l] = p->ch; + + l++; + asmrp_getch (p); + } + p->str[l]=0; + + p->sym = ASMRP_SYM_ID; +} + +#ifdef LOG +static void asmrp_print_sym (asmrp_t *p) { + + printf ("symbol: "); + + switch (p->sym) { + + case ASMRP_SYM_NONE: + printf ("NONE\n"); + break; + + case ASMRP_SYM_EOF: + printf ("EOF\n"); + break; + + case ASMRP_SYM_NUM: + printf ("NUM %d\n", p->num); + break; + + case ASMRP_SYM_ID: + printf ("ID '%s'\n", p->str); + break; + + case ASMRP_SYM_STRING: + printf ("STRING \"%s\"\n", p->str); + break; + + case ASMRP_SYM_HASH: + printf ("#\n"); + break; + + case ASMRP_SYM_SEMICOLON: + printf (";\n"); + break; + case ASMRP_SYM_COMMA: + printf (",\n"); + break; + case ASMRP_SYM_EQUALS: + printf ("==\n"); + break; + case ASMRP_SYM_AND: + printf ("&&\n"); + break; + case ASMRP_SYM_OR: + printf ("||\n"); + break; + case ASMRP_SYM_LESS: + printf ("<\n"); + break; + case ASMRP_SYM_LEQ: + printf ("<=\n"); + break; + case ASMRP_SYM_GEQ: + printf (">=\n"); + break; + case ASMRP_SYM_GREATER: + printf (">\n"); + break; + case ASMRP_SYM_DOLLAR: + printf ("$\n"); + break; + case ASMRP_SYM_LPAREN: + printf ("(\n"); + break; + case ASMRP_SYM_RPAREN: + printf (")\n"); + break; + + default: + printf ("unknown symbol %d\n", p->sym); + } +} +#endif + +static void asmrp_get_sym (asmrp_t *p) { + + while (p->ch <= 32) { + if (p->ch == 0) { + p->sym = ASMRP_SYM_EOF; + return; + } + + asmrp_getch (p); + } + + if (p->ch == '\\') + asmrp_getch (p); + + switch (p->ch) { + + case '#': + p->sym = ASMRP_SYM_HASH; + asmrp_getch (p); + break; + case ';': + p->sym = ASMRP_SYM_SEMICOLON; + asmrp_getch (p); + break; + case ',': + p->sym = ASMRP_SYM_COMMA; + asmrp_getch (p); + break; + case '=': + p->sym = ASMRP_SYM_EQUALS; + asmrp_getch (p); + if (p->ch=='=') + asmrp_getch (p); + break; + case '&': + p->sym = ASMRP_SYM_AND; + asmrp_getch (p); + if (p->ch=='&') + asmrp_getch (p); + break; + case '|': + p->sym = ASMRP_SYM_OR; + asmrp_getch (p); + if (p->ch=='|') + asmrp_getch (p); + break; + case '<': + p->sym = ASMRP_SYM_LESS; + asmrp_getch (p); + if (p->ch=='=') { + p->sym = ASMRP_SYM_LEQ; + asmrp_getch (p); + } + break; + case '>': + p->sym = ASMRP_SYM_GREATER; + asmrp_getch (p); + if (p->ch=='=') { + p->sym = ASMRP_SYM_GEQ; + asmrp_getch (p); + } + break; + case '$': + p->sym = ASMRP_SYM_DOLLAR; + asmrp_getch (p); + break; + case '(': + p->sym = ASMRP_SYM_LPAREN; + asmrp_getch (p); + break; + case ')': + p->sym = ASMRP_SYM_RPAREN; + asmrp_getch (p); + break; + + case '"': + asmrp_getch (p); + asmrp_string (p); + break; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + asmrp_number (p); + break; + + default: + asmrp_identifier (p); + } + +#ifdef LOG + asmrp_print_sym (p); +#endif + +} + +static int asmrp_find_id (asmrp_t *p, char *s) { + + int i; + + for (i=0; i<p->sym_tab_num; i++) { + if (!strcmp (s, p->sym_tab[i].id)) + return i; + } + + return -1; +} + +static int asmrp_set_id (asmrp_t *p, char *s, int v) { + + int i; + + i = asmrp_find_id (p, s); + + if (i<0) { + i = p->sym_tab_num; + p->sym_tab_num++; + p->sym_tab[i].id = strdup (s); + +#ifdef LOG + printf ("new symbol '%s'\n", s); +#endif + + } + + p->sym_tab[i].v = v; + +#ifdef LOG + printf ("symbol '%s' assigned %d\n", s, v); +#endif + + return i; +} + +static int asmrp_condition (asmrp_t *p) ; + +static int asmrp_operand (asmrp_t *p) { + + int i, ret; + +#ifdef LOG + printf ("operand\n"); +#endif + + ret = 0; + + switch (p->sym) { + + case ASMRP_SYM_DOLLAR: + + asmrp_get_sym (p); + + if (p->sym != ASMRP_SYM_ID) { + printf ("error: identifier expected.\n"); + abort(); + } + + i = asmrp_find_id (p, p->str); + if (i<0) { + printf ("error: unknown identifier %s\n", p->str); + } + ret = p->sym_tab[i].v; + + asmrp_get_sym (p); + break; + + case ASMRP_SYM_NUM: + ret = p->num; + + asmrp_get_sym (p); + break; + + case ASMRP_SYM_LPAREN: + asmrp_get_sym (p); + + ret = asmrp_condition (p); + + if (p->sym != ASMRP_SYM_RPAREN) { + printf ("error: ) expected.\n"); + abort(); + } + + asmrp_get_sym (p); + break; + + default: + printf ("syntax error, $ number or ( expected\n"); + abort(); + } + +#ifdef LOG + printf ("operand done, =%d\n", ret); +#endif + + return ret; +} + +static int asmrp_comp_expression (asmrp_t *p) { + + int a; + +#ifdef LOG + printf ("comp_expression\n"); +#endif + + a = asmrp_operand (p); + + while ( (p->sym == ASMRP_SYM_LESS) + || (p->sym == ASMRP_SYM_LEQ) + || (p->sym == ASMRP_SYM_EQUALS) + || (p->sym == ASMRP_SYM_GEQ) + || (p->sym == ASMRP_SYM_GREATER) ) { + int op = p->sym; + int b; + + asmrp_get_sym (p); + + b = asmrp_operand (p); + + switch (op) { + case ASMRP_SYM_LESS: + a = a<b; + break; + case ASMRP_SYM_LEQ: + a = a<=b; + break; + case ASMRP_SYM_EQUALS: + a = a==b; + break; + case ASMRP_SYM_GEQ: + a = a>=b; + break; + case ASMRP_SYM_GREATER: + a = a>b; + break; + } + + } + +#ifdef LOG + printf ("comp_expression done = %d\n", a); +#endif + return a; +} + +static int asmrp_condition (asmrp_t *p) { + + int a; + +#ifdef LOG + printf ("condition\n"); +#endif + + a = asmrp_comp_expression (p); + + while ( (p->sym == ASMRP_SYM_AND) || (p->sym == ASMRP_SYM_OR) ) { + int op, b; + + op = p->sym; + + asmrp_get_sym (p); + + b = asmrp_comp_expression (p); + + switch (op) { + case ASMRP_SYM_AND: + a = a & b; + break; + case ASMRP_SYM_OR: + a = a | b; + break; + } + } + +#ifdef LOG + printf ("condition done = %d\n", a); +#endif + return a; +} + +static void asmrp_assignment (asmrp_t *p) { + +#ifdef LOG + printf ("assignment\n"); +#endif + + if (p->sym == ASMRP_SYM_COMMA || p->sym == ASMRP_SYM_SEMICOLON) { +#ifdef LOG + printf ("empty assignment\n"); +#endif + return; + } + + if (p->sym != ASMRP_SYM_ID) { + printf ("error: identifier expected\n"); + abort (); + } + asmrp_get_sym (p); + + if (p->sym != ASMRP_SYM_EQUALS) { + printf ("error: = expected\n"); + abort (); + } + asmrp_get_sym (p); + + if ( (p->sym != ASMRP_SYM_NUM) && (p->sym != ASMRP_SYM_STRING) + && (p->sym != ASMRP_SYM_ID)) { + printf ("error: number or string expected\n"); + abort (); + } + asmrp_get_sym (p); + +#ifdef LOG + printf ("assignment done\n"); +#endif +} + +static int asmrp_rule (asmrp_t *p) { + + int ret; + +#ifdef LOG + printf ("rule\n"); +#endif + + ret = 1; + + if (p->sym == ASMRP_SYM_HASH) { + + asmrp_get_sym (p); + ret = asmrp_condition (p); + + while (p->sym == ASMRP_SYM_COMMA) { + + asmrp_get_sym (p); + + asmrp_assignment (p); + } + + } else if (p->sym != ASMRP_SYM_SEMICOLON) { + + asmrp_assignment (p); + + while (p->sym == ASMRP_SYM_COMMA) { + + asmrp_get_sym (p); + asmrp_assignment (p); + } + } + +#ifdef LOG + printf ("rule done = %d\n", ret); +#endif + + if (p->sym != ASMRP_SYM_SEMICOLON) { + printf ("semicolon expected.\n"); + abort (); + } + + asmrp_get_sym (p); + + return ret; +} + +static int asmrp_eval (asmrp_t *p, int *matches) { + + int rule_num, num_matches; + +#ifdef LOG + printf ("eval\n"); +#endif + + asmrp_get_sym (p); + + rule_num = 0; num_matches = 0; + while (p->sym != ASMRP_SYM_EOF) { + + if (asmrp_rule (p)) { +#ifdef LOG + printf ("rule #%d is true\n", rule_num); +#endif + matches[num_matches] = rule_num; + num_matches++; + } + + rule_num++; + } + + matches[num_matches] = -1; + return num_matches; +} + +int asmrp_match (const char *rules, int bandwidth, int *matches) { + + asmrp_t *p; + int num_matches; + + p = asmrp_new (); + + asmrp_init (p, rules); + + asmrp_set_id (p, "Bandwidth", bandwidth); + asmrp_set_id (p, "OldPNMPlayer", 0); + + num_matches = asmrp_eval (p, matches); + + asmrp_dispose (p); + + return num_matches; +} + diff --git a/stream/realrtsp/asmrp.h b/stream/realrtsp/asmrp.h new file mode 100644 index 0000000000..7cbd37d74a --- /dev/null +++ b/stream/realrtsp/asmrp.h @@ -0,0 +1,45 @@ +/* + * This file was ported to MPlayer from xine CVS asmrp.h,v 1.1 2002/12/12 22:14:54 + */ + +/* + * Copyright (C) 2002 the xine project + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * + * a parser for real's asm rules + * + * grammar for these rules: + * + + rule_book = { '#' rule ';'} + rule = condition {',' assignment} + assignment = id '=' const + const = ( number | string ) + condition = comp_expr { ( '&&' | '||' ) comp_expr } + comp_expr = operand { ( '<' | '<=' | '==' | '>=' | '>' ) operand } + operand = ( '$' id | num | '(' condition ')' ) + + */ + +#ifndef HAVE_ASMRP_H +#define HAVE_ASMRP_H + +int asmrp_match (const char *rules, int bandwidth, int *matches) ; + +#endif diff --git a/stream/realrtsp/real.c b/stream/realrtsp/real.c new file mode 100644 index 0000000000..00c0c124b3 --- /dev/null +++ b/stream/realrtsp/real.c @@ -0,0 +1,612 @@ +/* + * This file was ported to MPlayer from xine CVS real.c,v 1.8 2003/03/30 17:11:50 + */ + +/* + * Copyright (C) 2002 the xine project + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * + * special functions for real streams. + * adopted from joschkas real tools. + * + */ + +#include <stdio.h> +#include <string.h> + +#include "../config.h" +#include "../bswap.h" +#include "real.h" +#include "asmrp.h" +#include "sdpplin.h" +#include "xbuffer.h" +#if USE_LIBAVUTIL_SO +#include "ffmpeg/md5.h" +#else +#include "libavutil/md5.h" +#endif + +/* +#define LOG +*/ + +static const unsigned char xor_table[] = { + 0x05, 0x18, 0x74, 0xd0, 0x0d, 0x09, 0x02, 0x53, + 0xc0, 0x01, 0x05, 0x05, 0x67, 0x03, 0x19, 0x70, + 0x08, 0x27, 0x66, 0x10, 0x10, 0x72, 0x08, 0x09, + 0x63, 0x11, 0x03, 0x71, 0x08, 0x08, 0x70, 0x02, + 0x10, 0x57, 0x05, 0x18, 0x54, 0x00, 0x00, 0x00 }; + + +#define BE_32C(x,y) (*((uint32_t*)(x))=be2me_32(y)) + +#define BE_16(x) be2me_16(*(uint16_t*)(x)) + +#define BE_32(x) be2me_32(*(uint32_t*)(x)) + +#ifndef MAX +#define MAX(x,y) ((x>y) ? x : y) +#endif + +#define BUF_SIZE 4096 + +#ifdef LOG +static void hexdump (const char *buf, int length) { + + int i; + + printf (" hexdump> "); + for (i = 0; i < length; i++) { + unsigned char c = buf[i]; + + printf ("%02x", c); + + if ((i % 16) == 15) + printf ("\n "); + + if ((i % 2) == 1) + printf (" "); + + } + printf ("\n"); +} +#endif + + +static void calc_response_string (char *result, char *challenge) { + + char zres[16]; + int i; + + av_md5_sum(zres, challenge, 64); + + /* convert zres to ascii string */ + for (i=0; i<16; i++ ) { + char a, b; + + a = (zres[i] >> 4) & 15; + b = zres[i] & 15; + + result[i*2] = ((a<10) ? (a+48) : (a+87)) & 255; + result[i*2+1] = ((b<10) ? (b+48) : (b+87)) & 255; + } +} + +static void real_calc_response_and_checksum (char *response, char *chksum, char *challenge) { + + int ch_len, table_len, resp_len; + int i; + char *ptr; + char buf[128]; + + /* initialize return values */ + memset(response, 0, 64); + memset(chksum, 0, 34); + + /* initialize buffer */ + memset(buf, 0, 128); + ptr=buf; + BE_32C(ptr, 0xa1e9149d); + ptr+=4; + BE_32C(ptr, 0x0e6b3b59); + ptr+=4; + + /* some (length) checks */ + if (challenge != NULL) + { + ch_len = strlen (challenge); + + if (ch_len == 40) /* what a hack... */ + { + challenge[32]=0; + ch_len=32; + } + if ( ch_len > 56 ) ch_len=56; + + /* copy challenge to buf */ + memcpy(ptr, challenge, ch_len); + } + + table_len = strlen(xor_table); + + if (table_len > 56) table_len=56; + + /* xor challenge bytewise with xor_table */ + for (i=0; i<table_len; i++) + ptr[i] = ptr[i] ^ xor_table[i]; + + calc_response_string (response, buf); + + /* add tail */ + resp_len = strlen (response); + strcpy (&response[resp_len], "01d0a8e3"); + + /* calculate checksum */ + for (i=0; i<resp_len/4; i++) + chksum[i] = response[i*4]; +} + + +/* + * takes a MLTI-Chunk and a rule number got from match_asm_rule, + * returns a pointer to selected data and number of bytes in that. + */ + +static int select_mlti_data(const char *mlti_chunk, int mlti_size, int selection, char **out) { + + int numrules, codec, size; + int i; + + /* MLTI chunk should begin with MLTI */ + + if ((mlti_chunk[0] != 'M') + ||(mlti_chunk[1] != 'L') + ||(mlti_chunk[2] != 'T') + ||(mlti_chunk[3] != 'I')) + { +#ifdef LOG + printf("libreal: MLTI tag not detected, copying data\n"); +#endif + *out = xbuffer_copyin(*out, 0, mlti_chunk, mlti_size); + return mlti_size; + } + + mlti_chunk+=4; + + /* next 16 bits are the number of rules */ + numrules=BE_16(mlti_chunk); + if (selection >= numrules) return 0; + + /* now <numrules> indices of codecs follows */ + /* we skip to selection */ + mlti_chunk+=(selection+1)*2; + + /* get our index */ + codec=BE_16(mlti_chunk); + + /* skip to number of codecs */ + mlti_chunk+=(numrules-selection)*2; + + /* get number of codecs */ + numrules=BE_16(mlti_chunk); + + if (codec >= numrules) { + printf("codec index >= number of codecs. %i %i\n", codec, numrules); + return 0; + } + + mlti_chunk+=2; + + /* now seek to selected codec */ + for (i=0; i<codec; i++) { + size=BE_32(mlti_chunk); + mlti_chunk+=size+4; + } + + size=BE_32(mlti_chunk); + +#ifdef LOG + hexdump(mlti_chunk+4, size); +#endif + *out = xbuffer_copyin(*out, 0, mlti_chunk+4, size); + return size; +} + +/* + * looking at stream description. + */ + +static rmff_header_t *real_parse_sdp(char *data, char **stream_rules, uint32_t bandwidth) { + + sdpplin_t *desc; + rmff_header_t *header; + char *buf; + int len, i; + int max_bit_rate=0; + int avg_bit_rate=0; + int max_packet_size=0; + int avg_packet_size=0; + int duration=0; + + + if (!data) return NULL; + + desc=sdpplin_parse(data); + + if (!desc) return NULL; + + buf = xbuffer_init(2048); + header=calloc(1,sizeof(rmff_header_t)); + + header->fileheader=rmff_new_fileheader(4+desc->stream_count); + header->cont=rmff_new_cont( + desc->title, + desc->author, + desc->copyright, + desc->abstract); + header->data=rmff_new_dataheader(0,0); + header->streams=calloc(1,sizeof(rmff_mdpr_t*)*(desc->stream_count+1)); +#ifdef LOG + printf("number of streams: %u\n", desc->stream_count); +#endif + + for (i=0; i<desc->stream_count; i++) { + + int j=0; + int n; + char b[64]; + int rulematches[16]; + +#ifdef LOG + printf("calling asmrp_match with:\n%s\n%u\n", desc->stream[i]->asm_rule_book, bandwidth); +#endif + n=asmrp_match(desc->stream[i]->asm_rule_book, bandwidth, rulematches); + for (j=0; j<n; j++) { +#ifdef LOG + printf("asmrp rule match: %u for stream %u\n", rulematches[j], desc->stream[i]->stream_id); +#endif + sprintf(b,"stream=%u;rule=%u,", desc->stream[i]->stream_id, rulematches[j]); + *stream_rules = xbuffer_strcat(*stream_rules, b); + } + + if (!desc->stream[i]->mlti_data) { + len = 0; + buf = NULL; + } else + len=select_mlti_data(desc->stream[i]->mlti_data, desc->stream[i]->mlti_data_size, rulematches[0], &buf); + + header->streams[i]=rmff_new_mdpr( + desc->stream[i]->stream_id, + desc->stream[i]->max_bit_rate, + desc->stream[i]->avg_bit_rate, + desc->stream[i]->max_packet_size, + desc->stream[i]->avg_packet_size, + desc->stream[i]->start_time, + desc->stream[i]->preroll, + desc->stream[i]->duration, + desc->stream[i]->stream_name, + desc->stream[i]->mime_type, + len, + buf); + + duration=MAX(duration,desc->stream[i]->duration); + max_bit_rate+=desc->stream[i]->max_bit_rate; + avg_bit_rate+=desc->stream[i]->avg_bit_rate; + max_packet_size=MAX(max_packet_size, desc->stream[i]->max_packet_size); + if (avg_packet_size) + avg_packet_size=(avg_packet_size + desc->stream[i]->avg_packet_size) / 2; + else + avg_packet_size=desc->stream[i]->avg_packet_size; + } + + if (*stream_rules && strlen(*stream_rules) && (*stream_rules)[strlen(*stream_rules)-1] == ',') + (*stream_rules)[strlen(*stream_rules)-1]=0; /* delete last ',' in stream_rules */ + + header->prop=rmff_new_prop( + max_bit_rate, + avg_bit_rate, + max_packet_size, + avg_packet_size, + 0, + duration, + 0, + 0, + 0, + desc->stream_count, + desc->flags); + + rmff_fix_header(header); + buf = xbuffer_free(buf); + + return header; +} + +int real_get_rdt_chunk(rtsp_t *rtsp_session, char **buffer) { + + int n=1; + uint8_t header[8]; + rmff_pheader_t ph; + int size; + int flags1, flags2; + int unknown1; + uint32_t ts; + static uint32_t prev_ts = -1; + static int prev_stream_number = -1; + + n=rtsp_read_data(rtsp_session, header, 8); + if (n<8) return 0; + if (header[0] != 0x24) + { + printf("rdt chunk not recognized: got 0x%02x\n", header[0]); + return 0; + } + size=(header[1]<<16)+(header[2]<<8)+(header[3]); + flags1=header[4]; + if ((flags1!=0x40)&&(flags1!=0x42)) + { +#ifdef LOG + printf("got flags1: 0x%02x\n",flags1); +#endif + if(header[6] == 0x06) { + printf("Stream EOF detected\n"); + return -1; + } + header[0]=header[5]; + header[1]=header[6]; + header[2]=header[7]; + n=rtsp_read_data(rtsp_session, header+3, 5); + if (n<5) return 0; +#ifdef LOG + printf("ignoring bytes:\n"); + hexdump(header, 8); +#endif + n=rtsp_read_data(rtsp_session, header+4, 4); + if (n<4) return 0; + flags1=header[4]; + size-=9; + } + flags2=header[7]; + // header[5..6] == frame number in stream + unknown1=(header[5]<<16)+(header[6]<<8)+(header[7]); + n=rtsp_read_data(rtsp_session, header, 6); + if (n<6) return 0; + ts=BE_32(header); + +#ifdef LOG + printf("ts: %u, size: %u, flags: 0x%02x, unknown values: 0x%06x 0x%02x 0x%02x\n", + ts, size, flags1, unknown1, header[4], header[5]); +#endif + size+=2; + + ph.object_version=0; + ph.length=size; + ph.stream_number=(flags1>>1)&1; + ph.timestamp=ts; + ph.reserved=0; + if ((flags2&1) == 0 && (prev_ts != ts || prev_stream_number != ph.stream_number)) + { + prev_ts = ts; + prev_stream_number = ph.stream_number; + ph.flags=2; + } + else + ph.flags=0; + *buffer = xbuffer_ensure_size(*buffer, 12+size); + rmff_dump_pheader(&ph, *buffer); + size-=12; + n=rtsp_read_data(rtsp_session, (*buffer)+12, size); + + return (n <= 0) ? 0 : n+12; +} + +static int convert_timestamp(char *str, int *sec, int *msec) { + int hh, mm, ss, ms = 0; + if (sscanf(str, "%d:%d:%d.%d", &hh, &mm, &ss, &ms) < 3) { + hh = 0; + if (sscanf(str, "%d:%d.%d", &mm, &ss, &ms) < 2) { + mm = 0; + if (sscanf(str, "%d.%d", &ss, &ms) < 1) { + ss = 0; + ms = 0; + } + } + } + if (sec) + *sec = hh * 3600 + mm * 60 + ss; + if (msec) + *msec = ms; + return 1; +} + +//! maximum size of the rtsp description, must be < INT_MAX +#define MAX_DESC_BUF (20 * 1024 * 1024) +rmff_header_t *real_setup_and_get_header(rtsp_t *rtsp_session, uint32_t bandwidth) { + + char *description=NULL; + char *session_id=NULL; + rmff_header_t *h; + char *challenge1; + char challenge2[64]; + char checksum[34]; + char *subscribe; + char *buf = xbuffer_init(256); + char *mrl=rtsp_get_mrl(rtsp_session); + unsigned int size; + int status; + uint32_t maxbandwidth = bandwidth; + + /* get challenge */ + challenge1=strdup(rtsp_search_answers(rtsp_session,"RealChallenge1")); +#ifdef LOG + printf("real: Challenge1: %s\n", challenge1); +#endif + + /* set a reasonable default to get the best stream, unless bandwidth given */ + if (!bandwidth) + bandwidth = 10485800; + + /* request stream description */ + rtsp_schedule_field(rtsp_session, "Accept: application/sdp"); + sprintf(buf, "Bandwidth: %u", bandwidth); + rtsp_schedule_field(rtsp_session, buf); + rtsp_schedule_field(rtsp_session, "GUID: 00000000-0000-0000-0000-000000000000"); + rtsp_schedule_field(rtsp_session, "RegionData: 0"); + rtsp_schedule_field(rtsp_session, "ClientID: Linux_2.4_6.0.9.1235_play32_RN01_EN_586"); + rtsp_schedule_field(rtsp_session, "SupportsMaximumASMBandwidth: 1"); + rtsp_schedule_field(rtsp_session, "Language: en-US"); + rtsp_schedule_field(rtsp_session, "Require: com.real.retain-entity-for-setup"); + status=rtsp_request_describe(rtsp_session,NULL); + + if ( status<200 || status>299 ) + { + char *alert=rtsp_search_answers(rtsp_session,"Alert"); + if (alert) { + printf("real: got message from server:\n%s\n", alert); + } + rtsp_send_ok(rtsp_session); + buf = xbuffer_free(buf); + return NULL; + } + + /* receive description */ + size=0; + if (!rtsp_search_answers(rtsp_session,"Content-length")) + printf("real: got no Content-length!\n"); + else + size=atoi(rtsp_search_answers(rtsp_session,"Content-length")); + + // as size is unsigned this also catches the case (size < 0) + if (size > MAX_DESC_BUF) { + printf("real: Content-length f |