Commits

Haiko Schol committed 0d65a55

changed vlc libs from mac to windows

Comments (0)

Files changed (658)

include/vlc/deprecated.h

  * deprecated.h:  libvlc deprecated API
  *****************************************************************************
  * Copyright (C) 1998-2008 the VideoLAN team
- * $Id$
+ * $Id: 216b1caba458403370a2aad252bcd63a6f5ca33d $
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

include/vlc/libvlc_media_discoverer.h

  * libvlc.h:  libvlc external API
  *****************************************************************************
  * Copyright (C) 1998-2009 the VideoLAN team
- * $Id$
+ * $Id: 2552d6b39b311a3d35d72b7eebf0e180ff3d54aa $
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

include/vlc/libvlc_media_library.h

  * libvlc.h:  libvlc external API
  *****************************************************************************
  * Copyright (C) 1998-2009 the VideoLAN team
- * $Id$
+ * $Id: 76b5b161e6853479324ff23e86fa3b4a39f0036b $
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

include/vlc/libvlc_media_list.h

  * libvlc_media_list.h:  libvlc_media_list API
  *****************************************************************************
  * Copyright (C) 1998-2008 the VideoLAN team
- * $Id$
+ * $Id: 32304ee4304c2fb3272a922947123884a1f59f07 $
  *
  * Authors: Pierre d'Herbemont
  *

include/vlc/libvlc_media_list_player.h

  * libvlc_media_list.h:  libvlc_media_list API
  *****************************************************************************
  * Copyright (C) 1998-2008 the VideoLAN team
- * $Id$
+ * $Id: bd7563585547ddd87484dc96516f7c3a7f904578 $
  *
  * Authors: Pierre d'Herbemont
  *

include/vlc/libvlc_version.h

+/*****************************************************************************
+ * libvlc_version.h
+ *****************************************************************************
+ * Copyright (C) 2010 Rémi Denis-Courmont
+ *
+ * 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
+ * (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.
+ *
+ * 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.
+ *****************************************************************************/
+
+/**
+ * \file
+ * This file defines version macros for LibVLC.
+ * Those macros are primilarly intended for conditional (pre)compilation.
+ * To get the run-time LibVLC version, use libvlc_get_version() instead
+ * (the run-time version may be more recent than build-time one, thanks to
+ * backward binary compatibility).
+ *
+ * \version This header file is available in LibVLC 1.1.4 and higher.
+ */
+
+#ifndef LIBVLC_VERSION_H
+# define LIBVLC_VERSION_H 1
+
+/** LibVLC major version number */
+# define LIBVLC_VERSION_MAJOR    (1)
+
+/** LibVLC minor version number */
+# define LIBVLC_VERSION_MINOR    (1)
+
+/** LibVLC revision */
+# define LIBVLC_VERSION_REVISION (4)
+
+# define LIBVLC_VERSION_EXTRA    (0)
+
+/** Makes a single integer from a LibVLC version numbers */
+# define LIBVLC_VERSION(maj,min,rev,extra) \
+         ((maj << 24) | (min << 16) | (rev << 8) | (extra))
+
+/** LibVLC full version as a single integer (for comparison) */
+# define LIBVLC_VERSION_INT \
+         LIBVLC_VERSION(LIBVLC_VERSION_MAJOR, LIBVLC_VERSION_MINOR, \
+                        LIBVLC_VERSION_EXTRA, LIBVLC_VERSION_EXTRA)
+
+#endif

include/vlc/libvlc_vlm.h

  * libvlc_vlm.h:  libvlc_* new external API
  *****************************************************************************
  * Copyright (C) 1998-2008 the VideoLAN team
- * $Id$
+ * $Id: f09dbe506ef2f21b2d894e9086d91e11672bf2b9 $
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>

include/vlc/plugins/vlc_access.h

