X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=include%2Fvlc_stream.h;h=c85f8e5eba42ca8531d1f28b3618a94aebd1657f;hb=e4de05b7fd303c9a155d474ae4ab8751685c9c42;hp=3b4ff21827f5f698758cc6f1cad658cabc724ec0;hpb=2cb472dba008f7d877ffe6bae9c5575253365282;p=vlc diff --git a/include/vlc_stream.h b/include/vlc_stream.h index 3b4ff21827..c85f8e5eba 100644 --- a/include/vlc_stream.h +++ b/include/vlc_stream.h @@ -1,28 +1,35 @@ /***************************************************************************** * vlc_stream.h: Stream (between access and demux) descriptor and methods ***************************************************************************** - * Copyright (C) 1999-2004 the VideoLAN team + * Copyright (C) 1999-2004 VLC authors and VideoLAN * $Id$ * * Authors: Laurent Aimar * - * This program 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 + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or * (at your option) any later version. * * This program 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. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser 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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ -#ifndef _VLC_STREAM_H -#define _VLC_STREAM_H 1 +#ifndef VLC_STREAM_H +#define VLC_STREAM_H 1 + +#include + +/** + * \file + * This file defines structures and functions for stream (between access and demux) descriptor in vlc + */ # ifdef __cplusplus extern "C" { @@ -35,115 +42,98 @@ extern "C" { * @{ */ -/** - * Possible commands to send to stream_Control() and stream_vaControl() - */ -enum stream_query_e -{ - /* capabilities */ - STREAM_CAN_SEEK, /**< arg1= vlc_bool_t * res=cannot fail*/ - STREAM_CAN_FASTSEEK, /**< arg1= vlc_bool_t * res=cannot fail*/ - - /* */ - STREAM_SET_POSITION, /**< arg1= int64_t res=can fail */ - STREAM_GET_POSITION, /**< arg1= int64_t * res=cannot fail*/ - - STREAM_GET_SIZE, /**< arg1= int64_t * res=cannot fail (0 if no sense)*/ - - STREAM_GET_MTU, /**< arg1= int * res=cannot fail (0 if no sense)*/ - - /* Special for direct access control from demuxer. - * XXX: avoid using it by all means */ - STREAM_CONTROL_ACCESS /* arg1= int i_access_query, args res: can fail - if access unreachable or access control answer */ -}; +/* Opaque definition for text reader context */ +typedef struct stream_text_t stream_text_t; /** * stream_t definition */ + struct stream_t { VLC_COMMON_MEMBERS + bool b_error; + + /* Module properties for stream filter */ + module_t *p_module; + + char *psz_access; + /* Real or virtual path (it can only be changed during stream_t opening) */ + char *psz_path; + + /* Stream source for stream filter */ + stream_t *p_source; - block_t *(*pf_block) ( stream_t *, int i_size ); - int (*pf_read) ( stream_t *, void *p_read, int i_read ); - int (*pf_peek) ( stream_t *, uint8_t **pp_peek, int i_peek ); + /* */ + int (*pf_read) ( stream_t *, void *p_read, unsigned int i_read ); + int (*pf_peek) ( stream_t *, const uint8_t **pp_peek, unsigned int i_peek ); int (*pf_control)( stream_t *, int i_query, va_list ); + + /* */ void (*pf_destroy)( stream_t *); + /* Private data for module */ stream_sys_t *p_sys; - /* UTF-16 and UTF-32 file reading */ - vlc_iconv_t conv; - int i_char_width; - vlc_bool_t b_little_endian; + /* Text reader state */ + stream_text_t *p_text; + + /* Weak link to parent input */ + input_thread_t *p_input; }; /** - * Try to read "i_read" bytes into a buffer pointed by "p_read". If - * "p_read" is NULL then data are skipped instead of read. The return - * value is the real numbers of bytes read/skip. If this value is less - * than i_read that means that it's the end of the stream. + * Possible commands to send to stream_Control() and stream_vaControl() */ -static inline int stream_Read( stream_t *s, void *p_read, int i_read ) +enum stream_query_e { - return s->pf_read( s, p_read, i_read ); -} + /* capabilities */ + STREAM_CAN_SEEK, /**< arg1= bool * res=cannot fail*/ + STREAM_CAN_FASTSEEK, /**< arg1= bool * res=cannot fail*/ + STREAM_CAN_PAUSE, /**< arg1= bool * res=cannot fail*/ + STREAM_CAN_CONTROL_PACE, /**< arg1= bool * res=cannot fail*/ -/** - * Store in pp_peek a pointer to the next "i_peek" bytes in the stream - * \return The real numbers of valid bytes, if it's less - * or equal to 0, *pp_peek is invalid. - * \note pp_peek is a pointer to internal buffer and it will be invalid as - * soons as other stream_* functions are called. - * \note Due to input limitation, it could be less than i_peek without meaning - * the end of the stream (but only when you have i_peek >= - * p_input->i_bufsize) - */ -static inline int stream_Peek( stream_t *s, uint8_t **pp_peek, int i_peek ) -{ - return s->pf_peek( s, pp_peek, i_peek ); -} + /* */ + STREAM_SET_POSITION, /**< arg1= uint64_t res=can fail */ + STREAM_GET_POSITION, /**< arg1= uint64_t * res=cannot fail*/ -/** - * Use to control the "stream_t *". Look at #stream_query_e for - * possible "i_query" value and format arguments. Return VLC_SUCCESS - * if ... succeed ;) and VLC_EGENERIC if failed or unimplemented - */ -static inline int stream_vaControl( stream_t *s, int i_query, va_list args ) -{ - return s->pf_control( s, i_query, args ); -} + STREAM_GET_SIZE, /**< arg1= uint64_t * res=cannot fail (0 if no sense)*/ -/** - * Destroy a stream - */ -static inline void stream_Delete( stream_t *s ) -{ - s->pf_destroy( s ); -} + /* Special for direct access control from demuxer. + * XXX: avoid using it by all means */ + STREAM_CONTROL_ACCESS, /* arg1= int i_access_query, args res: can fail + if access unreachable or access control answer */ -static inline int stream_Control( stream_t *s, int i_query, ... ) -{ - va_list args; - int i_result; + /* You should update size of source if any and then update size + * FIXME find a way to avoid it */ + STREAM_UPDATE_SIZE, - if ( s == NULL ) - return VLC_EGENERIC; + /* */ + STREAM_GET_CONTENT_TYPE, /**< arg1= char ** res=can fail */ + STREAM_SET_PAUSE_STATE = 0x200, /**< arg1= bool res=can fail */ - va_start( args, i_query ); - i_result = s->pf_control( s, i_query, args ); - va_end( args ); - return i_result; -} + /* XXX only data read through stream_Read/Block will be recorded */ + STREAM_SET_RECORD_STATE, /**< arg1=bool, arg2=const char *psz_ext (if arg1 is true) res=can fail */ +}; + +VLC_API int stream_Read( stream_t *s, void *p_read, int i_read ); +VLC_API int stream_Peek( stream_t *s, const uint8_t **pp_peek, int i_peek ); +VLC_API int stream_vaControl( stream_t *s, int i_query, va_list args ); +VLC_API void stream_Delete( stream_t *s ); +VLC_API int stream_Control( stream_t *s, int i_query, ... ); +VLC_API block_t * stream_Block( stream_t *s, int i_size ); +VLC_API block_t * stream_BlockRemaining( stream_t *s, int i_max_size ); +VLC_API char * stream_ReadLine( stream_t * ); /** * Get the current position in a stream */ static inline int64_t stream_Tell( stream_t *s ) { - int64_t i_pos; + uint64_t i_pos; stream_Control( s, STREAM_GET_POSITION, &i_pos ); + if( i_pos >> 62 ) + return (int64_t)1 << 62; return i_pos; } @@ -152,67 +142,78 @@ static inline int64_t stream_Tell( stream_t *s ) */ static inline int64_t stream_Size( stream_t *s ) { - int64_t i_pos; + uint64_t i_pos; stream_Control( s, STREAM_GET_SIZE, &i_pos ); + if( i_pos >> 62 ) + return (int64_t)1 << 62; return i_pos; } -static inline int stream_MTU( stream_t *s ) -{ - int i_mtu; - stream_Control( s, STREAM_GET_MTU, &i_mtu ); - return i_mtu; -} -static inline int stream_Seek( stream_t *s, int64_t i_pos ) + +static inline int stream_Seek( stream_t *s, uint64_t i_pos ) { return stream_Control( s, STREAM_SET_POSITION, i_pos ); } /** - * Read "i_size" bytes and store them in a block_t. If less than "i_size" - * bytes are available then return what is left and if nothing is availble, - * return NULL. + * Get the Content-Type of a stream, or NULL if unknown. + * Result must be free()'d. */ -static inline block_t *stream_Block( stream_t *s, int i_size ) +static inline char *stream_ContentType( stream_t *s ) { - if( i_size <= 0 ) return NULL; - - if( s->pf_block ) - { - return s->pf_block( s, i_size ); - } - else - { - /* emulate block read */ - block_t *p_bk = block_New( s, i_size ); - if( p_bk ) - { - p_bk->i_buffer = stream_Read( s, p_bk->p_buffer, i_size ); - if( p_bk->i_buffer > 0 ) - { - return p_bk; - } - } - if( p_bk ) block_Release( p_bk ); + char *res; + if( stream_Control( s, STREAM_GET_CONTENT_TYPE, &res ) ) return NULL; - } + return res; } -VLC_EXPORT( char *, stream_ReadLine, ( stream_t * ) ); - /** * Create a special stream and a demuxer, this allows chaining demuxers + * You must delete it using stream_Delete. + */ +VLC_API stream_t * stream_DemuxNew( demux_t *p_demux, const char *psz_demux, es_out_t *out ); + +/** + * Send data to a stream handle created by stream_DemuxNew(). + */ +VLC_API void stream_DemuxSend( stream_t *s, block_t *p_block ); + +/** + * Perform a demux (i.e. DEMUX_...) control request on a stream handle + * created by stream_DemuxNew(). + */ +VLC_API int stream_DemuxControlVa( stream_t *s, int, va_list ); + +static inline int stream_DemuxControl( stream_t *s, int query, ... ) +{ + va_list ap; + int ret; + + va_start( ap, query ); + ret = stream_DemuxControlVa( s, query, ap ); + va_end( ap ); + return ret; +} + +/** + * Create a stream_t reading from memory. + * You must delete it using stream_Delete. */ -#define stream_DemuxNew( a, b, c ) __stream_DemuxNew( VLC_OBJECT(a), b, c) -VLC_EXPORT( stream_t *,__stream_DemuxNew, ( vlc_object_t *p_obj, char *psz_demux, es_out_t *out ) ); -VLC_EXPORT( void, stream_DemuxSend, ( stream_t *s, block_t *p_block ) ); -VLC_EXPORT( void, stream_DemuxDelete,( stream_t *s ) ); +VLC_API stream_t * stream_MemoryNew(vlc_object_t *p_obj, uint8_t *p_buffer, uint64_t i_size, bool b_preserve_memory ); +#define stream_MemoryNew( a, b, c, d ) stream_MemoryNew( VLC_OBJECT(a), b, c, d ) +/** + * Create a stream_t reading from a URL. + * You must delete it using stream_Delete. + */ +VLC_API stream_t * stream_UrlNew(vlc_object_t *p_this, const char *psz_url ); +#define stream_UrlNew( a, b ) stream_UrlNew( VLC_OBJECT(a), b ) -#define stream_MemoryNew( a, b, c, d ) __stream_MemoryNew( VLC_OBJECT(a), b, c, d ) -VLC_EXPORT( stream_t *,__stream_MemoryNew, (vlc_object_t *p_obj, uint8_t *p_buffer, int64_t i_size, vlc_bool_t i_preserve_memory ) ); -#define stream_UrlNew( a, b ) __stream_UrlNew( VLC_OBJECT(a), b ) -VLC_EXPORT( stream_t *,__stream_UrlNew, (vlc_object_t *p_this, const char *psz_url ) ); +/** + * Try to add a stream filter to an open stream. + * @return New stream to use, or NULL if the filter could not be added. + **/ +VLC_API stream_t* stream_FilterNew( stream_t *p_source, const char *psz_stream_filter ); /** * @} */