videolan
/
vlc
mirror of https://code.videolan.org/videolan/vlc
1
Fork 0
Code Releases Activity
vlc/include/vlc_stream.h

724 lines
24 KiB
C
Raw Blame History

/*****************************************************************************
* vlc_stream.h: Stream (between access and demux) descriptor and methods
*****************************************************************************
* Copyright (C) 1999-2004 VLC authors and VideoLAN
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* 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 Lesser General Public License for more details.
*
* 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
#include <vlc_tick.h>
#include <vlc_block.h>
#include <vlc_input.h>
# ifdef __cplusplus
extern "C" {
# endif
/**
* \defgroup stream Stream
* \ingroup input
* Buffered input byte streams
* @{
* \file
* Byte streams and byte stream filter modules interface
*/
struct vlc_stream_operations {
/* Cannot fail */
bool (*can_seek)(stream_t *);
bool (*can_pause)(stream_t *);
bool (*can_control_pace)(stream_t *);
int (*get_pts_delay)(stream_t *, vlc_tick_t *);
int (*get_signal)(stream_t *, double *, double *);
int (*get_meta)(stream_t *, vlc_meta_t *);
int (*get_type)(stream_t *, int *);
int (*set_pause_state)(stream_t *, bool);
int (*set_seek_point)(stream_t *, int);
int (*set_title)(stream_t *, int);
void (*close)(stream_t *);
union {
struct {
bool (*can_fastseek)(stream_t *);
ssize_t (*read)(stream_t *, void *buf, size_t len);
block_t *(*block)(stream_t *, bool *restrict eof);
int (*readdir)(stream_t *, input_item_node_t *);
int (*seek)(stream_t *, uint64_t);
int (*get_title)(stream_t *, unsigned *);
int (*get_seekpoint)(stream_t *, unsigned *);
int (*get_size)(stream_t *, uint64_t *);
int (*get_title_info)(stream_t *, input_title_t ***, int *);
int (*get_content_type)(stream_t *, char **);
int (*get_tags)(stream_t *, const block_t **);
int (*get_private_id_state)(stream_t *, int, bool *);
int (*set_record_state)(stream_t *, bool, const char *, const char *);
int (*set_private_id_state)(stream_t *, int, bool);
int (*set_private_id_ca)(stream_t *, void *);
} stream;
struct {
bool (*can_record)(demux_t *);
bool (*can_control_rate)(demux_t *);
int (*demux)(demux_t *);
int (*readdir)(demux_t *, input_item_node_t *);
bool (*has_unsupported_meta)(demux_t *);
int (*get_title)(demux_t *, int *);
int (*get_seekpoint)(demux_t *, int *);
double (*get_position)(demux_t *);
vlc_tick_t (*get_length)(demux_t *);
vlc_tick_t (*get_time)(demux_t *);
int (*get_normal_time)(demux_t *, vlc_tick_t *);
int (*get_title_info)(demux_t *, input_title_t ***, int *, int *, int *);
int (*get_fps)(demux_t *, double *);
int (*get_attachments)(demux_t *, input_attachment_t ***);
int (*set_position)(demux_t *, double, bool);
int (*set_time)(demux_t *, vlc_tick_t, bool);
int (*set_next_demux_time)(demux_t *, vlc_tick_t);
int (*set_record_state)(demux_t *, bool, const char *);
int (*set_rate)(demux_t *, float *);
int (*set_group_default)(demux_t *);
int (*set_group_all)(demux_t *);
int (*set_group_list)(demux_t *, size_t, const int *);
int (*set_es)(demux_t *, int);
int (*set_es_list)(demux_t *, size_t, const int *);
int (*nav_activate)(demux_t *);
int (*nav_up)(demux_t *);
int (*nav_down)(demux_t *);
int (*nav_left)(demux_t *);
int (*nav_right)(demux_t *);
int (*nav_popup)(demux_t *);
int (*nav_menu)(demux_t *);
int (*filter_enable)(demux_t *);
int (*filter_disable)(demux_t *);
int (*test_and_clear_flags)(demux_t *, unsigned *);
} demux;
};
};
/**
* stream_t definition
*/
struct stream_t
{
struct vlc_object_t obj;
char *psz_name;
char *psz_url; /**< Full URL or MRL (can be NULL) */
const char *psz_location; /**< Location (URL with the scheme stripped) */
char *psz_filepath; /**< Local file path (if applicable) */
bool b_preparsing; /**< True if this access is used to preparse */
input_item_t *p_input_item;/**< Input item (can be NULL) */
/**
* Input stream
*
* Depending on the module capability:
* - "stream filter" or "demux": input byte stream (not NULL)
* - "access": a NULL pointer
* - "demux_filter": upstream demuxer or demux filter
*/
stream_t *s;
/* es output */
es_out_t *out; /* our p_es_out */
/**
* Read data.
*
* Callback to read data from the stream into a caller-supplied buffer.
*
* This is the legacy implementor, using \ref vlc_stream_operations
* should be prefered.
*
* This may be NULL if the stream is actually a directory rather than a
* byte stream, or if \ref stream_t.pf_block is non-NULL.
*
* \param buf buffer to read data into
* \param len buffer length (in bytes)
*
* \retval -1 no data available yet
* \retval 0 end of stream (incl. fatal error)
* \retval positive number of bytes read (no more than len)
*/
ssize_t (*pf_read)(stream_t *, void *buf, size_t len);
/**
* Read data block.
*
* Callback to read a block of data. The data is read into a block of
* memory allocated by the stream. For some streams, data can be read more
* efficiently in block of a certain size, and/or using a custom allocator
* for buffers. In such case, this callback should be provided instead of
* \ref stream_t.pf_read; otherwise, this should be NULL.
*
* This is the legacy implementor, using \ref vlc_stream_operations
* should be prefered.
*
* \param eof storage space for end-of-stream flag [OUT]
* (*eof is always false when invoking pf_block(); pf_block() should set
* *eof to true if it detects the end of the stream)
*
* \return a data block,
* NULL if no data available yet, on error and at end-of-stream
*/
block_t *(*pf_block)(stream_t *, bool *restrict eof);
/**
* Read directory.
*
* Callback to fill an item node from a directory
* (see doc/browsing.txt for details).
*
* This is the legacy implementor, using \ref vlc_stream_operations
* should be prefered.
*
* NULL if the stream is not a directory.
*/
int (*pf_readdir)(stream_t *, input_item_node_t *);
int (*pf_demux)(stream_t *);
/**
* Seek.
*
* Callback to set the stream pointer (in bytes from start).
*
* This is the legacy implementor, using \ref vlc_stream_operations
* should be prefered.
*
* May be NULL if seeking is not supported.
*/
int (*pf_seek)(stream_t *, uint64_t);
/**
* Stream control.
*
* Legacy way of implementing callbacks.
* \ref vlc_stream_operations should be prefered.
*
* \see stream_query_e
*/
int (*pf_control)(stream_t *, int i_query, va_list);
/**
* Implementation of the Stream/Demux API.
*
* If NULL all operations will be redirected to \ref stream_t.pf_control.
*/
const struct vlc_stream_operations *ops;
/**
* Private data pointer
*/
void *p_sys;
};
/**
* Possible commands to send to vlc_stream_Control() and vlc_stream_vaControl()
*/
enum stream_query_e
{
/* 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*/
/* */
STREAM_GET_SIZE=6, /**< arg1= uint64_t * res=can fail */
/* */
STREAM_GET_PTS_DELAY = 0x101,/**< arg1= vlc_tick_t* res=cannot fail */
STREAM_GET_TITLE_INFO, /**< arg1=input_title_t*** arg2=int* res=can fail */
STREAM_GET_TITLE, /**< arg1=unsigned * res=can fail */
STREAM_GET_SEEKPOINT, /**< arg1=unsigned * res=can fail */
STREAM_GET_META, /**< arg1= vlc_meta_t * res=can fail */
STREAM_GET_CONTENT_TYPE, /**< arg1= char ** res=can fail */
STREAM_GET_SIGNAL, /**< arg1=double *pf_quality, arg2=double *pf_strength res=can fail */
STREAM_GET_TAGS, /**< arg1=const block_t ** res=can fail */
STREAM_GET_TYPE, /**< arg1=int* res=can fail */
STREAM_SET_PAUSE_STATE = 0x200, /**< arg1= bool res=can fail */
STREAM_SET_TITLE, /**< arg1= int res=can fail */
STREAM_SET_SEEKPOINT, /**< arg1= int res=can fail */
/* XXX only data read through vlc_stream_Read/Block will be recorded */
STREAM_SET_RECORD_STATE, /**< arg1=bool, arg2=const char *dir_path (if arg1 is true)
arg3=const char *psz_ext (if arg1 is true) res=can fail */
STREAM_SET_PRIVATE_ID_STATE = 0x1000, /* arg1= int i_private_data, bool b_selected res=can fail */
STREAM_SET_PRIVATE_ID_CA, /* arg1= void * */
STREAM_GET_PRIVATE_ID_STATE, /* arg1=int i_private_data arg2=bool * res=can fail */
};
/**
* Reads data from a byte stream.
*
* This function always waits for the requested number of bytes, unless a fatal
* error is encountered or the end-of-stream is reached first.
*
* If the buffer is NULL, data is skipped instead of read. This is effectively
* a relative forward seek, but it works even on non-seekable streams.
*
* \param buf start of buffer to read data into [OUT]
* \param len number of bytes to read
* \return the number of bytes read or a negative value on error.
*/
VLC_API ssize_t vlc_stream_Read(stream_t *, void *buf, size_t len) VLC_USED;
/**
* Reads partial data from a byte stream.
*
* This function waits until some data is available for reading from the
* stream, a fatal error is encountered or the end-of-stream is reached.
*
* Unlike vlc_stream_Read(), this function does not wait for the full requested
* bytes count. It can return a short count even before the end of the stream
* and in the absence of any error.
*
* \param buf start of buffer to read data into [OUT]
* \param len buffer size (maximum number of bytes to read)
* \return the number of bytes read, 0 on end of stream or -1 if no data available
*/
VLC_API ssize_t vlc_stream_ReadPartial(stream_t *, void *buf, size_t len)
VLC_USED;
/**
* Peeks at data from a byte stream.
*
* This function buffers for the requested number of bytes, waiting if
* necessary. Then it stores a pointer to the buffer. Unlike vlc_stream_Read()
* or vlc_stream_Block(), this function does not modify the stream read offset.
*
* \note
* The buffer remains valid until the next read/peek or seek operation on the
* same stream. In case of error, the buffer address is undefined.
*
* \param bufp storage space for the buffer address [OUT]
* \param len number of bytes to peek
* \return the number of bytes actually available (shorter than requested if
* the end-of-stream is reached), or a negative value on error.
*/
VLC_API ssize_t vlc_stream_Peek(stream_t *, const uint8_t **, size_t) VLC_USED;
/**
* Reads a data block from a byte stream.
*
* This function dequeues the next block of data from the byte stream. The
* byte stream back-end decides on the size of the block; the caller cannot
* make any assumption about it.
*
* The function might also return NULL spuriously - this does not necessarily
* imply that the stream is ended nor that it has encountered a nonrecoverable
* error.
*
* This function should be used instead of vlc_stream_Read() or
* vlc_stream_Peek() when the caller can handle reads of any size.
*
* \return either a data block or NULL
*/
VLC_API block_t *vlc_stream_ReadBlock(stream_t *) VLC_USED;
/**
* Tells the current stream position.
*
* This function tells the current read offset (in bytes) from the start of
* the start of the stream.
* @note The read offset may be larger than the stream size, either because of
* a seek past the end, or because the stream shrank asynchronously.
*
* @return the byte offset from the beginning of the stream (cannot fail)
*/
VLC_API uint64_t vlc_stream_Tell(const stream_t *) VLC_USED;
/**
* Checks for end of stream.
*
* Checks if the last attempt to reads data from the stream encountered the
* end of stream before the attempt could be fully satisfied.
* The value is initially false, and is reset to false by vlc_stream_Seek().
*
* \note The function can return false even though the current stream position
* is equal to the stream size. It will return true after the following attempt
* to read more than zero bytes.
*
* \note It might be possible to read after the end of the stream.
* It implies the size of the stream increased asynchronously in the mean time.
* Streams of most types cannot trigger such a case,
* but regular local files notably can.
*
* \note In principles, the stream size should match the stream offset when
* the end-of-stream is reached. But that rule is not enforced; it is entirely
* dependent on the underlying implementation of the stream.
*/
VLC_API bool vlc_stream_Eof(const stream_t *) VLC_USED;
/**
* Sets the current stream position.
*
* This function changes the read offset within a stream, if the stream
* supports seeking. In case of error, the read offset is not changed.
*
* @note It is possible (but not useful) to seek past the end of a stream.
*
* @param offset byte offset from the beginning of the stream
* @return zero on success, a negative value on error
*/
VLC_API int vlc_stream_Seek(stream_t *, uint64_t offset) VLC_USED;
VLC_API int vlc_stream_vaControl(stream_t *s, int query, va_list args);
static inline int vlc_stream_Control(stream_t *s, int query, ...)
{
va_list ap;
int ret;
va_start(ap, query);
ret = vlc_stream_vaControl(s, query, ap);
va_end(ap);
return ret;
}
VLC_API block_t *vlc_stream_Block(stream_t *s, size_t);
VLC_API char *vlc_stream_ReadLine(stream_t *);
/**
* Reads a directory.
*
* This function fills an input item node with any and all the items within
* a directory. The behaviour is undefined if the stream is not a directory.
*
* \param s directory object to read from
* \param node node to store the items into
* \return VLC_SUCCESS on success
*/
VLC_API int vlc_stream_ReadDir(stream_t *s, input_item_node_t *node);
/**
* Closes a byte stream.
* \param s byte stream to close
*/
VLC_API void vlc_stream_Delete(stream_t *s);
VLC_API stream_t *vlc_stream_CommonNew(vlc_object_t *, void (*)(stream_t *));
VLC_USED static inline bool vlc_stream_CanSeek(stream_t *s)
{
bool can_seek = false;
vlc_stream_Control(s, STREAM_CAN_SEEK, &can_seek);
return can_seek;
}
VLC_USED static inline bool vlc_stream_CanFastSeek(stream_t *s)
{
bool can_fast_seek = false;
vlc_stream_Control(s, STREAM_CAN_FASTSEEK, &can_fast_seek);
return can_fast_seek;
}
VLC_USED static inline bool vlc_stream_CanPause(stream_t *s)
{
bool can_pause = false;
vlc_stream_Control(s, STREAM_CAN_PAUSE, &can_pause);
return can_pause;
}
VLC_USED static inline bool vlc_stream_CanPace(stream_t *s)
{
bool can_control_pace = false;
vlc_stream_Control(s, STREAM_CAN_CONTROL_PACE, &can_control_pace);
return can_control_pace;
}
VLC_USED static inline int vlc_stream_GetPtsDelay(stream_t *s, vlc_tick_t *pts_delay)
{
return vlc_stream_Control(s, STREAM_GET_PTS_DELAY, pts_delay);
}
VLC_USED static inline int vlc_stream_GetSeekpoint(stream_t *s, unsigned *seekpoint)
{
return vlc_stream_Control(s, STREAM_GET_SEEKPOINT, seekpoint);
}
VLC_USED static inline int vlc_stream_GetSignal(stream_t *s, double *quality, double *strength)
{
return vlc_stream_Control(s, STREAM_GET_SIGNAL, quality, strength);
}
VLC_USED static inline int vlc_stream_GetTitle(stream_t *s, unsigned *title)
{
return vlc_stream_Control(s, STREAM_GET_TITLE, title);
}
VLC_USED static inline int vlc_stream_GetMeta(stream_t *s, vlc_meta_t *meta)
{
return vlc_stream_Control(s, STREAM_GET_META, meta);
}
VLC_USED static inline int vlc_stream_GetType(stream_t *s, int *type)
{
return vlc_stream_Control(s, STREAM_GET_TYPE, type);
}
/**
* Get the size of the stream.
*/
VLC_USED static inline int vlc_stream_GetSize(stream_t *s, uint64_t *size)
{
return vlc_stream_Control(s, STREAM_GET_SIZE, size);
}
VLC_USED static inline int vlc_stream_GetTitleInfo(stream_t *s, input_title_t ***title_info, int *size)
{
return vlc_stream_Control(s, STREAM_GET_TITLE_INFO, title_info, size);
}
VLC_USED static inline int vlc_stream_GetContentType(stream_t *s, char **content_type)
{
return vlc_stream_Control(s, STREAM_GET_CONTENT_TYPE, content_type);
}
VLC_USED static inline int vlc_stream_GetTags(stream_t *s, const block_t **tags)
{
return vlc_stream_Control(s, STREAM_GET_TAGS, tags);
}
VLC_USED static inline int vlc_stream_GetPrivateIdState(stream_t *s, int priv_id, bool *state)
{
return vlc_stream_Control(s, STREAM_GET_PRIVATE_ID_STATE, priv_id, state);
}
VLC_USED static inline int vlc_stream_SetPauseState(stream_t *s, bool pause_state)
{
return vlc_stream_Control(s, STREAM_SET_PAUSE_STATE, pause_state);
}
VLC_USED static inline int vlc_stream_SetSeekPoint(stream_t *s, int seekpoint)
{
return vlc_stream_Control(s, STREAM_SET_SEEKPOINT, seekpoint);
}
VLC_USED static inline int vlc_stream_SetTitle(stream_t *s, int title)
{
return vlc_stream_Control(s, STREAM_SET_TITLE, title);
}
VLC_USED static inline int vlc_stream_SetRecordState(stream_t *s, bool record_state, const char *dir_path, const char *ext)
{
return vlc_stream_Control(s, STREAM_SET_RECORD_STATE, record_state, dir_path, ext);
}
VLC_USED static inline int vlc_stream_SetPrivateIdState(stream_t *s, int priv_id, bool state)
{
return vlc_stream_Control(s, STREAM_SET_PRIVATE_ID_STATE, priv_id, state);
}
/**
* Set the private ID ca.
*
* The ca arg is of type `en50221_capmt_info_t`.
*/
VLC_USED static inline int vlc_stream_SetPrivateIdCa(stream_t *s, void *ca)
{
return vlc_stream_Control(s, STREAM_SET_PRIVATE_ID_CA, ca);
}
static inline int64_t stream_Size( stream_t *s )
{
uint64_t i_pos;
if( vlc_stream_GetSize( s, &i_pos ) )
return 0;
if( i_pos >> 62 )
return (int64_t)1 << 62;
return i_pos;
}
VLC_USED
static inline bool stream_HasExtension( stream_t *s, const char *extension )
{
const char *name = (s->psz_filepath != NULL) ? s->psz_filepath
: s->psz_url;
const char *ext = strrchr( name, '.' );
return ext != NULL && !strcasecmp( ext, extension );
}
/**
* Get the Content-Type of a stream, or NULL if unknown.
* Result must be free()'d.
*/
static inline char *stream_ContentType( stream_t *s )
{
char *res;
if (vlc_stream_GetContentType(s, &res))
return NULL;
return res;
}
/**
* Get the mime-type of a stream
*
* \warning the returned resource is to be freed by the caller
* \return the mime-type, or `NULL` if unknown
**/
VLC_USED
static inline char *stream_MimeType( stream_t *s )
{
char* mime_type = stream_ContentType( s );
if( mime_type ) /* strip parameters */
mime_type[strcspn( mime_type, " ;" )] = '\0';
return mime_type;
}
/**
* Checks for a MIME type.
*
* Checks if the stream has a specific MIME type.
*/
VLC_USED
static inline bool stream_IsMimeType(stream_t *s, const char *type)
{
char *mime = stream_MimeType(s);
if (mime == NULL)
return false;
bool ok = !strcasecmp(mime, type);
free(mime);
return ok;
}
/**
* Create a stream from a memory buffer.
*
* \param obj parent VLC object
* \param base start address of the memory buffer to read from
* \param size size in bytes of the memory buffer
* \param preserve if false, free(base) will be called when the stream is
* destroyed; if true, the memory buffer is preserved
*/
VLC_API stream_t *vlc_stream_MemoryNew(vlc_object_t *obj, uint8_t *base,
size_t size, bool preserve) VLC_USED;
#define vlc_stream_MemoryNew(a, b, c, d) \
vlc_stream_MemoryNew(VLC_OBJECT(a), b, c, d)
/**
* Create a stream_t reading from a URL.
* You must delete it using vlc_stream_Delete.
*/
VLC_API stream_t * vlc_stream_NewURL(vlc_object_t *obj, const char *url)
VLC_USED;
#define vlc_stream_NewURL(a, b) vlc_stream_NewURL(VLC_OBJECT(a), b)
/**
* \defgroup stream_fifo FIFO stream
* In-memory anonymous pipe
@{
*/
typedef struct vlc_stream_fifo vlc_stream_fifo_t;
/**
* Creates a FIFO stream.
*
* Creates a non-seekable byte stream object whose byte stream is generated
* by another thread in the process. This is the LibVLC equivalent of an
* anonymous pipe/FIFO.
*
* On the reader side, the normal stream functions are used,
* e.g. vlc_stream_Read() and vlc_stream_Delete().
*
* The created stream object is automatically destroyed when both the reader
* and the writer sides have been closed, with vlc_stream_Delete() and
* vlc_stream_fifo_Close() respectively.
*
* \param parent parent VLC object for the stream
* \param reader location to store read side stream pointer [OUT]
* \return a FIFO stream object or NULL on memory error.
*/
VLC_API vlc_stream_fifo_t *vlc_stream_fifo_New(vlc_object_t *parent,
stream_t **reader);
/**
* Writes a block to a FIFO stream.
*
* \param s FIFO stream created by vlc_stream_fifo_New()
* \param block data block to write to the stream
* \return 0 on success. -1 if the reader end has already been closed
* (errno is then set to EPIPE, and the block is deleted).
*
* \bug No congestion control is performed. If the reader end is not keeping
* up with the writer end, buffers will accumulate in memory.
*/
VLC_API int vlc_stream_fifo_Queue(vlc_stream_fifo_t *s, block_t *block);
/**
* Writes data to a FIFO stream.
*
* This is a convenience helper for vlc_stream_fifo_Queue().
* \param s FIFO stream created by vlc_stream_fifo_New()
* \param buf start address of data to write
* \param len length of data to write in bytes
* \return len on success, or -1 on error (errno is set accordingly)
*/
VLC_API ssize_t vlc_stream_fifo_Write(vlc_stream_fifo_t *s, const void *buf,
size_t len);
/**
* Terminates a FIFO stream.
*
* Marks the end of the FIFO stream and releases any underlying resources.
* \param s FIFO stream created by vlc_stream_fifo_New()
*/
VLC_API void vlc_stream_fifo_Close(vlc_stream_fifo_t *s);
/**
* @}
*/
/**
* 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* vlc_stream_FilterNew( stream_t *p_source, const char *psz_stream_filter );
/**
* @}
*/
# ifdef __cplusplus
}
# endif
#endif
View Git Blame Copy Permalink