+/*****************************************************************************
+ * vlc_access.h: Access descriptor, queries and methods
+ *****************************************************************************
+ * Copyright (C) 1999-2006 the VideoLAN team
+ * $Id: cc7a9c6b8dffcbdb72d19b48c1e60fb361164fe9 $
+ *
+ * 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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.
+ *
+ * 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.
+ *****************************************************************************/
+
+#ifndef VLC_ACCESS_H
+#define VLC_ACCESS_H 1
+
+/**
+ * \file
+ * This file defines functions and definitions for access object
+ */
+
+#include <vlc_block.h>
+
+/**
+ * \defgroup access Access
+ * @{
+ */
+
+enum access_query_e
+{
+    /* capabilities */
+    ACCESS_CAN_SEEK,        /* arg1= bool*    cannot fail */
+    ACCESS_CAN_FASTSEEK,    /* arg1= bool*    cannot fail */
+    ACCESS_CAN_PAUSE,       /* arg1= bool*    cannot fail */
+    ACCESS_CAN_CONTROL_PACE,/* arg1= bool*    cannot fail */
+
+    /* */
+    ACCESS_GET_PTS_DELAY = 0x101,/* arg1= int64_t*       cannot fail */
+    /* */
+    ACCESS_GET_TITLE_INFO,  /* arg1=input_title_t*** arg2=int*      res=can fail */
+    /* Meta data */
+    ACCESS_GET_META,        /* arg1= vlc_meta_t **                  res=can fail */
+
+    /* */
+    ACCESS_GET_CONTENT_TYPE,/* arg1=char **ppsz_content_type                       res=can fail */
+
+    /* */
+    ACCESS_GET_SIGNAL,      /* arg1=double *pf_quality, arg2=double *pf_strength   res=can fail */
+
+    /* */
+    ACCESS_SET_PAUSE_STATE = 0x200, /* arg1= bool           can fail */
+
+    /* */
+    ACCESS_SET_TITLE,       /* arg1= int            can fail */
+    ACCESS_SET_SEEKPOINT,   /* arg1= int            can fail */
+
+    /* Special mode for access/demux communication
+     * XXX: avoid to use it unless you can't */
+    ACCESS_SET_PRIVATE_ID_STATE = 0x1000, /* arg1= int i_private_data, bool b_selected    res=can fail */
+    ACCESS_SET_PRIVATE_ID_CA,             /* arg1= int i_program_number, uint16_t i_vpid, uint16_t i_apid1, uint16_t i_apid2, uint16_t i_apid3, uint8_t i_length, uint8_t *p_data */
+    ACCESS_GET_PRIVATE_ID_STATE,          /* arg1=int i_private_data arg2=bool *          res=can fail */
+};
+
+struct access_t
+{
+    VLC_COMMON_MEMBERS
+
+    /* Module properties */
+    module_t    *p_module;
+
+    /* Access name (empty if non forced) */
+    char        *psz_access;
+    /* Access path/url/filename/.... */
+    char        *psz_path;
+
+    /* Access can fill this entry to force a demuxer
+     * XXX: fill it once you know for sure you will succeed
+     * (if you fail, this value won't be reseted */
+    char        *psz_demux;
+
+    /* pf_read/pf_block is used to read data.
+     * XXX A access should set one and only one of them */
+    ssize_t     (*pf_read) ( access_t *, uint8_t *, size_t );  /* Return -1 if no data yet, 0 if no more data, else real data read */
+    block_t    *(*pf_block)( access_t * );                  /* return a block of data in his 'natural' size, NULL if not yet data or eof */
+
+    /* Called for each seek.
+     * XXX can be null */
+    int         (*pf_seek) ( access_t *, uint64_t );         /* can be null if can't seek */
+
+    /* Used to retreive and configure the access
+     * XXX mandatory. look at access_query_e to know what query you *have to* support */
+    int         (*pf_control)( access_t *, int i_query, va_list args);
+
+    /* Access has to maintain them uptodate */
+    struct
+    {
+        unsigned int i_update;  /* Access sets them on change,
+                                   Input removes them once take into account*/
+
+        uint64_t     i_size;    /* Write only for access, read only for input */
+        uint64_t     i_pos;     /* idem */
+        bool         b_eof;     /* idem */
+
+        int          i_title;    /* idem, start from 0 (could be menu) */
+        int          i_seekpoint;/* idem, start from 0 */
+    } info;
+    access_sys_t *p_sys;
+
+    /* Weak link to parent input */
+    input_thread_t *p_input;
+};
+
+static inline int access_vaControl( access_t *p_access, int i_query, va_list args )
+{
+    if( !p_access ) return VLC_EGENERIC;
+    return p_access->pf_control( p_access, i_query, args );
+}
+
+static inline int access_Control( access_t *p_access, int i_query, ... )
+{
+    va_list args;
+    int     i_result;
+
+    va_start( args, i_query );
+    i_result = access_vaControl( p_access, i_query, args );
+    va_end( args );
+    return i_result;
+}
+
+static inline void access_InitFields( access_t *p_a )
+{
+    p_a->info.i_update = 0;
+    p_a->info.i_size = 0;
+    p_a->info.i_pos = 0;
+    p_a->info.b_eof = false;
+    p_a->info.i_title = 0;
+    p_a->info.i_seekpoint = 0;
+}
+
+/**
+ * This function will return the parent input of this access.
+ * It is retained. It can return NULL.
+ */
+VLC_EXPORT( input_thread_t *, access_GetParentInput, ( access_t *p_access ) );
+
+#define ACCESS_SET_CALLBACKS( read, block, control, seek )              \
+    p_access->pf_read = read;                                           \
+    p_access->pf_block = block;                                         \
+    p_access->pf_control = control;                                     \
+    p_access->pf_seek = seek;
+
+#define STANDARD_READ_ACCESS_INIT                                       \
+    access_InitFields( p_access );                                      \
+    ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );                  \
+    p_sys = p_access->p_sys = calloc( 1, sizeof( access_sys_t ));       \
+    if( !p_sys ) return VLC_ENOMEM;
+
+#define STANDARD_BLOCK_ACCESS_INIT                                      \
+    access_InitFields( p_access );                                      \
+    ACCESS_SET_CALLBACKS( NULL, Block, Control, Seek );                 \
+    p_sys = p_access->p_sys = calloc( 1, sizeof( access_sys_t ) );      \
+    if( !p_sys ) return VLC_ENOMEM;
+
+/**
+ * @}
+ */
+
+#endif

include/vlc/plugins/vlc_acl.h

