开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
real_sdpplin.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：10k
源码类别：

midi

开发平台：

Unix_Linux

real_sdpplin.c：源码内容
  1. /*
  2.  * Copyright (C) 2002-2003 the xine project
  3.  *
  4.  * This file is part of xine, a free video player.
  5.  *
  6.  * xine is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * xine is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  19.  *
  20.  * $Id: 64e043af5431f0fed08769a6b62781b0f166cb7a $
  21.  *
  22.  * sdp/sdpplin parser.
  23.  *
  24.  */
  25.  
  26. #include "real.h"
  27. #define BUFLEN 32000
  29. /*
  30.  * Decodes base64 strings (based upon b64 package)
  31.  */
  33. static char *b64_decode(const char *in, char *out, int *size) {
  35.   char dtable[256];              /* Encode / decode table */
  36.   int i,k;
  37.   unsigned int j;
  39.   for( i = 0; i < 256; i++ )
  40.     dtable[i] = 0x80;
  42.   for( i = 'A'; i <= 'Z'; i++ )
  43.     dtable[i] = 0 + (i - 'A');
  45.   for( i = 'a'; i <= 'z'; i++ )
  46.     dtable[i] = 26 + (i - 'a');
  48.   for( i = '0'; i <= '9'; i++ )
  49.     dtable[i] = 52 + (i - '0');
  51.   dtable['+'] = 62;
  52.   dtable['/'] = 63;
  53.   dtable['='] = 0;
  55.   k=0;
  56.   /*CONSTANTCONDITION*/
  57.   int in_len = strlen(in);
  58.   for (j=0; j < in_len; j+=4) {
  59.     char a[4], b[4];
  61.     for (i = 0; i < 4 && j + i < in_len; i++) {
  62.       int c = in[i+j];
  64.       if (dtable[c] & 0x80) {
  65.         printf("Illegal character '%c' in input.n", c);
  66.         exit(1);
  67.       }
  68.       a[i] = (char) c;
  69.       b[i] = (char) dtable[c];
  70.     }
  71.     //xine_buffer_ensure_size(out, k+3);
  72.     out[k++] = (b[0] << 2) | (b[1] >> 4);
  73.     out[k++] = (b[1] << 4) | (b[2] >> 2);
  74.     out[k++] = (b[2] << 6) | b[3];
  75.     i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3);
  76.     if (i < 3) {
  77.       out[k]=0;
  78.       *size=k;
  79.       return out;
  80.     }
  81.   }
  82.   out[k]=0;
  83.   *size=k;
  84.   return out;
  85. }
  87. static char *nl(char *data) {
  89.   char *nlptr = (data) ? strchr(data,'n') : NULL;
  90.   return (nlptr) ? nlptr + 1 : NULL;
  91. }
  93. static int filter(const char *in, const char *filter, char **out, size_t outlen) {
  95.   int flen=strlen(filter);
  96.   size_t len;
  98.   if (!in) return 0;
  100.   len = (strchr(in,'n')) ? (size_t)(strchr(in,'n')-in) : strlen(in);
  101.   if (!strncmp(in,filter,flen)) {
  102.     if(in[flen]=='"') flen++;
  103.     if(in[len-1]==13) len--;
  104.     if(in[len-1]=='"') len--;
  105.     if( len-flen+1 > outlen )
  106.     {
  107.         printf("Discarding end of string to avoid overflow");
  108.         len=outlen+flen-1;
  109.     }
  110.     memcpy(*out, in+flen, len-flen+1);
  111.     (*out)[len-flen]=0;
  112.     return len-flen;
  113.   }
  114.   return 0;
  115. }
  117. static sdpplin_stream_t *sdpplin_parse_stream(char **data) {
  119.   sdpplin_stream_t *desc;
  120.   char* buf = NULL;
  121.   char* decoded = NULL;
  122.   int handled;
  124.   desc = calloc( 1, sizeof(sdpplin_stream_t) );
  125.   if( !desc )
  126.     return NULL;
  128.   buf = malloc( BUFLEN );
  129.   if( !buf )
  130.     goto error;
  132.   decoded = malloc( BUFLEN );
  133.   if( !decoded )
  134.     goto error;
  136.   if (filter(*data, "m=", &buf, BUFLEN)) {
  137.     desc->id = strdup(buf);
  138.   } else {
  139.     lprintf("sdpplin: no m= found.n");
  140.     goto error;
  141.   }
  142.   *data=nl(*data);
  144.   while (*data && **data && *data[0]!='m') {
  145.     handled=0;
  147.     if(filter(*data,"a=control:streamid=",&buf, BUFLEN)) {
  148.         /* This way negative values are mapped to unfeasibly high
  149.          * values, and will be discarded afterward
  150.          */
  151.         unsigned long tmp = strtoul(buf, NULL, 10);
  152.         if ( tmp > UINT16_MAX )
  153.             lprintf("stream id out of bound: %lun", tmp);
  154.         else
  155.             desc->stream_id=tmp;
  156.         handled=1;
  157.         *data=nl(*data);
  158.     }
  159.     if(filter(*data,"a=MaxBitRate:integer;",&buf, BUFLEN)) {
  160.       desc->max_bit_rate=atoi(buf);
  161.       if (!desc->avg_bit_rate)
  162.         desc->avg_bit_rate=desc->max_bit_rate;
  163.       handled=1;
  164.       *data=nl(*data);
  165.     }
  166.     if(filter(*data,"a=MaxPacketSize:integer;",&buf, BUFLEN)) {
  167.       desc->max_packet_size=atoi(buf);
  168.       if (!desc->avg_packet_size)
  169.         desc->avg_packet_size=desc->max_packet_size;
  170.       handled=1;
  171.       *data=nl(*data);
  172.     }
  173.     if(filter(*data,"a=StartTime:integer;",&buf, BUFLEN)) {
  174.       desc->start_time=atoi(buf);
  175.       handled=1;
  176.       *data=nl(*data);
  177.     }
  178.     if(filter(*data,"a=Preroll:integer;",&buf, BUFLEN)) {
  179.       desc->preroll=atoi(buf);
  180.       handled=1;
  181.       *data=nl(*data);
  182.     }
  183.     if(filter(*data,"a=length:npt=",&buf, BUFLEN)) {
  184.       desc->duration=(uint32_t)(atof(buf)*1000);
  185.       handled=1;
  186.       *data=nl(*data);
  187.     }
  188.     if(filter(*data,"a=StreamName:string;",&buf, BUFLEN)) {
  189.       desc->stream_name=strdup(buf);
  190.       desc->stream_name_size=strlen(desc->stream_name);
  191.       handled=1;
  192.       *data=nl(*data);
  193.     }
  194.     if(filter(*data,"a=mimetype:string;",&buf, BUFLEN)) {
  195.       desc->mime_type=strdup(buf);
  196.       desc->mime_type_size=strlen(desc->mime_type);
  197.       handled=1;
  198.       *data=nl(*data);
  199.     }
  200.     if(filter(*data,"a=OpaqueData:buffer;",&buf, BUFLEN)) {
  201.       decoded = b64_decode(buf, decoded, &(desc->mlti_data_size));
  202.       if ( decoded != NULL ) {
  203.           desc->mlti_data = malloc(desc->mlti_data_size);
  204.           memcpy(desc->mlti_data, decoded, desc->mlti_data_size);
  205.           handled=1;
  206.           *data=nl(*data);
  207.           lprintf("mlti_data_size: %in", desc->mlti_data_size);
  208.       }
  209.     }
  210.     if(filter(*data,"a=ASMRuleBook:string;",&buf, BUFLEN)) {
  211.       desc->asm_rule_book=strdup(buf);
  212.       handled=1;
  213.       *data=nl(*data);
  214.     }
  216.     if(!handled) {
  217. #ifdef LOG
  218.       int len=strchr(*data,'n')-(*data);
  219.       memcpy(buf, *data, len+1);
  220.       buf[len]=0;
  221.       printf("libreal: sdpplin: not handled: '%s'n", buf);
  222. #endif
  223.       *data=nl(*data);
  224.     }
  225.   }
  226.   free( buf );
  227.   free( decoded) ;
  228.   return desc;
  230. error:
  231.   free( decoded );
  232.   free( desc );
  233.   free( buf );
  234.   return NULL;
  235. }
  238. sdpplin_t *sdpplin_parse(char *data)
  239. {
  240.   sdpplin_t*        desc;
  241.   sdpplin_stream_t* stream;
  242.   char*             buf;
  243.   char*             decoded;
  244.   int               handled;
  245.   int               len;
  247.   desc = calloc( 1, sizeof(sdpplin_t) );
  248.   if( !desc )
  249.     return NULL;
  251.   buf = malloc( BUFLEN );
  252.   if( !buf )
  253.   {
  254.     free( desc );
  255.     return NULL;
  256.   }
  258.   decoded = malloc( BUFLEN );
  259.   if( !decoded )
  260.   {
  261.     free( buf );
  262.     free( desc );
  263.     return NULL;
  264.   }
  265.   desc->stream = NULL;
  267.   while (data && *data) {
  268.     handled=0;
  270.     if (filter(data, "m=", &buf, BUFLEN)) {
  271.         if ( !desc->stream ) {
  272.             fprintf(stderr, "sdpplin.c: stream identifier found before stream count, skipping.");
  273.             continue;
  274.         }
  275.         stream=sdpplin_parse_stream(&data);
  276.         lprintf("got data for stream id %un", stream->stream_id);
  277.         if ( stream->stream_id >= desc->stream_count )
  278.             lprintf("stream id %u is greater than stream count %un", stream->stream_id, desc->stream_count);
  279.         else
  280.             desc->stream[stream->stream_id]=stream;
  281.         continue;
  282.     }
  283.     if(filter(data,"a=Title:buffer;",&buf, BUFLEN)) {
  284.       decoded=b64_decode(buf, decoded, &len);
  285.   if ( decoded != NULL ) {
  286.           desc->title=strdup(decoded);
  287.           handled=1;
  288.           data=nl(data);
  289.       }
  290.     }
  291.     if(filter(data,"a=Author:buffer;",&buf, BUFLEN)) {
  292.       decoded=b64_decode(buf, decoded, &len);
  293.   if ( decoded != NULL ) {
  294.           desc->author=strdup(decoded);
  295.           handled=1;
  296.           data=nl(data);
  297.       }
  298.     }
  299.     if(filter(data,"a=Copyright:buffer;",&buf, BUFLEN)) {
  300.       decoded=b64_decode(buf, decoded, &len);
  301.   if ( decoded != NULL ) {
  302.           desc->copyright=strdup(decoded);
  303.           handled=1;
  304.           data=nl(data);
  305.       }
  306.     }
  307.     if(filter(data,"a=Abstract:buffer;",&buf, BUFLEN)) {
  308.       decoded=b64_decode(buf, decoded, &len);
  309.       if ( decoded != NULL ) {
  310.            desc->abstract=strdup(decoded);
  311.            handled=1;
  312.            data=nl(data);
  313.       }
  314.     }
  315.     if(filter(data,"a=StreamCount:integer;",&buf, BUFLEN)) {
  316.         /* This way negative values are mapped to unfeasibly high
  317.          * values, and will be discarded afterward
  318.          */
  319.         unsigned long tmp = strtoul(buf, NULL, 10);
  320.         if ( tmp > UINT16_MAX )
  321.             lprintf("stream count out of bound: %lun", tmp);
  322.         else
  323.             desc->stream_count = tmp;
  324.         desc->stream = malloc(sizeof(sdpplin_stream_t*)*desc->stream_count);
  325.         handled=1;
  326.         data=nl(data);
  327.     }
  328.     if(filter(data,"a=Flags:integer;",&buf, BUFLEN)) {
  329.       desc->flags=atoi(buf);
  330.       handled=1;
  331.       data=nl(data);
  332.     }
  334.     if(!handled) {
  335. #ifdef LOG
  336.       int len=strchr(data,'n')-data;
  337.       memcpy(buf, data, len+1);
  338.       buf[len]=0;
  339.       printf("libreal: sdpplin: not handled: '%s'n", buf);
  340. #endif
  341.       data=nl(data);
  342.     }
  343.   }
  345.   free( decoded );
  346.   free( buf );
  347.   return desc;
  348. }
  350. void sdpplin_free(sdpplin_t *description) {
  352.   int i;
  354.   if( !description ) return;
  356.   for( i=0; i<description->stream_count; i++ ) {
  357.     if( description->stream[i] ) {
  358.       free( description->stream[i]->id );
  359.       free( description->stream[i]->bandwidth );
  360.       free( description->stream[i]->range );
  361.       free( description->stream[i]->length );
  362.       free( description->stream[i]->rtpmap );
  363.       free( description->stream[i]->mimetype );
  364.       free( description->stream[i]->stream_name );
  365.       free( description->stream[i]->mime_type );
  366.       free( description->stream[i]->mlti_data );
  367.       free( description->stream[i]->rmff_flags );
  368.       free( description->stream[i]->asm_rule_book );
  369.       free( description->stream[i] );
  370.     }
  371.   }
  372.   if( description->stream_count )
  373.     free( description->stream );
  375.   free( description->owner );
  376.   free( description->session_name );
  377.   free( description->session_info );
  378.   free( description->uri );
  379.   free( description->email );
  380.   free( description->phone );
  381.   free( description->connection );
  382.   free( description->bandwidth );
  383.   free( description->title );
  384.   free( description->author );
  385.   free( description->copyright );
  386.   free( description->keywords );
  387.   free( description->asm_rule_book );
  388.   free( description->abstract );
  389.   free( description->range );
  390.   free( description );
  391. }