to activate or cancel the filter
# option.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
SEARCHENGINE = NO
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a web server instead of a web client using Javascript. There
# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
# setting. When disabled, doxygen will generate a PHP script for searching and
# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
# and searching needs to be provided by external tools. See the section
# "External Indexing and Searching" for details.
# The default value is: NO.
# This tag requires that the tag SEARCHENGINE is set to YES.
SERVER_BASED_SEARCH = NO
# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
# script for searching. Instead the search results are written to an XML file
# which needs to be processed by an external indexer. Doxygen will invoke an
# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
# search results.
#
# Doxygen ships with an example indexer (doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: http://xapian.org/).
#
# See the section "External Indexing and Searching" for details.
# The default value is: NO.
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTERNAL_SEARCH = NO
# The SEARCHENGINE_URL should point to a search engine hosted by a web server
# which will return the search results when EXTERNAL_SEARCH is enabled.
#
# Doxygen ships with an example indexer (doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: http://xapian.org/). See the section "External Indexing and
# Searching" for details.
# This tag requires that the tag SEARCHENGINE is set to YES.
SEARCHENGINE_URL =
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
# search data is written to a file for indexing by an external tool. With the
# SEARCHDATA_FILE tag the name of this file can be specified.
# The default file is: searchdata.xml.
# This tag requires that the tag SEARCHENGINE is set to YES.
SEARCHDATA_FILE = searchdata.xml
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
# projects and redirect the results back to the right project.
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTERNAL_SEARCH_ID =
# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
# projects other than the one defined by this configuration file, but that are
# all added to the same external search index. Each project needs to have a
# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
# to a relative location where the documentation can be found. The format is:
# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# Configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
# The default value is: YES.
GENERATE_LATEX = YES
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: latex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked.
#
# Note that when enabling USE_PDFLATEX this option is only used for generating
# bitmaps for formulas in the HTML output, but not in the Makefile that is
# written to the output directory.
# The default file is: latex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
# index for LaTeX.
# The default file is: makeindex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
MAKEINDEX_CMD_NAME = makeindex
# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
# documents. This may be useful for small projects and may help to save some
# trees in general.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used by the
# printer.
# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
# 14 inches) and executive (7.25 x 10.5 inches).
# The default value is: a4.
# This tag requires that the tag GENERATE_LATEX is set to YES.
PAPER_TYPE = a4wide
# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
# that should be included in the LaTeX output. The package can be specified just
# by its name or with the correct syntax as to be used with the LaTeX
# \usepackage command. To get the times font for instance you can specify :
# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
# To use the option intlimits with the amsmath package you can specify:
# EXTRA_PACKAGES=[intlimits]{amsmath}
# If left blank no extra packages will be included.
# This tag requires that the tag GENERATE_LATEX is set to YES.
EXTRA_PACKAGES =
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
# generated LaTeX document. The header should contain everything until the first
# chapter. If it is left blank doxygen will generate a standard header. See
# section "Doxygen usage" for information on how to let doxygen write the
# default header to a separate file.
#
# Note: Only use a user-defined header if you know what you are doing! The
# following commands have a special meaning inside the header: $title,
# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
# string, for the replacement values of the other commands the user is referred
# to HTML_HEADER.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_HEADER =
# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
# generated LaTeX document. The footer should contain everything after the last
# chapter. If it is left blank doxygen will generate a standard footer. See
# LATEX_HEADER for more information on how to generate a default footer and what
# special commands can be used inside the footer.
#
# Note: Only use a user-defined footer if you know what you are doing!
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_FOOTER =
# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
# LaTeX style sheets that are included after the standard style sheets created
# by doxygen. Using this option one can overrule certain style aspects. Doxygen
# will copy the style sheet files to the output directory.
# Note: The order of the extra style sheet files is of importance (e.g. the last
# style sheet in the list overrules the setting of the previous ones in the
# list).
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_EXTRA_STYLESHEET =
# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the LATEX_OUTPUT output
# directory. Note that the files will be copied as-is; there are no commands or
# markers available.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_EXTRA_FILES =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
# contain links (just like the HTML output) instead of page references. This
# makes the output suitable for online browsing using a PDF viewer.
# The default value is: YES.
# This tag requires that the tag GENERATE_LATEX is set to YES.
PDF_HYPERLINKS = NO
# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
# the PDF file directly from the LaTeX files. Set this option to YES, to get a
# higher quality PDF documentation.
# The default value is: YES.
# This tag requires that the tag GENERATE_LATEX is set to YES.
USE_PDFLATEX = NO
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
# command to the generated LaTeX files. This will instruct LaTeX to keep running
# if errors occur, instead of asking the user for help. This option is also used
# when generating formulas in HTML.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_BATCHMODE = NO
# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
# index chapters (such as File Index, Compound Index, etc.) in the output.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_HIDE_INDICES = NO
# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
# code with syntax highlighting in the LaTeX output.
#
# Note that which sources are shown also depends on other settings such as
# SOURCE_BROWSER.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_SOURCE_CODE = NO
# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. See
# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
# The default value is: plain.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_BIB_STYLE = plain
# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
# page will contain the date and time when the page was generated. Setting this
# to NO can help when comparing the output of multiple runs.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_TIMESTAMP = NO
#---------------------------------------------------------------------------
# Configuration options related to the RTF output
#---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
# RTF output is optimized for Word 97 and may not look too pretty with other RTF
# readers/editors.
# The default value is: NO.
GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: rtf.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
# documents. This may be useful for small projects and may help to save some
# trees in general.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
# contain hyperlink fields. The RTF file will contain links (just like the HTML
# output) instead of page references. This makes the output suitable for online
# browsing using Word or some other Word compatible readers that support those
# fields.
#
# Note: WordPad (write) and others do not support links.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_HYPERLINKS = NO
# Load stylesheet definitions from file. Syntax is similar to doxygen's config
# file, i.e. a series of assignments. You only have to provide replacements,
# missing definitions are set to their default value.
#
# See also section "Doxygen usage" for information on how to generate the
# default style sheet that doxygen normally uses.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an RTF document. Syntax is
# similar to doxygen's config file. A template extensions file can be generated
# using doxygen -e rtf extensionFile.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_EXTENSIONS_FILE =
# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
# with syntax highlighting in the RTF output.
#
# Note that which sources are shown also depends on other settings such as
# SOURCE_BROWSER.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_SOURCE_CODE = NO
#---------------------------------------------------------------------------
# Configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
# classes and files.
# The default value is: NO.
GENERATE_MAN = YES
# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it. A directory man3 will be created inside the directory specified by
# MAN_OUTPUT.
# The default directory is: man.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to the generated
# man pages. In case the manual section does not start with a number, the number
# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
# optional.
# The default value is: .3.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_EXTENSION = .3
# The MAN_SUBDIR tag determines the name of the directory created within
# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
# MAN_EXTENSION with the initial . removed.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_SUBDIR =
# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
# will generate one additional man file for each entity documented in the real
# man page(s). These additional files only source the real man page, but without
# them the man command would be unable to find the correct page.
# The default value is: NO.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_LINKS = NO
#---------------------------------------------------------------------------
# Configuration options related to the XML output
#---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
# captures the structure of the code including all documentation.
# The default value is: NO.
GENERATE_XML = YES
# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: xml.
# This tag requires that the tag GENERATE_XML is set to YES.
XML_OUTPUT = xml
# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
# listings (including syntax highlighting and cross-referencing information) to
# the XML output. Note that enabling this will significantly increase the size
# of the XML output.
# The default value is: YES.
# This tag requires that the tag GENERATE_XML is set to YES.
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
# that can be used to generate PDF.
# The default value is: NO.
GENERATE_DOCBOOK = NO
# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
# front of it.
# The default directory is: docbook.
# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
DOCBOOK_OUTPUT = docbook
# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
# program listings (including syntax highlighting and cross-referencing
# information) to the DOCBOOK output. Note that enabling this will significantly
# increase the size of the DOCBOOK output.
# The default value is: NO.
# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
DOCBOOK_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# Configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
# AutoGen Definitions (see http://autogen.sf.net) file that captures the
# structure of the code including all documentation. Note that this feature is
# still experimental and incomplete at the moment.
# The default value is: NO.
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# Configuration options related to the Perl module output
#---------------------------------------------------------------------------
# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
# file that captures the structure of the code including all documentation.
#
# Note that this feature is still experimental and incomplete at the moment.
# The default value is: NO.
GENERATE_PERLMOD = NO
# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
# output from the Perl module output.
# The default value is: NO.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_LATEX = NO
# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
# formatted so it can be parsed by a human reader. This is useful if you want to
# understand what is going on. On the other hand, if this tag is set to NO, the
# size of the Perl module output will be much smaller and Perl will parse it
# just the same.
# The default value is: YES.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_PRETTY = YES
# The names of the make variables in the generated doxyrules.make file are
# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
# so different doxyrules.make files included by the same Makefile don't
# overwrite each other's variables.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
# C-preprocessor directives found in the sources and include files.
# The default value is: YES.
ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
# in the source code. If set to NO, only conditional compilation will be
# performed. Macro expansion can be done in a controlled way by setting
# EXPAND_ONLY_PREDEF to YES.
# The default value is: NO.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
MACRO_EXPANSION = YES
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
# the macro expansion is limited to the macros specified with the PREDEFINED and
# EXPAND_AS_DEFINED tags.
# The default value is: NO.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES, the include files in the
# INCLUDE_PATH will be searched if a #include is found.
# The default value is: YES.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
SEARCH_INCLUDES = YES
# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by the
# preprocessor.
# This tag requires that the tag SEARCH_INCLUDES is set to YES.
INCLUDE_PATH = . ../include
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will be
# used.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
INCLUDE_FILE_PATTERNS = *.h
# The PREDEFINED tag can be used to specify one or more macro names that are
# defined before the preprocessor is started (similar to the -D option of e.g.
# gcc). The argument of the tag is a list of macros of the form: name or
# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
# is assumed. To prevent a macro definition from being undefined via #undef or
# recursively expanded use the := operator instead of the = operator.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
PREDEFINED = DOXYGEN \
MS2_PUBLIC= \
LINPHONE_PUBLIC=
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
# tag can be used to specify a list of macro names that should be expanded. The
# macro definition that is found in the sources will be used. Use the PREDEFINED
# tag if you want to use a different macro definition that overrules the
# definition found in the source code.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
# remove all references to function-like macros that are alone on a line, have
# an all uppercase name, and do not end with a semicolon. Such function macros
# are typically used for boiler-plate code, and will confuse the parser if not
# removed.
# The default value is: YES.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration options related to external references
#---------------------------------------------------------------------------
# The TAGFILES tag can be used to specify one or more tag files. For each tag
# file the location of the external documentation should be added. The format of
# a tag file without this location is as follows:
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where loc1 and loc2 can be relative or absolute paths or URLs. See the
# section "Linking to external documentation" for more information about the use
# of tag files.
# Note: Each tag file must have a unique name (where the name does NOT include
# the path). If a tag file is not located in the directory in which doxygen is
# run, you must also specify the path to the tagfile here.
TAGFILES =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
# tag file that is based on the input files it reads. See section "Linking to
# external documentation" for more information about the usage of tag files.
GENERATE_TAGFILE =
# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
# the class index. If set to NO, only the inherited external classes will be
# listed.
# The default value is: NO.
ALLEXTERNALS = NO
# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will be
# listed.
# The default value is: YES.
EXTERNAL_GROUPS = YES
# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
# the related pages index. If set to NO, only the current project's pages will
# be listed.
# The default value is: YES.
EXTERNAL_PAGES = YES
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of 'which perl').
# The default file (with absolute path) is: /usr/bin/perl.
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
# NO turns the diagrams off. Note that this option also works with HAVE_DOT
# disabled, but it is recommended to install and use dot, since it yields more
# powerful graphs.
# The default value is: YES.
CLASS_DIAGRAMS = YES
# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see:
# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.
MSCGEN_PATH =
# You can include diagrams made with dia in doxygen documentation. Doxygen will
# then run dia to produce the diagram and insert it in the documentation. The
# DIA_PATH tag allows you to specify the directory where the dia binary resides.
# If left empty dia is assumed to be found in the default search path.
DIA_PATH =
# If set to YES the inheritance and collaboration graphs will hide inheritance
# and usage relations if the target is undocumented or is not a class.
# The default value is: YES.
HIDE_UNDOC_RELATIONS = YES
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz (see:
# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
# Bell Labs. The other options in this section have no effect if this option is
# set to NO
# The default value is: NO.
HAVE_DOT = NO
# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
# to run in parallel. When set to 0 doxygen will base this on the number of
# processors available in the system. You can set it explicitly to a value
# larger than 0 to get control over the balance between CPU load and processing
# speed.
# Minimum value: 0, maximum value: 32, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_NUM_THREADS = 0
# When you want a differently looking font in the dot files that doxygen
# generates you can specify the font name using DOT_FONTNAME. You need to make
# sure dot is able to find the font, which can be done by putting it in a
# standard location or by setting the DOTFONTPATH environment variable or by
# setting DOT_FONTPATH to the directory containing the font.
# The default value is: Helvetica.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTNAME = Helvetica
# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
# dot graphs.
# Minimum value: 4, maximum value: 24, default value: 10.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTSIZE = 10
# By default doxygen will tell dot to use the default font as specified with
# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
# the path where dot can find it using this tag.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTPATH =
# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
# each documented class showing the direct and indirect inheritance relations.
# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
# graph for each documented class showing the direct and indirect implementation
# dependencies (inheritance, containment, and class references variables) of the
# class with other documented classes.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
# groups, showing the direct groups dependencies.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GROUP_GRAPHS = YES
# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
UML_LOOK = NO
# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
# class node. If there are many fields or methods and many nodes the graph may
# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
# number of items for each type to make the size more manageable. Set this to 0
# for no limit. Note that the threshold may be exceeded by 50% before the limit
# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
# but if the number exceeds 15, the total amount of fields shown is limited to
# 10.
# Minimum value: 0, maximum value: 100, default value: 10.
# This tag requires that the tag HAVE_DOT is set to YES.
UML_LIMIT_NUM_FIELDS = 10
# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
# collaboration graphs will show the relations between templates and their
# instances.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
TEMPLATE_RELATIONS = YES
# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
# YES then doxygen will generate a graph for each documented file showing the
# direct and indirect include dependencies of the file with other documented
# files.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
INCLUDE_GRAPH = YES
# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
# set to YES then doxygen will generate a graph for each documented file showing
# the direct and indirect include dependencies of the file with other documented
# files.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
INCLUDED_BY_GRAPH = YES
# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
# dependency graph for every global function or class method.
#
# Note that enabling this option will significantly increase the time of a run.
# So in most cases it will be better to enable call graphs for selected
# functions only using the \callgraph command. Disabling a call graph can be
# accomplished by means of the command \hidecallgraph.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
CALL_GRAPH = NO
# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
# dependency graph for every global function or class method.
#
# Note that enabling this option will significantly increase the time of a run.
# So in most cases it will be better to enable caller graphs for selected
# functions only using the \callergraph command. Disabling a caller graph can be
# accomplished by means of the command \hidecallergraph.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
# hierarchy of all classes instead of a textual one.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GRAPHICAL_HIERARCHY = YES
# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
# dependencies a directory has on other directories in a graphical way. The
# dependency relations are determined by the #include relations between the
# files in the directories.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. For an explanation of the image formats see the section
# output formats in the documentation of the dot tool (Graphviz (see:
# http://www.graphviz.org/)).
# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
# to make the SVG files visible in IE 9+ (other browsers do not have this
# requirement).
# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
# png:gdiplus:gdiplus.
# The default value is: png.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_IMAGE_FORMAT = png
# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
#
# Note that this requires a modern browser other than Internet Explorer. Tested
# and working are Firefox, Chrome, Safari, and Opera.
# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
# the SVG files visible. Older versions of IE do not have SVG support.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
INTERACTIVE_SVG = NO
# The DOT_PATH tag can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_PATH =
# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the \dotfile
# command).
# This tag requires that the tag HAVE_DOT is set to YES.
DOTFILE_DIRS =
# The MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the \mscfile
# command).
MSCFILE_DIRS =
# The DIAFILE_DIRS tag can be used to specify one or more directories that
# contain dia files that are included in the documentation (see the \diafile
# command).
DIAFILE_DIRS =
# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
# path where java can find the plantuml.jar file. If left blank, it is assumed
# PlantUML is not used or called during a preprocessing step. Doxygen will
# generate a warning when it encounters a \startuml command in this case and
# will not generate output for the diagram.
PLANTUML_JAR_PATH =
# When using plantuml, the specified paths are searched for files specified by
# the !include statement in a plantuml block.
PLANTUML_INCLUDE_PATH =
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
# that will be shown in the graph. If the number of nodes in a graph becomes
# larger than this value, doxygen will truncate the graph, which is visualized
# by representing a node as a red box. Note that doxygen if the number of direct
# children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
# Minimum value: 0, maximum value: 10000, default value: 50.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_GRAPH_MAX_NODES = 50
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
# generated by dot. A depth value of 3 means that only nodes reachable from the
# root by following a path via at most 3 edges will be shown. Nodes that lay
# further from the root node will be omitted. Note that setting this option to 1
# or 2 may greatly reduce the computation time needed for large code bases. Also
# note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
# Minimum value: 0, maximum value: 1000, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.
MAX_DOT_GRAPH_DEPTH = 1000
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not seem
# to support this out of the box.
#
# Warning: Depending on the platform used, enabling this option may lead to
# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
# read).
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_TRANSPARENT = NO
# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10) support
# this, this feature is disabled by default.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
# explaining the meaning of the various boxes and arrows in the dot generated
# graphs.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GENERATE_LEGEND = YES
# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
# files that are used to generate the various graphs.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_CLEANUP = YES
mediastreamer2-5.2.0+dfsg/help/Makefile.am 0000664 0000000 0000000 00000001426 14346134245 0020336 0 ustar 00root root 0000000 0000000
DOXFILES = doxygen.dox filters.dox ht0-buildagraph.dox
EXTRA_DIST = Doxyfile.in $(DOXFILES)
SOURCES=$(DOXFILES) $(top_srcdir)/include/mediastreamer2/*.h $(top_srcdir)/src/*.h
#html doc
if HAVE_DOXYGEN
# docdir & pkgdocdir are not always defined by automake
pkgdocdir=$(docdir)/$(PACKAGE)-$(VERSION)
doc_htmldir=$(pkgdocdir)/html
doc_html_DATA = $(top_builddir)/help/doc/html/html.tar
$(doc_html_DATA): $(top_builddir)/help/doc/html/index.html
cd $(top_builddir)/help/doc/html/ && tar cf html.tar *
$(top_builddir)/help/doc/html/index.html: $(SOURCES) Doxyfile Makefile.am
rm -rf doc
$(DOXYGEN) Doxyfile
install-data-hook:
cd $(DESTDIR)$(doc_htmldir) && tar xf html.tar && rm -f html.tar
uninstall-hook:
cd $(DESTDIR)$(doc_htmldir) && rm -f *
endif
clean-local:
rm -rf doc
mediastreamer2-5.2.0+dfsg/help/doxygen.dox 0000664 0000000 0000000 00000012221 14346134245 0020466 0 ustar 00root root 0000000 0000000 /**
* @mainpage
*
* Project Website: http://www.mediastreamer2.com
*/
/**
* @defgroup mediastreamer2_intro Introduction to mediastreamer2 concepts
*
* @section what_is_it What is mediastreamer2?
*
* mediastreamer2 is a powerful engine to make audio and video streams.
* mediastreamer2 is GPL (COPYING). Please understand the licencing details
* before using it!
*
* Commercial support and licensing is provided by Belledonne Communications
* http://www.belledonne-communications.com
*
* @see http://www.linphone.org/eng/documentation/dev/mediastreamer2.html
*
* @section definitions Some definitions
*
* - Filter:
* A filter is a mediastreamer2 component that process data. A filter
* have 0 or several INPUT pins and 0 or several OUTPUT pins.
* Here is a list of possible use of filters:
* - capture audio or video data.
* - play audio or display video data.
* - send or receive RTP data.
* - encode or decode audio or video data.
* - transform (resize video, resample audio...) data.
* - duplicate any kind of data.
* - mix audio/video data.
* - Graph:
* A graph is a manager of filters connected together. It will transfer
* data from OUTPUT pins to INPUT pins and will be responsible for
* running filters.
*
* @section how_do_i_use_mediastreamer2 How do I use mediastreamer2?
*
* Mediastreamer2 can be used for a lot of different purpose. The primary
* use is to manage RTP audio and video session. You will need to use
* the API to build filters, link them together in a graph. Then the
* ticker API will help you to start and stop the graph.
*
* Basic graph example:
*
* @dot
* digraph example {
* rankdir=LR
* node [shape=record, fontname=Helvetica, fontsize=10];
* capt [ label="AUDIO CAPTURE FILTER"];
* enc [ label="ENCODE FILTER"];
* rtp [ label="RTP FILTER"];
* capt -> enc;
* enc -> rtp;
* }
* @enddot
*
*
* The above graph is composed of three filters. The first one has no input:
* it captures audio data directly from the drivers and provide it to the
* OUTPUT pin. This data is sent to the INPUT pin of the encoder which of
* course encodes the data and sends it to its OUTPUT pin. This pin is connected
* to the INPUT pin of a filter capable of building and sending RTP packets.
*
* The modular design helps you to encode in many different formats just by
* replacing the "ENCODE FILTER" with another one. mediastreamer2 contains
* internal support for g711u, g711a, speex and gsm. Other encoding formats
* can be added by implementing new filters as plugins which can then be dynamically
* loaded.
*
* @sa filters
*/
/**
* @defgroup mediastreamer2_api Mediastreamer2's base APIs
* @brief Base APIs of mediastreamer2
*
* Mediastreamer2 expose a low level API to directly control filters, chain and have them running.
*/
/**
* @defgroup mediastreamer2_init Init API - Starting mediastreamer2 library
* @ingroup mediastreamer2_api
* @brief Starting mediastreamer2 library
*/
/**
* @defgroup mediastreamer2_soundcard Sound Card API - Manage audio capture/play filters
* @ingroup mediastreamer2_api
* @brief Sound Card API to manage audio capture/play filters
*/
/**
* @defgroup mediastreamer2_filter Filter API - Manage mediastreamer2 filters
* @ingroup mediastreamer2_api
* @brief Filter API to manage mediastreamer2 filters
*
* This section documents the API needed to create, link,
* unlink, find and destroy filters.
*
* It also provides definitions if you wish to implement
* your own filters.
*/
/**
* @defgroup mediastreamer2_ticker Ticker API - Manage mediastreamer2 graphs
* @ingroup mediastreamer2_api
* @brief Ticker API to manage mediastreamer2 graphs
*
* Describes the ticker API. The ticker is the thread responsible for scheduling audio & video processing for
* one or several filter graphs.
*/
/**
* @defgroup mediastreamer2_high_api Mediastreamer2's high level APIs
* @brief High level APIs of mediastreamer2
*
* The high level apis are designed to provide an easy way to create audio or video processing graphs for
* VoIP.
*/
/**
* @defgroup audio_stream_api Audio streaming API - Create and run VoIP audio streams.
* @ingroup mediastreamer2_high_api
* @brief Audio streaming API - Easily run audio streams from soundcard or wav files to RTP.
*/
/**
* @defgroup mediastreamer2_audio_conference Audio conferencing API - Easily create conferences.
* @ingroup mediastreamer2_high_api
* @brief Audio conferencing API - Easily create conferences.
*/
/**
* @defgroup video_stream_api Video streaming API - Create and run video streams.
* @ingroup mediastreamer2_high_api
* @brief Video streaming API - Easily run video streams from camera capture or static picture files to RTP.
*/
/**
* @defgroup ring_api Ring playing API - Play ring files.
* @ingroup mediastreamer2_high_api
* @brief Ring playing API - Easily play a local ring from a wav file.
*/
/**
* @page mediastreamer2_readme README
* @verbinclude README
*/
/**
* @page mediastreamer2_install INSTALL
* @verbinclude INSTALL
*/
/**
* @page mediastreamer2_license COPYING
* @verbinclude COPYING
*/
/**
* @page mediastreamer2_changelog ChangeLog
* @verbinclude ChangeLog
*/
mediastreamer2-5.2.0+dfsg/help/filters.dox 0000664 0000000 0000000 00000020044 14346134245 0020463 0 ustar 00root root 0000000 0000000 /**
* @defgroup filters Filters documentation
* @ingroup mediastreamer2
*
* Each filter provides its own functionalities. The filters can be organized as audio, video and other more general filters.
* The majority of the available filters are built in the mediastreamer2 library. But additional filters can be provided as plugins that will
* be loaded dynamically by calling the ms_load_plugins() function.
*
* @section list_of_filters List of built-in filters
*
* - Audio filters:
* - Audio capture and audio playing filters:
* - Alsa (Linux): src/audiofilters/alsa.c
* - Android native sound (libmedia): src/android/androidsound.cpp
* - Android sound (deprecated): src/android/androidsound_depr.cpp
* - Audio Queue Service (Mac OS X): src/audiofilters/aqsnd.m
* - Audio Unit Service (Mac OS X): src/audiofilters/msiounit.m
* - Arts (Linux): src/audiofilters/arts.c
* - DirectSound (Windows): src/audiofilters/winsndds.cpp
* - File player (raw/wav/pcap files) (Linux): src/audiofilters/msfileplayer.c
* - File player (raw/wav files) (Windows): src/audiofilters/msfileplayer_win.c
* - File recorder (wav files) (Linux): src/audiofilters/msfilerec.c
* - File recorder (wav files) (Windows): src/audiofilters/msfilerec_win.c
* - Mac Audio Unit (Mac OS X): src/audiofilters/macsnd.c
* - MME (Windows): src/audiofilters/winsnd2.c
* - OSS (Linux): src/audiofilters/oss.c
* - PortAudio (Mac OS X): src/audiofilters/pasnd.c
* - PulseAudio (Linux): src/audiofilters/pulseaudio.c
* - Windows Sound (Windows): src/audiofilters/winsnd.c, src/audiofilters/winsnd3.c
* - Audio encoder/decoder filters:
* - G.711 alaw: src/audiofilters/alaw.c
* - G.711 µlaw: src/audiofilters/ulaw.c
* - G.722: src/audiofilters/msg722.c
* - G.726: src/audiofilters/g726.c
* - GSM: src/audiofilters/gsm.c
* - Linear PCM: src/audiofilters/l16.c
* - Speex: src/audiofilters/msspeex.c
* - Audio processing filters:
* - Channels adaptation (mono->stereo or stereo->mono): src/audiofilters/chanadapt.c
* - Conferencing: src/audiofilters/msconf.c
* - DTMF generation: src/audiofilters/dtmfgen.c
* - Echo cancellation (speex): src/audiofilters/speexec.c
* - Equalizer: src/audiofilters/equalizer.c
* - Mixer: src/audiofilters/audiomixer.c
* - Packet Loss Concealment (PLC): src/audiofilters/genericplc.c
* - Resampler: src/audiofilters/msresample.c
* - Tone detector: src/audiofilters/tonedetector.c
* - Volume control and measure: src/audiofilters/msvolume.c
* - Video filters:
* - Video capture and video display filters:
* - Android capture: src/android/androidvideo.cpp
* - Android display: src/android/android-display.c
* - AV Foundation capture (iOS): src/videofilters/ioscapture.m
* - AV Foundation display (iOS): src/videofilters/iosdisplay.mm
* - DirectShow capture (Windows): src/videofilters/msdscap-mingw.cc
* - DrawDib display (Windows): src/videofilters/drawdib-display.c
* - External display - Send video to the upper layer: src/videofilters/extdisplay.c
* - GLX display (Linux): src/videofilters/glxvideo.c
* - Mire - Synthetic moving picture: src/videofilters/mire.c
* - OpenGL display (Mac OS X): src/videofilters/msosxdisplay.m
* - OpenGL ES2 display (Android): src/videofilters/android-opengl-display.c
* - Quicktime capture (Mac OS X): src/videofilters/qtcapture.m
* - SDL display: src/videofilters/videoout.c
* - Static image output: src/videofilters/nowebcam.c
* - Video For Linux (V4L) capture (Linux): src/videofilters/msv4l.c
* - Video For Linux 2 (V4L2) capture (Linux): src/videofilters/msv4l2.c
* - Video4windows (DirectShow) capture (Windows): src/videofilters/winvideods.c
* - Video4windows (DirectShow) capture (Windows CE): src/videofilters/wincevideods.c
* - Video For Windows (vfw) capture (Windows): src/videofilters/winvideo.c, src/videofilters/winvideo2.c
* - XV display (Linux): src/videofilters/x11video.c
* - Video encoder/decoder filters:
* - H.263, H.263-1998, MP4V-ES, JPEG, MJPEG, Snow: src/videofilters/videodec.c, src/videofilters/videoenc.c
* - H.264 (decoder only): src/videofilters/h264dec.c
* - Theora: src/videofilters/theora.c
* - VP8: src/videofilters/vp8.c
* - Video processing filters:
* - JPEG snapshot: src/videofilters/jpegwriter.c
* - Pixel format converter: src/videofilters/pixconv.c
* - Resizer: src/videofilters/sizeconv.c
* - Other filters:
* - Inter-ticker communication: src/otherfilters/itc.c
* - Join - Send several inputs to one output: src/otherfilters/join.c
* - RTP sending/receiving: src/otherfilters/msrtp.c
* - Tee - Send one input to several outputs: src/otherfilters/tee.c
* - Void - Trash input: src/otherfilters/void.c
*
* @section list_of_plugin_filters List of existing plugin filters
*
* - Audio filters:
* - AMR-NB encoder/decoder
* - G.729 encoder/decoder
* - iLBC encoder/decoder
* - SILK encoder/decoder
* - Video filters:
* - H.264 software encoder
* - H.264 hardware accelerated V4L2 encoder/decoder
*/
/**
* @defgroup audiofilters Audio filters
* @ingroup filters
*/
/**
* @defgroup videofilters Video filters
* @ingroup filters
*/
/**
* @defgroup otherfilters Other general filters
* @ingroup filters
*/
/**
* @defgroup mssilk - SILK (Skype codec) plugin
* @ingroup audiofilters
* @brief SILK Speech Codec (draft-vos-silk-02) plugins filters to encode and decode audio.
*
*MSSILKEnc and MSSILKDec are 2 Mediastremer2's filters available to encode/decode speech using SILK sdk from Skype.
*This integration leverage on source code from: http://developer.skype.com/silk. Note that usage of this plugin is subject to license from Skype.
*
* Supported SILK features
*
SILK is a multi rate, multi sampling frequency codec with variable packetization time. SILK allows control of these parameters using standard Mediastreamer2 functions.
*
* init
*
mssilk is automatically loaded by Medistreamer2 in case libmssilk.so is present in the Mediastremer2 plugin directory. Alternatively it is possible to load it by calling the function
\code void libmssilk_init() \endcode Very usefull for Android or IOS.
*
* MSSILKEnc
MSSILKEnc is a filter from category #MS_FILTER_ENCODER. It has its enc_fmt value set to "SILK".The following key control functions are implemented:
*
* - #MS_FILTER_SET_SAMPLE_RATE Set both the output and input sampling rate. This value is internally mapped to both maximum codec sampling rate and API sampling rate. Supported value are 8000, 12000, 16000 and 24000. This value can be changed at any time.
*
- #MS_FILTER_SET_BITRATE Set the target network output bitrate for this filter. As this value takes into account RTP/UDP/IP overhead, this filter first computes a codec bitrate from both this input and current packetization time value (I.E ptime). Computed codec bitrate value is passed to the SILK encoder as target bitrate. This value can be changed at any time.
*
- #MS_FILTER_ADD_FMTP Set codec specific parameter as described in draft-vos-silk-02. Default values are those proposed by draft-vos-silk-02. Supported parameters are maxptime, ptime, useinbandfec.
*
*
* Preset SILK encoder's values not configurable are: encoder complexity set to 1, packetLossPercentage set to 10 and useDTX set to 0.
*
* MSSILDec
MSSILDec is a filter from category #MS_FILTER_DECODER. It has its enc_fmt value set to "SILK".This filter make use of SILK's builtin Packet Lose Concealment and Forward Error Correction feature.The following key control functions are implemented:
*
* - #MS_FILTER_SET_SAMPLE_RATE Set output sampling rate. This value is internally mapped to API sampling rate.Supported value are 8000, 12000, 16000, 24000, 32000, 44000 and 48000. This value can be changed at any time.
*
*
*
*/
mediastreamer2-5.2.0+dfsg/help/ht0-buildagraph.dox 0000664 0000000 0000000 00000011535 14346134245 0021773 0 ustar 00root root 0000000 0000000 /**
* @defgroup howto0_samplegraph Howto 1: build a sample audio graph.
* @ingroup mediastreamer2_intro
Initialize mediastreamer2
When using mediastreamer2, your first task is to initialize the
library:
#include
int i;
i=ms_init();
if (i!=0)
return -1;
Mediastreamer2 provides internal components which are called filters. Those
filters must be linked together so that OUTPUT from one filter is sent to
INPUT of the other filters.
Usually, filters are used for processing audio or video data. They could
capture data, play/draw data, encode/decode data, mix data (conference),
transform data (echo canceller). One of the most important filter is the
RTP filters that are able to send and receive RTP data.
Graph sample
If you are using mediastreamer2, you probably want to do Voice Over IP
and get a graph providing a 2 way communication. This 2 graphs are very
simple:
This first graph shows the filters needed to capture data from a sound
card, encode them and send it through an RTP session.
AUDIO -> ENCODER -> RTP
CAPTURE -> -> SENDER
This second graph shows the filters needed to receive data from an RTP
session decode it and send it to the playback device.
RTP -> DECODER -> DTMF -> AUDIO
RECEIVER -> -> GENERATION -> PLAYBACK
Code to initiate the filters of the Graph sample
Note that the NULL/error checks are not done for better reading.
To build the graph, you'll need some information: you need to
select the sound card and of course have an RTP session created
with oRTP.
MSSndCard *sndcard;
sndcard=ms_snd_card_manager_get_default_card(ms_snd_card_manager_get());
/* audio capture filter */
MSFilter *soundread=ms_snd_card_create_reader(captcard);
MSFilter *soundwrite=ms_snd_card_create_writer(playcard);
MSFilter *encoder=ms_filter_create_encoder("PCMU");
MSFilter *decoder=ms_filter_create_decoder("PCMU");
MSFilter *rtpsend=ms_filter_new(MS_RTP_SEND_ID);
MSFilter *rtprecv=ms_filter_new(MS_RTP_RECV_ID);
RtpSession *rtp_session = *** your_ortp_session *** ;
ms_filter_call_method(rtpsend,MS_RTP_SEND_SET_SESSION,rtp_session);
ms_filter_call_method(rtprecv,MS_RTP_RECV_SET_SESSION,rtp_session);
MSFilter *dtmfgen=ms_filter_new(MS_DTMF_GEN_ID);
In most cases, the above graph is not enough: you'll need to configure
filter's options. As an example, you need to set sampling rate of sound
cards' filters:
int sr = 8000;
int chan=1;
ms_filter_call_method(soundread,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(soundwrite,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(stream->encoder,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(stream->decoder,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(soundwrite,MS_FILTER_SET_NCHANNELS, &chan);
/* if you have some fmtp parameters (from SDP for example!) */
char *fmtp1 = ** get your fmtp line **;
char *fmtp2 = ** get your fmtp line **;
ms_filter_call_method(stream->encoder,MS_FILTER_ADD_FMTP, (void*)fmtp1);
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)fmtp2);
Code to link the filters and run the graph sample
ms_filter_link(stream->soundread,0,stream->encoder,0);
ms_filter_link(stream->encoder,0,stream->rtpsend,0);
ms_filter_link(stream->rtprecv,0,stream->decoder,0);
ms_filter_link(stream->decoder,0,stream->dtmfgen,0);
ms_filter_link(stream->dtmfgen,0,stream->soundwrite,0);
Then you need to 'attach' the filters to a ticker. A ticker is a graph
manager responsible for running filters.
In the above case, there is 2 independant graph within the ticker: you
need to attach the first element of each graph (the one that does not
contains any INPUT pins)
/* create ticker */
MSTicker *ticker=ms_ticker_new();
ms_ticker_attach(ticker,soundread);
ms_ticker_attach(ticker,rtprecv);
Code to unlink the filters and stop the graph sample
ms_ticker_detach(ticker,soundread);
ms_ticker_detach(ticker,rtprecv);
ms_filter_unlink(stream->soundread,0,stream->encoder,0);
ms_filter_unlink(stream->encoder,0,stream->rtpsend,0);
ms_filter_unlink(stream->rtprecv,0,stream->decoder,0);
ms_filter_unlink(stream->decoder,0,stream->dtmfgen,0);
ms_filter_unlink(stream->dtmfgen,0,stream->soundwrite,0);
if (rtp_session!=NULL) rtp_session_destroy(rtp_session);
if (rtpsend!=NULL) ms_filter_destroy(rtpsend);
if (rtprecv!=NULL) ms_filter_destroy(rtprecv);
if (soundread!=NULL) ms_filter_destroy(soundread);
if (soundwrite!=NULL) ms_filter_destroy(soundwrite);
if (encoder!=NULL) ms_filter_destroy(encoder);
if (decoder!=NULL) ms_filter_destroy(decoder);
if (dtmfgen!=NULL) ms_filter_destroy(dtmfgen);
if (ticker!=NULL) ms_ticker_destroy(ticker);
*/ mediastreamer2-5.2.0+dfsg/include/ 0000775 0000000 0000000 00000000000 14346134245 0016772 5 ustar 00root root 0000000 0000000 mediastreamer2-5.2.0+dfsg/include/.gitignore 0000664 0000000 0000000 00000000025 14346134245 0020757 0 ustar 00root root 0000000 0000000 Makefile.in
Makefile
mediastreamer2-5.2.0+dfsg/include/CMakeLists.txt 0000664 0000000 0000000 00000004747 14346134245 0021546 0 ustar 00root root 0000000 0000000 ############################################################################
# Copyright (c) 2010-2022 Belledonne Communications SARL.
#
# This file is part of mediastreamer2
# (see https://gitlab.linphone.org/BC/public/mediastreamer2).
#
############################################################################
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see .
############################################################################
set(HEADER_FILES
allfilters.h
android_utils.h
bitratecontrol.h
bits_rw.h
box-plot.h
devices.h
dsptools.h
dtls_srtp.h
dtmfgen.h
flowcontrol.h
formats.h
ice.h
mediastream.h
ms_srtp.h
msaudiomixer.h
mschanadapter.h
mscodecutils.h
mscommon.h
msconference.h
msequalizer.h
mseventqueue.h
msextdisplay.h
msanalysedisplay.h
msfactory.h
msfileplayer.h
msfilerec.h
msfilter.h
msgenericplc.h
msinterfaces.h
msitc.h
msjava.h
msjpegwriter.h
msogl.h
msogl_functions.h
msqrcodereader.h
msmediaplayer.h
msmediarecorder.h
msqueue.h
msrtp.h
mssndcard.h
mstee.h
msticker.h
mstonedetector.h
msutils.h
msv4l.h
msvaddtx.h
msvideo.h
msvideoout.h
msvideopresets.h
msvideoqualitycontroller.h
msvolume.h
mswebcam.h
qualityindicator.h
rfc3984.h
stun.h
upnp_igd.h
x11_helper.h
zrtp.h
msrtt4103.h
msasync.h
msudp.h
mspcapfileplayer.h
msvideoswitcher.h
msanalysedisplay.h
msmire.h
msvideorouter.h
)
set(MEDIASTREAMER2_HEADER_FILES )
foreach(HEADER_FILE ${HEADER_FILES})
list(APPEND MEDIASTREAMER2_HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/mediastreamer2/${HEADER_FILE}")
endforeach()
set(MEDIASTREAMER2_HEADER_FILES ${MEDIASTREAMER2_HEADER_FILES} PARENT_SCOPE)
install(FILES ${MEDIASTREAMER2_HEADER_FILES}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mediastreamer2
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
)
if(ENABLE_VIDEO)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/OpenGL
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
endif()
mediastreamer2-5.2.0+dfsg/include/MSVC/ 0000775 0000000 0000000 00000000000 14346134245 0017542 5 ustar 00root root 0000000 0000000 mediastreamer2-5.2.0+dfsg/include/MSVC/inttypes.h 0000664 0000000 0000000 00000021215 14346134245 0021573 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
// ISO C9x compliant inttypes.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The name of the author may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]
#ifndef _MSC_INTTYPES_H_ // [
#define _MSC_INTTYPES_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include "stdint.h"
// 7.8 Format conversion of integer types
typedef struct {
intmax_t quot;
intmax_t rem;
} imaxdiv_t;
// 7.8.1 Macros for format specifiers
#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198
// The fprintf macros for signed integers are:
#define PRId8 "d"
#define PRIi8 "i"
#define PRIdLEAST8 "d"
#define PRIiLEAST8 "i"
#define PRIdFAST8 "d"
#define PRIiFAST8 "i"
#define PRId16 "hd"
#define PRIi16 "hi"
#define PRIdLEAST16 "hd"
#define PRIiLEAST16 "hi"
#define PRIdFAST16 "hd"
#define PRIiFAST16 "hi"
#define PRId32 "I32d"
#define PRIi32 "I32i"
#define PRIdLEAST32 "I32d"
#define PRIiLEAST32 "I32i"
#define PRIdFAST32 "I32d"
#define PRIiFAST32 "I32i"
#define PRId64 "I64d"
#define PRIi64 "I64i"
#define PRIdLEAST64 "I64d"
#define PRIiLEAST64 "I64i"
#define PRIdFAST64 "I64d"
#define PRIiFAST64 "I64i"
#define PRIdMAX "I64d"
#define PRIiMAX "I64i"
#define PRIdPTR "Id"
#define PRIiPTR "Ii"
// The fprintf macros for unsigned integers are:
#define PRIo8 "o"
#define PRIu8 "u"
#define PRIx8 "x"
#define PRIX8 "X"
#define PRIoLEAST8 "o"
#define PRIuLEAST8 "u"
#define PRIxLEAST8 "x"
#define PRIXLEAST8 "X"
#define PRIoFAST8 "o"
#define PRIuFAST8 "u"
#define PRIxFAST8 "x"
#define PRIXFAST8 "X"
#define PRIo16 "ho"
#define PRIu16 "hu"
#define PRIx16 "hx"
#define PRIX16 "hX"
#define PRIoLEAST16 "ho"
#define PRIuLEAST16 "hu"
#define PRIxLEAST16 "hx"
#define PRIXLEAST16 "hX"
#define PRIoFAST16 "ho"
#define PRIuFAST16 "hu"
#define PRIxFAST16 "hx"
#define PRIXFAST16 "hX"
#define PRIo32 "I32o"
#define PRIu32 "I32u"
#define PRIx32 "I32x"
#define PRIX32 "I32X"
#define PRIoLEAST32 "I32o"
#define PRIuLEAST32 "I32u"
#define PRIxLEAST32 "I32x"
#define PRIXLEAST32 "I32X"
#define PRIoFAST32 "I32o"
#define PRIuFAST32 "I32u"
#define PRIxFAST32 "I32x"
#define PRIXFAST32 "I32X"
#define PRIo64 "I64o"
#define PRIu64 "I64u"
#define PRIx64 "I64x"
#define PRIX64 "I64X"
#define PRIoLEAST64 "I64o"
#define PRIuLEAST64 "I64u"
#define PRIxLEAST64 "I64x"
#define PRIXLEAST64 "I64X"
#define PRIoFAST64 "I64o"
#define PRIuFAST64 "I64u"
#define PRIxFAST64 "I64x"
#define PRIXFAST64 "I64X"
#define PRIoMAX "I64o"
#define PRIuMAX "I64u"
#define PRIxMAX "I64x"
#define PRIXMAX "I64X"
#define PRIoPTR "Io"
#define PRIuPTR "Iu"
#define PRIxPTR "Ix"
#define PRIXPTR "IX"
// The fscanf macros for signed integers are:
#define SCNd8 "d"
#define SCNi8 "i"
#define SCNdLEAST8 "d"
#define SCNiLEAST8 "i"
#define SCNdFAST8 "d"
#define SCNiFAST8 "i"
#define SCNd16 "hd"
#define SCNi16 "hi"
#define SCNdLEAST16 "hd"
#define SCNiLEAST16 "hi"
#define SCNdFAST16 "hd"
#define SCNiFAST16 "hi"
#define SCNd32 "ld"
#define SCNi32 "li"
#define SCNdLEAST32 "ld"
#define SCNiLEAST32 "li"
#define SCNdFAST32 "ld"
#define SCNiFAST32 "li"
#define SCNd64 "I64d"
#define SCNi64 "I64i"
#define SCNdLEAST64 "I64d"
#define SCNiLEAST64 "I64i"
#define SCNdFAST64 "I64d"
#define SCNiFAST64 "I64i"
#define SCNdMAX "I64d"
#define SCNiMAX "I64i"
#ifdef _WIN64 // [
# define SCNdPTR "I64d"
# define SCNiPTR "I64i"
#else // _WIN64 ][
# define SCNdPTR "ld"
# define SCNiPTR "li"
#endif // _WIN64 ]
// The fscanf macros for unsigned integers are:
#define SCNo8 "o"
#define SCNu8 "u"
#define SCNx8 "x"
#define SCNX8 "X"
#define SCNoLEAST8 "o"
#define SCNuLEAST8 "u"
#define SCNxLEAST8 "x"
#define SCNXLEAST8 "X"
#define SCNoFAST8 "o"
#define SCNuFAST8 "u"
#define SCNxFAST8 "x"
#define SCNXFAST8 "X"
#define SCNo16 "ho"
#define SCNu16 "hu"
#define SCNx16 "hx"
#define SCNX16 "hX"
#define SCNoLEAST16 "ho"
#define SCNuLEAST16 "hu"
#define SCNxLEAST16 "hx"
#define SCNXLEAST16 "hX"
#define SCNoFAST16 "ho"
#define SCNuFAST16 "hu"
#define SCNxFAST16 "hx"
#define SCNXFAST16 "hX"
#define SCNo32 "lo"
#define SCNu32 "lu"
#define SCNx32 "lx"
#define SCNX32 "lX"
#define SCNoLEAST32 "lo"
#define SCNuLEAST32 "lu"
#define SCNxLEAST32 "lx"
#define SCNXLEAST32 "lX"
#define SCNoFAST32 "lo"
#define SCNuFAST32 "lu"
#define SCNxFAST32 "lx"
#define SCNXFAST32 "lX"
#define SCNo64 "I64o"
#define SCNu64 "I64u"
#define SCNx64 "I64x"
#define SCNX64 "I64X"
#define SCNoLEAST64 "I64o"
#define SCNuLEAST64 "I64u"
#define SCNxLEAST64 "I64x"
#define SCNXLEAST64 "I64X"
#define SCNoFAST64 "I64o"
#define SCNuFAST64 "I64u"
#define SCNxFAST64 "I64x"
#define SCNXFAST64 "I64X"
#define SCNoMAX "I64o"
#define SCNuMAX "I64u"
#define SCNxMAX "I64x"
#define SCNXMAX "I64X"
#ifdef _WIN64 // [
# define SCNoPTR "I64o"
# define SCNuPTR "I64u"
# define SCNxPTR "I64x"
# define SCNXPTR "I64X"
#else // _WIN64 ][
# define SCNoPTR "lo"
# define SCNuPTR "lu"
# define SCNxPTR "lx"
# define SCNXPTR "lX"
#endif // _WIN64 ]
#endif // __STDC_FORMAT_MACROS ]
// 7.8.2 Functions for greatest-width integer types
// 7.8.2.1 The imaxabs function
#define imaxabs _abs64
// 7.8.2.2 The imaxdiv function
// This is modified version of div() function from Microsoft's div.c found
// in %MSVC.NET%\crt\src\div.c
#ifdef STATIC_IMAXDIV // [
static
#else // STATIC_IMAXDIV ][
_inline
#endif // STATIC_IMAXDIV ]
imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
{
imaxdiv_t result;
result.quot = numer / denom;
result.rem = numer % denom;
if (numer < 0 && result.rem > 0) {
// did division wrong; must fix up
++result.quot;
result.rem -= denom;
}
return result;
}
// 7.8.2.3 The strtoimax and strtoumax functions
#define strtoimax _strtoi64
#define strtoumax _strtoui64
// 7.8.2.4 The wcstoimax and wcstoumax functions
#define wcstoimax _wcstoi64
#define wcstoumax _wcstoui64
#endif // _MSC_INTTYPES_H_ ]
mediastreamer2-5.2.0+dfsg/include/MSVC/stdint.h 0000664 0000000 0000000 00000020571 14346134245 0021225 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
// ISO C9x compliant stdint.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006-2008 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The name of the author may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]
#ifndef _MSC_STDINT_H_ // [
#define _MSC_STDINT_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include
// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
// compiling for ARM we should wrap include with 'extern "C++" {}'
// or compiler give many errors like this:
// error C2733: second C linkage of overloaded function 'wmemchr' not allowed
#ifdef __cplusplus
extern "C" {
#endif
# include
#ifdef __cplusplus
}
#endif
// Define _W64 macros to mark types changing their size, like intptr_t.
#ifndef _W64
# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
# define _W64 __w64
# else
# define _W64
# endif
#endif
// 7.18.1 Integer types
// 7.18.1.1 Exact-width integer types
// Visual Studio 6 and Embedded Visual C++ 4 doesn't
// realize that, e.g. char has the same size as __int8
// so we give up on __intX for them.
#if (_MSC_VER < 1300)
typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
#else
typedef signed __int8 int8_t;
typedef signed __int16 int16_t;
typedef signed __int32 int32_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
#endif
typedef signed __int64 int64_t;
typedef unsigned __int64 uint64_t;
// 7.18.1.2 Minimum-width integer types
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
// 7.18.1.3 Fastest minimum-width integer types
typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;
// 7.18.1.4 Integer types capable of holding object pointers
#ifdef _WIN64 // [
typedef signed __int64 intptr_t;
typedef unsigned __int64 uintptr_t;
#else // _WIN64 ][
typedef _W64 signed int intptr_t;
typedef _W64 unsigned int uintptr_t;
#endif // _WIN64 ]
// 7.18.1.5 Greatest-width integer types
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
// 7.18.2 Limits of specified-width integer types
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259
// 7.18.2.1 Limits of exact-width integer types
#define INT8_MIN ((int8_t)_I8_MIN)
#define INT8_MAX _I8_MAX
#define INT16_MIN ((int16_t)_I16_MIN)
#define INT16_MAX _I16_MAX
#define INT32_MIN ((int32_t)_I32_MIN)
#define INT32_MAX _I32_MAX
#define INT64_MIN ((int64_t)_I64_MIN)
#define INT64_MAX _I64_MAX
#define UINT8_MAX _UI8_MAX
#define UINT16_MAX _UI16_MAX
#define UINT32_MAX _UI32_MAX
#define UINT64_MAX _UI64_MAX
// 7.18.2.2 Limits of minimum-width integer types
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST64_MAX INT64_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX
// 7.18.2.3 Limits of fastest minimum-width integer types
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST16_MIN INT16_MIN
#define INT_FAST16_MAX INT16_MAX
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST32_MAX INT32_MAX
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST64_MAX INT64_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST16_MAX UINT16_MAX
#define UINT_FAST32_MAX UINT32_MAX
#define UINT_FAST64_MAX UINT64_MAX
// 7.18.2.4 Limits of integer types capable of holding object pointers
#ifdef _WIN64 // [
# define INTPTR_MIN INT64_MIN
# define INTPTR_MAX INT64_MAX
# define UINTPTR_MAX UINT64_MAX
#else // _WIN64 ][
# define INTPTR_MIN INT32_MIN
# define INTPTR_MAX INT32_MAX
# define UINTPTR_MAX UINT32_MAX
#endif // _WIN64 ]
// 7.18.2.5 Limits of greatest-width integer types
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
// 7.18.3 Limits of other integer types
#ifdef _WIN64 // [
# define PTRDIFF_MIN _I64_MIN
# define PTRDIFF_MAX _I64_MAX
#else // _WIN64 ][
# define PTRDIFF_MIN _I32_MIN
# define PTRDIFF_MAX _I32_MAX
#endif // _WIN64 ]
#define SIG_ATOMIC_MIN INT_MIN
#define SIG_ATOMIC_MAX INT_MAX
#ifndef SIZE_MAX // [
# ifdef _WIN64 // [
# define SIZE_MAX _UI64_MAX
# else // _WIN64 ][
# define SIZE_MAX _UI32_MAX
# endif // _WIN64 ]
#endif // SIZE_MAX ]
// WCHAR_MIN and WCHAR_MAX are also defined in
#ifndef WCHAR_MIN // [
# define WCHAR_MIN 0
#endif // WCHAR_MIN ]
#ifndef WCHAR_MAX // [
# define WCHAR_MAX _UI16_MAX
#endif // WCHAR_MAX ]
#define WINT_MIN 0
#define WINT_MAX _UI16_MAX
#endif // __STDC_LIMIT_MACROS ]
// 7.18.4 Limits of other integer types
#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260
// 7.18.4.1 Macros for minimum-width integer constants
#define INT8_C(val) val##i8
#define INT16_C(val) val##i16
#define INT32_C(val) val##i32
#define INT64_C(val) val##i64
#define UINT8_C(val) val##ui8
#define UINT16_C(val) val##ui16
#define UINT32_C(val) val##ui32
#define UINT64_C(val) val##ui64
// 7.18.4.2 Macros for greatest-width integer constants
#define INTMAX_C INT64_C
#define UINTMAX_C UINT64_C
#endif // __STDC_CONSTANT_MACROS ]
#endif // _MSC_STDINT_H_ ]
mediastreamer2-5.2.0+dfsg/include/Makefile.am 0000664 0000000 0000000 00000000027 14346134245 0021025 0 ustar 00root root 0000000 0000000 SUBDIRS=mediastreamer2
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/ 0000775 0000000 0000000 00000000000 14346134245 0021676 5 ustar 00root root 0000000 0000000 mediastreamer2-5.2.0+dfsg/include/mediastreamer2/.gitignore 0000664 0000000 0000000 00000000025 14346134245 0023663 0 ustar 00root root 0000000 0000000 Makefile.in
Makefile
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/Makefile.am 0000664 0000000 0000000 00000002302 14346134245 0023727 0 ustar 00root root 0000000 0000000
mediastreamer2_includedir=$(includedir)/mediastreamer2
mediastreamer2_include_HEADERS=allfilters.h \
bitratecontrol.h \
bits_rw.h \
devices.h \
dsptools.h \
dtls_srtp.h \
dtmfgen.h \
flowcontrol.h \
formats.h \
ice.h \
mediastream.h \
ms_srtp.h \
msaudiomixer.h \
mschanadapter.h \
mscodecutils.h \
mscommon.h \
msconference.h \
msequalizer.h \
mseventqueue.h \
msextdisplay.h \
msfactory.h \
msfileplayer.h \
msfilerec.h \
msfilter.h \
msgenericplc.h \
msinterfaces.h \
msitc.h \
msogl.h \
msogl_functions.h \
msjava.h \
msjpegwriter.h \
msmediaplayer.h \
msqueue.h \
msrtp.h \
msrtt4103.h \
mssndcard.h \
mstee.h \
msticker.h \
mstonedetector.h \
msutils.h \
msv4l.h \
msvaddtx.h \
msvideo.h \
msvideoout.h \
msvideopresets.h \
msvideoqualitycontroller.h \
msvolume.h \
mswebcam.h \
qualityindicator.h \
rfc3984.h \
stun.h \
upnp_igd.h \
x11_helper.h \
zrtp.h \
msasync.h \
mspcapfileplayer.h \
msudp.h \
msanalysedisplay.h \
msmire.h
EXTRA_DIST=$(mediastreamer2_include_HEADERS)
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/allfilters.h 0000775 0000000 0000000 00000010225 14346134245 0024213 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef allfilters_h
#define allfilters_h
/* this is the enum where to add your own filter id.
Please take care of always add new IDs at the end in order to preserve the binary interface*/
/*this id is used for type checking of methods, events with filters */
/*it must be used also to create filters */
typedef enum MSFilterId{
MS_FILTER_NOT_SET_ID,
MS_FILTER_PLUGIN_ID, /* no type checking will be performed on plugins */
MS_FILTER_BASE_ID,
MS_ALSA_READ_ID,
MS_ALSA_WRITE_ID,
MS_OSS_READ_ID,
MS_OSS_WRITE_ID,
MS_ULAW_ENC_ID,
MS_ULAW_DEC_ID,
MS_ALAW_ENC_ID,
MS_ALAW_DEC_ID,
MS_RTP_SEND_ID,
MS_RTP_RECV_ID,
MS_FILE_PLAYER_ID,
MS_FILE_REC_ID,
MS_DTMF_GEN_ID,
MS_SPEEX_ENC_ID,
MS_SPEEX_DEC_ID,
MS_GSM_ENC_ID,
MS_GSM_DEC_ID,
MS_V4L_ID,
MS_SDL_OUT_ID,
MS_H263_ENC_ID,
MS_H263_DEC_ID,
MS_ARTS_READ_ID,
MS_ARTS_WRITE_ID,
MS_WINSND_READ_ID,
MS_WINSND_WRITE_ID,
MS_SPEEX_EC_ID,
MS_PIX_CONV_ID,
MS_TEE_ID,
MS_SIZE_CONV_ID,
MS_CONF_ID,
MS_THEORA_ENC_ID,
MS_THEORA_DEC_ID,
MS_PASND_READ_ID,
MS_PASND_WRITE_ID,
MS_MPEG4_ENC_ID,
MS_MPEG4_DEC_ID,
MS_MJPEG_DEC_ID,
MS_JOIN_ID,
MS_RESAMPLE_ID,
MS_VIDEO_OUT_ID,
MS_VOLUME_ID,
MS_SNOW_DEC_ID,
MS_SNOW_ENC_ID,
MS_CA_READ_ID,
MS_CA_WRITE_ID,
MS_WINSNDDS_READ_ID,
MS_WINSNDDS_WRITE_ID,
MS_STATIC_IMAGE_ID,
MS_V4L2_CAPTURE_ID,
MS_H263_OLD_DEC_ID,
MS_H263_OLD_ENC_ID,
MS_MIRE_ID,
MS_VFW_ID,
MS_VOID_SOURCE_ID,
MS_VOID_SINK_ID,
MS_DSCAP_ID,
MS_AQ_READ_ID,
MS_AQ_WRITE_ID,
MS_EQUALIZER_ID,
MS_JPEG_DEC_ID,
MS_JPEG_ENC_ID,
MS_PULSE_READ_ID,
MS_PULSE_WRITE_ID,
MS_DRAWDIB_DISPLAY_ID,
MS_CHANNEL_ADAPTER_ID,
MS_AUDIO_MIXER_ID,
MS_ITC_SINK_ID,
MS_ITC_SOURCE_ID,
MS_EXT_DISPLAY_ID,
MS_ANALYSE_DISPLAY_ID,
MS_H264_DEC_ID,
MS_IOUNIT_READ_ID,
MS_IOUNIT_WRITE_ID,
MS_ANDROID_SOUND_READ_ID,
MS_ANDROID_SOUND_WRITE_ID,
MS_JPEG_WRITER_ID,
MS_QRCODE_READER_ID,
MS_X11VIDEO_ID,
MS_ANDROID_DISPLAY_ID,
MS_ANDROID_VIDEO_READ_ID,
MS_ANDROID_VIDEO_WRITE_ID,
MS_TONE_DETECTOR_ID,
MY_FILTER_ID,
MS_IOS_DISPLAY_ID,
MS_VP8_ENC_ID,
MS_VP8_DEC_ID,
MS_G722_ENC_ID,
MS_G722_DEC_ID,
MS_G726_40_ENC_ID,
MS_G726_32_ENC_ID,
MS_G726_24_ENC_ID,
MS_G726_16_ENC_ID,
MS_AAL2_G726_40_ENC_ID,
MS_AAL2_G726_32_ENC_ID,
MS_AAL2_G726_24_ENC_ID,
MS_AAL2_G726_16_ENC_ID,
MS_G726_40_DEC_ID,
MS_G726_32_DEC_ID,
MS_G726_24_DEC_ID,
MS_G726_16_DEC_ID,
MS_AAL2_G726_40_DEC_ID,
MS_AAL2_G726_32_DEC_ID,
MS_AAL2_G726_24_DEC_ID,
MS_AAL2_G726_16_DEC_ID,
MS_L16_ENC_ID,
MS_L16_DEC_ID,
MS_OSX_GL_DISPLAY_ID,
MS_GLXVIDEO_ID,
MS_GENERIC_PLC_ID,
MS_WEBRTC_AEC_ID,
MS_AAC_ELD_ENC_ID,
MS_AAC_ELD_DEC_ID,
MS_OPUS_ENC_ID,
MS_OPUS_DEC_ID,
MS_QSA_READ_ID,
MS_QSA_WRITE_ID,
MS_MKV_RECORDER_ID,
MS_MKV_PLAYER_ID,
MS_VAD_DTX_ID,
MS_BB10_DISPLAY_ID,
MS_BB10_CAPTURE_ID,
MS_VT_H263_ENC_ID,
MS_VT_H263_DEC_ID,
MS_VT_H264_ENC_ID,
MS_VT_H264_DEC_ID,
MS_RTT_4103_SOURCE_ID,
MS_RTT_4103_SINK_ID,
MS_MEDIACODEC_H264_DEC_ID,
MS_MEDIACODEC_H264_ENC_ID,
MS_BV16_DEC_ID,
MS_BV16_ENC_ID,
MS_UDP_SEND_ID,
MS_PCAP_FILE_PLAYER_ID,
MS_OGL_ID,
MS_G729_DEC_ID,
MS_G729_ENC_ID,
MS_WASAPI_READ_ID,
MS_WASAPI_WRITE_ID,
MS_AUDIO_FLOW_CONTROL_ID,
MS_MEDIACODEC_H265_DEC_ID,
MS_MEDIACODEC_H265_ENC_ID,
MS_VT_H265_DEC_ID,
MS_VT_H265_ENC_ID,
MS_ANDROID_DISPLAY_BAD_ID,
MS_ANDROID_OPENGL_DISPLAY_ID,
MS_ANDROID_TEXTURE_DISPLAY_ID,
MS_VIDEO_SWITCHER_ID,
MS_VIDEO_ROUTER_ID,
MS_FRAMEMARKING_TESTER_ID
} MSFilterId;
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/android_utils.h 0000664 0000000 0000000 00000006721 14346134245 0024715 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef android_utils_h
#define android_utils_h
#include
#include
#include
/**
* Retrieve whether or not RECORD_AUDIO permission has been granted.
**/
MS2_PUBLIC bool ms_android_is_record_audio_permission_granted();
/**
* Retrieve preferred buffer size from Mediastreamer Android Context.
**/
MS2_PUBLIC int ms_android_get_preferred_buffer_size();
/**
* Retrieve preferred sample rate from Mediastreamer Android Context.
**/
MS2_PUBLIC int ms_android_get_preferred_sample_rate();
/**
* Retrieve all devices in a given direction.
* Valid values for string dir are "all" "output" "input"
**/
MS2_PUBLIC jobjectArray ms_android_get_all_devices(JNIEnv *env, const char * dir);
/**
* Retrieve device ID for the device deviceInfo.
**/
MS2_PUBLIC unsigned int ms_android_get_device_id(JNIEnv *env, jobject deviceInfo);
/**
* Retrieve the value of a JV class field fieldName.
**/
MS2_PUBLIC int ms_android_getJVIntField(JNIEnv *env, const char * className, const char * fieldName);
/**
* Retrieve device type for the device deviceInfo.
**/
MS2_PUBLIC MSSndCardDeviceType ms_android_get_device_type(JNIEnv *env, jobject deviceInfo);
/**
* Retrieve device capabilities (recorder or playback) for the device deviceInfo.
**/
MS2_PUBLIC unsigned int ms_android_get_device_capabilities(JNIEnv *env, jobject deviceInfo);
/**
* Retrieve product name for the device deviceInfo.
**/
MS2_PUBLIC char * ms_android_get_device_product_name(JNIEnv *env, jobject deviceInfo);
/**
* Retrieve SDK version the app is running on.
**/
MS2_PUBLIC int ms_android_get_sdk_version(JNIEnv *env);
/**
* Make upcalls to change device from mediastreamer.
**/
MS2_PUBLIC void ms_android_change_device(JNIEnv *env, int deviceID, MSSndCardDeviceType type);
/**
* Make upcalls to enable/disable bluetooth devices from mediastreamer.
**/
MS2_PUBLIC void ms_android_set_bt_enable(JNIEnv *env, const bool_t enable);
/**
* Hack required to have volume not set to 0 on some devices
**/
MS2_PUBLIC void ms_android_hack_volume(JNIEnv *env);
#ifdef __cplusplus
extern "C"{
#endif
/**
* Creates an AcousticEchoCanceler java object for the given session ID so the sound card uses the device's hardware echo canceller if available.
* Currently only AndroidSound, AndroidSoundDepr and AAudio sound cards support it.
**/
MS2_PUBLIC jobject ms_android_enable_hardware_echo_canceller(JNIEnv *env, int sessionId);
/**
* Deletes the AcousticEchoCanceler created by ms_android_enable_hardware_echo_canceller.
**/
MS2_PUBLIC void ms_android_delete_hardware_echo_canceller(JNIEnv *env, jobject aec);
#ifdef __cplusplus
}
#endif
#endif // android_utils_h
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/bitratecontrol.h 0000664 0000000 0000000 00000024733 14346134245 0025113 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef ms2_ratecontrol
#define ms2_ratecontrol
#include "mediastreamer2/msfilter.h"
#include
#ifdef __cplusplus
extern "C" {
#endif
struct _MediaStream;
typedef struct _MSBandwidthControllerStats{
float estimated_download_bandwidth; /*in bits/seconds*/
float controlled_stream_bandwidth;
bool_t in_congestion;
}MSBandwidthControllerStats;
struct _MSBandwidthController{
bctbx_list_t *streams; /*list of MediaStream objects*/
bctbx_list_t *controlled_streams; /*the most bandwidth consuming streams*/
MSBandwidthControllerStats stats;
float remote_video_bandwidth_available_estimated;
float maximum_bw_usage;
float currently_requested_stream_bandwidth; // According to congestion control and bandwith estimator only.
bool_t congestion_detected;
};
/**
* The MSBandwidthController is a object managing several streams (audio, video) and monitoring congestion of inbound streams.
* If a congestion is detected, it will send RTCP TMMBR packet to the remote sender in order to stop the congestion and adapt
* the incoming bitrate of received streams to the available bandwidth.
* It superseeds the MSBitrateController, MSQosAnalyzer, MSBitrateDriver objects, which were using different but less robust techniques
* to detect congestion and adapt bandwidth usage.
**/
typedef struct _MSBandwidthController MSBandwidthController;
MS2_PUBLIC MSBandwidthController *ms_bandwidth_controller_new(void);
/**
* Set an explicit download bandwidth target usage expressed in bits/seconds, used for video conferencing cases.
* This target bandwidth is considered as a maximum that shall not be exceeded.
* The congestion control and bandwidth estimations are used normally to find the correct bandwidth usage below this target usage.
*/
MS2_PUBLIC void ms_bandwidth_controller_set_maximum_bandwidth_usage(MSBandwidthController *obj, int bitrate);
MS2_PUBLIC void ms_bandwidth_controller_add_stream(MSBandwidthController *obj, struct _MediaStream *stream);
MS2_PUBLIC void ms_bandwidth_controller_remove_stream(MSBandwidthController *obj, struct _MediaStream *stream);
MS2_PUBLIC const MSBandwidthControllerStats * ms_bandwidth_controller_get_stats(MSBandwidthController *obj);
MS2_PUBLIC void ms_bandwidth_controller_reset_state(MSBandwidthController *obj);
MS2_PUBLIC void ms_bandwidth_controller_destroy(MSBandwidthController *obj);
MS2_PUBLIC void ms_bandwidth_controller_elect_controlled_streams(MSBandwidthController *obj);
/**
* Audio Bitrate controller object.
* @deprecated
**/
typedef struct _MSAudioBitrateController MSAudioBitrateController;
enum _MSRateControlActionType{
MSRateControlActionDoNothing,
MSRateControlActionDecreaseBitrate,
MSRateControlActionDecreasePacketRate,
MSRateControlActionIncreaseQuality,
};
typedef enum _MSRateControlActionType MSRateControlActionType;
const char *ms_rate_control_action_type_name(MSRateControlActionType t);
typedef struct _MSRateControlAction{
MSRateControlActionType type;
int value;
}MSRateControlAction;
typedef struct _MSBitrateDriver MSBitrateDriver;
typedef struct _MSBitrateDriverDesc MSBitrateDriverDesc;
struct _MSBitrateDriverDesc{
int (*execute_action)(MSBitrateDriver *obj, const MSRateControlAction *action);
void (*uninit)(MSBitrateDriver *obj);
};
/**
* The MSBitrateDriver has the responsibility to execute rate control actions.
* This is an abstract interface.
* @deprecated
**/
struct _MSBitrateDriver{
MSBitrateDriverDesc *desc;
int refcnt;
};
MS2_PUBLIC int ms_bitrate_driver_execute_action(MSBitrateDriver *obj, const MSRateControlAction *action);
MS2_PUBLIC MSBitrateDriver * ms_bitrate_driver_ref(MSBitrateDriver *obj);
MS2_PUBLIC void ms_bitrate_driver_unref(MSBitrateDriver *obj);
MS2_PUBLIC MSBitrateDriver *ms_audio_bitrate_driver_new(RtpSession *session, MSFilter *encoder);
MS2_PUBLIC MSBitrateDriver *ms_av_bitrate_driver_new(RtpSession *asession, MSFilter *aenc, RtpSession *vsession, MSFilter *venc);
MS2_PUBLIC MSBitrateDriver *ms_bandwidth_bitrate_driver_new(RtpSession *asession, MSFilter *aenc, RtpSession *vsession, MSFilter *venc);
typedef struct _MSQosAnalyzer MSQosAnalyzer;
typedef struct _MSQosAnalyzerDesc MSQosAnalyzerDesc;
struct _MSQosAnalyzerDesc{
bool_t (*process_rtcp)(MSQosAnalyzer *obj, mblk_t *rtcp);
void (*suggest_action)(MSQosAnalyzer *obj, MSRateControlAction *action);
bool_t (*has_improved)(MSQosAnalyzer *obj);
void (*update)(MSQosAnalyzer *);
void (*uninit)(MSQosAnalyzer *);
};
enum _MSQosAnalyzerAlgorithm {
MSQosAnalyzerAlgorithmSimple,
MSQosAnalyzerAlgorithmStateful
};
typedef enum _MSQosAnalyzerAlgorithm MSQosAnalyzerAlgorithm;
MS2_PUBLIC const char* ms_qos_analyzer_algorithm_to_string(MSQosAnalyzerAlgorithm alg);
MS2_PUBLIC MSQosAnalyzerAlgorithm ms_qos_analyzer_algorithm_from_string(const char* alg);
/**
* A MSQosAnalyzer is responsible to analyze RTCP feedback and suggest
* actions on bitrate or packet rate accordingly.
* This is an abstract interface.
* @deprecated
**/
struct _MSQosAnalyzer{
MSQosAnalyzerDesc *desc;
OrtpLossRateEstimator *lre;
char *label;
/**
* Each time the algorithm suggest an action, this callback is called with the userpointer
* @param userpointer on_action_suggested_user_pointer pointer given
* @param argc number of arguments on the third argument array
* @param argv array containing various algorithm dependent information
**/
void (*on_action_suggested)(void* userpointer, int argc, const char** argv);
/** User pointer given at #on_action_suggested callback **/
void *on_action_suggested_user_pointer;
int refcnt;
MSQosAnalyzerAlgorithm type;
};
MS2_PUBLIC MSQosAnalyzer * ms_qos_analyzer_ref(MSQosAnalyzer *obj);
MS2_PUBLIC void ms_qos_analyzer_unref(MSQosAnalyzer *obj);
MS2_PUBLIC void ms_qos_analyser_set_label(MSQosAnalyzer *obj, const char *label);
MS2_PUBLIC void ms_qos_analyzer_suggest_action(MSQosAnalyzer *obj, MSRateControlAction *action);
MS2_PUBLIC bool_t ms_qos_analyzer_has_improved(MSQosAnalyzer *obj);
MS2_PUBLIC bool_t ms_qos_analyzer_process_rtcp(MSQosAnalyzer *obj, mblk_t *rtcp);
MS2_PUBLIC void ms_qos_analyzer_update(MSQosAnalyzer *obj);
MS2_PUBLIC const char* ms_qos_analyzer_get_name(MSQosAnalyzer *obj);
MS2_PUBLIC void ms_qos_analyzer_set_on_action_suggested(MSQosAnalyzer *obj, void (*on_action_suggested)(void*,int,const char**),void* u);
/**
* The simple qos analyzer is an implementation of MSQosAnalyzer that performs analysis for single stream.
**/
MS2_PUBLIC MSQosAnalyzer * ms_simple_qos_analyzer_new(RtpSession *session);
MS2_PUBLIC MSQosAnalyzer * ms_stateful_qos_analyzer_new(RtpSession *session);
/**
* The audio/video qos analyzer is an implementation of MSQosAnalyzer that performs analysis of two audio and video streams.
**/
/*MSQosAnalyzer * ms_av_qos_analyzer_new(RtpSession *asession, RtpSession *vsession);*/
/**
* The MSBitrateController the overall behavior and state machine of the adaptive rate control system.
* It requires a MSQosAnalyzer to obtain analyse of the quality of service, and a MSBitrateDriver
* to run the actions on media streams, like decreasing or increasing bitrate.
**/
typedef struct _MSBitrateController MSBitrateController;
/**
* Instanciates MSBitrateController
* @param qosanalyzer a Qos analyzer object
* @param driver a bitrate driver object.
* The newly created bitrate controller owns references to the analyzer and the driver.
**/
MS2_PUBLIC MSBitrateController *ms_bitrate_controller_new(MSQosAnalyzer *qosanalyzer, MSBitrateDriver *driver);
/**
* Asks the bitrate controller to process a newly received RTCP packet.
* @param MSBitrateController the bitrate controller object.
* @param rtcp an RTCP packet received for the media session(s) being managed by the controller.
* If the RTCP packet contains useful feedback regarding quality of the media streams received by the far end,
* then the bitrate controller may take decision and execute actions on the local media streams to adapt the
* output bitrate.
**/
MS2_PUBLIC void ms_bitrate_controller_process_rtcp(MSBitrateController *obj, mblk_t *rtcp);
MS2_PUBLIC void ms_bitrate_controller_update(MSBitrateController *obj);
/**
* Return the QoS analyzer associated to the bitrate controller
**/
MS2_PUBLIC MSQosAnalyzer * ms_bitrate_controller_get_qos_analyzer(MSBitrateController *obj);
/**
* Destroys the bitrate controller
*
* If no other entity holds references to the underlyings MSQosAnalyzer and MSBitrateDriver object,
* then they will be destroyed too.
**/
MS2_PUBLIC void ms_bitrate_controller_destroy(MSBitrateController *obj);
/**
* Convenience function to create a bitrate controller managing a single audio stream.
* @param session the RtpSession object for the media stream
* @param encoder the MSFilter object responsible for encoding the audio data.
* @param flags unused.
* This function actually calls internally:
*
* \code
* ms_bitrate_controller_new(ms_simple_qos_analyzer_new(session),ms_audio_bitrate_driver_new(encoder));
* \endcode
**/
MS2_PUBLIC MSBitrateController *ms_audio_bitrate_controller_new(RtpSession *session, MSFilter *encoder, unsigned int flags);
/**
* Convenience fonction to create a bitrate controller managing a video and an audio stream.
* @param vsession the video RtpSession
* @param venc the video encoder
* @param asession the audio RtpSession
* @param aenc the audio encoder
* This function actually calls internally:
*
* \code
* ms_bitrate_controller_new(ms_av_qos_analyzer_new(asession,vsession),ms_av_bitrate_driver_new(aenc,venc));
* \endcode
**/
MS2_PUBLIC MSBitrateController *ms_av_bitrate_controller_new(RtpSession *asession, MSFilter *aenc, RtpSession *vsession, MSFilter *venc);
MS2_PUBLIC MSBitrateController *ms_bandwidth_bitrate_controller_new(RtpSession *asession, MSFilter *aenc, RtpSession *vsession, MSFilter *venc);
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/bits_rw.h 0000664 0000000 0000000 00000003660 14346134245 0023525 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#if !defined(_BITS_RW_H_)
#define _BITS_RW_H_
#include
typedef struct ms_bits_reader{
const uint8_t *buffer;
size_t buf_size;
int bit_index;
} MSBitsReader;
#ifdef __cplusplus
extern "C" {
#endif
void ms_bits_reader_init(MSBitsReader *reader, const uint8_t *buffer, size_t bufsize);
int ms_bits_reader_n_bits(MSBitsReader *reader, int count, unsigned int *ret, const char* symbol_name);
int ms_bits_reader_ue(MSBitsReader *reader, unsigned int* ret, const char* symbol_name);
int ms_bits_reader_se(MSBitsReader *reader, int* ret, const char* symbol_name);
typedef struct ms_bits_writer {
uint8_t* buffer;
size_t buf_size;
int bit_index;
} MSBitsWriter;
void ms_bits_writer_init(MSBitsWriter *writer, size_t initialbufsize);
int ms_bits_writer_n_bits(MSBitsWriter *writer, int count, unsigned int value, const char* symbol_name);
int ms_bits_writer_ue(MSBitsWriter *writer, unsigned int value, const char* symbol_name);
int ms_bits_writer_se(MSBitsWriter *writer, int value, const char* symbol_name);
int ms_bits_writer_trailing_bits(MSBitsWriter *writer);
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/box-plot.h 0000664 0000000 0000000 00000003404 14346134245 0023614 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef _MS2_BOX_PLOT_H
#define _MS2_BOX_PLOT_H
#include
typedef struct _MSBoxPlot {
int64_t min;
int64_t max;
double mean;
double quad_moment; // E(X^2)
uint64_t count;
} MSBoxPlot;
void ms_box_plot_reset(MSBoxPlot *bp);
void ms_box_plot_add_value(MSBoxPlot *bp, int64_t value);
double ms_box_plot_get_variance(const MSBoxPlot *bp);
double ms_box_plot_get_standard_deviation(const MSBoxPlot *bp);
char *ms_box_plot_to_string(const MSBoxPlot *bp, const char *unit);
typedef struct _MSUBoxPlot {
uint64_t min;
uint64_t max;
double mean;
double quad_moment; // E(X^2)
uint64_t count;
} MSUBoxPlot;
void ms_u_box_plot_reset(MSUBoxPlot *bp);
void ms_u_box_plot_add_value(MSUBoxPlot *bp, uint64_t value);
double ms_u_box_plot_get_variance(const MSUBoxPlot *bp);
double ms_u_box_plot_get_standard_deviation(const MSUBoxPlot *bp);
char *ms_u_box_plot_to_string(const MSUBoxPlot *bp, const char *unit);
#endif // _MS2_BOX_PLOT_H
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/devices.h 0000664 0000000 0000000 00000007560 14346134245 0023501 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef ms_devices_h
#define ms_devices_h
#include
#define DEVICE_HAS_BUILTIN_AEC (1)
#define DEVICE_HAS_BUILTIN_AEC_CRAPPY (1<<1) /* set when the device is claiming to have AEC but we should not trust it */
#define DEVICE_USE_ANDROID_MIC (1<<2) /* set when the device needs to capture using MIC instead of Voice communication (I.E kindle fire) */
#define DEVICE_HAS_BUILTIN_OPENSLES_AEC (1<<3) /* set when the device automatically enables it's AEC when using OpenSLES */
#define DEVICE_HAS_CRAPPY_ANDROID_FASTTRACK (1<<4) /* set when the AUDIO_OUTPUT_FLAG_FAST flag of android AudioTrack doesn't work*/
#define DEVICE_HAS_CRAPPY_ANDROID_FASTRECORD (1<<5) /* set when the AUDIO_INPUT_FLAG_FAST flag of android AudioRecord doesn't work*/
#define DEVICE_HAS_UNSTANDARD_LIBMEDIA (1<<6) /* set when the libmedia backend shall not be used because of proprietary modifications made into it by the manufacturer*/
#define DEVICE_HAS_CRAPPY_OPENGL (1<<7) /* set when the opengl is crappy and our opengl surfaceview will crash */
#define DEVICE_HAS_CRAPPY_OPENSLES (1<<8) /* set when the opensles latency is crappy*/
#define DEVICE_USE_ANDROID_CAMCORDER (1<<9) /* set when the device needs to capture using CAMCORDER instead of Voice communication (I.E kindle fire) */
#define DEVICE_MCH264ENC_NO_PIX_FMT_CONV (1<<10) /* set in order to avoid pixel format convervion before MediaCodec H264 encoder input */
#define DEVICE_MCH265_LIMIT_DEQUEUE_OF_OUTPUT_BUFFERS (1<<11) /* set in order to avoid calling dequeueOutputBuffers() too often. */
#define DEVICE_HAS_CRAPPY_AAUDIO (1<<12) /* set to prevent aaudio plugin to create a soundcard */
struct SoundDeviceAudioHacks {
const char *mic_equalizer;
float mic_gain;
const char *spk_equalizer;
float spk_gain;
};
typedef struct SoundDeviceAudioHacks SoundDeviceAudioHacks;
struct SoundDeviceDescription{
const char *manufacturer;
const char *model;
const char *platform;
unsigned int flags;
int delay;
int recommended_rate;
SoundDeviceAudioHacks *hacks;
};
typedef struct SoundDeviceDescription SoundDeviceDescription;
struct MSDevicesInfo {
MSList *sound_devices_descriptions;
};
typedef struct MSDevicesInfo MSDevicesInfo;
#ifdef __cplusplus
extern "C"{
#endif
MSDevicesInfo *ms_devices_info_new(void);
void ms_devices_info_free(MSDevicesInfo *devices_info);
int ms2_android_get_sdk_version(void);
MS2_PUBLIC void ms_devices_info_add(MSDevicesInfo *devices_info, const char *manufacturer, const char *model, const char *platform, unsigned int flags, int delay, int recommended_rate);
MS2_PUBLIC SoundDeviceDescription* ms_devices_info_lookup_device(MSDevicesInfo *devices_info, const char *manufacturer, const char* model, const char *platform);
MS2_PUBLIC SoundDeviceDescription* ms_devices_info_get_sound_device_description(MSDevicesInfo *devices_info);
MS2_PUBLIC bool_t ms_sound_devices_description_equals(const SoundDeviceDescription *sdd1, const SoundDeviceDescription *sdd2);
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/dsptools.h 0000664 0000000 0000000 00000027731 14346134245 0023730 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
/* This file contains useful DSP routines from the speex project.
*/
/* Copyright (C) 2002-2006 Jean-Marc Valin
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of the Xiph.org Foundation nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ms_dsptools_h
#define ms_dsptools_h
#include
typedef int32_t ms_int32_t;
#ifdef MS_FIXED_POINT
typedef short ms_word16_t;
typedef int ms_word32_t;
typedef int ms_mem_t;
typedef short ms_coef_t;
#define QCONST16(x,bits) ((ms_word16_t)(.5+(x)*(((ms_word32_t)1)<<(bits))))
#define QCONST32(x,bits) ((ms_word32_t)(.5+(x)*(((ms_word32_t)1)<<(bits))))
#define NEG16(x) (-(x))
#define NEG32(x) (-(x))
#define EXTRACT16(x) ((ms_word16_t)(x))
#define EXTEND32(x) ((ms_word32_t)(x))
#define SHR16(a,shift) ((a) >> (shift))
#define SHL16(a,shift) ((a) << (shift))
#define SHR32(a,shift) ((a) >> (shift))
#define SHL32(a,shift) ((a) << (shift))
#define PSHR16(a,shift) (SHR16((a)+((1<<((shift))>>1)),shift))
#define PSHR32(a,shift) (SHR32((a)+((EXTEND32(1)<<((shift))>>1)),shift))
#define VSHR32(a, shift) (((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift)))
#define SATURATE16(x,a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))
#define SATURATE32(x,a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))
#define SHR(a,shift) ((a) >> (shift))
#define SHL(a,shift) ((ms_word32_t)(a) << (shift))
#define PSHR(a,shift) (SHR((a)+((EXTEND32(1)<<((shift))>>1)),shift))
#define SATURATE(x,a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))
#define ADD16(a,b) ((ms_word16_t)((ms_word16_t)(a)+(ms_word16_t)(b)))
#define SUB16(a,b) ((ms_word16_t)(a)-(ms_word16_t)(b))
#define ADD32(a,b) ((ms_word32_t)(a)+(ms_word32_t)(b))
#define SUB32(a,b) ((ms_word32_t)(a)-(ms_word32_t)(b))
/* result fits in 16 bits */
#define MULT16_16_16(a,b) ((((ms_word16_t)(a))*((ms_word16_t)(b))))
/* (ms_word32_t)(ms_word16_t) gives TI compiler a hint that it's 16x16->32 multiply */
#define MULT16_16(a,b) (((ms_word32_t)(ms_word16_t)(a))*((ms_word32_t)(ms_word16_t)(b)))
#define MAC16_16(c,a,b) (ADD32((c),MULT16_16((a),(b))))
#define MULT16_32_Q12(a,b) ADD32(MULT16_16((a),SHR((b),12)), SHR(MULT16_16((a),((b)&0x00000fff)),12))
#define MULT16_32_Q13(a,b) ADD32(MULT16_16((a),SHR((b),13)), SHR(MULT16_16((a),((b)&0x00001fff)),13))
#define MULT16_32_Q14(a,b) ADD32(MULT16_16((a),SHR((b),14)), SHR(MULT16_16((a),((b)&0x00003fff)),14))
#define MULT16_32_Q11(a,b) ADD32(MULT16_16((a),SHR((b),11)), SHR(MULT16_16((a),((b)&0x000007ff)),11))
#define MAC16_32_Q11(c,a,b) ADD32(c,ADD32(MULT16_16((a),SHR((b),11)), SHR(MULT16_16((a),((b)&0x000007ff)),11)))
#define MULT16_32_P15(a,b) ADD32(MULT16_16((a),SHR((b),15)), PSHR(MULT16_16((a),((b)&0x00007fff)),15))
#define MULT16_32_Q15(a,b) ADD32(MULT16_16((a),SHR((b),15)), SHR(MULT16_16((a),((b)&0x00007fff)),15))
#define MAC16_32_Q15(c,a,b) ADD32(c,ADD32(MULT16_16((a),SHR((b),15)), SHR(MULT16_16((a),((b)&0x00007fff)),15)))
#define MAC16_16_Q11(c,a,b) (ADD32((c),SHR(MULT16_16((a),(b)),11)))
#define MAC16_16_Q13(c,a,b) (ADD32((c),SHR(MULT16_16((a),(b)),13)))
#define MAC16_16_P13(c,a,b) (ADD32((c),SHR(ADD32(4096,MULT16_16((a),(b))),13)))
#define MULT16_16_Q11_32(a,b) (SHR(MULT16_16((a),(b)),11))
#define MULT16_16_Q13(a,b) (SHR(MULT16_16((a),(b)),13))
#define MULT16_16_Q14(a,b) (SHR(MULT16_16((a),(b)),14))
#define MULT16_16_Q15(a,b) (SHR(MULT16_16((a),(b)),15))
#define MULT16_16_P13(a,b) (SHR(ADD32(4096,MULT16_16((a),(b))),13))
#define MULT16_16_P14(a,b) (SHR(ADD32(8192,MULT16_16((a),(b))),14))
#define MULT16_16_P15(a,b) (SHR(ADD32(16384,MULT16_16((a),(b))),15))
#define MUL_16_32_R15(a,bh,bl) ADD32(MULT16_16((a),(bh)), SHR(MULT16_16((a),(bl)),15))
#define DIV32_16(a,b) ((ms_word16_t)(((ms_word32_t)(a))/((ms_word16_t)(b))))
#define PDIV32_16(a,b) ((ms_word16_t)(((ms_word32_t)(a)+((ms_word16_t)(b)>>1))/((ms_word16_t)(b))))
#define DIV32(a,b) (((ms_word32_t)(a))/((ms_word32_t)(b)))
#define PDIV32(a,b) (((ms_word32_t)(a)+((ms_word16_t)(b)>>1))/((ms_word32_t)(b)))
#ifdef ARM5E_ASM
#error "Fix me"
#elif defined (ARM4_ASM)
#error "Fix me"
#elif defined (BFIN_ASM)
#undef PDIV32_16
static inline ms_word16_t PDIV32_16(ms_word32_t a, ms_word16_t b)
{
ms_word32_t res, bb;
bb = b;
a += b>>1;
__asm__ (
"P0 = 15;\n\t"
"R0 = %1;\n\t"
"R1 = %2;\n\t"
//"R0 = R0 + R1;\n\t"
"R0 <<= 1;\n\t"
"DIVS (R0, R1);\n\t"
"LOOP divide%= LC0 = P0;\n\t"
"LOOP_BEGIN divide%=;\n\t"
"DIVQ (R0, R1);\n\t"
"LOOP_END divide%=;\n\t"
"R0 = R0.L;\n\t"
"%0 = R0;\n\t"
: "=m" (res)
: "m" (a), "m" (bb)
: "P0", "R0", "R1", "cc");
return res;
}
#undef DIV32_16
static inline ms_word16_t DIV32_16(ms_word32_t a, ms_word16_t b)
{
ms_word32_t res, bb;
bb = b;
/* Make the roundinf consistent with the C version
(do we need to do that?)*/
if (a<0)
a += (b-1);
__asm__ (
"P0 = 15;\n\t"
"R0 = %1;\n\t"
"R1 = %2;\n\t"
"R0 <<= 1;\n\t"
"DIVS (R0, R1);\n\t"
"LOOP divide%= LC0 = P0;\n\t"
"LOOP_BEGIN divide%=;\n\t"
"DIVQ (R0, R1);\n\t"
"LOOP_END divide%=;\n\t"
"R0 = R0.L;\n\t"
"%0 = R0;\n\t"
: "=m" (res)
: "m" (a), "m" (bb)
: "P0", "R0", "R1", "cc");
return res;
}
#undef MAX16
static inline ms_word16_t MAX16(ms_word16_t a, ms_word16_t b)
{
ms_word32_t res;
__asm__ (
"%1 = %1.L (X);\n\t"
"%2 = %2.L (X);\n\t"
"%0 = MAX(%1,%2);"
: "=d" (res)
: "%d" (a), "d" (b)
);
return res;
}
#undef MULT16_32_Q15
static inline ms_word32_t MULT16_32_Q15(ms_word16_t a, ms_word32_t b)
{
ms_word32_t res;
__asm__
(
"A1 = %2.L*%1.L (M);\n\t"
"A1 = A1 >>> 15;\n\t"
"%0 = (A1 += %2.L*%1.H) ;\n\t"
: "=&W" (res), "=&d" (b)
: "d" (a), "1" (b)
: "A1"
);
return res;
}
#undef MAC16_32_Q15
static inline ms_word32_t MAC16_32_Q15(ms_word32_t c, ms_word16_t a, ms_word32_t b)
{
ms_word32_t res;
__asm__
(
"A1 = %2.L*%1.L (M);\n\t"
"A1 = A1 >>> 15;\n\t"
"%0 = (A1 += %2.L*%1.H);\n\t"
"%0 = %0 + %4;\n\t"
: "=&W" (res), "=&d" (b)
: "d" (a), "1" (b), "d" (c)
: "A1"
);
return res;
}
#undef MULT16_32_Q14
static inline ms_word32_t MULT16_32_Q14(ms_word16_t a, ms_word32_t b)
{
ms_word32_t res;
__asm__
(
"%2 <<= 1;\n\t"
"A1 = %1.L*%2.L (M);\n\t"
"A1 = A1 >>> 15;\n\t"
"%0 = (A1 += %1.L*%2.H);\n\t"
: "=W" (res), "=d" (a), "=d" (b)
: "1" (a), "2" (b)
: "A1"
);
return res;
}
#undef MAC16_32_Q14
static inline ms_word32_t MAC16_32_Q14(ms_word32_t c, ms_word16_t a, ms_word32_t b)
{
ms_word32_t res;
__asm__
(
"%1 <<= 1;\n\t"
"A1 = %2.L*%1.L (M);\n\t"
"A1 = A1 >>> 15;\n\t"
"%0 = (A1 += %2.L*%1.H);\n\t"
"%0 = %0 + %4;\n\t"
: "=&W" (res), "=&d" (b)
: "d" (a), "1" (b), "d" (c)
: "A1"
);
return res;
}
#endif
#else
typedef float ms_mem_t;
typedef float ms_coef_t;
typedef float ms_lsp_t;
typedef float ms_sig_t;
typedef float ms_word16_t;
typedef float ms_word32_t;
#define Q15ONE 1.0f
#define LPC_SCALING 1.f
#define SIG_SCALING 1.f
#define LSP_SCALING 1.f
#define GAMMA_SCALING 1.f
#define GAIN_SCALING 1.f
#define GAIN_SCALING_1 1.f
#define VERY_SMALL 1e-15f
#define VERY_LARGE32 1e15f
#define VERY_LARGE16 1e15f
#define Q15_ONE ((ms_word16_t)1.f)
#define QCONST16(x,bits) (x)
#define QCONST32(x,bits) (x)
#define NEG16(x) (-(x))
#define NEG32(x) (-(x))
#define EXTRACT16(x) (x)
#define EXTEND32(x) (x)
#define SHR16(a,shift) (a)
#define SHL16(a,shift) (a)
#define SHR32(a,shift) (a)
#define SHL32(a,shift) (a)
#define PSHR16(a,shift) (a)
#define PSHR32(a,shift) (a)
#define VSHR32(a,shift) (a)
#define SATURATE16(x,a) (x)
#define SATURATE32(x,a) (x)
#define PSHR(a,shift) (a)
#define SHR(a,shift) (a)
#define SHL(a,shift) (a)
#define SATURATE(x,a) (x)
#define ADD16(a,b) ((a)+(b))
#define SUB16(a,b) ((a)-(b))
#define ADD32(a,b) ((a)+(b))
#define SUB32(a,b) ((a)-(b))
#define MULT16_16_16(a,b) ((a)*(b))
#define MULT16_16(a,b) ((ms_word32_t)(a)*(ms_word32_t)(b))
#define MAC16_16(c,a,b) ((c)+(ms_word32_t)(a)*(ms_word32_t)(b))
#define MULT16_32_Q11(a,b) ((a)*(b))
#define MULT16_32_Q13(a,b) ((a)*(b))
#define MULT16_32_Q14(a,b) ((a)*(b))
#define MULT16_32_Q15(a,b) ((a)*(b))
#define MULT16_32_P15(a,b) ((a)*(b))
#define MAC16_32_Q11(c,a,b) ((c)+(a)*(b))
#define MAC16_32_Q15(c,a,b) ((c)+(a)*(b))
#define MAC16_16_Q11(c,a,b) ((c)+(a)*(b))
#define MAC16_16_Q13(c,a,b) ((c)+(a)*(b))
#define MAC16_16_P13(c,a,b) ((c)+(a)*(b))
#define MULT16_16_Q11_32(a,b) ((a)*(b))
#define MULT16_16_Q13(a,b) ((a)*(b))
#define MULT16_16_Q14(a,b) ((a)*(b))
#define MULT16_16_Q15(a,b) ((a)*(b))
#define MULT16_16_P15(a,b) ((a)*(b))
#define MULT16_16_P13(a,b) ((a)*(b))
#define MULT16_16_P14(a,b) ((a)*(b))
#define DIV32_16(a,b) (((ms_word32_t)(a))/(ms_word16_t)(b))
#define PDIV32_16(a,b) (((ms_word32_t)(a))/(ms_word16_t)(b))
#define DIV32(a,b) (((ms_word32_t)(a))/(ms_word32_t)(b))
#define PDIV32(a,b) (((ms_word32_t)(a))/(ms_word32_t)(b))
#endif
#define MIN16(a,b) ((a) < (b) ? (a) : (b)) /**< Maximum 16-bit value. */
#ifdef __cplusplus
extern "C"{
#endif
/*abstraction layer over kiss fft, taken from speex as well*/
/** Compute tables for an FFT */
void *ms_fft_init(int size);
/** Destroy tables for an FFT */
void ms_fft_destroy(void *table);
/** Forward (real to half-complex) transform */
void ms_fft(void *table, ms_word16_t *in, ms_word16_t *out);
/** Backward (half-complex to real) transform */
void ms_ifft(void *table, ms_word16_t *in, ms_word16_t *out);
/** digital filtering api*/
void ms_fir_mem16(const ms_word16_t *x, const ms_coef_t *num, ms_word16_t *y, int N, int ord, ms_mem_t *mem);
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/dtls_srtp.h 0000664 0000000 0000000 00000010233 14346134245 0024064 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef ms_dtls_srtp_h
#define ms_dtls_srtp_h
#include
#include "mediastreamer2/mscommon.h"
#ifdef __cplusplus
extern "C"{
#endif
/* defined in mediastream.h */
struct _MSMediaStreamSessions;
typedef enum {
MSDtlsSrtpRoleInvalid,
MSDtlsSrtpRoleIsServer,
MSDtlsSrtpRoleIsClient,
MSDtlsSrtpRoleUnset
} MSDtlsSrtpRole;
typedef struct MSDtlsSrtpParams {
const char *pem_certificate; /**< Self certificate in pem format */
const char *pem_pkey; /**< Private key associated to self certificate */
MSDtlsSrtpRole role; /**< Unset(at caller init, role is then choosen by responder but we must still be able to receive packets) */
int mtu;
} MSDtlsSrtpParams;
/* an opaque structure containing all context data needed by DTLS-SRTP */
typedef struct _MSDtlsSrtpContext MSDtlsSrtpContext;
/**
* check if DTLS-SRTP is available
* @return TRUE if it is available, FALSE if not
*/
MS2_PUBLIC bool_t ms_dtls_srtp_available(void);
/**
* Create an initialise a DTLS-SRTP context
* @param[in] sessions A link to the stream sessions structures, used to get rtp session to add transport modifier and needed to set SRTP sessions when keys are ready
* @param[in] params Self certificate and private key to be used for this session. Role (client/server) may be given but can be set later
* @return a pointer to the opaque context structure needed by DTLS-SRTP
*/
MS2_PUBLIC MSDtlsSrtpContext* ms_dtls_srtp_context_new(struct _MSMediaStreamSessions *sessions, MSDtlsSrtpParams *params);
/**
* Start the DTLS-SRTP channel: send DTLS ClientHello if we are client
* @param[in/out] context the DTLS-SRTP context
*/
MS2_PUBLIC void ms_dtls_srtp_start(MSDtlsSrtpContext* context);
/**
* Free ressources used by DTLS-SRTP context
* @param[in/out] context the DTLS-SRTP context
*/
MS2_PUBLIC void ms_dtls_srtp_context_destroy(MSDtlsSrtpContext *ctx);
/**
* Reset DTLS context to renegotiate keys and carry out once again SSL handshake next time DTLS starts
* @param[in/out] context the DTLS-SRTP context
*/
MS2_PUBLIC void ms_dtls_srtp_reset_context(MSDtlsSrtpContext *context);
/**
* Set DTLS role: server or client, called when SDP exchange reach the point where we can determine self role
* @param[in/out] context the DTLS-SRTP context
* @param[in] role Client/Server/Invalid/Unset according to SDP INVITE processing
*/
MS2_PUBLIC void ms_dtls_srtp_set_role(MSDtlsSrtpContext *context, MSDtlsSrtpRole role);
/**
* Get DTLS role: server or client, called when SDP exchange reach the point where we can determine self role
* @param[in/out] context the DTLS-SRTP context
* @return role Client/Server/Invalid/Unset according to SDP INVITE processing
*/
MS2_PUBLIC MSDtlsSrtpRole ms_dtls_srtp_get_role(const MSDtlsSrtpContext *context);
/**
* Give to the DTLS-SRTP context the peer certificate fingerprint extracted from trusted SDP INVITE,
* it will be compared(case insensitive) with locally computed one after DTLS handshake is completed successfully and peer certicate retrieved
* @param[in/out] context the DTLS-SRTP context
* @param[in] peer_fingerprint a null terminated string containing the peer certificate as found in the SDP INVITE(including the heading hash algorithm name)
*/
MS2_PUBLIC void ms_dtls_srtp_set_peer_fingerprint(MSDtlsSrtpContext *context, const char *peer_fingerprint);
#ifdef __cplusplus
}
#endif
#endif /* ms_dtls_srtp_h */
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/dtmfgen.h 0000664 0000000 0000000 00000005267 14346134245 0023505 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef dtmfgen_h
#define dtmfgen_h
#include
#define MS_DTMF_GEN_PUT MS_FILTER_METHOD(MS_DTMF_GEN_ID,0,const char)
/** Plays dtmf tone given in argument with default duration*/
#define MS_DTMF_GEN_PLAY MS_FILTER_METHOD(MS_DTMF_GEN_ID,0,const char) /*alias to put*/
/**Start playing a given dtmf, then it has to be stopped using MS_DTMF_GEN_STOP */
#define MS_DTMF_GEN_START MS_FILTER_METHOD(MS_DTMF_GEN_ID,1,const char)
/**Stop currently played dtmf*/
#define MS_DTMF_GEN_STOP MS_FILTER_METHOD_NO_ARG(MS_DTMF_GEN_ID,2)
/**
* Structure describing a custom tone.
**/
struct _MSDtmfGenCustomTone{
char tone_name[8]; /**.
*/
#ifndef flowcontrol_h
#define flowcontrol_h
typedef enum _MSAudioFlowControlStrategy{
MSAudioFlowControlBasic, /**< Immediately drop requested number of samples */
MSAudioFlowControlSoft /**< Elimate silent frames first, use zero-crossing sample deletion */
}MSAudioFlowControlStrategy;
typedef struct _MSAudioFlowControlConfig{
MSAudioFlowControlStrategy strategy;
float silent_threshold; /**< threshold under which a frame is considered as silent (linear), used by "soft" strategy */
}MSAudioFlowControlConfig;
typedef struct _MSAudioFlowController {
MSAudioFlowControlConfig config;
uint32_t target_samples;
uint32_t total_samples;
uint32_t current_pos;
uint32_t current_dropped;
} MSAudioFlowController;
#ifdef __cplusplus
extern "C"{
#endif
MS2_PUBLIC void ms_audio_flow_controller_init(MSAudioFlowController *ctl);
MS2_PUBLIC void ms_audio_flow_controller_set_config(MSAudioFlowController *ctl, const MSAudioFlowControlConfig *config);
MS2_PUBLIC void ms_audio_flow_controller_set_target(MSAudioFlowController *ctl, uint32_t samples_to_drop, uint32_t total_samples);
MS2_PUBLIC mblk_t *ms_audio_flow_controller_process(MSAudioFlowController *ctl, mblk_t *m);
/**
* Structure carried by MS_AUDIO_FLOW_CONTROL_DROP_EVENT
**/
typedef struct _MSAudioFlowControlDropEvent{
uint32_t flow_control_interval_ms;
uint32_t drop_ms;
} MSAudioFlowControlDropEvent;
/**
* Event than can be emitted by any filter each time some samples need to be dropped.
* @FIXME It is badly named. It should belong to MSFilter base class or to a specific audio interface.
**/
#define MS_AUDIO_FLOW_CONTROL_DROP_EVENT MS_FILTER_EVENT(MS_AUDIO_FLOW_CONTROL_ID, 0, MSAudioFlowControlDropEvent)
/**
* Set configuration of the flow controller. It can be changed at run-time.
*/
#define MS_AUDIO_FLOW_CONTROL_SET_CONFIG MS_FILTER_METHOD(MS_AUDIO_FLOW_CONTROL_ID, 0, MSAudioFlowControlConfig)
/**
* Request to drop samples.
*/
#define MS_AUDIO_FLOW_CONTROL_DROP MS_FILTER_METHOD(MS_AUDIO_FLOW_CONTROL_ID, 1, MSAudioFlowControlDropEvent)
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/formats.h 0000664 0000000 0000000 00000004207 14346134245 0023525 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef msformats_h
#define msformats_h
#include "mediastreamer2/mscommon.h"
#ifdef __cplusplus
extern "C"{
#endif
/**
* Simple enum to indicate whether a format is audio or video.
**/
typedef enum _MSFormatType{
MSAudio,
MSVideo,
MSText,
MSUnknownMedia
}MSFormatType;
/**
* to string from enum.
**/
MS2_PUBLIC const char* ms_format_type_to_string(MSFormatType type);
/* those structs are part of the ABI: don't change their size otherwise binary plugins will be broken*/
typedef struct MSVideoSize{
int width,height;
} MSVideoSize;
/**
* Structure describing fully a media format.
**/
struct _MSFmtDescriptor{
MSFormatType type; /**.
*/
#ifndef ice_h
#define ice_h
#include
#include
#include
/**
* @file ice.h
* @brief mediastreamer2 ice.h include file
*
* This file provides the API to handle the ICE protocol defined in the RFC 5245.
*/
/**
* The maximum number of check lists in an ICE session.
*/
#define ICE_SESSION_MAX_CHECK_LISTS 8
#define ICE_RTP_COMPONENT_ID 1
#define ICE_RTCP_COMPONENT_ID 2
/**
* ICE agent role.
*
* See the terminology in paragraph 3 of the RFC 5245 for more details.
*/
typedef enum {
IR_Controlling,
IR_Controlled
} IceRole;
/**
* ICE candidate type.
*
* See the terminology in paragraph 3 of the RFC 5245 for more details.
*/
typedef enum {
ICT_CandidateInvalid = -1,
ICT_HostCandidate,
ICT_ServerReflexiveCandidate,
ICT_PeerReflexiveCandidate,
ICT_RelayedCandidate,
ICT_CandidateTypeMax
} IceCandidateType;
/**
* ICE candidate pair state.
*
* See paragraph 5.7.4 ("Computing states") of RFC 5245 for more details.
*/
typedef enum {
ICP_Waiting,
ICP_InProgress,
ICP_Succeeded,
ICP_Failed,
ICP_Frozen
} IceCandidatePairState;
/**
* ICE check list state.
*
* See paragraph 5.7.4 ("Computing states") of RFC 5245 for more details.
*/
typedef enum {
ICL_Running,
ICL_Completed,
ICL_Failed
} IceCheckListState;
/**
* ICE session state.
*/
typedef enum {
IS_Stopped,
IS_Running,
IS_Completed,
IS_Failed
} IceSessionState;
struct _IceCheckList;
/**
* Structure representing an ICE session.
*/
typedef struct _IceSession {
struct _IceCheckList * streams[ICE_SESSION_MAX_CHECK_LISTS]; /**< Table of IceChecklist structure pointers. Each element represents a media stream */
MSStunAuthRequestedCb stun_auth_requested_cb; /**< Callback called when authentication is requested */
void *stun_auth_requested_userdata; /**< Userdata to pass to the STUN authentication requested callback */
char *local_ufrag; /**< Local username fragment for the session (assigned during the session creation) */
char *local_pwd; /**< Local password for the session (assigned during the session creation) */
char *remote_ufrag; /**< Remote username fragment for the session (provided via SDP by the peer) */
char *remote_pwd; /**< Remote password for the session (provided via SDP by the peer) */
IceRole role; /**< Role played by the agent for this session */
IceSessionState state; /**< State of the session */
uint64_t tie_breaker; /**< Random number used to resolve role conflicts (see paragraph 5.2 of the RFC 5245) */
int32_t ta; /**< Duration of timer for sending connectivity checks in ms */
int event_value; /** Value of the event to send */
MSTimeSpec event_time; /**< Time when an event must be sent */
struct sockaddr_storage ss; /**< STUN server address to use for the candidates gathering process */
socklen_t ss_len; /**< Length of the STUN server address to use for the candidates gathering process */
MSTimeSpec gathering_start_ts;
MSTimeSpec gathering_end_ts;
MSTimeSpec connectivity_checks_start_ts;
IceCandidateType default_types[ICT_CandidateTypeMax];
bool_t check_message_integrity; /*set to false for backward compatibility only*/
bool_t send_event; /**< Boolean value telling whether an event must be sent or not */
uint8_t max_connectivity_checks; /**< Configuration parameter to limit the number of connectivity checks performed by the agent (default is 100) */
uint8_t keepalive_timeout; /**< Configuration parameter to define the timeout between each keepalive packets (default is 15s) */
bool_t forced_relay; /**< Force use of relay by modifying the local and reflexive candidates */
bool_t turn_enabled; /**< TURN protocol enabled */
bool_t short_turn_refresh; /**< Short TURN refresh for tests */
bool_t default_candidates_prefer_ipv6; /** < Whether ipv6 candidates should be prefered compared to their ipv4 equivalent as "default candidate" */
} IceSession;
typedef struct _IceStunServerRequestTransaction {
UInt96 transactionID;
MSTimeSpec request_time;
MSTimeSpec response_time;
} IceStunServerRequestTransaction;
typedef struct _IceStunServerRequest {
struct _IceCheckList *cl;
RtpTransport *rtptp;
MSTurnContext *turn_context;
struct addrinfo *source_ai;
MSList *transactions; /**< List of IceStunServerRequestTransaction structures. */
MSTimeSpec next_transmission_time;
MSStunAddress peer_address;
uint16_t channel_number;
uint16_t stun_method;
uint8_t requested_address_family;
bool_t gathering;
bool_t responded;
bool_t to_remove;
} IceStunServerRequest;
typedef struct _IceStunRequestRoundTripTime {
int nb_responses;
int sum;
} IceStunRequestRoundTripTime;
/**
* Structure representing an ICE transport address.
*/
typedef struct _IceTransportAddress {
char ip[64];
int port;
int family;
// TODO: Handling of transport type: TCP, UDP...
} IceTransportAddress;
/**
* Structure representing an ICE candidate.
*/
typedef struct _IceCandidate {
char foundation[32]; /**< Foundation of the candidate (see paragraph 3 of the RFC 5245 for more details */
IceTransportAddress taddr; /**< Transport address of the candidate */
IceCandidateType type; /**< Type of the candidate */
uint32_t priority; /**< Priority of the candidate */
uint16_t componentID; /**< component ID between 1 and 256: usually 1 for RTP component and 2 for RTCP component */
struct _IceCandidate *base; /**< Pointer to the candidate that is the base of the current one */
bool_t is_default; /**< Boolean value telling whether this candidate is a default candidate or not */
} IceCandidate;
/**
* Structure representing an ICE candidate pair.
*/
typedef struct _IceCandidatePair {
IceRole role; /**< Role of the agent when the connectivity check has been sent for the candidate pair */
IceCandidate *local; /**< Pointer to the local candidate of the pair */
IceCandidate *remote; /**< Pointer to the remote candidate of the pair */
IceCandidatePairState state; /**< State of the candidate pair */
uint64_t priority; /**< Priority of the candidate pair */
MSTimeSpec transmission_time; /**< Time when the connectivity check for the candidate pair has been sent */
int32_t rto; /**< Duration of the retransmit timer for the connectivity check sent for the candidate pair in ms */
uint8_t retransmissions; /**< Number of retransmissions for the connectivity check sent for the candidate pair */
bool_t is_default; /**< Boolean value telling whether this candidate pair is a default candidate pair or not */
bool_t use_candidate; /**< Boolean value telling if the USE-CANDIDATE attribute must be set for the connectivity checks send for the candidate pair */
bool_t is_nominated; /**< Boolean value telling whether this candidate pair is nominated or not */
bool_t nomination_pending; /** Boolean value telling whether this candidate pair was nominated by the remote (in controlled mode), but we could not yet complete the check*/
bool_t has_canceled_transaction; /**< Boolean value telling that the pair has a cancelled transaction, see RFC5245 7.2.1.4. Triggered Checks */
bool_t nomination_failing; /**.
*/
#ifndef MEDIASTREAM_H
#define MEDIASTREAM_H
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup ring_api
* @{
**/
struct _RingStream
{
MSSndCard *card;
MSTicker *ticker;
MSFilter *source;
MSFilter *gendtmf;
MSFilter *write_resampler;
MSFilter *sndwrite;
MSFilter *decoder;
int srcpin;
};
typedef struct _RingStream RingStream;
MS2_PUBLIC RingStream *ring_start(MSFactory *factory, const char * file, int interval, MSSndCard *sndcard);
MS2_PUBLIC RingStream *ring_start_with_cb(MSFactory *factory, const char * file, int interval, MSSndCard *sndcard, MSFilterNotifyFunc func, void * user_data);
MS2_PUBLIC void ring_stop (RingStream * stream);
/**
* Asks the ring filter to route to the selected sound card (currently only used for AAudio and OpenSLES)
* @param[in] stream The RingStream object
* @param[in] sndcard_playback The wanted audio output soundcard
*/
MS2_PUBLIC void ring_stream_set_output_ms_snd_card(RingStream *stream, MSSndCard * sndcard_playback);
/**
* Retrieve the current sound card from the audio playback filter (currently only used for AAudio and OpenSLES)
* @param[in] stream The AudioStream object
*/
MS2_PUBLIC MSSndCard * ring_stream_get_output_ms_snd_card(RingStream *stream);
/**
* @}
**/
/**
* The MediaStream is an object describing a stream (one of AudioStream or VideoStream).
**/
typedef struct _MediaStream MediaStream;
/*
* internal cb to process rtcp stream
* */
typedef void (*media_stream_process_rtcp_callback_t)(MediaStream *stream, mblk_t *m);
struct _MSMediaStreamSessions{
RtpSession *rtp_session;
MSSrtpCtx* srtp_context;
MSZrtpContext *zrtp_context;
MSDtlsSrtpContext *dtls_context;
MSTicker *ticker;
};
#ifndef MS_MEDIA_STREAM_SESSIONS_DEFINED
typedef struct _MSMediaStreamSessions MSMediaStreamSessions;
#define MS_MEDIA_STREAM_SESSIONS_DEFINED 1
#endif
MS2_PUBLIC void ms_media_stream_sessions_uninit(MSMediaStreamSessions *sessions);
typedef enum _MSStreamState{
MSStreamInitialized,
MSStreamPreparing,
MSStreamStarted,
MSStreamStopped
}MSStreamState;
typedef enum MediaStreamDir{
MediaStreamSendRecv,
MediaStreamSendOnly,
MediaStreamRecvOnly,
}MediaStreamDir;
/**
* Base struct for both AudioStream and VideoStream structure.
**/
struct _MediaStream {
MSFormatType type;
MSStreamState state;
MSMediaStreamSessions sessions;
OrtpEvQueue *evq;
MSFilter *rtprecv;
MSFilter *rtpsend;
MSFilter *encoder;
MSFilter *decoder;
MSFilter *voidsink;
MSBitrateController *rc;
MSQualityIndicator *qi;
IceCheckList *ice_check_list;
time_t start_time;
time_t last_iterate_time;
uint64_t last_packet_count;
time_t last_packet_time;
MSQosAnalyzerAlgorithm rc_algorithm;
PayloadType *current_pt;/*doesn't need to be freed*/
bool_t rc_enable;
bool_t is_beginning;
bool_t owns_sessions;
bool_t stun_allowed; /* Whether sending basic stun packet as keepalive is permitted, default is yes */
/**
* defines encoder target network bit rate, uses #media_stream_set_target_network_bitrate() setter.
* */
int target_bitrate;
int max_target_bitrate;
media_stream_process_rtcp_callback_t process_rtcp;
OrtpEvDispatcher *evd;
MSFactory *factory;
MSBandwidthController *bandwidth_controller;
MSVideoQualityController *video_quality_controller;
MediaStreamDir direction;
};
MS2_PUBLIC void media_stream_init(MediaStream *stream, MSFactory *factory, const MSMediaStreamSessions *sessions);
MS2_PUBLIC MSFactory* media_stream_get_factory(MediaStream *stream);
/**
* @addtogroup audio_stream_api
* @{
**/
MS2_PUBLIC bool_t media_stream_started(MediaStream *stream);
MS2_PUBLIC int media_stream_join_multicast_group(MediaStream *stream, const char *ip);
MS2_PUBLIC bool_t media_stream_dtls_supported(void);
/* enable DTLS on the media stream */
MS2_PUBLIC void media_stream_enable_dtls(MediaStream *stream, const MSDtlsSrtpParams *params);
MS2_PUBLIC void media_stream_set_rtcp_information(MediaStream *stream, const char *cname, const char *tool);
MS2_PUBLIC void media_stream_get_local_rtp_stats(MediaStream *stream, rtp_stats_t *stats);
MS2_PUBLIC int media_stream_set_dscp(MediaStream *stream, int dscp);
MS2_PUBLIC void media_stream_enable_adaptive_bitrate_control(MediaStream *stream, bool_t enabled);
MS2_PUBLIC void media_stream_set_adaptive_bitrate_algorithm(MediaStream *stream, MSQosAnalyzerAlgorithm algorithm);
MS2_PUBLIC void media_stream_enable_adaptive_jittcomp(MediaStream *stream, bool_t enabled);
MS2_PUBLIC void media_stream_set_ice_check_list(MediaStream *stream, IceCheckList *cl);
MS2_PUBLIC void media_stream_set_stun_allowed(MediaStream *stream, bool_t value);
/*
* deprecated, use media_stream_set_srtp_recv_key and media_stream_set_srtp_send_key.
**/
MS2_PUBLIC bool_t media_stream_enable_srtp(MediaStream* stream, MSCryptoSuite suite, const char* snd_key, const char* rcv_key);
/**
* @param[in] stream MediaStream object
* @return true if stream is encrypted
* */
MS2_PUBLIC bool_t media_stream_secured(const MediaStream *stream);
#define media_stream_is_secured media_stream_secured
/**
* Tells whether AVPF is enabled or not.
* @param[in] stream #MediaStream object.
* @return True if AVPF is enabled, false otherwise.
*/
MS2_PUBLIC bool_t media_stream_avpf_enabled(const MediaStream *stream);
/**
* Gets the AVPF Regular RTCP report interval.
* @param[in] stream #MediaStream object.
* @return The AVPF Regular RTCP report interval in seconds.
*/
MS2_PUBLIC uint16_t media_stream_get_avpf_rr_interval(const MediaStream *stream);
/**
* Gets the RTP session of the media stream.
* @param[in] stream #MediaStream object.
* @return The RTP session of the media stream.
*/
MS2_PUBLIC RtpSession * media_stream_get_rtp_session(const MediaStream *stream);
MS2_PUBLIC const MSQualityIndicator *media_stream_get_quality_indicator(MediaStream *stream);
/* *
* returns a realtime indicator of the stream quality between 0 and 5
* */
MS2_PUBLIC float media_stream_get_quality_rating(MediaStream *stream);
MS2_PUBLIC float media_stream_get_average_quality_rating(MediaStream *stream);
MS2_PUBLIC float media_stream_get_lq_quality_rating(MediaStream *stream);
MS2_PUBLIC float media_stream_get_average_lq_quality_rating(MediaStream *stream);
/**
*
For multirate codecs like OPUS, encoder output target bitrate must be set.
*
Encoder will compute output codec bitrate from this value.
*
default value is the value corresponding the rtp PayloadType
* @param stream stream to apply parameter on
* @param target_bitrate in bit per seconds
* @return 0 if succeed
* */
MS2_PUBLIC int media_stream_set_target_network_bitrate(MediaStream *stream,int target_bitrate);
/**
* Set a maximum target bitrate for the stream. Indeed, the MSBandwidthController may adapt the target bitrate
* according to network conditions, which includes the possibility to increase it if remote side sends a TMMBR
* to invite to increase bitrate. The max_network_bitrate defines the upper limit for increasing the bitrate usage automatically.
* @param stream stream to apply parameter on
* @param target_bitrate in bit per seconds
**/
MS2_PUBLIC int media_stream_set_max_network_bitrate(MediaStream *stream,int max_bitrate);
/**
* get the stream target bitrate.
* @param stream stream to apply parameter on
* @return target_bitrate in bit per seconds
* */
MS2_PUBLIC int media_stream_get_target_network_bitrate(const MediaStream *stream);
/**
* get current stream upload bitrate. Value is updated every seconds
* @param stream
* @return bitrate in bit per seconds
* */
MS2_PUBLIC float media_stream_get_up_bw(const MediaStream *stream);
/**
* get current stream download bitrate. Value is updated every seconds
* @param stream
* @return bitrate in bit per seconds
* */
MS2_PUBLIC float media_stream_get_down_bw(const MediaStream *stream);
/**
* get current stream rtcp upload bitrate. Value is updated every seconds
* @param stream
* @return bitrate in bit per seconds
* */
MS2_PUBLIC float media_stream_get_rtcp_up_bw(const MediaStream *stream);
/**
* get current stream rtcp download bitrate. Value is updated every seconds
* @param stream
* @return bitrate in bit per seconds
* */
MS2_PUBLIC float media_stream_get_rtcp_down_bw(const MediaStream *stream);
/**
* Returns the sessions that were used in the media stream (RTP, SRTP, ZRTP...) so that they can be re-used.
* As a result of calling this function, the media stream no longer owns the sessions and thus will not free them.
**/
MS2_PUBLIC void media_stream_reclaim_sessions(MediaStream *stream, MSMediaStreamSessions *sessions);
MS2_PUBLIC void media_stream_iterate(MediaStream * stream);
MS2_PUBLIC void media_stream_set_direction(MediaStream *stream, MediaStreamDir dir);
MS2_PUBLIC MediaStreamDir media_stream_get_direction(const MediaStream *stream);
/**
* Returns TRUE if stream was still actively receiving packets (RTP or RTCP) in the last period specified in timeout_seconds.
**/
MS2_PUBLIC bool_t media_stream_alive(MediaStream *stream, int timeout_seconds);
/**
* @return current streams state
* */
MS2_PUBLIC MSStreamState media_stream_get_state(const MediaStream *stream);
MS2_PUBLIC OrtpEvDispatcher* media_stream_get_event_dispatcher(const MediaStream *stream);
/**
* Retrieve the receive ssrc of the stream
*
* @param stream the media stream
* @return the receive ssrc of the stream
*/
MS2_PUBLIC uint32_t media_stream_get_recv_ssrc(const MediaStream *stream);
/**
* Retrieve the send ssrc of the stream
*
* @param stream the media stream
* @return the send ssrc of the stream
*/
MS2_PUBLIC uint32_t media_stream_get_send_ssrc(const MediaStream *stream);
typedef enum EchoLimiterType{
ELInactive,
ELControlMic,
ELControlFull
} EchoLimiterType;
typedef enum EqualizerLocation {
MSEqualizerHP = 0,
MSEqualizerMic
} EqualizerLocation;
typedef enum MSResourceType{
MSResourceInvalid,
MSResourceDefault,
MSResourceFile,
MSResourceRtp,
MSResourceCamera,
MSResourceSoundcard,
MSResourceVoid,
MSResourceItc
}MSResourceType;
MS2_PUBLIC const char *ms_resource_type_to_string(MSResourceType type);
/**
* Structure describing the input or the output of a MediaStream.
* type must be set to one the member of the MSResourceType enum, and the correspoding
* resource argument must be set: the file name (const char*) for MSResourceFile,
* the RtpSession for MSResourceRtp, an MSWebCam for MSResourceCamera, an MSSndCard for MSResourceSoundcard.
* an MSFilter for MSResourceItc
* @warning due to implementation, if RTP is to be used for input and output, the same RtpSession must be passed for both sides.
*/
typedef struct _MSMediaResource{
MSResourceType type;
union{
void *resource_arg;
const char *file;
RtpSession *session;
MSWebCam *camera;
MSSndCard *soundcard;
MSFilter *itc;
};
}MSMediaResource;
MS2_PUBLIC bool_t ms_media_resource_is_consistent(const MSMediaResource *r);
#define ms_media_resource_get_file(r) (((r)->type == MSResourceFile) ? (r)->file : NULL)
#define ms_media_resource_get_rtp_session(r) (((r)->type == MSResourceRtp) ? (r)->session : NULL)
#define ms_media_resource_get_camera(r) (((r)->type == MSResourceCamera) ? (r)->camera : NULL)
#define ms_media_resource_get_soundcard(r) (((r)->type == MSResourceSoundcard) ? (r)->soundcard : NULL)
/**
* Structure describing the input/output of a MediaStream.
* Input and output are described as MSMediaResource.
*/
typedef struct _MSMediaStreamIO {
MSMediaResource input;
MSMediaResource output;
} MSMediaStreamIO;
#define MS_MEDIA_STREAM_IO_INITIALIZER { {MSResourceInvalid}, {MSResourceInvalid} }
MS2_PUBLIC bool_t ms_media_stream_io_is_consistent(const MSMediaStreamIO *io);
typedef void (*AudioStreamIsSpeakingCallback)(void *user_pointer, uint32_t speaker_ssrc, bool_t is_speaking);
typedef void (*AudioStreamIsMutedCallback)(void *user_pointer, uint32_t speaker_ssrc, bool_t is_muted);
typedef void (*MSAudioRouteChangedCallback)(void* audioStream, bool_t needReloadSoundDevices, char* newInputPort, char* newOutputPort);
struct _AudioStream
{
MediaStream ms;
MSSndCard *playcard;
MSSndCard *captcard;
MSFilter *soundread;
MSFilter *soundwrite;
MSFilter *dtmfgen;
MSFilter *dtmfgen_rtp;
MSFilter *plc;
MSFilter *ec;/*echo canceler*/
MSFilter *volsend,*volrecv; /*MSVolumes*/
MSFilter *local_mixer;
MSFilter *local_player;
MSFilter *local_player_resampler;
MSFilter *read_decoder; /* Used when the input is done via RTP */
MSFilter *write_encoder; /* Used when the output is done via RTP */
MSFilter *read_resampler;
MSFilter *write_resampler;
MSFilter *mic_equalizer;
MSFilter *spk_equalizer;
MSFilter *dummy;
MSFilter *recv_tee;
MSFilter *recorder_mixer;
MSFilter *recorder;
MSFilter *outbound_mixer;
struct {
MSFilter *resampler;
MSFilter *encoder;
MSFilter *recorder;
MSFilter *video_input;
}av_recorder;
struct _AVPlayer{
MSFilter *player;
MSFilter *resampler;
MSFilter *decoder;
MSFilter *video_output;
int audiopin;
int videopin;
bool_t plumbed;
}av_player;
MSFilter *flowcontrol;
RtpSession *rtp_io_session; /**< The RTP session used for RTP input/output. */
MSFilter *vaddtx;
char *recorder_file;
EchoLimiterType el_type; /*use echo limiter: two MSVolume, measured input level controlling local output level*/
EqualizerLocation eq_loc;
uint32_t features;
int sample_rate;
int nchannels;
struct _VideoStream *videostream;/*the stream with which this audiostream is paired*/
MSAudioRoute audio_route;
bool_t play_dtmfs;
bool_t use_ec;
bool_t use_gc;
bool_t use_agc;
bool_t mic_eq_active;
bool_t spk_eq_active;
bool_t use_ng;/*noise gate*/
bool_t is_ec_delay_set;
bool_t disable_record_on_mute;
float last_mic_gain_level_db;
struct _AudioStreamVolumes *participants_volumes;
int mixer_to_client_extension_id;
int client_to_mixer_extension_id;
uint32_t speaking_ssrc;
AudioStreamIsSpeakingCallback is_speaking_cb;
AudioStreamIsMutedCallback is_muted_cb;
void *user_pointer;
bool_t is_speaking;
MSAudioRouteChangedCallback audio_route_changed_cb;
void * audio_route_changed_cb_user_data;
};
/**
* The AudioStream holds all resources to create and run typical VoIP audiostream.
**/
typedef struct _AudioStream AudioStream;
/* start a thread that does sampling->encoding->rtp_sending|rtp_receiving->decoding->playing */
MS2_PUBLIC AudioStream *audio_stream_start(MSFactory* factory, RtpProfile * prof, int locport, const char *remip,
int remport, int payload_type, int jitt_comp, bool_t echo_cancel);
MS2_PUBLIC AudioStream *audio_stream_start_with_sndcards(MSFactory* factory, RtpProfile* prof, int locport, const char *remip4, int remport, int payload_type, int jitt_comp, MSSndCard *playcard,
MSSndCard *captcard, bool_t echocancel);
MS2_PUBLIC int audio_stream_start_with_files (AudioStream * stream, RtpProfile * prof,
const char *remip, int remport, int rem_rtcp_port,
int pt, int jitt_comp,
const char * infile, const char * outfile);
/**
* Start an audio stream according to the specified AudioStreamIO.
*
* @param[in] stream AudioStream object previously created with audio_stream_new().
* @param[in] profile RtpProfile object holding the PayloadType that can be used during the audio session.
* @param[in] rem_rtp_ip The remote IP address where to send the encoded audio to.
* @param[in] rem_rtp_port The remote port where to send the encoded audio to.
* @param[in] rem_rtcp_ip The remote IP address for RTCP.
* @param[in] rem_rtcp_port The remote port for RTCP.
* @param[in] payload_type The payload type number used to send the audio stream. A valid PayloadType must be available at this index in the profile.
* @param[in] io A MSMediaStreamIO describing the local input/output of the audio stream.
*/
MS2_PUBLIC int audio_stream_start_from_io(AudioStream *stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload_type, const MSMediaStreamIO *io);
/**
* Starts an audio stream from/to local wav files or soundcards.
*
* This method starts the processing of the audio stream, that is playing from wav file or soundcard, voice processing, encoding,
* sending through RTP, receiving from RTP, decoding, voice processing and wav file recording or soundcard playback.
*
*
* @param stream an AudioStream previously created with audio_stream_new().
* @param profile a RtpProfile containing all PayloadType possible during the audio session.
* @param rem_rtp_ip remote IP address where to send the encoded audio.
* @param rem_rtp_port remote IP port where to send the encoded audio.
* @param rem_rtcp_ip remote IP address for RTCP.
* @param rem_rtcp_port remote port for RTCP.
* @param payload payload type index to use for the sending stream. This index must point to a valid PayloadType in the RtpProfile.
* @param jitt_comp Nominal jitter buffer size in milliseconds.
* @param infile path to wav file to play out (can be NULL)
* @param outfile path to wav file to record into (can be NULL)
* @param playcard The soundcard to be used for playback (can be NULL)
* @param captcard The soundcard to be used for catpure. (can be NULL)
* @param use_ec whether echo cancellation is to be performed.
* @return 0 if sucessful, -1 otherwise.
**/
MS2_PUBLIC int audio_stream_start_full(AudioStream *stream, RtpProfile *profile, const char *rem_rtp_ip,int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload,int jitt_comp, const char *infile, const char *outfile,
MSSndCard *playcard, MSSndCard *captcard, bool_t use_ec);
MS2_PUBLIC void audio_stream_play(AudioStream *st, const char *name);
MS2_PUBLIC void audio_stream_record(AudioStream *st, const char *name);
static MS2_INLINE void audio_stream_set_rtcp_information(AudioStream *st, const char *cname, const char *tool) {
media_stream_set_rtcp_information(&st->ms, cname, tool);
}
MS2_PUBLIC void audio_stream_play_received_dtmfs(AudioStream *st, bool_t yesno);
/**
* Creates an AudioStream object listening on a RTP port.
* @param loc_rtp_port the local UDP port to listen for RTP packets.
* @param loc_rtcp_port the local UDP port to listen for RTCP packets
* @param ipv6 TRUE if ipv6 must be used.
* @param factory
* @return a new AudioStream.
**/
MS2_PUBLIC AudioStream *audio_stream_new(MSFactory* factory, int loc_rtp_port, int loc_rtcp_port, bool_t ipv6);
/**
* Creates an AudioStream object listening on a RTP port for a dedicated address.
* @param loc_ip the local ip to listen for RTP packets. Can be ::, O.O.O.O or any ip4/6 addresses
* @param loc_rtp_port the local UDP port to listen for RTP packets.
* @param loc_rtcp_port the local UDP port to listen for RTCP packets
* @param factory
* @return a new AudioStream.
**/
MS2_PUBLIC AudioStream *audio_stream_new2(MSFactory* factory, const char* ip, int loc_rtp_port, int loc_rtcp_port);
/**Creates an AudioStream object from initialized MSMediaStreamSessions.
* @param sessions the MSMediaStreamSessions
* @param factory the MSFActory from the core object
* @return a new AudioStream
**/
MS2_PUBLIC AudioStream *audio_stream_new_with_sessions(MSFactory* factory, const MSMediaStreamSessions *sessions);
#define AUDIO_STREAM_FEATURE_PLC (1 << 0)
#define AUDIO_STREAM_FEATURE_EC (1 << 1)
#define AUDIO_STREAM_FEATURE_EQUALIZER (1 << 2)
#define AUDIO_STREAM_FEATURE_VOL_SND (1 << 3)
#define AUDIO_STREAM_FEATURE_VOL_RCV (1 << 4)
#define AUDIO_STREAM_FEATURE_DTMF (1 << 5)
#define AUDIO_STREAM_FEATURE_DTMF_ECHO (1 << 6)
#define AUDIO_STREAM_FEATURE_MIXED_RECORDING (1 << 7)
#define AUDIO_STREAM_FEATURE_LOCAL_PLAYING (1 << 8)
#define AUDIO_STREAM_FEATURE_REMOTE_PLAYING (1 << 9)
#define AUDIO_STREAM_FEATURE_FLOW_CONTROL (1 << 10)
#define AUDIO_STREAM_FEATURE_ALL (\
AUDIO_STREAM_FEATURE_PLC | \
AUDIO_STREAM_FEATURE_EC | \
AUDIO_STREAM_FEATURE_EQUALIZER | \
AUDIO_STREAM_FEATURE_VOL_SND | \
AUDIO_STREAM_FEATURE_VOL_RCV | \
AUDIO_STREAM_FEATURE_DTMF | \
AUDIO_STREAM_FEATURE_DTMF_ECHO |\
AUDIO_STREAM_FEATURE_MIXED_RECORDING |\
AUDIO_STREAM_FEATURE_LOCAL_PLAYING | \
AUDIO_STREAM_FEATURE_REMOTE_PLAYING | \
AUDIO_STREAM_FEATURE_FLOW_CONTROL \
)
MS2_PUBLIC uint32_t audio_stream_get_features(AudioStream *st);
MS2_PUBLIC void audio_stream_set_features(AudioStream *st, uint32_t features);
MS2_PUBLIC void audio_stream_prepare_sound(AudioStream *st, MSSndCard *playcard, MSSndCard *captcard);
MS2_PUBLIC void audio_stream_unprepare_sound(AudioStream *st);
MS2_PUBLIC bool_t audio_stream_started(AudioStream *stream);
/**
* Starts an audio stream from local soundcards.
*
* This method starts the processing of the audio stream, that is capture from soundcard, voice processing, encoding,
* sending through RTP, receiving from RTP, decoding, voice processing and soundcard playback.
*
* @param stream an AudioStream previously created with audio_stream_new().
* @param prof a RtpProfile containing all PayloadType possible during the audio session.
* @param remip remote IP address where to send the encoded audio.
* @param remport remote IP port where to send the encoded audio
* @param rem_rtcp_port remote port for RTCP.
* @param payload_type payload type index to use for the sending stream. This index must point to a valid PayloadType in the RtpProfile.
* @param jitt_comp Nominal jitter buffer size in milliseconds.
* @param playcard The soundcard to be used for playback
* @param captcard The soundcard to be used for catpure.
* @param echo_cancel whether echo cancellation is to be performed.
**/
MS2_PUBLIC int audio_stream_start_now(AudioStream * stream, RtpProfile * prof, const char *remip, int remport, int rem_rtcp_port, int payload_type, int jitt_comp,MSSndCard *playcard, MSSndCard *captcard, bool_t echo_cancel);
MS2_PUBLIC void audio_stream_set_relay_session_id(AudioStream *stream, const char *relay_session_id);
/*returns true if we are still receiving some data from remote end in the last timeout seconds*/
MS2_PUBLIC bool_t audio_stream_alive(AudioStream * stream, int timeout);
/**
* Executes background low priority tasks related to audio processing (RTP statistics analysis).
* It should be called periodically, for example with an interval of 100 ms or so.
*/
MS2_PUBLIC void audio_stream_iterate(AudioStream *stream);
/**
* enable echo-limiter dispositve: one MSVolume in input branch controls a MSVolume in the output branch
* */
MS2_PUBLIC void audio_stream_enable_echo_limiter(AudioStream *stream, EchoLimiterType type);
/**
* enable gain control, to be done before start()
* */
MS2_PUBLIC void audio_stream_enable_gain_control(AudioStream *stream, bool_t val);
/**
* enable automatic gain control, to be done before start()
* */
MS2_PUBLIC void audio_stream_enable_automatic_gain_control(AudioStream *stream, bool_t val);
/**
* to be done before start
* */
MS2_PUBLIC void audio_stream_set_echo_canceller_params(AudioStream *st, int tail_len_ms, int delay_ms, int framesize);
/**
* to be done before start
* */
MS2_PUBLIC void audio_stream_enable_echo_canceller(AudioStream *st, bool_t enabled);
/**
* enable adaptive rate control
* */
static MS2_INLINE void audio_stream_enable_adaptive_bitrate_control(AudioStream *stream, bool_t enabled) {
media_stream_enable_adaptive_bitrate_control(&stream->ms, enabled);
}
/**
* Enable adaptive jitter compensation
* */
static MS2_INLINE void audio_stream_enable_adaptive_jittcomp(AudioStream *stream, bool_t enabled) {
media_stream_enable_adaptive_jittcomp(&stream->ms, enabled);
}
/**
* Calling this method with disable=true will cause the microhone to be completely deactivated when muted
* Currently only implemented for IOS, this will cause the playback sound to be interrupted for a short moment while the audio is reconfigured.
* On IOS 14, it will also disable Apple's microphone recording indicator when microphone is muted.
*
* @param stream The stream.
* @param disable True if you wish to entirely stop the audio recording when muting the microphone.
*/
MS2_PUBLIC void audio_stream_disable_record_on_mute(AudioStream *stream, bool_t disable);
/**
* Mute or unmute the microphone
* For IOS, if "audio_stream_disable_record_on_mute" was enabled, this will completely stop the microphone recording.
* Else, sound recording remains active but silence is sent instead of recorded audiow@
*
* @param stream The stream.
* @param enable Wether the microphone must be enabled.
*/
MS2_PUBLIC void audio_stream_enable_mic(AudioStream *stream, bool_t enable);
/**
* Apply a software gain on the microphone.
* Be note that this method neither changes the volume gain
* of the sound card nor the system mixer one. If you intends
* to control the volume gain at sound card level, you should
* use audio_stream_set_sound_card_input_gain() instead.
*
* @param stream The stream.
* @param gain_db Gain to apply in dB.
*/
MS2_PUBLIC void audio_stream_set_mic_gain_db(AudioStream *stream, float gain_db);
/**
* @deprecated
* Like audio_stream_set_mic_gain_db() excepted that the gain is specified
* in percentage.
*
* @param stream The stream.
* @param gain Gain to apply in percentage of the max supported gain.
*/
MS2_PUBLIC void audio_stream_set_mic_gain(AudioStream *stream, float gain);
/**
* enable/disable rtp stream
*/
MS2_PUBLIC void audio_stream_mute_rtp(AudioStream *stream, bool_t val);
/**
* Apply a gain on received RTP packets.
* @param stream An AudioStream.
* @param gain_db Gain to apply in dB.
*/
MS2_PUBLIC void audio_stream_set_spk_gain_db(AudioStream *stream, float gain_db);
/**
* Like audio_stream_set_spk_gain_db() excepted that the gain is specified
* in percentage.
*
* @param stream The stream.
* @param gain Gain to apply in percentage of the max supported gain.
*/
MS2_PUBLIC void audio_stream_set_spk_gain(AudioStream *stream, float gain);
/**
* Set microphone volume gain.
* If the sound backend supports it, the set volume gain will be synchronized
* with the host system mixer. If you intended to apply a static software gain,
* you should use audio_stream_set_mic_gain_db() or audio_stream_set_mic_gain().
*
* @param stream The audio stream.
* @param gain Percentage of the max supported volume gain. Valid values are in [0.0 : 1.0].
*/
MS2_PUBLIC void audio_stream_set_sound_card_input_gain(AudioStream *stream, float gain);
/**
* Get microphone volume gain.
* @param stream The audio stream.
* @return double Volume gain in percentage of the max suppored gain.
* Valid returned values are in [0.0 : 1.0]. A negative value is returned in case of failure.
*/
MS2_PUBLIC float audio_stream_get_sound_card_input_gain(const AudioStream *stream);
/**
* Set speaker volume gain.
* If the sound backend supports it, the set volume gain will be synchronized
* with the host system mixer.
* @param stream The audio stream.
* @param gain Percentage of the max supported volume gain. Valid values are in [0.0 : 1.0].
*/
MS2_PUBLIC void audio_stream_set_sound_card_output_gain(AudioStream *stream, float volume);
/**
* Get speaker volume gain.
* @param stream The audio stream.
* @return Volume gain in percentage of the max suppored gain.
* Valid returned values are in [0.0 : 1.0]. A negative value is returned in case of failure.
*/
MS2_PUBLIC float audio_stream_get_sound_card_output_gain(const AudioStream *stream);
/**
* enable noise gate, must be done before start()
* */
MS2_PUBLIC void audio_stream_enable_noise_gate(AudioStream *stream, bool_t val);
/**
* Enable a parametric equalizer
* @param[in] stream An AudioStream
* @param[in] location Location of the equalizer to enable (speaker or microphone)
* @param[in] enabled Whether the equalizer must be enabled
*/
MS2_PUBLIC void audio_stream_enable_equalizer(AudioStream *stream, EqualizerLocation location, bool_t enabled);
/**
* Apply a gain on a given frequency band.
* @param[in] stream An AudioStream
* @param[in] location Location of the concerned equalizer (speaker or microphone)
* @param[in] gain Description of the band and the gain to apply.
*/
MS2_PUBLIC void audio_stream_equalizer_set_gain(AudioStream *stream, EqualizerLocation location, const MSEqualizerGain *gain);
/**
* stop the audio streaming thread and free everything
* */
MS2_PUBLIC void audio_stream_stop (AudioStream * stream);
/**
* send a dtmf
* */
MS2_PUBLIC int audio_stream_send_dtmf (AudioStream * stream, char dtmf);
MS2_PUBLIC MSFilter *audio_stream_get_local_player(AudioStream *stream);
MS2_PUBLIC int audio_stream_set_mixed_record_file(AudioStream *st, const char*filename);
MS2_PUBLIC int audio_stream_mixed_record_start(AudioStream *st);
MS2_PUBLIC int audio_stream_mixed_record_stop(AudioStream *st);
/**
* Open a player to play an audio/video file to remote end.
* The player is returned as a MSFilter so that application can make usual player controls on it using the MSPlayerInterface.
**/
MS2_PUBLIC MSFilter * audio_stream_open_remote_play(AudioStream *stream, const char *filename);
MS2_PUBLIC void audio_stream_close_remote_play(AudioStream *stream);
MS2_PUBLIC void audio_stream_set_default_card(int cardindex);
/* retrieve RTP statistics*/
static MS2_INLINE void audio_stream_get_local_rtp_stats(AudioStream *stream, rtp_stats_t *stats) {
media_stream_get_local_rtp_stats(&stream->ms, stats);
}
/* returns a realtime indicator of the stream quality between 0 and 5 */
MS2_PUBLIC float audio_stream_get_quality_rating(AudioStream *stream);
/* returns the quality rating as an average since the start of the streaming session.*/
MS2_PUBLIC float audio_stream_get_average_quality_rating(AudioStream *stream);
/* returns a realtime indicator of the listening quality of the stream between 0 and 5 */
MS2_PUBLIC float audio_stream_get_lq_quality_rating(AudioStream *stream);
/* returns the listening quality rating as an average since the start of the streaming session.*/
MS2_PUBLIC float audio_stream_get_average_lq_quality_rating(AudioStream *stream);
/* enable ZRTP on the audio stream */
MS2_PUBLIC void audio_stream_enable_zrtp(AudioStream *stream, MSZrtpParams *params);
MS2_PUBLIC void audio_stream_start_zrtp(AudioStream *stream);
/**
* return TRUE if zrtp is enabled, it does not mean that stream is encrypted, but only that zrtp is configured to know encryption status, uses #
* */
bool_t audio_stream_zrtp_enabled(const AudioStream *stream);
/* enable SRTP on the audio stream */
static MS2_INLINE bool_t audio_stream_enable_srtp(AudioStream* stream, MSCryptoSuite suite, const char* snd_key, const char* rcv_key) {
return media_stream_enable_srtp(&stream->ms, suite, snd_key, rcv_key);
}
static MS2_INLINE int audio_stream_set_dscp(AudioStream *stream, int dscp) {
return media_stream_set_dscp(&stream->ms, dscp);
}
/**
* Gets the RTP session of an audio stream.
* @param[in] stream #MediaStream object.
* @return The RTP session of the audio stream.
*/
static MS2_INLINE RtpSession * audio_stream_get_rtp_session(const AudioStream *stream) {
return media_stream_get_rtp_session(&stream->ms);
}
/**
* Sets the header extension id for mixer to client audio level indication.
* This has to be called before starting the audio stream.
*
* @param stream the audio stream
* @param extension_id the extension id
*/
MS2_PUBLIC void audio_stream_set_mixer_to_client_extension_id(AudioStream *stream, int extension_id);
/**
* Sets the header extension id for client to mixer audio level indication.
* This has to be called before starting the audio stream.
*
* @param stream the audio stream
* @param extension_id the extension id
*/
MS2_PUBLIC void audio_stream_set_client_to_mixer_extension_id(AudioStream *stream, int extension_id);
MS2_PUBLIC void audio_stream_set_is_speaking_callback(AudioStream *s, AudioStreamIsSpeakingCallback cb, void *user_pointer);
MS2_PUBLIC void audio_stream_set_is_muted_callback(AudioStream *s, AudioStreamIsMutedCallback cb, void *user_pointer);
/**
* Retrieve the volume of the given participant.
*
* @param stream the audio stream
* @param participant_ssrc the ssrc of the participant
* @return the volume of the participant in dbm0, if participant isn't found it will return the lowest volume.
*/
MS2_PUBLIC int audio_stream_get_participant_volume(const AudioStream *stream, uint32_t participant_ssrc);
/**
* Retrieve the receive ssrc of the stream
*
* @param stream the audio stream
* @return the receive ssrc of the stream
*/
MS2_PUBLIC uint32_t audio_stream_get_recv_ssrc(const AudioStream *stream);
/**
* Retrieve the send ssrc of the stream
*
* @param stream the audio stream
* @return the send ssrc of the stream
*/
MS2_PUBLIC uint32_t audio_stream_get_send_ssrc(const AudioStream *stream);
/* Map api to be able to keep participants volumes */
typedef struct _AudioStreamVolumes AudioStreamVolumes;
#define AUDIOSTREAMVOLUMES_NOT_FOUND INT16_MIN
MS2_PUBLIC AudioStreamVolumes* audio_stream_volumes_new(void);
MS2_PUBLIC void audio_stream_volumes_delete(AudioStreamVolumes *volumes);
MS2_PUBLIC void audio_stream_volumes_insert(AudioStreamVolumes *volumes, uint32_t ssrc, int volume);
MS2_PUBLIC void audio_stream_volumes_erase(AudioStreamVolumes *volumes, uint32_t ssrc);
MS2_PUBLIC void audio_stream_volumes_clear(AudioStreamVolumes *volumes);
MS2_PUBLIC int audio_stream_volumes_size(AudioStreamVolumes *volumes);
MS2_PUBLIC int audio_stream_volumes_find(AudioStreamVolumes *volumes, uint32_t ssrc);
MS2_PUBLIC int audio_stream_volumes_append(AudioStreamVolumes *volumes, AudioStreamVolumes *append);
MS2_PUBLIC void audio_stream_volumes_reset_values(AudioStreamVolumes *volumes);
MS2_PUBLIC void audio_stream_volumes_populate_audio_levels(AudioStreamVolumes *volumes, rtp_audio_level_t *audio_levels);
MS2_PUBLIC bool_t audio_stream_volumes_is_speaking(AudioStreamVolumes *volumes);
MS2_PUBLIC uint32_t audio_stream_volumes_get_best(AudioStreamVolumes *volumes);
/**
* @}
**/
/**
* @addtogroup video_stream_api
* @{
**/
typedef void (*VideoStreamRenderCallback)(void *user_pointer, const MSPicture *local_view, const MSPicture *remote_view);
typedef void (*VideoStreamEventCallback)(void *user_pointer, const MSFilter *f, const unsigned int event_id, const void *args);
typedef void (*VideoStreamCameraNotWorkingCallback)(void *user_pointer, const MSWebCam *old_webcam);
typedef void (*VideoStreamEncoderControlCb)(struct _VideoStream *, unsigned int method_id, void *arg, void *user_data);
typedef void (*VideoStreamCsrcChangedCb)(void *user_pointer, uint32_t new_csrc);
struct _MediastreamVideoStat
{
int counter_rcvd_pli; /*Picture Loss Indication counter */
int counter_rcvd_sli;/* Slice Loss Indication counter */
int counter_rcvd_rpsi; /*Reference Picture Selection Indication */
int counter_rcvd_fir; /* Full INTRA-frame Request */
};
typedef struct _MediastreamVideoStat MediaStreamVideoStat;
typedef enum _MSVideoContent{
MSVideoContentDefault,
MSVideoContentSpeaker,
MSVideoContentThumbnail
} MSVideoContent;
struct _VideoStream
{
MediaStream ms;
MSFilter *jpegwriter;
MSFilter *local_jpegwriter;
MSFilter *output;
MSFilter *output2;
MSFilter *pixconv;
MSFilter *qrcode;
MSFilter *recorder_output; /*can be an ItcSink to send video to the audiostream's multimedia recorder, or directly a MkvRecorder */
MSFilter *sizeconv;
MSFilter *source;
MSFilter *tee;
MSFilter *tee2;
MSFilter *tee3;
MSFilter *void_source;
MSFilter *itcsink;
MSFilter *forward_sink;
MSVideoSize sent_vsize;
MSVideoSize preview_vsize;
MSVideoSize max_sent_vsize;
float forced_fps; /*the target fps explicitely set by application, overrides internally selected fps*/
float configured_fps; /*the fps that was configured to the encoder. It might be different from the one really obtained from camera.*/
float real_fps; /*the fps obtained from camera.*/
int corner; /*for selfview*/
VideoStreamRenderCallback rendercb;
void *render_pointer;
VideoStreamEventCallback eventcb;
void *event_pointer;
char *display_name;
void *window_id;
void *preview_window_id;
MediaStreamDir dir; /* Not used anymore, see direction in MediaStream */
MSRect decode_rect; //Used for the qrcode decoder
MSWebCam *cam;
RtpSession *rtp_io_session; /**< The RTP session used for RTP input/output. */
char *preset;
MSVideoConfiguration *vconf_list;
struct _AudioStream *audiostream;/*the audio stream with which this videostream is paired*/
OrtpNackContext *nack_context;
int device_orientation; /* warning: meaning of this variable depends on the platform (Android, iOS, ...) */
uint64_t last_reported_decoding_error_time;
uint64_t last_fps_check;
uint64_t last_camera_check;
int dead_camera_check_count;
VideoStreamCameraNotWorkingCallback cameracb;
void *camera_pointer;
MediaStreamVideoStat ms_video_stat;
VideoStreamEncoderControlCb encoder_control_cb;
void *encoder_control_cb_user_data;
MSVideoDisplayMode display_mode;
int frame_marking_extension_id;
char *label;
MSVideoContent content;
bool_t use_preview_window;
bool_t enable_qrcode_decoder;
bool_t freeze_on_error;
bool_t display_filter_auto_rotate_enabled;
bool_t source_performs_encoding;
bool_t output_performs_decoding;
bool_t player_active;
bool_t staticimage_webcam_fps_optimization; /* if TRUE, the StaticImage webcam will ignore the fps target in order to save CPU time. Default is TRUE */
bool_t is_forwarding;
bool_t wait_for_frame_decoded;
VideoStreamCsrcChangedCb csrc_changed_cb;
void *csrc_changed_cb_user_data;
uint32_t new_csrc;
};
typedef struct _VideoStream VideoStream;
MS2_PUBLIC VideoStream *video_stream_new(MSFactory* factory, int loc_rtp_port, int loc_rtcp_port, bool_t use_ipv6);
/**
* Creates a VideoStream object listening on a RTP port for a dedicated address.
* @param loc_ip the local ip to listen for RTP packets. Can be ::, O.O.O.O or any ip4/6 addresses
* @param [in] loc_rtp_port the local UDP port to listen for RTP packets.
* @param [in] loc_rtcp_port the local UDP port to listen for RTCP packets
* @return a new VideoStream.
**/
MS2_PUBLIC VideoStream *video_stream_new2(MSFactory* factory, const char* ip, int loc_rtp_port, int loc_rtcp_port);
MS2_PUBLIC VideoStream *video_stream_new_with_sessions(MSFactory* factory, const MSMediaStreamSessions *sessions);
/**
* Use media_stream_set_direction() instead
**/
MS2_DEPRECATED MS2_PUBLIC void video_stream_set_direction(VideoStream *vs, MediaStreamDir dir);
static MS2_INLINE void video_stream_enable_adaptive_bitrate_control(VideoStream *stream, bool_t enabled) {
media_stream_enable_adaptive_bitrate_control(&stream->ms, enabled);
}
static MS2_INLINE void video_stream_enable_adaptive_jittcomp(VideoStream *stream, bool_t enabled) {
media_stream_enable_adaptive_jittcomp(&stream->ms, enabled);
}
MS2_PUBLIC void video_stream_set_render_callback(VideoStream *s, VideoStreamRenderCallback cb, void *user_pointer);
MS2_PUBLIC void video_stream_set_event_callback(VideoStream *s, VideoStreamEventCallback cb, void *user_pointer);
MS2_PUBLIC void video_stream_set_camera_not_working_callback(VideoStream *s, VideoStreamCameraNotWorkingCallback cb, void *user_pointer);
MS2_PUBLIC void video_stream_set_display_filter_name(VideoStream *s, const char *fname);
MS2_PUBLIC void video_stream_set_label(VideoStream *s, const char *label);
MS2_PUBLIC void video_stream_set_content(VideoStream *s, MSVideoContent content);
MS2_PUBLIC MSVideoContent video_stream_get_content(const VideoStream *vs);
MS2_PUBLIC int video_stream_start_with_source(VideoStream *stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload, int jitt_comp, MSWebCam* cam, MSFilter* source);
MS2_PUBLIC int video_stream_start(VideoStream * stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port, const char *rem_rtcp_ip,
int rem_rtcp_port, int payload, int jitt_comp, MSWebCam *device);
MS2_PUBLIC int video_stream_start_with_files(VideoStream *stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload_type, const char *play_file, const char *record_file);
/**
* Start a video stream according to the specified VideoStreamIO.
*
* @param[in] stream VideoStream object previously created with video_stream_new().
* @param[in] profile RtpProfile object holding the PayloadType that can be used during the video session.
* @param[in] rem_rtp_ip The remote IP address where to send the encoded video to.
* @param[in] rem_rtp_port The remote port where to send the encoded video to.
* @param[in] rem_rtcp_ip The remote IP address for RTCP.
* @param[in] rem_rtcp_port The remote port for RTCP.
* @param[in] payload_type The payload type number used to send the video stream. A valid PayloadType must be available at this index in the profile.
* @param[in] io A VideoStreamIO describing the input/output of the video stream.
*/
MS2_PUBLIC int video_stream_start_from_io(VideoStream *stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload_type, const MSMediaStreamIO *io);
/**
* Link a video stream with ItcSink filter. Used for starting another video stream.
*
* @param[in] stream VideoStream object previously created with video_stream_new().
*/
MS2_PUBLIC void link_video_stream_with_itc_sink(VideoStream *stream);
MS2_PUBLIC void video_stream_prepare_video(VideoStream *stream);
MS2_PUBLIC void video_stream_unprepare_video(VideoStream *stream);
MS2_PUBLIC void video_stream_set_relay_session_id(VideoStream *stream, const char *relay_session_id);
static MS2_INLINE void video_stream_set_rtcp_information(VideoStream *st, const char *cname, const char *tool) {
media_stream_set_rtcp_information(&st->ms, cname, tool);
}
/*
* returns current MSWebCam for a given stream
* */
MS2_PUBLIC const MSWebCam * video_stream_get_camera(const VideoStream *stream);
/**
* Returns the current video stream source filter. Be careful, this source will be
* destroyed if the stream is stopped.
* @return current stream source
*/
MS2_PUBLIC MSFilter* video_stream_get_source_filter(const VideoStream* stream);
MS2_PUBLIC void video_preview_stream_change_camera(VideoStream* stream, MSWebCam* cam);
MS2_PUBLIC void video_stream_change_camera(VideoStream *stream, MSWebCam *cam);
MS2_PUBLIC void video_stream_change_camera_skip_bitrate(VideoStream *stream, MSWebCam *cam);
/**
* @brief This functions changes the source filter for the passed video stream.
* @details This is quite the same function as \ref video_stream_change_camera, but this one
* allows you to pass the source filter that is created for the camera and reuse it. This gives you the
* ability to switch rapidly between two streams, whereas re-creating them each time would be
* costly (especially with webcams).
*
* @note Since the \ref video_stream_stop() will automatically destroy the source, it is
* advised that you use \ref video_stream_stop_keep_source() instead, so that you
* can manually destroy the source filters after the stream is stopped.
*
* Example usage:
*
* video_stream_start(stream, profile, [...], noWebcamDevice);
* // We manage the sources for the stream ourselves:
* MSFilter* noWebCamFilter = video_stream_get_source_filter(stream);
* MSFilter* frontCamFilter = ms_web_cam_create_reader(frontCamDevice);
*
* sleep(1);
* video_stream_change_source_filter(stream, frontCamDevice, frontCamFilter, TRUE); // will keep the previous filter
* sleep(1);
* video_stream_change_source_filter(stream, noWebcamDevice, noWebCamFilter, TRUE); // keep the previous filter
*
* sleep(1)
* video_stream_stop_keep_source(stream);
* ms_filter_destroy(noWebCamFilter);
* ms_filter_destroy(frontCamFilter);
*
*
* @param stream the video stream to modify
* @param cam the camera that you want to set as the new source
* @param cam_filter the filter for this camera. It can be obtained with ms_web_cam_create_reader(cam)
* @return the previous source if keep_previous_source is TRUE, otherwise NULL
*/
MS2_PUBLIC MSFilter* video_stream_change_source_filter(VideoStream *stream, MSWebCam* cam, MSFilter* filter, bool_t keep_previous_source );
/**
* @brief This function forwards the video from the source stream to the specifed one.
* @details This will connect the received video stream from source and will pass it to current stream
* to send. Using \ref video_stream_change_camera will stop the forwarding and use the provided camera.
* If the source stream is stopped before this stream, a call to \ref video_stream_change_camera is also
* required in order to restart the graph.
* @param stream the video stream to modify
* @param source the video stream that will be used as a source
*/
MS2_PUBLIC void video_stream_forward_source_stream(VideoStream *stream, VideoStream *source);
/**
* @brief This is the same function as \ref video_stream_change_source_filter() called with keep_source=1, but
* the new filter will be created from the MSWebcam that is passed as argument.
*
* @param stream the video stream
* @param cam the MSWebcam from which the new source filter should be created.
* @return the previous source filter
*/
MS2_PUBLIC MSFilter* video_stream_change_camera_keep_previous_source(VideoStream *stream, MSWebCam *cam);
/* Calling video_stream_set_sent_video_size() or changing the bitrate value in the used PayloadType during a stream is running does nothing.
The following functions allow to take into account new parameters by redrawing the sending graph*/
MS2_PUBLIC void video_preview_stream_update_video_params(VideoStream *stream);
MS2_PUBLIC void video_stream_update_video_params(VideoStream *stream);
/*function to call periodically to handle various events */
MS2_PUBLIC void video_stream_iterate(VideoStream *stream);
/*
* Assign a specific callback to process PLI, SLI, FIR received by RTCP.
* When set to NULL, or not assigned, the default behavior is to target these commands to the video encoder.
*/
MS2_PUBLIC void video_stream_set_encoder_control_callback(VideoStream *stream, VideoStreamEncoderControlCb cb, void *user_data);
/**
* Asks the video stream to send a Full-Intra Request.
* @param[in] stream The videostream object.
*/
MS2_PUBLIC void video_stream_send_fir(VideoStream *stream);
/**
* Asks the video stream to generate a Video Fast Update (generally after receiving a Full-Intra Request.
* @param[in] stream The videostream object.
*/
MS2_PUBLIC void video_stream_send_vfu(VideoStream *stream);
MS2_PUBLIC void video_stream_stop(VideoStream * stream);
/**
* Stop the video stream, but does not destroy the source of the video. This function
* can be use in conjunction with \ref video_stream_change_source_filter() to allow
* manual management of the source filters for a video stream.
* @param stream the stream to stop
* @return returns the source of the video stream, which you should manually destroy when appropriate.
*/
MS2_PUBLIC MSFilter* video_stream_stop_keep_source(VideoStream * stream);
MS2_PUBLIC bool_t video_stream_started(VideoStream *stream);
/**
* Try to set the size of the video that is sent. Since this relies also on the
* bitrate specified, make sure to set the payload bitrate accordingly with
* rtp_profile_get_payload and normal_bitrate value otherwise the best
* possible resolution will be taken instead of the requested one.
* @param[in] stream The videostream for which to get the sent video size.
* @param[in] vsize The sent video size wished.
*/
MS2_PUBLIC void video_stream_set_sent_video_size(VideoStream *stream, MSVideoSize vsize);
/**
* Gets the size of the video that is sent.
* @param[in] stream The videostream for which to get the sent video size.
* @return The sent video size or MS_VIDEO_SIZE_UNKNOWN if not available.
*/
MS2_PUBLIC MSVideoSize video_stream_get_sent_video_size(const VideoStream *stream);
/**
* Gets the size of the video that is received.
* @param[in] stream The videostream for which to get the received video size.
* @return The received video size or MS_VIDEO_SIZE_UNKNOWN if not available.
*/
MS2_PUBLIC MSVideoSize video_stream_get_received_video_size(const VideoStream *stream);
/**
* Gets the framerate of the video that is sent.
* @param[in] stream The videostream.
* @return The actual framerate, 0 if not available..
*/
MS2_PUBLIC float video_stream_get_sent_framerate(const VideoStream *stream);
/**
* Gets the framerate of the video that is received.
* @param[in] stream The videostream.
* @return The received framerate or 0 if not available.
*/
MS2_PUBLIC float video_stream_get_received_framerate(const VideoStream *stream);
MS2_PUBLIC void video_stream_enable_self_view(VideoStream *stream, bool_t val);
MS2_PUBLIC void * video_stream_create_native_window_id(VideoStream *stream);
MS2_PUBLIC void * video_stream_get_native_window_id(VideoStream *stream);
MS2_PUBLIC void video_stream_set_native_window_id(VideoStream *stream, void *id);
MS2_PUBLIC void * video_stream_create_native_preview_window_id(VideoStream *stream);
MS2_PUBLIC void video_stream_set_native_preview_window_id(VideoStream *stream, void *id);
MS2_PUBLIC void * video_stream_get_native_preview_window_id(VideoStream *stream);
MS2_PUBLIC void video_stream_use_preview_video_window(VideoStream *stream, bool_t yesno);
MS2_PUBLIC void video_stream_set_device_rotation(VideoStream *stream, int orientation);
MS2_PUBLIC void video_stream_show_video(VideoStream *stream, bool_t show);
MS2_PUBLIC void video_stream_set_freeze_on_error(VideoStream *stream, bool_t yesno);
MS2_PUBLIC void video_stream_set_display_mode(VideoStream *stream, MSVideoDisplayMode mode);
/**
* @brief Gets the camera sensor rotation.
*
* This is needed on some mobile platforms to get the number of degrees the camera sensor
* is rotated relative to the screen.
*
* @param stream The video stream related to the operation
* @return The camera sensor rotation in degrees (0 to 360) or -1 if it could not be retrieved
*/
MS2_PUBLIC int video_stream_get_camera_sensor_rotation(VideoStream *stream);
/*provided for compatibility, use media_stream_set_direction() instead */
MS2_PUBLIC int video_stream_recv_only_start(VideoStream *videostream, RtpProfile *profile, const char *addr, int port, int used_pt, int jitt_comp);
MS2_PUBLIC int video_stream_send_only_start(VideoStream *videostream,
RtpProfile *profile, const char *addr, int port, int rtcp_port,
int used_pt, int jitt_comp, MSWebCam *device);
MS2_PUBLIC void video_stream_recv_only_stop(VideoStream *vs);
MS2_PUBLIC void video_stream_send_only_stop(VideoStream *vs);
/* enable ZRTP on the video stream using information from the audio stream */
MS2_PUBLIC void video_stream_enable_zrtp(VideoStream *vstream, AudioStream *astream);
MS2_PUBLIC void video_stream_start_zrtp(VideoStream *stream);
/* enable SRTP on the video stream */
static MS2_INLINE bool_t video_stream_enable_strp(VideoStream* stream, MSCryptoSuite suite, const char* snd_key, const char* rcv_key) {
return media_stream_enable_srtp(&stream->ms, suite, snd_key, rcv_key);
}
/* if enabled, the display filter will internaly rotate the video, according to the device orientation */
MS2_PUBLIC void video_stream_enable_display_filter_auto_rotate(VideoStream* stream, bool_t enable);
/* retrieve RTP statistics*/
static MS2_INLINE void video_stream_get_local_rtp_stats(VideoStream *stream, rtp_stats_t *stats) {
media_stream_get_local_rtp_stats(&stream->ms, stats);
}
static MS2_INLINE int video_stream_set_dscp(VideoStream *stream, int dscp) {
return media_stream_set_dscp(&stream->ms, dscp);
}
/**
* Gets the RTP session of a video stream.
* @param[in] stream #MediaStream object.
* @return The RTP session of the video stream.
*/
static MS2_INLINE RtpSession * video_stream_get_rtp_session(const VideoStream *stream) {
return media_stream_get_rtp_session(&stream->ms);
}
/**
* Ask the video stream whether a decoding error should be reported (eg. to send a VFU request).
* @param[in] stream The VideoStream object.
* @param[in] ms The minimum interval in milliseconds between to decoding error report.
* @return TRUE if the decoding error should be reported, FALSE otherwise.
*/
MS2_PUBLIC bool_t video_stream_is_decoding_error_to_be_reported(VideoStream *stream, uint32_t ms);
/**
* Tell the video stream that a decoding error has been reported.
* @param[in] stream The VideoStream object.
*/
MS2_PUBLIC void video_stream_decoding_error_reported(VideoStream *stream);
/**
* Tell the video stream that a decoding error has been recovered so that new decoding can be reported sooner.
* @param[in] stream The VideoStream object.
*/
MS2_PUBLIC void video_stream_decoding_error_recovered(VideoStream *stream);
/**
* Force a resolution for the preview.
* @param[in] stream The VideoStream object.
* @param[in] vsize video resolution.
**/
MS2_PUBLIC void video_stream_set_preview_size(VideoStream *stream, MSVideoSize vsize);
/**
* Force a resolution for the preview.
* @param[in] stream The VideoStream object.
* @param[in] fps the frame rate in frame/seconds. A value of zero means "use encoder default value".
**/
MS2_PUBLIC void video_stream_set_fps(VideoStream *stream, float fps);
/**
* Link the audio stream with an existing video stream.
* This is necessary to enable recording of audio & video into a multimedia file.
*/
MS2_PUBLIC void audio_stream_link_video(AudioStream *stream, VideoStream *video);
/**
* Unlink the audio stream from the video stream.
* This must be done if the video stream is about to be stopped.
**/
MS2_PUBLIC void audio_stream_unlink_video(AudioStream *stream, VideoStream *video);
/**
* Set a video preset to be used for the video stream.
* @param[in] stream VideoStream object
* @param[in] preset The name of the video preset to be used.
*/
MS2_PUBLIC void video_stream_use_video_preset(VideoStream *stream, const char *preset);
/**
* Returns the name of the video preset used for the video stream.
* @param[in] stream VideoStream object
*/
MS2_PUBLIC const char* video_stream_get_video_preset(VideoStream *stream);
/**
* Sets the header extension id for frame marking.
* This has to be called before starting the video stream.
*
* @param stream the video stream
* @param extension_id the extension id
*/
MS2_PUBLIC void video_stream_set_frame_marking_extension_id(VideoStream *stream, int extension_id);
/**
* Open a player to play a video file (mkv) to remote end.
* The player is returned as a MSFilter so that application can make usual player controls on it using the MSPlayerInterface.
**/
MS2_PUBLIC MSFilter * video_stream_open_remote_play(VideoStream *stream, const char *filename);
MS2_PUBLIC void video_stream_close_remote_play(VideoStream *stream);
/**
* Open a recorder to record the video coming from remote end into a mkv file.
* This must be done before the stream is started.
**/
MS2_PUBLIC MSFilter * video_stream_open_remote_record(VideoStream *stream, const char *filename);
MS2_PUBLIC void video_stream_close_remote_record(VideoStream *stream);
MS2_PUBLIC void video_stream_enable_retransmission_on_nack(VideoStream *stream, bool_t enable);
MS2_PUBLIC void video_stream_set_retransmission_on_nack_max_packet(VideoStream *stream, unsigned int max);
MS2_PUBLIC void video_stream_enable_fec(VideoStream *stream, char* local_ip, int local_port, int local_rtcp_port, char* remote_ip, int remote_port, int L, int D);
/**
* Sets the max size the sent video stream can reach.
*
* @param stream the video stream
* @param max the max size the sent videostream can reach. 0x0 will remove this limitation.
*/
MS2_PUBLIC void video_stream_set_sent_video_size_max(VideoStream *stream, MSVideoSize max);
MS2_PUBLIC void video_stream_set_csrc_changed_callback(VideoStream *stream, VideoStreamCsrcChangedCb cb, void *user_pointer);
/**
* Small API to display a local preview window.
**/
typedef VideoStream VideoPreview;
MS2_PUBLIC VideoPreview * video_preview_new(MSFactory *factory);
#define video_preview_set_event_callback(p,c,u) video_stream_set_event_callback(p,c,u)
#define video_preview_set_size(p,s) video_stream_set_sent_video_size(p,s)
#define video_preview_set_display_filter_name(p,dt) video_stream_set_display_filter_name(p,dt)
#define video_preview_create_native_window_id(p) video_stream_create_native_preview_window_id(p)
#define video_preview_set_native_window_id(p,id) video_stream_set_native_preview_window_id(p,id)
#define video_preview_get_native_window_id(p) video_stream_get_native_preview_window_id(p)
#define video_preview_set_fps(p,fps) video_stream_set_fps((VideoStream*)p,fps)
#define video_preview_set_device_rotation(p, r) video_stream_set_device_rotation(p, r)
MS2_PUBLIC void video_preview_start(VideoPreview *stream, MSWebCam *device);
MS2_PUBLIC void video_preview_enable_qrcode(VideoPreview *stream, bool_t enable);
MS2_PUBLIC void video_preview_set_decode_rect(VideoPreview *stream, MSRect rect);
MS2_PUBLIC bool_t video_preview_qrcode_enabled(VideoPreview *stream);
MS2_PUBLIC MSVideoSize video_preview_get_current_size(VideoPreview *stream);
MS2_PUBLIC void video_preview_stop(VideoPreview *stream);
MS2_PUBLIC void video_preview_change_camera(VideoPreview *stream, MSWebCam *cam);
MS2_PUBLIC void video_preview_update_video_params(VideoPreview *stream);
/**
* Stops the video preview graph but keep the source filter for reuse.
* This is useful when transitioning from a preview-only to a duplex video.
* The filter needs to be passed to the #video_stream_start_with_source function,
* otherwise you should destroy it.
* @param[in] stream VideoPreview object
* @return The source filter to be passed to the #video_stream_start_with_source function.
*/
MS2_PUBLIC MSFilter* video_preview_stop_reuse_source(VideoPreview *stream);
/*
* Returns the web cam descriptor for the mire kind of camera.
**/
MS2_PUBLIC MSWebCamDesc *ms_mire_webcam_desc_get(void);
/**
* Create an RTP session for duplex communication.
* @param[in] local_ip The local IP to bind the RTP and RTCP sockets to.
* @param[in] local_rtp_port The local port to bind the RTP socket to.
* @param[in] local_rtcp_port The local port to bind the RTCP socket to.
*/
MS2_PUBLIC RtpSession * ms_create_duplex_rtp_session(const char* local_ip, int loc_rtp_port, int loc_rtcp_port, int mtu);
/**
* Asks the audio playback filter to route to the selected device (currently only used for blackberry)
* @param[in] stream The AudioStream object
* @param[in] route The wanted audio output device (earpiece, speaker)
*/
MS2_PUBLIC void audio_stream_set_audio_route(AudioStream *stream, MSAudioRoute route);
/**
* Set a callback to be called when an audio route change is notified (IOS only)
* @param[in] stream The AudioStream object
* @param[in] callback The function to call when receiving the route change event
* @param[in] audio_route_changed_cb_user_data Context for the callback
*/
MS2_PUBLIC void audio_stream_set_audio_route_changed_callback(AudioStream *stream, MSAudioRouteChangedCallback callback, void *audio_route_changed_cb_user_data);
/**
* Asks the audio capture filter to route to the selected sound card (currently only used for AAudio and OpenSLES)
* @param[in] stream The AudioStream object
* @param[in] sndcard_capture The wanted audio input soundcard
* @return '0' if MS_AUDIO_CAPTURE_SET_INTERNAL_ID has been successfully called, '-1' if not
*/
MS2_PUBLIC int audio_stream_set_input_ms_snd_card(AudioStream *stream, MSSndCard * sndcard_capture);
/**
* Asks the audio playback filter to route to the selected sound card (currently only used for AAudio and OpenSLES)
* @param[in] stream The AudioStream object
* @param[in] sndcard_playback The wanted audio output soundcard
* @return '0' if MS_AUDIO_PLAYBACK_SET_INTERNAL_ID has been successfully called, '-1' if not
*/
MS2_PUBLIC int audio_stream_set_output_ms_snd_card(AudioStream *stream, MSSndCard * sndcard_playback);
/**
* Retrieve the current sound card from the audio capture filter (currently only used for AAudio and OpenSLES)
* @param[in] stream The AudioStream object
*/
MS2_PUBLIC MSSndCard * audio_stream_get_input_ms_snd_card(AudioStream *stream);
/**
* Retrieve the current sound card from the audio playback filter (currently only used for AAudio and OpenSLES)
* @param[in] stream The AudioStream object
*/
MS2_PUBLIC MSSndCard * audio_stream_get_output_ms_snd_card(AudioStream *stream);
/**
* @}
**/
/**
* @addtogroup text_stream_api
* @{
**/
struct _TextStream
{
MediaStream ms;
MSFilter *rttsource;
MSFilter *rttsink;
int pt_t140;
int pt_red;
};
typedef struct _TextStream TextStream;
/**
* Creates a TextStream object listening on a RTP port.
* @param loc_rtp_port the local UDP port to listen for RTP packets.
* @param loc_rtcp_port the local UDP port to listen for RTCP packets
* @param ipv6 TRUE if ipv6 must be used.
* @param factory
* @return a new TextStream.
**/
MS2_PUBLIC TextStream *text_stream_new(MSFactory *factory, int loc_rtp_port, int loc_rtcp_port, bool_t ipv6);
/**
* Creates a TextStream object from initialized MSMediaStreamSessions.
* @param sessions the MSMediaStreamSessions
* @param factory
* @return a new TextStream
**/
MS2_PUBLIC TextStream *text_stream_new_with_sessions(MSFactory *factory, const MSMediaStreamSessions *sessions);
/**
* Creates a TextStream object listening on a RTP port for a dedicated address.
* @param loc_ip the local ip to listen for RTP packets. Can be ::, O.O.O.O or any ip4/6 addresses
* @param [in] loc_rtp_port the local UDP port to listen for RTP packets.
* @param [in] loc_rtcp_port the local UDP port to listen for RTCP packets
* @param factory
* @return a new TextStream.
**/
MS2_PUBLIC TextStream *text_stream_new2(MSFactory *factory, const char* ip, int loc_rtp_port, int loc_rtcp_port);
/**
* Starts a text stream.
*
* @param[in] stream TextStream object previously created with text_stream_new().
* @param[in] profile RtpProfile object holding the PayloadType that can be used during the text session.
* @param[in] rem_rtp_addr The remote IP address where to send the text to.
* @param[in] rem_rtp_port The remote port where to send the text to.
* @param[in] rem_rtcp_addr The remote IP address for RTCP.
* @param[in] rem_rtcp_port The remote port for RTCP.
* @param[in] payload_type The payload type number used to send the text stream. A valid PayloadType must be available at this index in the profile.
* @param[in] factory
*/
MS2_PUBLIC TextStream* text_stream_start(TextStream *stream, RtpProfile *profile, const char *rem_rtp_addr, int rem_rtp_port, const char *rem_rtcp_addr, int rem_rtcp_port,
int payload_type);
/**
* Stops the text streaming thread and free everything
**/
MS2_PUBLIC void text_stream_stop (TextStream * stream);
/**
* Executes background low priority tasks related to text processing (RTP statistics analysis).
* It should be called periodically, for example with an interval of 100 ms or so.
*
* @param[in] stream TextStream object previously created with text_stream_new().
*/
MS2_PUBLIC void text_stream_iterate(TextStream *stream);
/**
* Writes a character to stream in UTF-32 format.
*
* @param[in] stream TextStream object previously created with text_stream_new().
* @param[in] i the Char in UTF-32 format.
**/
MS2_PUBLIC void text_stream_putchar32(TextStream *stream, uint32_t i);
MS2_PUBLIC void text_stream_prepare_text(TextStream *stream);
MS2_PUBLIC void text_stream_unprepare_text(TextStream *stream);
/**
* @}
**/
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/ms_srtp.h 0000664 0000000 0000000 00000014707 14346134245 0023547 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef ms_srtp_h
#define ms_srtp_h
#include
#include "mediastreamer2/mscommon.h"
#ifdef __cplusplus
extern "C"{
#endif
/* defined in mediastream.h */
#ifndef MS_MEDIA_STREAM_SESSIONS_DEFINED
typedef struct _MSMediaStreamSessions MSMediaStreamSessions;
#define MS_MEDIA_STREAM_SESSIONS_DEFINED 1
#endif
/*
* Crypto suite used configure encrypted stream*/
typedef enum _MSCryptoSuite{
MS_CRYPTO_SUITE_INVALID=0,
MS_AES_128_SHA1_80,
MS_AES_128_SHA1_80_NO_AUTH,
MS_AES_128_SHA1_80_SRTP_NO_CIPHER,
MS_AES_128_SHA1_80_SRTCP_NO_CIPHER,
MS_AES_128_SHA1_80_NO_CIPHER,
MS_AES_256_SHA1_80,
MS_AES_CM_256_SHA1_80,
MS_AES_128_SHA1_32,
MS_AES_128_SHA1_32_NO_AUTH,
MS_AES_256_SHA1_32,
MS_AEAD_AES_128_GCM,
MS_AEAD_AES_256_GCM
} MSCryptoSuite;
typedef struct _MSCryptoSuiteNameParams{
const char *name;
const char *params;
}MSCryptoSuiteNameParams;
MS2_PUBLIC MSCryptoSuite ms_crypto_suite_build_from_name_params(const MSCryptoSuiteNameParams *nameparams);
MS2_PUBLIC int ms_crypto_suite_to_name_params(MSCryptoSuite cs, MSCryptoSuiteNameParams *nameparams);
MS2_PUBLIC bool_t ms_crypto_suite_is_unencrypted(MSCryptoSuite cs);
MS2_PUBLIC bool_t ms_crypto_suite_is_unauthenticated(MSCryptoSuite cs);
/* defined in srtp.h*/
typedef struct _MSSrtpCtx MSSrtpCtx;
typedef enum {
MSSRTP_RTP_STREAM,
MSSRTP_RTCP_STREAM,
MSSRTP_ALL_STREAMS
} MSSrtpStreamType;
/**
* return humanly readable string
* @param[in] type
* @return
*
* */
MS2_PUBLIC const char * ms_srtp_stream_type_to_string(const MSSrtpStreamType type);
/**
* Check if SRTP is supported
* @return true if SRTP is supported
*/
MS2_PUBLIC bool_t ms_srtp_supported(void);
/**
* Set encryption requirements.
* srtp session might be created/deleted depending on requirement parameter and already set keys
* @param[in/out] sessions The sessions associated to the current media stream
* @param[in] yesno If yes, any incoming/outgoing rtp packets are silently discarded.
* until keys are provided using functions #media_stream_set_srtp_recv_key_b64 or #media_stream_set_srtp_recv_key
* @return 0 on success, error code otherwise
*/
MS2_PUBLIC int ms_media_stream_sessions_set_encryption_mandatory(MSMediaStreamSessions *sessions, bool_t yesno);
/**
* Get encryption requirements.
* @param[in/out] sessions The sessions associated to the current media stream
* @return TRUE if only encrypted rtp packet shall be sent/received
*/
MS2_PUBLIC bool_t ms_media_stream_sessions_get_encryption_mandatory(const MSMediaStreamSessions *sessions);
/**
* Set srtp receiver key for the given media stream.
* If no srtp session exists on the stream it is created, if it already exists srtp policy is created/modified for the receiver side of the stream.
*
* @param[in/out] sessions The sessions associated to the current media stream
* @param[in] suite The srtp crypto suite to use
* @param[in] key Srtp master key and master salt in a base 64 NULL terminated string
* @return 0 on success, error code otherwise
*/
MS2_PUBLIC int ms_media_stream_sessions_set_srtp_recv_key_b64(MSMediaStreamSessions *sessions, MSCryptoSuite suite, const char* key);
/**
* Set srtp receiver key for the given media stream.
* If no srtp session exists on the stream it is created, if it already exists srtp policy is created/modified for the receiver side of the stream.
*
* @param[in/out] sessions The sessions associated to the current media stream
* @param[in] suite The srtp crypto suite to use
* @param[in] key Srtp master key and master salt
* @param[in] key_length key buffer length
* @param[in] stream_type Srtp suite is applied to RTP stream, RTCP stream or both
* @return 0 on success, error code otherwise
*/
MS2_PUBLIC int ms_media_stream_sessions_set_srtp_recv_key(MSMediaStreamSessions *sessions, MSCryptoSuite suite, const char* key, size_t key_length, MSSrtpStreamType stream_type);
/**
* Set srtp sender key for the given media stream.
* If no srtp session exists on the stream it is created, if it already exists srtp policy is created/modified for the sender side of the stream.
*
* @param[in/out] sessions The sessions associated to the current media stream
* @param[in] suite The srtp crypto suite to use
* @param[in] key Srtp master key and master salt in a base 64 NULL terminated string
* @return 0 on success, error code otherwise
*/
MS2_PUBLIC int ms_media_stream_sessions_set_srtp_send_key_b64(MSMediaStreamSessions *sessions, MSCryptoSuite suite, const char* key);
/**
* Set srtp sender key for the given media stream.
* If no srtp session exists on the stream it is created, if it already exists srtp policy is created/modified for the sender side of the stream.
*
* @param[in/out] stream The mediastream to operate on
* @param[in] suite The srtp crypto suite to use
* @param[in] key Srtp master key and master salt
* @param[in] key_length key buffer length
* @param[in] stream_type Srtp suite is applied to RTP stream, RTCP stream or both
* @return 0 on success, error code otherwise
*/
MS2_PUBLIC int ms_media_stream_sessions_set_srtp_send_key(MSMediaStreamSessions *sessions, MSCryptoSuite suite, const char* key, size_t key_length, MSSrtpStreamType stream_type);
/**
* Convert MSCryptoSuite enum to a string.
*
* @param[in] suite The srtp crypto suite to use
* @return the string corresponding the crypto suite
*/
MS2_PUBLIC const char * ms_crypto_suite_to_string(MSCryptoSuite suite);
/**
* Free ressources used by SRTP context
* @param[in/out] context the DTLS-SRTP context
*/
MS2_PUBLIC void ms_srtp_context_delete(MSSrtpCtx *session);
#ifdef __cplusplus
}
#endif
#endif /* ms_srtp_h */
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/msanalysedisplay.h 0000664 0000000 0000000 00000002126 14346134245 0025432 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef msanalysedisplay_h
#define msanalysedisplay_h
#include
#include
#include "mediastreamer2/msmire.h"
#define MS_ANALYSE_DISPLAY_COMPARE_COLOR MS_FILTER_METHOD(MS_ANALYSE_DISPLAY_ID,0,MSMireControl)
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/msasync.h 0000664 0000000 0000000 00000007131 14346134245 0023526 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef msasync_h
#define msasync_h
#include "mediastreamer2/mscommon.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
* Simple API to execute tasks on a worker thread.
* Prequisite: the user code must not destroy every MSTask it holds before the MSWorkerThread is destroyed,
* otherwise a crash will occur.
*/
struct _MSWorkerThread{
ms_thread_t thread;
ms_cond_t cond;
ms_mutex_t mutex;
bctbx_list_t *tasks;
unsigned int task_wait_count;
char *name;
bool_t running;
bool_t inwait;
bool_t finish_tasks;
};
typedef struct _MSWorkerThread MSWorkerThread;
typedef void (*MSTaskFunc)(void *);
typedef enum _MSTaskState{
MSTaskInit,
MSTaskQueued,
MSTaskCancelled,
MSTaskRunning,
MSTaskDone /**< the task was completed. This is the final state even for cancelled tasks.*/
}MSTaskState;
struct _MSTask{
MSWorkerThread *worker;
MSTaskFunc func;
void *data;
MSTaskState state; /* changed only when worker->mutex is hold */
uint64_t repeat_at;
int repeat_interval; /* in milliseconds*/
bool_t auto_release;
};
typedef struct _MSTask MSTask;
/*
* Cancel a task. There is no warranty that it will be actually canceled, since the task may
* be executing, or have been executed already.
*/
MS2_PUBLIC void ms_task_cancel(MSTask *task);
/*
* Cancel a task and schedule it for destruction.
* If the task is already completed, it is destroyed synchronously.
* Unlike ms_task_destroy(), ms_task_cancel_and_destroy() does not wait
* the task to be processed by the worker thread, but returns immediately.
*/
MS2_PUBLIC void ms_task_cancel_and_destroy(MSTask *task);
/*
* Wait for the task to reach the MSTaskDone state.
*/
MS2_PUBLIC void ms_task_wait_completion(MSTask *task);
/*
* Automatically cancels if necessary, and waits for completion before destroying the task.
*/
MS2_PUBLIC void ms_task_destroy(MSTask *task);
/* Create a worker thread. Name is mandatory to ease debugging. */
MS2_PUBLIC MSWorkerThread * ms_worker_thread_new(const char *name);
/* Add a task to execute. The task object is internal, not returned. For simple usages. */
MS2_PUBLIC void ms_worker_thread_add_task(MSWorkerThread *obj, MSTaskFunc fn, void *data);
/* Add a task to execute. A MSTask object is returned to the caller, that can be wait upon. It must be destroyed. */
MS2_PUBLIC MSTask * ms_worker_thread_add_waitable_task(MSWorkerThread *obj, MSTaskFunc fn, void *data);
/* Add a task that must be repeated at regular interval.
* Note that with the current implementation, the scheduling is not accurate: granularity is 10 ms, and there is no catchup.
*/
MS2_PUBLIC MSTask * ms_worker_thread_add_repeated_task(MSWorkerThread *obj, MSTaskFunc func, void *data, int repeat_interval);
MS2_PUBLIC void ms_worker_thread_destroy(MSWorkerThread *obj, bool_t finish_tasks);
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/msaudiomixer.h 0000664 0000000 0000000 00000003410 14346134245 0024553 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef msaudiomixer_h
#define msaudiomixer_h
#include
typedef struct MSAudioMixerCtl{
int pin;
union param_t {
float gain; /**.
*/
#ifndef mchanadapter_h
#define mchanadapter_h
#include
#define MS_CHANNEL_ADAPTER_SET_OUTPUT_NCHANNELS MS_FILTER_METHOD(MS_CHANNEL_ADAPTER_ID,0,int)
#define MS_CHANNEL_ADAPTER_GET_OUTPUT_NCHANNELS MS_FILTER_METHOD(MS_CHANNEL_ADAPTER_ID,1,int)
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/mscngdtx.h 0000664 0000000 0000000 00000002151 14346134245 0023675 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#include "mediastreamer2/msfilter.h"
typedef struct _MSCngData{
int datasize;
uint8_t data[32];
}MSCngData;
/** Event generated when silence is detected. Payload contains the data encoding the background noise*/
#define MS_VAD_DTX_NO_VOICE MS_FILTER_EVENT(MSVadDtxId, 0, MSCngData)
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/mscodecutils.h 0000664 0000000 0000000 00000021634 14346134245 0024553 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef mscodecutils_h
#define mscodecutils_h
#include "mediastreamer2/mscommon.h"
#ifdef __cplusplus
extern "C"{
#endif
/**
* Helper object for audio decoders to determine whether PLC (packet loss concealment is needed).
**/
typedef struct _MSConcealerContext MSConcealerContext;
/**
* Creates a new concealer object.
* @param max_plc_count the number of consecutive milliseconds of PLC allowed.
**/
MS2_PUBLIC MSConcealerContext* ms_concealer_context_new(uint32_t max_plc_count);
/**
* Destroys a concealer object.
**/
MS2_PUBLIC void ms_concealer_context_destroy(MSConcealerContext* context);
/**
* Returns 1 when PLC is needed, 0 otherwise.
* @param obj the concealer object
* @param current_time the current time in milliseconds, as pointed by f->ticker->time .
**/
MS2_PUBLIC unsigned int ms_concealer_context_is_concealement_required(MSConcealerContext* obj, uint64_t current_time);
/**
* Call this function whenever you decoded a packet, for true or in PLC mode, to inform the concealer
* of how the audio stream is going.
* @param obj the concealer object
* @param current_time the current time in milliseconds, as pointed by f->ticker->time.
* @param time_increment the number of milliseconds of audio decoded.
* @param got_packet set to TRUE if a real frame was decoded, FALSE if it was a PLC frame.
* @return if a PLC period terminates, returns the duration of this PLC period in milliseconds, 0 otherwise.
**/
MS2_PUBLIC uint32_t ms_concealer_inc_sample_time(MSConcealerContext* obj, uint64_t current_time, uint32_t time_increment, bool_t got_packet);
MS2_PUBLIC unsigned long ms_concealer_context_get_total_number_of_plc(MSConcealerContext* obj);
/**
* Helper object for audio decoders to determine whether PLC (packet loss concealment is needed), based on timestamp information.
**/
typedef struct _MSConcealerTsContext MSConcealerTsContext;
/**
* Creates a new concealer object.
* @param max_plc_count maximum duration of PLC allowed, expressed in timestamp units.
**/
MS2_PUBLIC MSConcealerTsContext* ms_concealer_ts_context_new(unsigned int max_plc_ts);
/**
* Destroys a concealer object.
**/
MS2_PUBLIC void ms_concealer_ts_context_destroy(MSConcealerTsContext* context);
/**
* Returns 1 when PLC is needed, 0 otherwise.
* @param obj the concealer object
* @param current_ts the current time converted in timestamp units, usually (f->ticker->time*clock_rate)/1000 .
**/
MS2_PUBLIC unsigned int ms_concealer_ts_context_is_concealement_required(MSConcealerTsContext* obj,uint64_t current_ts);
/**
* Call this function whenever you decoded a packet, for true or in PLC mode, to inform the concealer
* of how the audio stream is going.
* @param obj the concealer object
* @param current_ts the current time converted in timestamp units, usually (f->ticker->time*clock_rate)/1000
* @param ts_increment the duration of audio decoded expressed in timestamp units
* @param got_packet set to TRUE if a real frame was decoded, FALSE if it was a PLC frame.
* @return if a PLC period terminates, returns the duration of this PLC period in timestamp units, 0 otherwise.
**/
MS2_PUBLIC uint32_t ms_concealer_ts_context_inc_sample_ts(MSConcealerTsContext* obj, uint64_t current_ts, uint32_t ts_increment, bool_t got_packet);
MS2_PUBLIC unsigned long ms_concealer_ts_context_get_total_number_of_plc(MSConcealerTsContext* obj);
/*FEC API*/
typedef struct _MSRtpPayloadPickerContext MSRtpPayloadPickerContext;
typedef mblk_t* (*RtpPayloadPicker)(MSRtpPayloadPickerContext* context,unsigned int sequence_number);
struct _MSRtpPayloadPickerContext {
void* filter_graph_manager; /*I.E stream*/
RtpPayloadPicker picker;
};
struct _MSOfferAnswerContext;
#ifndef MS_OFFER_ANSWER_CONTEXT_DEFINED
#define MS_OFFER_ANSWER_CONTEXT_DEFINED
typedef struct _MSOfferAnswerContext MSOfferAnswerContext;
#endif
/* SDP offer answer payload matching API*/
/**
* The MSPayloadMatcherFunc prototype takes:
* - a list of local payload types
* - a remote payload type (offered or answered) by remote to be matched agains payload types of the local payload type list.
* - the full list of remote (offered or answered) payload types, which is sometimes necessary to do the matching in ambiguous situations.
* - is_reading, a boolean indicating whether we are doing the match processing while reading a SDP response, or (if FALSE) to prepare a response to be sent.
* The expected return value is a newly allocated PayloadType similar to the local payload type that was matched.
* Due to specific per codec offer/answer logic, the fmtp of the payload type might be changed compared to the original local payload type.
* If there is no match, NULL must be returned.
**/
typedef PayloadType * (*MSPayloadMatcherFunc)(MSOfferAnswerContext *context, const MSList *local_payloads, const PayloadType *remote_payload, const MSList *remote_payloads, bool_t is_reading);
/**
* The MSOfferAnswerContext is only there to provide a context during the SDP offer/answer handshake.
* It could be used in the future to provide extra information, for the moment the context is almost useless*/
struct _MSOfferAnswerContext{
MSPayloadMatcherFunc match_payload;
void (*destroy)(MSOfferAnswerContext *ctx);
void *context_data;
};
/**
* Executes an offer/answer processing for a given codec.
* @param context the context
* @param local_payloads the local payload type supported
* @param remote_payload a remote payload type (offered or answered) by remote to be matched agains payload types of the local payload type list.
* @param remote_payloads the full list of remote (offered or answered) payload types, which is sometimes necessary to do the matching in ambiguous situations.
* @param is_reading, a boolean indicating whether we are doing the match processing while reading a SDP response, or (if FALSE) to prepare a response to be sent.
* The expected return value is a newly allocated PayloadType similar to the local payload type that was matched.
* Due to specific per codec offer/answer logic, the fmtp of the payload type might be changed compared to the original local payload type.
* If there is no match, NULL must be returned.
**/
MS2_PUBLIC PayloadType * ms_offer_answer_context_match_payload(MSOfferAnswerContext *context, const MSList *local_payloads, const PayloadType *remote_payload, const MSList *remote_payloads, bool_t is_reading);
MS2_PUBLIC void ms_offer_answer_context_destroy(MSOfferAnswerContext *ctx);
/**
* A convenience function to instanciate an offer answer context giving only the payload matching function pointer.
**/
MS2_PUBLIC MSOfferAnswerContext *ms_offer_answer_create_simple_context(MSPayloadMatcherFunc func);
/**
* The struct to declare offer-answer provider, that act as factories per mime type to instanciate MSOfferAnswerContext object able to take in charge
* the offer answer model for a particular codec
**/
struct _MSOfferAnswerProvider{
const char *mime_type;
MSOfferAnswerContext *(*create_context)(void);
};
/**
* A convenience structure and API to intellengently limit the number of key frame request of an encoder.
**/
typedef struct _MSIFrameRequestsLimiterCtx {
uint64_t last_sent_iframe_time;
int min_iframe_interval;
bool_t iframe_required;
} MSIFrameRequestsLimiterCtx;
MS2_PUBLIC void ms_iframe_requests_limiter_init(MSIFrameRequestsLimiterCtx *obj, int min_iframe_interval_ms);
MS2_PUBLIC void ms_iframe_requests_limiter_request_iframe(MSIFrameRequestsLimiterCtx *obj);
MS2_PUBLIC bool_t ms_iframe_requests_limiter_iframe_requested(const MSIFrameRequestsLimiterCtx *obj, uint64_t curtime_ms);
MS2_PUBLIC void ms_iframe_requests_limiter_notify_iframe_sent(MSIFrameRequestsLimiterCtx *obj, uint64_t curtime_ms);
/**
* The goal of this small object is to tell when to send I frames at startup:
* at 2 and 4 seconds.
*/
typedef struct MSVideoStarter {
uint64_t next_time;
int i_frame_count;
bool_t active;
} MSVideoStarter;
MS2_PUBLIC void ms_video_starter_init(MSVideoStarter *vs);
MS2_PUBLIC void ms_video_starter_first_frame(MSVideoStarter *vs, uint64_t curtime);
MS2_PUBLIC bool_t ms_video_starter_need_i_frame(MSVideoStarter *vs, uint64_t curtime);
MS2_PUBLIC void ms_video_starter_deactivate(MSVideoStarter *vs);
#ifdef __cplusplus
}
#endif
#endif
mediastreamer2-5.2.0+dfsg/include/mediastreamer2/mscommon.h 0000664 0000000 0000000 00000046616 14346134245 0023714 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2022 Belledonne Communications SARL.
*
* This file is part of mediastreamer2
* (see https://gitlab.linphone.org/BC/public/mediastreamer2).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
#ifndef mscommon_h
#define mscommon_h
#include
#include
#include
#include
#include
#include
#include
#if defined(__APPLE__)
#include "TargetConditionals.h"
#endif
#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM)
#define MS_HAS_ARM 1
#endif
#if defined(__ARM_NEON__) || defined(__ARM_NEON)
#define MS_HAS_ARM_NEON 1
#endif
#if MS_HAS_ARM_NEON && !(defined(__arm64__) || defined(__aarch64__))
#define MS_HAS_ARM_NEON_32 1
#endif
#ifndef MS2_DEPRECATED
#if defined(_MSC_VER)
#define MS2_DEPRECATED __declspec(deprecated)
#else
#define MS2_DEPRECATED __attribute__ ((deprecated))
#endif
#endif
#define MS_UNUSED(x) ((void)(x))
#define ms_malloc ortp_malloc
#define ms_malloc0 ortp_malloc0
#define ms_realloc ortp_realloc
#define ms_new ortp_new
#define ms_new0 ortp_new0
#define ms_free ortp_free
#define ms_strdup ortp_strdup
#define ms_strndup bctbx_strndup
#define ms_strdup_printf ortp_strdup_printf
#define ms_strcat_printf ortp_strcat_printf
#define ms_mutex_t ortp_mutex_t
#define ms_mutex_init ortp_mutex_init
#define ms_mutex_destroy ortp_mutex_destroy
#define ms_mutex_lock ortp_mutex_lock
#define ms_mutex_unlock ortp_mutex_unlock
#define ms_cond_t ortp_cond_t
#define ms_cond_init ortp_cond_init
#define ms_cond_wait ortp_cond_wait
#define ms_cond_signal ortp_cond_signal
#define ms_cond_broadcast ortp_cond_broadcast
#define ms_cond_destroy ortp_cond_destroy
#define MS_DEFAULT_MAX_PAYLOAD_SIZE 1440
#define MS2_INLINE ORTP_INLINE
#ifdef _WIN32
#if defined(__MINGW32__) || !defined(WINAPI_FAMILY_PARTITION) || !defined(WINAPI_PARTITION_DESKTOP)
#define MS2_WINDOWS_DESKTOP 1
#elif defined(WINAPI_FAMILY_PARTITION)
// See bctoolbox/include/port.h for WINAPI_PARTITION checker
#if defined(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#define MS2_WINDOWS_DESKTOP 1
#elif defined (WINAPI_PARTITION_PC_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP)
#define MS2_WINDOWS_DESKTOP 1
#define MS2_WINDOWS_UNIVERSAL 1
#define MS2_WINDOWS_UWP 1
#elif defined(WINAPI_PARTITION_PHONE_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
#define MS2_WINDOWS_PHONE 1
#elif defined(WINAPI_PARTITION_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define MS2_WINDOWS_UNIVERSAL 1
#endif
#endif
#endif
#if defined(_MSC_VER)
#ifdef MS2_STATIC
#define MS2_PUBLIC
#define MS2_VAR_PUBLIC extern
#else
#ifdef MS2_EXPORTS
#define MS2_PUBLIC __declspec(dllexport)
#define MS2_VAR_PUBLIC extern __declspec(dllexport)
#else
#define MS2_PUBLIC __declspec(dllimport)
#define MS2_VAR_PUBLIC extern __declspec(dllimport)
#endif
#endif
#else
#define MS2_PUBLIC
#define MS2_VAR_PUBLIC extern
#endif
#if defined(_WIN32_WCE)
time_t ms_time (time_t *t);
#else
#define ms_time time
#endif
#ifdef DEBUG
static MS2_INLINE void ms_debug(const char *fmt,...)
{
va_list args;
va_start (args, fmt);
bctbx_logv(BCTBX_LOG_DOMAIN, BCTBX_LOG_DEBUG, fmt, args);
va_end (args);
}
#else
#define ms_debug(fmt, ...)
#endif
#define ms_message bctbx_message
#define ms_warning bctbx_warning
#define ms_error bctbx_error
#define ms_fatal bctbx_fatal
#define ms_return_val_if_fail(_expr_,_ret_)\
if (!(_expr_)) { ms_fatal("assert "#_expr_ "failed"); return (_ret_);}
#define ms_return_if_fail(_expr_) \
if (!(_expr_)){ ms_fatal("assert "#_expr_ "failed"); return ;}
#define ms_thread_t ortp_thread_t
#define ms_thread_create ortp_thread_create
#define ms_thread_join ortp_thread_join
#define ms_thread_self ortp_thread_self
typedef ortpTimeSpec MSTimeSpec;
#define ms_get_cur_time ortp_get_cur_time
#define ms_get_cur_time_ms bctbx_get_cur_time_ms
typedef bctbx_compare_func MSCompareFunc;
typedef void (*MSIterateFunc)(void *a);
typedef void (*MSIterate2Func)(void *a, void *b);
typedef void (*MSIterate3Func)(void *a, void *b, void *c);
#ifdef __cplusplus
extern "C"{
#endif
/*for stun*/
typedef struct { unsigned char octet[12]; } UInt96;
typedef struct { unsigned char octet[16]; } UInt128;
MS2_PUBLIC void ms_thread_exit(void* ret_val);
#define MSList bctbx_list_t
/**
* @addtogroup ms_list
* @{
**/
/** Inserts a new element containing data to the end of a given list
* @param list list where data should be added. If NULL, a new list will be created.
* @param data data to insert into the list
* @return first element of the list
* @deprecated Use bctbx_list_append() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_append(MSList *list, void * data);
/** Inserts given element to the end of a given list
* @param list list where data should be added. If NULL, a new list will be created.
* @param new_elem element to append
* @return first element of the list
* @deprecated Use bctbx_list_append_link() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_append_link(MSList *list, MSList *new_elem);
/** Inserts a new element containing data to the start of a given list
* @param list list where data should be added. If NULL, a new list will be created.
* @param data data to insert into the list
* @return first element of the list - the one which was just created.
* @deprecated Use bctbx_list_prepend() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_prepend(MSList *list, void * data);
/** Frees all elements of a given list
* Note that data contained in each element will not be freed. If you need to clean
* them, consider using @ms_list_free_with_data
* @param list object to free.
* @return NULL
* @deprecated Use bctbx_list_free() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_free(MSList *list);
/** Frees all elements of a given list after having called freefunc on each element
* @param list object to free.
* @param freefunc function to invoke on each element data before destroying the element
* @return NULL
* @deprecated Use bctbx_list_free_with_data() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_free_with_data(MSList *list, void (*freefunc)(void*));
/** Concatenates second list to the end of first list
* @param first First list
* @param second Second list to append at the end of first list.
* @return first element of the merged list
* @deprecated Use bctbx_list_concat() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_concat(MSList *first, MSList *second);
/** Finds and remove the first element containing the given data. Nothing is done if element is not found.
* @param list List in which data must be removed
* @param data Data to remove
* @return first element of the modified list
* @deprecated Use bctbx_list_remove() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_remove(MSList *list, void *data);
/** Finds and remove any elements according to the given predicate function
* @param list List in which data must be removed
* @param compare_func Function to invoke on each element. If it returns TRUE, the given element will be deleted.
* @param user_data User data to pass to compare_func function
* @return first element of the modified list
* @deprecated Use bctbx_list_remove_custom() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList * ms_list_remove_custom(MSList *list, MSCompareFunc compare_func, const void *user_data);
/** Returns size of a given list
* @param list List to measure
* @return Size of list
* @deprecated Use bctbx_list_size() instead
**/
MS2_PUBLIC MS2_DEPRECATED int ms_list_size(const MSList *list);
/** Invoke function on each element of the list
* @param list List object
* @param iterate_func Function to invoke on each element.
* @deprecated Use bctbx_list_for_each() instead
**/
MS2_PUBLIC MS2_DEPRECATED void ms_list_for_each(const MSList *list, MSIterateFunc iterate_func);
/** Invoke function on each element of the list
* @param list List object
* @param iterate_func Function to invoke on each element.
* @param user_data User data to pass to iterate_func function.
* @deprecated Use bctbx_list_for_each2() instead
**/
MS2_PUBLIC MS2_DEPRECATED void ms_list_for_each2(const MSList *list, MSIterate2Func iterate_func, void *user_data);
MS2_PUBLIC MS2_DEPRECATED void ms_list_for_each3(const MSList *list, MSIterate3Func iterate_func, void *user_data, void *factory);
/** Finds and remove given element in list.
* @param list List in which element must be removed
* @param element element to remove
* @return first element of the modified list
* @deprecated Use bctbx_list_remove_link() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_remove_link(MSList *list, MSList *elem);
/** Finds first element containing data in the given list.
* @param list List in which element must be found
* @param data data to find
* @return element containing data, or NULL if not found
* @deprecated Use bctbx_list_find() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_find(MSList *list, void *data);
/** Finds first element according to the given predicate function
* @param list List in which element must be found
* @param compare_func Function to invoke on each element. If it returns TRUE, the given element will be returned.
* @param user_data User data to pass to compare_func function
* @return Element matching the predicate, or NULL if none is found.
* @deprecated Use bctbx_list_find_custom() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_find_custom(MSList *list, MSCompareFunc compare_func, const void *user_data);
/** Returns the nth element data of the list
* @param list List object
* @param index data index which must be returned.
* @return Element at the given index. NULL if index is invalid (negative or greater or equal to ms_list_size).
* @deprecated Use bctbx_list_nth_data() instead
**/
MS2_PUBLIC MS2_DEPRECATED void * ms_list_nth_data(const MSList *list, int index);
/** Returns the index of the given element
* @param list List object
* @param elem Element to search for.
* @return Index of the given element. -1 if not found.
* @deprecated Use bctbx_list_position() instead
**/
MS2_PUBLIC MS2_DEPRECATED int ms_list_position(const MSList *list, MSList *elem);
/** Returns the index of the first element containing data
* @param list List object
* @param data Data to search for.
* @return Index of the element containing data. -1 if not found.
* @deprecated Use bctbx_list_index() instead
**/
MS2_PUBLIC MS2_DEPRECATED int ms_list_index(const MSList *list, void *data);
/** Inserts a new element containing data at the place given by compare_func
* @param list list where data should be added. If NULL, a new list will be created.
* @param data data to insert into the list
* @param compare_func function determining where should the new element be placed
* @return first element of the list.
* @deprecated Use bctbx_list_insert_sorted() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_insert_sorted(MSList *list, void *data, MSCompareFunc compare_func);
/** Inserts a new element containing data before the given element
* @param list list where data should be added. If NULL, a new list will be created.
* @param before element parent to the one we will insert.
* @param data data to insert into the list
* @return first element of the modified list.
* @deprecated Use bctbx_list_insert() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_insert(MSList *list, MSList *before, void *data);
/** Copies a list in another one, duplicating elements but not data
* @param list list to copy
* @return Newly created list
* @deprecated Use bctbx_list_copy() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_copy(const MSList *list);
/** Copies a list in another one, duplicating elements according to the given function
* @param list list to copy
* @param copyfunc function to invoke on each element which will return the new list data value
* @return Newly created list
* @deprecated Use bctbx_list_copy_with_data() instead
**/
MS2_PUBLIC MS2_DEPRECATED MSList *ms_list_copy_with_data(const MSList *list, void *(*copyfunc)(void *));
/**
* @deprecated @deprecated Use bctbx_list_next() instead
*/
MS2_PUBLIC MS2_DEPRECATED MSList* ms_list_next(const MSList *list);
/** @} */
MS2_PUBLIC char * ms_tags_list_as_string(const MSList *list);
MS2_PUBLIC bool_t ms_tags_list_contains_tag(const MSList *list, const char *tag);
#undef MIN
#define MIN(a,b) ((a)>(b) ? (b) : (a))
#undef MAX
#define MAX(a,b) ((a)>(b) ? (a) : (b))
/**
* @file mscommon.h
* @brief mediastreamer2 mscommon.h include file
*
* This file provide the API needed to initialize
* and reset the mediastreamer2 library.
*
*/
/**
* @addtogroup mediastreamer2_init
* @{
*/
/**
* Helper macro for backward compatibility.
* Use ms_base_init() and ms_voip_init() instead.
*/
#define ms_init() ms_base_init(), ms_voip_init(), ms_plugins_init()
/**
* Helper macro for backward compatibility.
* Use ms_base_exit() and ms_voip_exit() instead.
*/
#define ms_exit() ms_voip_exit(), ms_plugins_exit(), ms_base_exit()
/**
* Initialize the mediastreamer2 base library.
*
* This must be called once before calling any other API.
* @deprecated use ms_factory_new()
*/
MS2_PUBLIC MS2_DEPRECATED void ms_base_init(void);
/**
* Initialize the mediastreamer2 VoIP library.
*
* This must be called one before calling any other API.
* @deprecated use ms_factory_new_with_voip().
*/
MS2_PUBLIC MS2_DEPRECATED void ms_voip_init(void);
/**
* Load the plugins from the default plugin directory.
*
* This is just a wrapper around ms_load_plugins().
* This must be called after ms_base_init() and after ms_voip_init().
* @deprecated use ms_factory_init_plugins(), or ms_factory_new_with_voip() that does it automatically.
*/
MS2_PUBLIC MS2_DEPRECATED void ms_plugins_init(void);
/**
* Set the directory from where the plugins are to be loaded when calling ms_plugins_init().
* @param[in] path The path to the plugins directory.
* @deprecated use ms_factory_set_plugins_dir().
*/
MS2_PUBLIC MS2_DEPRECATED void ms_set_plugins_dir(const char *path);
/**
* Load plugins from a specific directory.
* This method basically loads all libraries in the specified directory and attempts to call a C function called
* \