+/*****************************************************************************
+ * vlc_acl.h: interface to the network Access Control List internal API
+ *****************************************************************************
+ * Copyright (C) 2005 Rémi Denis-Courmont
+ * Copyright (C) 2005 the VideoLAN team
+ * $Id: df50788b14adac9cd14690de38f38c4b87a3cba2 $
+ *
+ * Authors: Rémi Denis-Courmont <rem # videolan.org>
+ *
+ * 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
+ * (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.
+ *
+ * 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.
+ *****************************************************************************/
+
+#ifndef VLC_ACL_H
+# define VLC_ACL_H
+
+
+VLC_EXPORT( int, ACL_Check, ( vlc_acl_t *p_acl, const char *psz_ip ) );
+VLC_EXPORT( vlc_acl_t *, ACL_Create, ( vlc_object_t *p_this, bool b_allow ) LIBVLC_USED );
+#define ACL_Create(a, b) ACL_Create(VLC_OBJECT(a), b)
+VLC_EXPORT( vlc_acl_t *, ACL_Duplicate, ( vlc_object_t *p_this, const vlc_acl_t *p_acl ) LIBVLC_USED );
+#define ACL_Duplicate(a,b) ACL_Duplicate(VLC_OBJECT(a),b)
+VLC_EXPORT( void, ACL_Destroy, ( vlc_acl_t *p_acl ) );
+
+#define ACL_AddHost(a,b,c) ACL_AddNet(a,b,-1,c)
+VLC_EXPORT( int, ACL_AddNet, ( vlc_acl_t *p_acl, const char *psz_ip, int i_len, bool b_allow ) );
+VLC_EXPORT( int, ACL_LoadFile, ( vlc_acl_t *p_acl, const char *path ) );
+
+#endif

include/vlc/plugins/vlc_aout.h

