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

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

midi

开发平台：

Unix_Linux

mmsh.c：源码内容
  1. /*****************************************************************************
  2.  * mmsh.c:
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 the VideoLAN team
  5.  * $Id: c0117339b77290a08ae5bfb2b3784e49dd67b6a4 $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <vlc_common.h>
  33. #include <vlc_access.h>
  34. #include "vlc_strings.h"
  35. #include "vlc_input.h"
  37. #include <vlc_network.h>
  38. #include "vlc_url.h"
  39. #include "asf.h"
  40. #include "buffer.h"
  42. #include "mms.h"
  43. #include "mmsh.h"
  45. /* TODO:
  46.  *  - authentication
  47.  */
  49. /*****************************************************************************
  50.  * Local prototypes
  51.  *****************************************************************************/
  52. int  MMSHOpen  ( access_t * );
  53. void MMSHClose ( access_t * );
  55. static block_t *Block( access_t *p_access );
  56. static ssize_t ReadRedirect( access_t *, uint8_t *, size_t );
  57. static int  Seek( access_t *, int64_t );
  58. static int  Control( access_t *, int, va_list );
  60. static int  Describe( access_t  *, char **ppsz_location );
  61. static int  Start( access_t *, int64_t );
  62. static void Stop( access_t * );
  64. static int  GetPacket( access_t *, chunk_t * );
  65. static void GetHeader( access_t *p_access );
  67. static int Restart( access_t * );
  68. static int Reset( access_t * );
  70. //#define MMSH_USER_AGENT "NSPlayer/4.1.0.3856"
  71. #define MMSH_USER_AGENT "NSPlayer/7.10.0.3059"
  73. /****************************************************************************
  74.  * Open: connect to ftp server and ask for file
  75.  ****************************************************************************/
  76. int MMSHOpen( access_t *p_access )
  77. {
  78.     access_sys_t    *p_sys;
  79.     char            *psz_location = NULL;
  80.     char            *psz_proxy;
  82.     STANDARD_BLOCK_ACCESS_INIT
  84.     p_sys->i_proto= MMS_PROTO_HTTP;
  85.     p_sys->fd     = -1;
  87.     /* Handle proxy */
  88.     p_sys->b_proxy = false;
  89.     memset( &p_sys->proxy, 0, sizeof(p_sys->proxy) );
  91.     /* Check proxy */
  92.     /* TODO reuse instead http-proxy from http access ? */
  93.     psz_proxy = var_CreateGetString( p_access, "mmsh-proxy" );
  94.     if( !*psz_proxy )
  95.     {
  96.         char *psz_http_proxy = config_GetPsz( p_access, "http-proxy" );
  97.         if( psz_http_proxy && *psz_http_proxy )
  98.         {
  99.             free( psz_proxy );
  100.             psz_proxy = psz_http_proxy;
  101.             var_SetString( p_access, "mmsh-proxy", psz_proxy );
  102.         }
  103.         else
  104.         {
  105.             free( psz_http_proxy );
  106.         }
  107.     }
  109.     if( *psz_proxy )
  110.     {
  111.         p_sys->b_proxy = true;
  112.         vlc_UrlParse( &p_sys->proxy, psz_proxy, 0 );
  113.     }
  114. #ifdef HAVE_GETENV
  115.     else
  116.     {
  117.         char *psz_proxy = getenv( "http_proxy" );
  118.         if( psz_proxy && *psz_proxy )
  119.         {
  120.             p_sys->b_proxy = true;
  121.             vlc_UrlParse( &p_sys->proxy, psz_proxy, 0 );
  122.         }
  123.     }
  124. #endif
  125.     free( psz_proxy );
  127.     if( p_sys->b_proxy )
  128.     {
  129.         if( ( p_sys->proxy.psz_host == NULL ) ||
  130.             ( *p_sys->proxy.psz_host == '' ) )
  131.         {
  132.             msg_Warn( p_access, "invalid proxy host" );
  133.             vlc_UrlClean( &p_sys->proxy );
  134.             free( p_sys );
  135.             return VLC_EGENERIC;
  136.         }
  138.         if( p_sys->proxy.i_port <= 0 )
  139.             p_sys->proxy.i_port = 80;
  140.         msg_Dbg( p_access, "Using http proxy %s:%d",
  141.                  p_sys->proxy.psz_host, p_sys->proxy.i_port );
  142.     }
  144.     /* open a tcp connection */
  145.     vlc_UrlParse( &p_sys->url, p_access->psz_path, 0 );
  146.     if( ( p_sys->url.psz_host == NULL ) ||
  147.         ( *p_sys->url.psz_host == '' ) )
  148.     {
  149.         msg_Err( p_access, "invalid host" );
  150.         vlc_UrlClean( &p_sys->proxy );
  151.         vlc_UrlClean( &p_sys->url );
  152.         free( p_sys );
  153.         return VLC_EGENERIC;
  154.     }
  155.     if( p_sys->url.i_port <= 0 )
  156.         p_sys->url.i_port = 80;
  158.     if( Describe( p_access, &psz_location ) )
  159.     {
  160.         vlc_UrlClean( &p_sys->proxy );
  161.         vlc_UrlClean( &p_sys->url );
  162.         free( p_sys );
  163.         return VLC_EGENERIC;
  164.     }
  165.     /* Handle redirection */
  166.     if( psz_location && *psz_location )
  167.     {
  168.         msg_Dbg( p_access, "redirection to %s", psz_location );
  170.         input_thread_t * p_input = vlc_object_find( p_access, VLC_OBJECT_INPUT, FIND_PARENT );
  171.         input_item_t * p_new_loc;
  173.         if( !p_input )
  174.         {
  175.             vlc_UrlClean( &p_sys->proxy );
  176.             vlc_UrlClean( &p_sys->url );
  177.             free( p_sys );
  178.             free( psz_location );
  179.             return VLC_EGENERIC;
  180.         }
  181.         /** bug we do not autodelete here */
  182.         p_new_loc = input_item_New( p_access, psz_location, psz_location );
  183.         input_item_AddSubItem( input_GetItem( p_input ), p_new_loc );
  184.         vlc_gc_decref( p_new_loc );
  185.         vlc_object_release( p_input );
  187.         free( psz_location );
  189.         p_access->pf_block = NULL;
  190.         p_access->pf_read = ReadRedirect;
  191.         return VLC_SUCCESS;
  192.     }
  193.     free( psz_location );
  195.     /* Start playing */
  196.     if( Start( p_access, 0 ) )
  197.     {
  198.         msg_Err( p_access, "cannot start stream" );
  199.         free( p_sys->p_header );
  200.         vlc_UrlClean( &p_sys->proxy );
  201.         vlc_UrlClean( &p_sys->url );
  202.         free( p_sys );
  203.         return VLC_EGENERIC;
  204.     }
  206.     if( !p_sys->b_broadcast )
  207.     {
  208.         p_access->info.i_size = p_sys->asfh.i_file_size;
  209.     }
  211.     return VLC_SUCCESS;
  212. }
  214. /*****************************************************************************
  215.  * Close: free unused data structures
  216.  *****************************************************************************/
  217. void  MMSHClose ( access_t *p_access )
  218. {
  219.     access_sys_t *p_sys = p_access->p_sys;
  221.     Stop( p_access );
  223.     free( p_sys->p_header  );
  225.     vlc_UrlClean( &p_sys->proxy );
  226.     vlc_UrlClean( &p_sys->url );
  227.     free( p_sys );
  228. }
  230. /*****************************************************************************
  231.  * Control:
  232.  *****************************************************************************/
  233. static int Control( access_t *p_access, int i_query, va_list args )
  234. {
  235.     access_sys_t *p_sys = p_access->p_sys;
  236.     bool   *pb_bool;
  237.     bool    b_bool;
  238.     int64_t      *pi_64;
  239.     int          i_int;
  241.     switch( i_query )
  242.     {
  243.         /* */
  244.         case ACCESS_CAN_SEEK:
  245.             pb_bool = (bool*)va_arg( args, bool* );
  246.             *pb_bool = !p_sys->b_broadcast;
  247.             break;
  249.         case ACCESS_CAN_FASTSEEK:
  250.             pb_bool = (bool*)va_arg( args, bool* );
  251.             *pb_bool = false;
  252.             break;
  254.         case ACCESS_CAN_PAUSE:
  255.         case ACCESS_CAN_CONTROL_PACE:
  256.             pb_bool = (bool*)va_arg( args, bool* );
  257.             *pb_bool = true;
  258.             break;
  260.         /* */
  261.         case ACCESS_GET_PTS_DELAY:
  262.             pi_64 = (int64_t*)va_arg( args, int64_t * );
  263.             *pi_64 = (int64_t)var_GetInteger( p_access, "mms-caching" ) * INT64_C(1000);
  264.             break;
  266.         case ACCESS_GET_PRIVATE_ID_STATE:
  267.             i_int = (int)va_arg( args, int );
  268.             pb_bool = (bool *)va_arg( args, bool * );
  270.             if( (i_int < 0) || (i_int > 127) )
  271.                 return VLC_EGENERIC;
  272.             *pb_bool =  p_sys->asfh.stream[i_int].i_selected ? true : false;
  273.             break;
  275.         /* */
  276.         case ACCESS_SET_PAUSE_STATE:
  277.             b_bool = (bool)va_arg( args, int );
  278.             if( b_bool )
  279.                 Stop( p_access );
  280.             else
  281.                 Seek( p_access, p_access->info.i_pos );
  282.             break;
  284.         case ACCESS_GET_TITLE_INFO:
  285.         case ACCESS_SET_TITLE:
  286.         case ACCESS_SET_SEEKPOINT:
  287.         case ACCESS_SET_PRIVATE_ID_STATE:
  288.         case ACCESS_GET_CONTENT_TYPE:
  289.             return VLC_EGENERIC;
  291.         default:
  292.             msg_Warn( p_access, "unimplemented query in control" );
  293.             return VLC_EGENERIC;
  295.     }
  296.     return VLC_SUCCESS;
  297. }
  299. /*****************************************************************************
  300.  * Seek: try to go at the right place
  301.  *****************************************************************************/
  302. static int Seek( access_t *p_access, int64_t i_pos )
  303. {
  304.     access_sys_t *p_sys = p_access->p_sys;
  305.     chunk_t      ck;
  306.     off_t        i_offset;
  307.     off_t        i_packet;
  309.     msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
  311.     i_packet = ( i_pos - p_sys->i_header ) / p_sys->asfh.i_min_data_packet_size;
  312.     i_offset = ( i_pos - p_sys->i_header ) % p_sys->asfh.i_min_data_packet_size;
  314.     Stop( p_access );
  315.     Start( p_access, i_packet * p_sys->asfh.i_min_data_packet_size );
  317.     while( vlc_object_alive (p_access) )
  318.     {
  319.         if( GetPacket( p_access, &ck ) )
  320.             break;
  322.         /* skip headers */
  323.         if( ck.i_type != 0x4824 )
  324.             break;
  326.         msg_Warn( p_access, "skipping header" );
  327.     }
  329.     p_access->info.i_pos = i_pos;
  330.     p_access->info.b_eof = false;
  331.     p_sys->i_packet_used += i_offset;
  333.     return VLC_SUCCESS;
  334. }
  336. /*****************************************************************************
  337.  * ReadRedirect:
  338.  *****************************************************************************/
  339. static ssize_t ReadRedirect( access_t *p_access, uint8_t *p, size_t i_len )
  340. {
  341.     VLC_UNUSED(p_access); VLC_UNUSED(p); VLC_UNUSED(i_len);
  342.     return 0;
  343. }
  345. /*****************************************************************************
  346.  * Block:
  347.  *****************************************************************************/
  348. static block_t *Block( access_t *p_access )
  349. {
  350.     access_sys_t *p_sys = p_access->p_sys;
  351.     const unsigned i_packet_min = p_sys->asfh.i_min_data_packet_size;
  353.     if( p_access->info.i_pos < p_sys->i_start + p_sys->i_header )
  354.     {
  355.         const size_t i_offset = p_access->info.i_pos - p_sys->i_start;
  356.         const size_t i_copy = p_sys->i_header - i_offset;
  358.         block_t *p_block = block_New( p_access, i_copy );
  359.         if( !p_block )
  360.             return NULL;
  362.         memcpy( p_block->p_buffer, &p_sys->p_header[i_offset], i_copy );
  363.         p_access->info.i_pos += i_copy;
  364.         return p_block;
  365.     }
  366.     else if( p_sys->i_packet_length > 0 &&
  367.              p_sys->i_packet_used < __MAX( p_sys->i_packet_length, i_packet_min ) )
  368.     {
  369.         size_t i_copy = 0;
  370.         size_t i_padding = 0;
  372.         if( p_sys->i_packet_used < p_sys->i_packet_length )
  373.             i_copy = p_sys->i_packet_length - p_sys->i_packet_used;
  374.         if( __MAX( p_sys->i_packet_used, p_sys->i_packet_length ) < i_packet_min )
  375.             i_padding = i_packet_min - __MAX( p_sys->i_packet_used, p_sys->i_packet_length );
  377.         block_t *p_block = block_New( p_access, i_copy + i_padding );
  378.         if( !p_block )
  379.             return NULL;
  381.         if( i_copy > 0 )
  382.             memcpy( &p_block->p_buffer[0], &p_sys->p_packet[p_sys->i_packet_used], i_copy );
  383.         if( i_padding > 0 )
  384.             memset( &p_block->p_buffer[i_copy], 0, i_padding );
  386.         p_sys->i_packet_used += i_copy + i_padding;
  387.         p_access->info.i_pos += i_copy + i_padding;
  388.         return p_block;
  390.     }
  392.     chunk_t ck;
  393.     if( GetPacket( p_access, &ck ) )
  394.     {
  395.         int i_ret = -1;
  396.         if( p_sys->b_broadcast )
  397.         {
  398.             if( (ck.i_type == 0x4524) && (ck.i_sequence != 0) )
  399.                 i_ret = Restart( p_access );
  400.             else if( ck.i_type == 0x4324 )
  401.                 i_ret = Reset( p_access );
  402.         }
  403.         if( i_ret )
  404.         {
  405.             p_access->info.b_eof = true;
  406.             return 0;
  407.         }
  408.     }
  409.     if( ck.i_type != 0x4424 )
  410.     {
  411.         p_sys->i_packet_used = 0;
  412.         p_sys->i_packet_length = 0;
  413.     }
  415.     return NULL;
  416. }
  418. /* */
  419. static int Restart( access_t *p_access )
  420. {
  421.     access_sys_t *p_sys = p_access->p_sys;
  422.     char *psz_location = NULL;
  424.     msg_Dbg( p_access, "Restart the stream" );
  425.     p_sys->i_start = p_access->info.i_pos;
  427.     /* */
  428.     msg_Dbg( p_access, "stoping the stream" );
  429.     Stop( p_access );
  431.     /* */
  432.     msg_Dbg( p_access, "describe the stream" );
  433.     if( Describe( p_access, &psz_location ) )
  434.     {
  435.         msg_Err( p_access, "describe failed" );
  436.         return VLC_EGENERIC;
  437.     }
  438.     /* */
  439.     if( Start( p_access, 0 ) )
  440.     {
  441.         msg_Err( p_access, "Start failed" );
  442.         return VLC_EGENERIC;
  443.     }
  444.     return VLC_SUCCESS;
  445. }
  446. static int Reset( access_t *p_access )
  447. {
  448.     access_sys_t *p_sys = p_access->p_sys;
  449.     asf_header_t old_asfh = p_sys->asfh;
  450.     int i;
  452.     msg_Dbg( p_access, "Reset the stream" );
  453.     p_sys->i_start = p_access->info.i_pos;
  455.     /* */
  456.     p_sys->i_packet_sequence = 0;
  457.     p_sys->i_packet_used = 0;
  458.     p_sys->i_packet_length = 0;
  459.     p_sys->p_packet = NULL;
  461.     /* Get the next header FIXME memory loss ? */
  462.     GetHeader( p_access );
  463.     if( p_sys->i_header <= 0 )
  464.         return VLC_EGENERIC;
  466.     asf_HeaderParse ( &p_sys->asfh,
  467.                        p_sys->p_header, p_sys->i_header );
  468.     msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
  469.              p_sys->asfh.i_data_packets_count,
  470.              p_sys->asfh.i_min_data_packet_size );
  472.     asf_StreamSelect( &p_sys->asfh,
  473.                        var_CreateGetInteger( p_access, "mms-maxbitrate" ),
  474.                        var_CreateGetInteger( p_access, "mms-all" ),
  475.                        var_CreateGetInteger( p_access, "audio" ),
  476.                        var_CreateGetInteger( p_access, "video" ) );
  478.     /* Check we have comptible asfh */
  479.     for( i = 1; i < 128; i++ )
  480.     {
  481.         asf_stream_t *p_old = &old_asfh.stream[i];
  482.         asf_stream_t *p_new = &p_sys->asfh.stream[i];
  484.         if( p_old->i_cat != p_new->i_cat || p_old->i_selected != p_new->i_selected )
  485.             break;
  486.     }
  487.     if( i < 128 )
  488.     {
  489.         msg_Warn( p_access, "incompatible asf header, restart" );
  490.         return Restart( p_access );
  491.     }
  493.     /* */
  494.     p_sys->i_packet_used = 0;
  495.     p_sys->i_packet_length = 0;
  496.     return VLC_SUCCESS;
  497. }
  499. static int OpenConnection( access_t *p_access )
  500. {
  501.     access_sys_t *p_sys = p_access->p_sys;
  502.     vlc_url_t    srv = p_sys->b_proxy ? p_sys->proxy : p_sys->url;
  504.     if( ( p_sys->fd = net_ConnectTCP( p_access,
  505.                                       srv.psz_host, srv.i_port ) ) < 0 )
  506.     {
  507.         msg_Err( p_access, "cannot connect to %s:%d",
  508.                  srv.psz_host, srv.i_port );
  509.         return VLC_EGENERIC;
  510.     }
  512.     if( p_sys->b_proxy )
  513.     {
  514.         net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  515.                     "GET http://%s:%d%s HTTP/1.0rn",
  516.                     p_sys->url.psz_host, p_sys->url.i_port,
  517.                     ( (p_sys->url.psz_path == NULL) ||
  518.                       (*p_sys->url.psz_path == '') ) ?
  519.                          "/" : p_sys->url.psz_path );
  521.         /* Proxy Authentication */
  522.         if( p_sys->proxy.psz_username && *p_sys->proxy.psz_username )
  523.         {
  524.             char *buf;
  525.             char *b64;
  527.             if( asprintf( &buf, "%s:%s", p_sys->proxy.psz_username,
  528.                        p_sys->proxy.psz_password ? p_sys->proxy.psz_password : "" ) == -1 )
  529.                 return VLC_ENOMEM;
  531.             b64 = vlc_b64_encode( buf );
  532.             free( buf );
  534.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  535.                         "Proxy-Authorization: Basic %srn", b64 );
  536.             free( b64 );
  537.         }
  538.     }
  539.     else
  540.     {
  541.         net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  542.                     "GET %s HTTP/1.0rn"
  543.                     "Host: %s:%drn",
  544.                     ( (p_sys->url.psz_path == NULL) ||
  545.                       (*p_sys->url.psz_path == '') ) ?
  546.                             "/" : p_sys->url.psz_path,
  547.                     p_sys->url.psz_host, p_sys->url.i_port );
  548.     }
  549.     return VLC_SUCCESS;
  550. }
  552. /*****************************************************************************
  553.  * Describe:
  554.  *****************************************************************************/
  555. static int Describe( access_t  *p_access, char **ppsz_location )
  556. {
  557.     access_sys_t *p_sys = p_access->p_sys;
  558.     char         *psz_location = NULL;
  559.     char         *psz;
  560.     int          i_code;
  562.     /* Reinit context */
  563.     p_sys->b_broadcast = true;
  564.     p_sys->i_request_context = 1;
  565.     p_sys->i_packet_sequence = 0;
  566.     p_sys->i_packet_used = 0;
  567.     p_sys->i_packet_length = 0;
  568.     p_sys->p_packet = NULL;
  570.     GenerateGuid ( &p_sys->guid );
  572.     if( OpenConnection( p_access ) )
  573.         return VLC_EGENERIC;
  575.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  576.                 "Accept: */*rn"
  577.                 "User-Agent: "MMSH_USER_AGENT"rn"
  578.                 "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,request-context=%d,max-duration=0rn"
  579.                 "Pragma: xClientGUID={"GUID_FMT"}rn"
  580.                 "Connection: Closern",
  581.                 p_sys->i_request_context++,
  582.                 GUID_PRINT( p_sys->guid ) );
  584.     if( net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL, "rn" ) < 0 )
  585.     {
  586.         msg_Err( p_access, "failed to send request" );
  587.         goto error;
  588.     }
  590.     /* Receive the http header */
  591.     if( ( psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, NULL ) ) == NULL )
  592.     {
  593.         msg_Err( p_access, "failed to read answer" );
  594.         goto error;
  595.     }
  597.     if( strncmp( psz, "HTTP/1.", 7 ) )
  598.     {
  599.         msg_Err( p_access, "invalid HTTP reply '%s'", psz );
  600.         free( psz );
  601.         goto error;
  602.     }
  603.     i_code = atoi( &psz[9] );
  604.     if( i_code >= 400 )
  605.     {
  606.         msg_Err( p_access, "error: %s", psz );
  607.         free( psz );
  608.         goto error;
  609.     }
  611.     msg_Dbg( p_access, "HTTP reply '%s'", psz );
  612.     free( psz );
  613.     for( ;; )
  614.     {
  615.         char *psz = net_Gets( p_access, p_sys->fd, NULL );
  616.         char *p;
  618.         if( psz == NULL )
  619.         {
  620.             msg_Err( p_access, "failed to read answer" );
  621.             goto error;
  622.         }
  624.         if( *psz == '' )
  625.         {
  626.             free( psz );
  627.             break;
  628.         }
  630.         if( ( p = strchr( psz, ':' ) ) == NULL )
  631.         {
  632.             msg_Err( p_access, "malformed header line: %s", psz );
  633.             free( psz );
  634.             goto error;
  635.         }
  636.         *p++ = '';
  637.         while( *p == ' ' ) p++;
  639.         /* FIXME FIXME test Content-Type to see if it's a plain stream or an
  640.          * asx FIXME */
  641.         if( !strcasecmp( psz, "Pragma" ) )
  642.         {
  643.             if( strstr( p, "features" ) )
  644.             {
  645.                 /* FIXME, it is a bit badly done here ..... */
  646.                 if( strstr( p, "broadcast" ) )
  647.                 {
  648.                     msg_Dbg( p_access, "stream type = broadcast" );
  649.                     p_sys->b_broadcast = true;
  650.                 }
  651.                 else if( strstr( p, "seekable" ) )
  652.                 {
  653.                     msg_Dbg( p_access, "stream type = seekable" );
  654.                     p_sys->b_broadcast = false;
  655.                 }
  656.                 else
  657.                 {
  658.                     msg_Warn( p_access, "unknow stream types (%s)", p );
  659.                     p_sys->b_broadcast = false;
  660.                 }
  661.             }
  662.         }
  663.         else if( !strcasecmp( psz, "Location" ) )
  664.         {
  665.             psz_location = strdup( p );
  666.         }
  668.         free( psz );
  669.     }
  671.     /* Handle the redirection */
  672.     if( ( (i_code == 301) || (i_code == 302) ||
  673.           (i_code == 303) || (i_code == 307) ) &&
  674.         psz_location && *psz_location )
  675.     {
  676.         msg_Dbg( p_access, "redirection to %s", psz_location );
  677.         net_Close( p_sys->fd ); p_sys->fd = -1;
  679.         *ppsz_location = psz_location;
  680.         return VLC_SUCCESS;
  681.     }
  683.     /* Read the asf header */
  684.     GetHeader( p_access );
  685.     if( p_sys->i_header <= 0 )
  686.     {
  687.         msg_Err( p_access, "header size == 0" );
  688.         goto error;
  689.     }
  690.     /* close this connection */
  691.     net_Close( p_sys->fd );
  692.     p_sys->fd = -1;
  694.     /* *** parse header and get stream and their id *** */
  695.     /* get all streams properties,
  696.      *
  697.      * TODO : stream bitrates properties(optional)
  698.      *        and bitrate mutual exclusion(optional) */
  699.     asf_HeaderParse ( &p_sys->asfh,
  700.                        p_sys->p_header, p_sys->i_header );
  701.     msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
  702.              p_sys->asfh.i_data_packets_count,
  703.              p_sys->asfh.i_min_data_packet_size );
  705.     if( p_sys->asfh.i_min_data_packet_size <= 0 )
  706.         goto error;
  708.     asf_StreamSelect( &p_sys->asfh,
  709.                        var_CreateGetInteger( p_access, "mms-maxbitrate" ),
  710.                        var_CreateGetInteger( p_access, "mms-all" ),
  711.                        var_CreateGetInteger( p_access, "audio" ),
  712.                        var_CreateGetInteger( p_access, "video" ) );
  713.     return VLC_SUCCESS;
  715. error:
  716.     if( p_sys->fd > 0 )
  717.     {
  718.         net_Close( p_sys->fd  );
  719.         p_sys->fd = -1;
  720.     }
  721.     return VLC_EGENERIC;
  722. }
  724. static void GetHeader( access_t *p_access )
  725. {
  726.     access_sys_t *p_sys = p_access->p_sys;
  728.     /* Read the asf header */
  729.     p_sys->i_header = 0;
  730.     free( p_sys->p_header  );
  731.     p_sys->p_header = NULL;
  732.     for( ;; )
  733.     {
  734.         chunk_t ck;
  735.         if( GetPacket( p_access, &ck ) || ck.i_type != 0x4824 )
  736.             break;
  738.         if( ck.i_data > 0 )
  739.         {
  740.             p_sys->i_header += ck.i_data;
  741.             p_sys->p_header = realloc( p_sys->p_header, p_sys->i_header );
  742.             memcpy( &p_sys->p_header[p_sys->i_header - ck.i_data],
  743.                     ck.p_data, ck.i_data );
  744.         }
  745.     }
  746.     msg_Dbg( p_access, "complete header size=%d", p_sys->i_header );
  747. }
  750. /*****************************************************************************
  751.  * Start stream
  752.  ****************************************************************************/
  753. static int Start( access_t *p_access, int64_t i_pos )
  754. {
  755.     access_sys_t *p_sys = p_access->p_sys;
  756.     int  i_streams = 0;
  757.     int  i_streams_selected = 0;
  758.     int  i;
  759.     char *psz = NULL;
  761.     msg_Dbg( p_access, "starting stream" );
  763.     for( i = 1; i < 128; i++ )
  764.     {
  765.         if( p_sys->asfh.stream[i].i_cat == ASF_STREAM_UNKNOWN )
  766.             continue;
  767.         i_streams++;
  768.         if( p_sys->asfh.stream[i].i_selected )
  769.             i_streams_selected++;
  770.     }
  771.     if( i_streams_selected <= 0 )
  772.     {
  773.         msg_Err( p_access, "no stream selected" );
  774.         return VLC_EGENERIC;
  775.     }
  777.     if( OpenConnection( p_access ) )
  778.         return VLC_EGENERIC;
  780.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  781.                 "Accept: */*rn"
  782.                 "User-Agent: "MMSH_USER_AGENT"rn" );
  783.     if( p_sys->b_broadcast )
  784.     {
  785.         net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  786.                     "Pragma: no-cache,rate=1.000000,request-context=%drn",
  787.                     p_sys->i_request_context++ );
  788.     }
  789.     else
  790.     {
  791.         net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  792.                     "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=%u:%u,request-context=%d,max-duration=0rn",
  793.                     (uint32_t)((i_pos >> 32)&0xffffffff),
  794.                     (uint32_t)(i_pos&0xffffffff),
  795.                     p_sys->i_request_context++ );
  796.     }
  797.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  798.                 "Pragma: xPlayStrm=1rn"
  799.                 "Pragma: xClientGUID={"GUID_FMT"}rn"
  800.                 "Pragma: stream-switch-count=%drn"
  801.                 "Pragma: stream-switch-entry=",
  802.                 GUID_PRINT( p_sys->guid ),
  803.                 i_streams);
  805.     for( i = 1; i < 128; i++ )
  806.     {
  807.         if( p_sys->asfh.stream[i].i_cat != ASF_STREAM_UNKNOWN )
  808.         {
  809.             int i_select = 2;
  810.             if( p_sys->asfh.stream[i].i_selected )
  811.             {
  812.                 i_select = 0;
  813.             }
  814.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  815.                         "ffff:%d:%d ", i, i_select );
  816.         }
  817.     }
  818.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL, "rn" );
  819.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  820.                 "Connection: Closern" );
  822.     if( net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL, "rn" ) < 0 )
  823.     {
  824.         msg_Err( p_access, "failed to send request" );
  825.         return VLC_EGENERIC;
  826.     }
  828.     psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, NULL );
  829.     if( psz == NULL )
  830.     {
  831.         msg_Err( p_access, "cannot read data 0" );
  832.         return VLC_EGENERIC;
  833.     }
  835.     if( atoi( &psz[9] ) >= 400 )
  836.     {
  837.         msg_Err( p_access, "error: %s", psz );
  838.         free( psz );
  839.         return VLC_EGENERIC;
  840.     }
  841.     msg_Dbg( p_access, "HTTP reply '%s'", psz );
  842.     free( psz );
  844.     /* FIXME check HTTP code */
  845.     for( ;; )
  846.     {
  847.         char *psz = net_Gets( p_access, p_sys->fd, NULL );
  848.         if( psz == NULL )
  849.         {
  850.             msg_Err( p_access, "cannot read data 1" );
  851.             return VLC_EGENERIC;
  852.         }
  853.         if( *psz == '' )
  854.         {
  855.             free( psz );
  856.             break;
  857.         }
  858.         msg_Dbg( p_access, "%s", psz );
  859.         free( psz );
  860.     }
  862.     p_sys->i_packet_used   = 0;
  863.     p_sys->i_packet_length = 0;
  865.     return VLC_SUCCESS;
  866. }
  868. /*****************************************************************************
  869.  * closing stream
  870.  *****************************************************************************/
  871. static void Stop( access_t *p_access )
  872. {
  873.     access_sys_t *p_sys = p_access->p_sys;
  875.     msg_Dbg( p_access, "closing stream" );
  876.     if( p_sys->fd > 0 )
  877.     {
  878.         net_Close( p_sys->fd );
  879.         p_sys->fd = -1;
  880.     }
  881. }
  883. /*****************************************************************************
  884.  * get packet
  885.  *****************************************************************************/
  886. static int GetPacket( access_t * p_access, chunk_t *p_ck )
  887. {
  888.     access_sys_t *p_sys = p_access->p_sys;
  889.     int restsize;
  891.     /* chunk_t */
  892.     memset( p_ck, 0, sizeof( chunk_t ) );
  894.     /* Read the chunk header */
  895.     /* Some headers are short, like 0x4324. Reading 12 bytes will cause us
  896.      * to lose synchronization with the stream. Just read to the length
  897.      * (4 bytes), decode and then read up to 8 additional bytes to get the
  898.      * entire header.
  899.      */
  900.     if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer, 4, true ) < 4 )
  901.     {
  902.        msg_Err( p_access, "cannot read data 2" );
  903.        return VLC_EGENERIC;
  904.     }
  906.     p_ck->i_type = GetWLE( p_sys->buffer);
  907.     p_ck->i_size = GetWLE( p_sys->buffer + 2);
  909.     restsize = p_ck->i_size;
  910.     if( restsize > 8 )
  911.         restsize = 8;
  913.     if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer + 4, restsize, true ) < restsize )
  914.     {
  915.         msg_Err( p_access, "cannot read data 3" );
  916.         return VLC_EGENERIC;
  917.     }
  918.     p_ck->i_sequence  = GetDWLE( p_sys->buffer + 4);
  919.     p_ck->i_unknown   = GetWLE( p_sys->buffer + 8);
  921.     /* Set i_size2 to 8 if this header was short, since a real value won't be
  922.      * present in the buffer. Using 8 avoid reading additional data for the
  923.      * packet.
  924.      */
  925.     if( restsize < 8 )
  926.         p_ck->i_size2 = 8;
  927.     else
  928.         p_ck->i_size2 = GetWLE( p_sys->buffer + 10);
  930.     p_ck->p_data      = p_sys->buffer + 12;
  931.     p_ck->i_data      = p_ck->i_size2 - 8;
  933.     if( p_ck->i_type == 0x4524 )   // Transfer complete
  934.     {
  935.         if( p_ck->i_sequence == 0 )
  936.         {
  937.             msg_Warn( p_access, "EOF" );
  938.             return VLC_EGENERIC;
  939.         }
  940.         else
  941.         {
  942.             msg_Warn( p_access, "next stream following" );
  943.             return VLC_EGENERIC;
  944.         }
  945.     }
  946.     else if( p_ck->i_type == 0x4324 )
  947.     {
  948.         /* 0x4324 is CHUNK_TYPE_RESET: a new stream will follow with a sequence of 0 */
  949.         msg_Warn( p_access, "next stream following (reset) seq=%d", p_ck->i_sequence  );
  950.         return VLC_EGENERIC;
  951.     }
  952.     else if( (p_ck->i_type != 0x4824) && (p_ck->i_type != 0x4424) )
  953.     {
  954.         msg_Err( p_access, "invalid chunk FATAL (0x%x)", p_ck->i_type );
  955.         return VLC_EGENERIC;
  956.     }
  958.     if( (p_ck->i_data > 0) &&
  959.         (net_Read( p_access, p_sys->fd, NULL, &p_sys->buffer[12],
  960.                    p_ck->i_data, true ) < p_ck->i_data) )
  961.     {
  962.         msg_Err( p_access, "cannot read data 4" );
  963.         return VLC_EGENERIC;
  964.     }
  966. #if 0
  967.     if( (p_sys->i_packet_sequence != 0) &&
  968.         (p_ck->i_sequence != p_sys->i_packet_sequence) )
  969.     {
  970.         msg_Warn( p_access, "packet lost ? (%d != %d)", p_ck->i_sequence, p_sys->i_packet_sequence );
  971.     }
  972. #endif
  974.     p_sys->i_packet_sequence = p_ck->i_sequence + 1;
  975.     p_sys->i_packet_used   = 0;
  976.     p_sys->i_packet_length = p_ck->i_data;
  977.     p_sys->p_packet        = p_ck->p_data;
  979.     return VLC_SUCCESS;
  980. }