+/*****************************************************************************
+ * audio_output.h : audio output interface
+ *****************************************************************************
+ * Copyright (C) 2002-2005 the VideoLAN team
+ * $Id: f3d55ecfab442d895d0558f2b6a7f66f657d4930 $
+ *
+ * Authors: Christophe Massiot <massiot@via.ecp.fr>
+ *
+ * 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
+ * (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.
+ *
+ * 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.
+ *****************************************************************************/
+
+#ifndef VLC_AOUT_H
+#define VLC_AOUT_H 1
+
+/**
+ * \file
+ * This file defines functions, structures and macros for audio output object
+ */
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+#include "vlc_es.h"
+
+#define AOUT_FMTS_IDENTICAL( p_first, p_second ) (                          \
+    ((p_first)->i_format == (p_second)->i_format)                           \
+      && AOUT_FMTS_SIMILAR(p_first, p_second) )
+
+/* Check if i_rate == i_rate and i_channels == i_channels */
+#define AOUT_FMTS_SIMILAR( p_first, p_second ) (                            \
+    ((p_first)->i_rate == (p_second)->i_rate)                               \
+      && ((p_first)->i_physical_channels == (p_second)->i_physical_channels)\
+      && ((p_first)->i_original_channels == (p_second)->i_original_channels) )
+
+#define VLC_CODEC_SPDIFL VLC_FOURCC('s','p','d','i')
+#define VLC_CODEC_SPDIFB VLC_FOURCC('s','p','d','b')
+
+#define AOUT_FMT_NON_LINEAR( p_format )                 \
+    ( ((p_format)->i_format == VLC_CODEC_SPDIFL)       \
+       || ((p_format)->i_format == VLC_CODEC_SPDIFB)   \
+       || ((p_format)->i_format == VLC_CODEC_A52)       \
+       || ((p_format)->i_format == VLC_CODEC_DTS) )
+
+/* This is heavily borrowed from libmad, by Robert Leslie <rob@mars.org> */
+/*
+ * Fixed-point format: 0xABBBBBBB
+ * A == whole part      (sign + 3 bits)
+ * B == fractional part (28 bits)
+ *
+ * Values are signed two's complement, so the effective range is:
+ * 0x80000000 to 0x7fffffff
+ *       -8.0 to +7.9999999962747097015380859375
+ *
+ * The smallest representable value is:
+ * 0x00000001 == 0.0000000037252902984619140625 (i.e. about 3.725e-9)
+ *
+ * 28 bits of fractional accuracy represent about
+ * 8.6 digits of decimal accuracy.
+ *
+ * Fixed-point numbers can be added or subtracted as normal
+ * integers, but multiplication requires shifting the 64-bit result
+ * from 56 fractional bits back to 28 (and rounding.)
+ */
+typedef int32_t vlc_fixed_t;
+#define FIXED32_FRACBITS 28
+#define FIXED32_MIN ((vlc_fixed_t) -0x80000000L)
+#define FIXED32_MAX ((vlc_fixed_t) +0x7fffffffL)
+#define FIXED32_ONE ((vlc_fixed_t) 0x10000000)
+
+/*
+ * Channels descriptions
+ */
+
+/* Values available for physical and original channels */
+#define AOUT_CHAN_CENTER            0x1
+#define AOUT_CHAN_LEFT              0x2
+#define AOUT_CHAN_RIGHT             0x4
+#define AOUT_CHAN_REARCENTER        0x10
+#define AOUT_CHAN_REARLEFT          0x20
+#define AOUT_CHAN_REARRIGHT         0x40
+#define AOUT_CHAN_MIDDLELEFT        0x100
+#define AOUT_CHAN_MIDDLERIGHT       0x200
+#define AOUT_CHAN_LFE               0x1000
+
+/* Values available for original channels only */
+#define AOUT_CHAN_DOLBYSTEREO       0x10000
+#define AOUT_CHAN_DUALMONO          0x20000
+#define AOUT_CHAN_REVERSESTEREO     0x40000
+
+#define AOUT_CHAN_PHYSMASK          0xFFFF
+#define AOUT_CHAN_MAX               9
+
+/* Values used for the audio-device and audio-channels object variables */
+#define AOUT_VAR_MONO               1
+#define AOUT_VAR_STEREO             2
+#define AOUT_VAR_2F2R               4
+#define AOUT_VAR_3F2R               5
+#define AOUT_VAR_5_1                6
+#define AOUT_VAR_6_1                7
+#define AOUT_VAR_7_1                8
+#define AOUT_VAR_SPDIF              10
+
+#define AOUT_VAR_CHAN_STEREO        1
+#define AOUT_VAR_CHAN_RSTEREO       2
+#define AOUT_VAR_CHAN_LEFT          3
+#define AOUT_VAR_CHAN_RIGHT         4
+#define AOUT_VAR_CHAN_DOLBYS        5
+
+/*****************************************************************************
+ * Main audio output structures
+ *****************************************************************************/
+
+#define aout_BufferFree( buffer ) block_Release( buffer )
+
+/* Size of a frame for S/PDIF output. */
+#define AOUT_SPDIF_SIZE 6144
+
+/* Number of samples in an A/52 frame. */
+#define A52_FRAME_NB 1536
+
+/* Max input rate factor (1/4 -> 4) */
+#define AOUT_MAX_INPUT_RATE (4)
+
+/** allocation of memory in the audio output */
+typedef struct aout_alloc_t
+{
+    bool                    b_alloc;
+    int                     i_bytes_per_sec;
+} aout_alloc_t;
+
+/** audio output buffer FIFO */
+struct aout_fifo_t
+{
+    aout_buffer_t *         p_first;
+    aout_buffer_t **        pp_last;
+    date_t                  end_date;
+};
+
+/* FIXME to remove once aout.h is cleaned a bit more */
+#include <vlc_aout_mixer.h>
+#include <vlc_block.h>
+
+/** audio output filter */
+typedef struct aout_filter_owner_sys_t aout_filter_owner_sys_t;
+typedef struct aout_filter_sys_t aout_filter_sys_t;
+struct aout_filter_t
+{
+    VLC_COMMON_MEMBERS
+
+    module_t *              p_module;
+    aout_filter_sys_t       *p_sys;
+
+    es_format_t             fmt_in;
+    es_format_t             fmt_out;
+
+    aout_alloc_t            output_alloc;
+
+    bool                    b_in_place;
+
+    void                    (*pf_do_work)( aout_instance_t *, aout_filter_t *,
+                                           aout_buffer_t *, aout_buffer_t * );
+
+    /* Private structure for the owner of the filter */
+    aout_filter_owner_sys_t *p_owner;
+};
+
+#define AOUT_RESAMPLING_NONE     0
+#define AOUT_RESAMPLING_UP       1
+#define AOUT_RESAMPLING_DOWN     2
+
+/** an output stream for the audio output */
+typedef struct aout_output_t
+{
+    audio_sample_format_t   output;
+    /* Indicates whether the audio output is currently starving, to avoid
+     * printing a 1,000 "output is starving" messages. */
+    bool              b_starving;
+
+    /* post-filters */
+    filter_t *              pp_filters[AOUT_MAX_FILTERS];
+    int                     i_nb_filters;
+
+    aout_fifo_t             fifo;
+
+    struct module_t *       p_module;
+    struct aout_sys_t *     p_sys;
+    void                 (* pf_play)( aout_instance_t * );
+    int                  (* pf_volume_get )( aout_instance_t *, audio_volume_t * );
+    int                  (* pf_volume_set )( aout_instance_t *, audio_volume_t );
+    int                     i_nb_samples;
+
+    /* Current volume for the output - it's just a placeholder, the plug-in
+     * may or may not use it. */
+    audio_volume_t          i_volume;
+
+    /* If b_error == 1, there is no audio output pipeline. */
+    bool              b_error;
+} aout_output_t;
+
+/** audio output thread descriptor */
+struct aout_instance_t
+{
+    VLC_COMMON_MEMBERS
+
+    /* Locks : please note that if you need several of these locks, it is
+     * mandatory (to avoid deadlocks) to take them in the following order :
+     * mixer_lock, p_input->lock, output_fifo_lock, input_fifos_lock.
+     * --Meuuh */
+    /* When input_fifos_lock is taken, none of the p_input->fifo structures
+     * can be read or modified by a third-party thread. */
+    vlc_mutex_t             input_fifos_lock;
+    /* When mixer_lock is taken, all decoder threads willing to mix a
+     * buffer must wait until it is released. The output pipeline cannot
+     * be modified. No input stream can be added or removed. */
+    vlc_mutex_t             mixer_lock;
+    /* When output_fifo_lock is taken, the p_aout->output.fifo structure
+     * cannot be read or written  by a third-party thread. */
+    vlc_mutex_t             output_fifo_lock;
+    /* volume_vars_lock is taken */
+    vlc_mutex_t             volume_vars_lock;
+
+    /* Input streams & pre-filters */
+    aout_input_t *          pp_inputs[AOUT_MAX_INPUTS];
+    int                     i_nb_inputs;
+
+    /* Mixer */
+    audio_sample_format_t   mixer_format;
+    aout_alloc_t            mixer_allocation;
+    float                   mixer_multiplier;
+    aout_mixer_t            *p_mixer;
+
+    /* Output plug-in */
+    aout_output_t           output;
+};
+
+/**
+ * It describes the audio channel order VLC expect.
+ */
+static const uint32_t pi_vlc_chan_order_wg4[] =
+{
+    AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT,
+    AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_MIDDLERIGHT,
+    AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, AOUT_CHAN_REARCENTER,
+    AOUT_CHAN_CENTER, AOUT_CHAN_LFE, 0
+};
+
+/*****************************************************************************
+ * Prototypes
+ *****************************************************************************/
+
+VLC_EXPORT( aout_buffer_t *, aout_OutputNextBuffer, ( aout_instance_t *, mtime_t, bool ) LIBVLC_USED );
+
+/**
+ * This function computes the reordering needed to go from pi_chan_order_in to
+ * pi_chan_order_out.
+ * If pi_chan_order_in or pi_chan_order_out is NULL, it will assume that vlc
+ * internal (WG4) order is requested.
+ */
+VLC_EXPORT( int, aout_CheckChannelReorder, ( const uint32_t *pi_chan_order_in, const uint32_t *pi_chan_order_out, uint32_t i_channel_mask, int i_channels, int *pi_chan_table ) );
+VLC_EXPORT( void, aout_ChannelReorder, ( uint8_t *, int, int, const int *, int ) );
+
+/**
+ * This fonction will compute the extraction parameter into pi_selection to go
+ * from i_channels with their type given by pi_order_src[] into the order
+ * describe by pi_order_dst.
+ * It will also set :
+ * - *pi_channels as the number of channels that will be extracted which is
+ * lower (in case of non understood channels type) or equal to i_channels.
+ * - the layout of the channels (*pi_layout).
+ *
+ * It will return true if channel extraction is really needed, in which case
+ * aout_ChannelExtract must be used
+ *
+ * XXX It must be used when the source may have channel type not understood
+ * by VLC. In this case the channel type pi_order_src[] must be set to 0.
+ * XXX It must also be used if multiple channels have the same type.
+ */
+VLC_EXPORT( bool, aout_CheckChannelExtraction, ( int *pi_selection, uint32_t *pi_layout, int *pi_channels, const uint32_t pi_order_dst[AOUT_CHAN_MAX], const uint32_t *pi_order_src, int i_channels ) );
+
+/**
+ * Do the actual channels extraction using the parameters created by
+ * aout_CheckChannelExtraction.
+ *
+ * XXX this function does not work in place (p_dst and p_src must not overlap).
+ * XXX Only 8, 16, 24, 32, 64 bits per sample are supported.
+ */
+VLC_EXPORT( void, aout_ChannelExtract, ( void *p_dst, int i_dst_channels, const void *p_src, int i_src_channels, int i_sample_count, const int *pi_selection, int i_bits_per_sample ) );
+
+/* */
+VLC_EXPORT( unsigned int, aout_FormatNbChannels, ( const audio_sample_format_t * p_format ) LIBVLC_USED );
+VLC_EXPORT( unsigned int, aout_BitsPerSample, ( vlc_fourcc_t i_format ) LIBVLC_USED );
+VLC_EXPORT( void, aout_FormatPrepare, ( audio_sample_format_t * p_format ) );
+VLC_EXPORT( void, aout_FormatPrint, ( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format ) );
+VLC_EXPORT( const char *, aout_FormatPrintChannels, ( const audio_sample_format_t * ) LIBVLC_USED );
+
+VLC_EXPORT( mtime_t, aout_FifoFirstDate, ( aout_instance_t *, aout_fifo_t * ) LIBVLC_USED );
+VLC_EXPORT( aout_buffer_t *, aout_FifoPop, ( aout_instance_t * p_aout, aout_fifo_t * p_fifo ) LIBVLC_USED );
+
+/* From intf.c : */
+VLC_EXPORT( void, aout_VolumeSoftInit, ( aout_instance_t * ) );
+VLC_EXPORT( void, aout_VolumeNoneInit, ( aout_instance_t * ) );
+VLC_EXPORT( int, aout_VolumeGet, ( vlc_object_t *, audio_volume_t * ) );
+#define aout_VolumeGet(a, b) aout_VolumeGet(VLC_OBJECT(a), b)
+VLC_EXPORT( int, aout_VolumeSet, ( vlc_object_t *, audio_volume_t ) );
+#define aout_VolumeSet(a, b) aout_VolumeSet(VLC_OBJECT(a), b)
+VLC_EXPORT( int, aout_VolumeUp, ( vlc_object_t *, int, audio_volume_t * ) );
+#define aout_VolumeUp(a, b, c) aout_VolumeUp(VLC_OBJECT(a), b, c)
+VLC_EXPORT( int, aout_VolumeDown, ( vlc_object_t *, int, audio_volume_t * ) );
+#define aout_VolumeDown(a, b, c) aout_VolumeDown(VLC_OBJECT(a), b, c)
+VLC_EXPORT( int, aout_ToggleMute, ( vlc_object_t *, audio_volume_t * ) );
+#define aout_ToggleMute(a, b) aout_ToggleMute(VLC_OBJECT(a), b)
+VLC_EXPORT( int, aout_SetMute, ( vlc_object_t *, audio_volume_t *, bool ) );
+VLC_EXPORT( bool, aout_IsMuted, ( vlc_object_t * ) );
+VLC_EXPORT( int, aout_FindAndRestart, ( vlc_object_t *, const char *, vlc_value_t, vlc_value_t, void * ) );
+VLC_EXPORT( int, aout_ChannelsRestart, ( vlc_object_t *, const char *, vlc_value_t, vlc_value_t, void * ) );
+
+VLC_EXPORT( void, aout_EnableFilter, (vlc_object_t *, const char *, bool ));
+#define aout_EnableFilter( o, n, b ) \
+        aout_EnableFilter( VLC_OBJECT(o), n, b )
+
+/* */
+VLC_EXPORT( vout_thread_t *, aout_filter_RequestVout, ( filter_t *, vout_thread_t *p_vout, video_format_t *p_fmt ) );
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif /* _VLC_AOUT_H */

include/vlc/plugins/vlc_aout_mixer.h

+/*****************************************************************************
+ * vlc_aout_mixer.h : audio output mixer interface
+ *****************************************************************************
+ * Copyright (C) 2002-2009 the VideoLAN team
+ * $Id: 5fd2ce0953dc8814fc6e7cfa921503fb60bb917c $
+ *
+ * Authors: Christophe Massiot <massiot@via.ecp.fr>
+ *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
+ *
+ * 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
+ * (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.
+ *
+ * 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.
+ *****************************************************************************/
+
+#ifndef VLC_AOUT_MIXER_H
+#define VLC_AOUT_MIXER_H 1
+
+/**
+ * \file
+ * This file defines functions, structures and macros for audio output mixer object
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//#include <vlc_aout.h>
+
+/* */
+typedef struct aout_mixer_sys_t aout_mixer_sys_t;
+typedef struct aout_mixer_t aout_mixer_t;
+
+typedef struct {
+    /* Is the input to be ignored while mixing */
+    bool        is_invalid;
+
+    /* */
+    aout_fifo_t fifo;
+
+    /* Pointer on the first byte of data to mix.
+     *
+     * It points in the first buffer of fifo
+     */
+    uint8_t     *begin;
+
+    /* Software multiplier */
+    float       multiplier;
+} aout_mixer_input_t;
+
+/** 
+ * audio output mixer
+ */
+struct aout_mixer_t {
+    VLC_COMMON_MEMBERS
+
+    /* Module */
+    module_t *module;
+
+    /* Mixer format.
+     *
+     * You cannot modify it.
+     */
+    audio_sample_format_t fmt;
+
+    /* Mixer output buffer allocation method.
+     *
+     * You can override it in the open function only.
+     */
+    aout_alloc_t          allocation;
+
+    /* Multiplier used to raise or lower the volume of the sound in
+     * software.
+     */
+    float                 multiplier;
+
+    /* Array of mixer inputs */
+    unsigned              input_count;
+    aout_mixer_input_t    **input;
+
+    /* Mix input into the given buffer (mandatory) */
+    void (*mix)(aout_mixer_t *, aout_buffer_t *);
+
+    /* Private place holder for the aout_mixer_t module (optional)
+     *
+     * A module is free to use it as it wishes.
+     */
+    aout_mixer_sys_t *sys;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/vlc/plugins/vlc_arrays.h

+/*****************************************************************************
+ * vlc_arrays.h : Arrays and data structures handling
+ *****************************************************************************
+ * Copyright (C) 1999-2004 the VideoLAN team
+ * $Id: 390c1b6d9df4d275619b9c62945d352e063b4229 $
+ *
+ * Authors: Samuel Hocevar <sam@zoy.org>
+ *          Clément Stenac <zorglub@videolan.org>
+ *
+ * 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
+ * (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.
+ *
+ * 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.
+ *****************************************************************************/
+
+#ifndef VLC_ARRAYS_H_
+#define VLC_ARRAYS_H_
+
+/**
+ * \file
+ * This file defines functions, structures and macros for handling arrays in vlc
+ */
+
+/* realloc() that never fails *if* downsizing */
+static inline void *realloc_down( void *ptr, size_t size )
+{
+    void *ret = realloc( ptr, size );
+    return ret ? ret : ptr;
+}
+
+/**
+ * Simple dynamic array handling. Array is realloced at each insert/removal
+ */
+#if defined( _MSC_VER ) && _MSC_VER < 1300 && !defined( UNDER_CE )
+#   define VLCCVP (void**) /* Work-around for broken compiler */
+#else
+#   define VLCCVP
+#endif
+#define INSERT_ELEM( p_ar, i_oldsize, i_pos, elem )                           \
+    do                                                                        \
+    {                                                                         \
+        if( !i_oldsize ) (p_ar) = NULL;                                       \
+        (p_ar) = VLCCVP realloc( p_ar, ((i_oldsize) + 1) * sizeof(*(p_ar)) ); \
+        if( !(p_ar) ) abort();                                                \
+        if( (i_oldsize) - (i_pos) )                                           \
+        {                                                                     \
+            memmove( (p_ar) + (i_pos) + 1, (p_ar) + (i_pos),                  \
+                     ((i_oldsize) - (i_pos)) * sizeof( *(p_ar) ) );           \
+        }                                                                     \
+        (p_ar)[i_pos] = elem;                                                 \
+        (i_oldsize)++;                                                        \
+    }                                                                         \
+    while( 0 )
+
+#define REMOVE_ELEM( p_ar, i_size, i_pos )                                    \
+    do                                                                        \
+    {                                                                         \
+        if( (i_size) - (i_pos) - 1 )                                          \
+        {                                                                     \
+            memmove( (p_ar) + (i_pos),                                        \
+                     (p_ar) + (i_pos) + 1,                                    \
+                     ((i_size) - (i_pos) - 1) * sizeof( *(p_ar) ) );          \
+        }                                                                     \
+        if( i_size > 1 )                                                      \
+            (p_ar) = realloc_down( p_ar, ((i_size) - 1) * sizeof( *(p_ar) ) );\
+        else                                                                  \
+        {                                                                     \
+            free( p_ar );                                                     \
+            (p_ar) = NULL;                                                    \
+        }                                                                     \
+        (i_size)--;                                                           \
+    }                                                                         \
+    while( 0 )
+
+#define TAB_INIT( count, tab )                  \
+  do {                                          \
+    (count) = 0;                                \
+    (tab) = NULL;                               \
+  } while(0)
+
+#define TAB_CLEAN( count, tab )                 \
+  do {                                          \
+    free( tab );                                \
+    (count)= 0;                                 \
+    (tab)= NULL;                                \
+  } while(0)
+
+#define TAB_APPEND_CAST( cast, count, tab, p )             \
+  do {                                          \
+    if( (count) > 0 )                           \
+        (tab) = cast realloc( tab, sizeof( void ** ) * ( (count) + 1 ) ); \
+    else                                        \
+        (tab) = cast malloc( sizeof( void ** ) );    \
+    if( !(tab) ) abort();                       \
+    (tab)[count] = (p);                         \
+    (count)++;                                  \
+  } while(0)
+
+#define TAB_APPEND( count, tab, p )             \
+    TAB_APPEND_CAST( , count, tab, p )
+#define TAB_APPEND_CPP( type, count, tab, p )   \
+    TAB_APPEND_CAST( (type**), count, tab, p )
+
+#define TAB_FIND( count, tab, p, index )        \
+  do {                                          \
+        int _i_;                                \
+        (index) = -1;                           \
+        for( _i_ = 0; _i_ < (count); _i_++ )    \
+        {                                       \
+            if( (tab)[_i_] == (p) )             \
+            {                                   \
+                (index) = _i_;                  \
+                break;                          \
+            }                                   \
+        }                                       \
+  } while(0)
+
+
+#define TAB_REMOVE( count, tab, p )             \
+  do {                                          \
+        int _i_index_;                          \
+        TAB_FIND( count, tab, p, _i_index_ );   \
+        if( _i_index_ >= 0 )                    \
+        {                                       \
+            if( (count) > 1 )                   \
+            {                                   \
+                memmove( ((void**)(tab) + _i_index_),    \
+                         ((void**)(tab) + _i_index_+1),  \
+                         ( (count) - _i_index_ - 1 ) * sizeof( void* ) );\
+            }                                   \
+            (count)--;                          \
+            if( (count) == 0 )                  \
+            {                                   \
+                free( tab );                    \
+                (tab) = NULL;                   \
+            }                                   \
+        }                                       \
+  } while(0)
+
+#define TAB_INSERT_CAST( cast, count, tab, p, index ) do { \
+    if( (count) > 0 )                           \
+        (tab) = cast realloc( tab, sizeof( void ** ) * ( (count) + 1 ) ); \
+    else                                        \
+        (tab) = cast malloc( sizeof( void ** ) );       \
+    if( !(tab) ) abort();                       \
+    if( (count) - (index) > 0 )                 \
+        memmove( (void**)(tab) + (index) + 1,   \
+                 (void**)(tab) + (index),       \
+                 ((count) - (index)) * sizeof(*(tab)) );\
+    (tab)[(index)] = (p);                       \
+    (count)++;                                  \
+} while(0)
+
+#define TAB_INSERT( count, tab, p, index )      \
+    TAB_INSERT_CAST( , count, tab, p, index )
+
+/**
+ * Binary search in a sorted array. The key must be comparable by < and >
+ * \param entries array of entries
+ * \param count number of entries
+ * \param elem key to check within an entry (like .id, or ->i_id)
+ * \param zetype type of the key
+ * \param key value of the key
+ * \param answer index of answer within the array. -1 if not found
+ */
+#define BSEARCH( entries, count, elem, zetype, key, answer ) \
+   do {  \
+    int low = 0, high = count - 1;   \
+    answer = -1; \
+    while( low <= high ) {\
+        int mid = (low + high ) / 2; /* Just don't care about 2^30 tables */ \
+        zetype mid_val = entries[mid] elem;\
+        if( mid_val < key ) \
+            low = mid + 1; \
+        else if ( mid_val > key ) \
+            high = mid -1;  \
+        else    \
+        {   \
+            answer = mid;  break;   \
+        }\
+    } \
+ } while(0)
+
+
+/************************************************************************
+ * Dynamic arrays with progressive allocation
+ ************************************************************************/
+
+/* Internal functions */
+#define _ARRAY_ALLOC(array, newsize) {                                      \
+    (array).i_alloc = newsize;                                              \
+    (array).p_elems = VLCCVP realloc( (array).p_elems, (array).i_alloc *    \
+                                    sizeof(*(array).p_elems) );             \
+    if( !(array).p_elems ) abort();                                         \
+}
+
+#define _ARRAY_GROW1(array) {                                               \
+    if( (array).i_alloc < 10 )                                              \
+        _ARRAY_ALLOC(array, 10 )                                            \
+    else if( (array).i_alloc == (array).i_size )                            \
+        _ARRAY_ALLOC(array, (int)(array.i_alloc * 1.5) )                    \
+}
+
+#define _ARRAY_GROW(array,additional) {                                     \
+     int i_first = (array).i_alloc;                                         \
+     while( (array).i_alloc - i_first < additional )                        \
+     {                                                                      \
+         if( (array).i_alloc < 10 )                                         \
+            _ARRAY_ALLOC(array, 10 )                                        \
+        else if( (array).i_alloc == (array).i_size )                        \
+            _ARRAY_ALLOC(array, (int)((array).i_alloc * 1.5) )              \
+        else break;                                                         \
+     }                                                                      \
+}
+
+#define _ARRAY_SHRINK(array) {                                              \
+    if( (array).i_size > 10 && (array).i_size < (int)((array).i_alloc / 1.5) ) {  \
+        _ARRAY_ALLOC(array, (array).i_size + 5);                            \
+    }                                                                       \
+}
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+/* API */
+#define DECL_ARRAY(type) struct {                                           \
+    int i_alloc;                                                            \
+    int i_size;                                                             \
+    type *p_elems;                                                          \
+}
+
+#define TYPEDEF_ARRAY(type, name) typedef DECL_ARRAY(type) name;
+
+#define ARRAY_INIT(array)                                                   \
+  do {                                                                      \
+    (array).i_alloc = 0;                                                    \
+    (array).i_size = 0;                                                     \
+    (array).p_elems = NULL;                                                 \
+  } while(0)
+
+#define ARRAY_RESET(array)                                                  \
+  do {                                                                      \
+    (array).i_alloc = 0;                                                    \
+    (array).i_size = 0;                                                     \
+    free( (array).p_elems ); (array).p_elems = NULL;                        \
+  } while(0)
+
+#define ARRAY_APPEND(array, elem)                                           \
+  do {                                                                      \
+    _ARRAY_GROW1(array);                                                    \
+    (array).p_elems[(array).i_size] = elem;                                 \
+    (array).i_size++;                                                       \
+  } while(0)
+
+#define ARRAY_INSERT(array,elem,pos)                                        \
+  do {                                                                      \
+    _ARRAY_GROW1(array);                                                    \
+    if( (array).i_size - pos ) {                                            \
+        memmove( (array).p_elems + pos + 1, (array).p_elems + pos,          \
+                 ((array).i_size-pos) * sizeof(*(array).p_elems) );         \
+    }                                                                       \
+    (array).p_elems[pos] = elem;                                            \
+    (array).i_size++;                                                       \
+  } while(0)
+
+#define ARRAY_REMOVE(array,pos)                                             \
+  do {                                                                      \
+    if( (array).i_size - (pos) - 1 )                                        \
+    {                                                                       \
+        memmove( (array).p_elems + pos, (array).p_elems + pos + 1,          \
+                 ( (array).i_size - pos - 1 ) *sizeof(*(array).p_elems) );  \
+    }                                                                       \
+    (array).i_size--;                                                       \
+    _ARRAY_SHRINK(array);                                                   \
+  } while(0)
+
+#define ARRAY_VAL(array, pos) array.p_elems[pos]
+
+#define ARRAY_BSEARCH(array, elem, zetype, key, answer) \
+    BSEARCH( (array).p_elems, (array).i_size, elem, zetype, key, answer)
+
+#define FOREACH_ARRAY( item, array ) { \
+    int fe_idx; \
+    for( fe_idx = 0 ; fe_idx < (array).i_size ; fe_idx++ ) \
+    { \
+        item = (array).p_elems[fe_idx];
+
+#define FOREACH_END() } }
+
+
+/************************************************************************
+ * Dynamic arrays with progressive allocation (Preferred API)
+ ************************************************************************/
+typedef struct vlc_array_t
+{
+    int i_count;
+    void ** pp_elems;
+} vlc_array_t;
+
+static inline void vlc_array_init( vlc_array_t * p_array )
+{
+    memset( p_array, 0, sizeof(vlc_array_t) );
+}
+
+static inline void vlc_array_clear( vlc_array_t * p_array )
+{
+    free( p_array->pp_elems );
+    memset( p_array, 0, sizeof(vlc_array_t) );
+}
+
+static inline vlc_array_t * vlc_array_new( void )
+{
+    vlc_array_t * ret = (vlc_array_t *)malloc( sizeof(vlc_array_t) );
+    if( ret ) vlc_array_init( ret );
+    return ret;
+}
+
+static inline void vlc_array_destroy( vlc_array_t * p_array )
+{
+    if( !p_array )
+        return;
+    vlc_array_clear( p_array );
+    free( p_array );
+}
+
+
+/* Read */
+static inline int
+vlc_array_count( vlc_array_t * p_array )
+{
+    return p_array->i_count;
+}
+
+static inline void *
+vlc_array_item_at_index( vlc_array_t * p_array, int i_index )
+{
+    return p_array->pp_elems[i_index];
+}
+
+static inline int
+vlc_array_index_of_item( vlc_array_t * p_array, void * item )
+{
+    int i;
+    for( i = 0; i < p_array->i_count; i++)
+    {
+        if( p_array->pp_elems[i] == item )
+            return i;
+    }
+    return -1;
+}
+
+/* Write */
+static inline void
+vlc_array_insert( vlc_array_t * p_array, void * p_elem, int i_index )
+{
+    TAB_INSERT_CAST( (void **), p_array->i_count, p_array->pp_elems, p_elem, i_index );
+}
+
+static inline void
+vlc_array_append( vlc_array_t * p_array, void * p_elem )
+{
+    vlc_array_insert( p_array, p_elem, p_array->i_count );
+}
+
+static inline void
+vlc_array_remove( vlc_array_t * p_array, int i_index )
+{
+    if( i_index >= 0 )
+    {
+        if( p_array->i_count > 1 )
+        {
+            memmove( p_array->pp_elems + i_index,
+                     p_array->pp_elems + i_index+1,
+                     ( p_array->i_count - i_index - 1 ) * sizeof( void* ) );
+        }
+        p_array->i_count--;
+        if( p_array->i_count == 0 )
+        {
+            free( p_array->pp_elems );
+            p_array->pp_elems = NULL;